npm install @weavz/sdk

import { WeavzClient } from '@weavz/sdk'
 
const client = new WeavzClient({
  apiKey: 'wvz_your_api_key',
})
 
// Execute an action
const { output } = await client.actions.execute('slack', 'send_channel_message', {
  workspaceId: 'proj_abc123',
  input: { channel: '#general', text: 'Hello from Weavz!' },
  connectionExternalId: 'my_slack',
})
 
console.log('Message sent:', output)

const client = new WeavzClient({
  apiKey: 'wvz_your_api_key',
  baseUrl: 'https://api.weavz.io',  // Default
})

// List workspaces
const { workspaces } = await client.workspaces.list()
 
// Create a workspace
const { workspace } = await client.workspaces.create({
  name: 'My Workspace',
  slug: 'my-workspace',
})
 
// Delete a workspace
await client.workspaces.delete(workspace.id)

// Create an API key connection
const { connection } = await client.connections.create({
  type: 'SECRET_TEXT',
  integrationName: 'openai',
  externalId: 'tenant_123_openai',
  displayName: 'OpenAI Key',
  secretText: 'sk-...',
})
 
// Resolve a connection
const resolved = await client.connections.resolve({
  integrationName: 'openai',
  workspaceId: 'proj_abc123',
  externalId: 'tenant_123_openai',
})
 
// Delete a connection
await client.connections.delete(connection.id)

const { output } = await client.actions.execute('github', 'create_issue', {
  workspaceId: 'proj_abc123',
  input: {
    repo: 'my-org/my-repo',
    title: 'Bug Report',
    body: 'Something went wrong',
    labels: ['bug'],
  },
  connectionExternalId: 'my_github',
})

// Create a server
const { server, bearerToken, mcpEndpoint } = await client.mcpServers.create({
  name: 'AI Agent Tools',
  mode: 'TOOLS',
  workspaceId: 'proj_abc123',
})
 
// Create a server scoped to an end user
const { server: userServer, bearerToken: userToken } = await client.mcpServers.create({
  name: 'User Agent',
  workspaceId: 'proj_abc123',
  endUserId: 'user_123',
})
 
// Add a tool
await client.mcpServers.addTool(server.id, {
  integrationName: 'slack',
  actionName: 'send_channel_message',
  connectionId: 'conn_abc',
})
 
// Regenerate token
const { bearerToken: newToken } = await client.mcpServers.regenerateToken(server.id)

// Enable a trigger
const { triggerSource } = await client.triggers.enable({
  integrationName: 'github',
  triggerName: 'new_push',
  workspaceId: 'proj_abc123',
  callbackUrl: 'https://yourapp.com/webhooks/github',
  connectionExternalId: 'my_github',
})
 
// List active triggers
const { triggers } = await client.triggers.list()
 
// Disable a trigger
await client.triggers.disable(triggerSource.id)

// Create a partial (saved parameter preset)
const { partial } = await client.partials.create({
  name: 'Default Slack Channel',
  workspaceId: 'proj_abc123',
  integrationName: 'slack',
  actionName: 'send_channel_message',
  values: { channel: '#general' },
  enforcedKeys: ['channel'],
})
 
// List partials for a workspace
const { partials } = await client.partials.list({ workspaceId: 'proj_abc123' })
 
// Set as default for this action
await client.partials.setDefault(partial.id, true)
 
// Use partial with action execution
const { output } = await client.actions.execute('slack', 'send_channel_message', {
  workspaceId: 'proj_abc123',
  partialIds: [partial.id],
  input: { text: 'Hello!' }, // channel comes from the partial
})
 
// Delete a partial
await client.partials.delete(partial.id)

// Step 1: Create a connect session
const session = await client.connect.createToken({
  integrationName: 'google-sheets',
  connectionName: 'Google Sheets',
  externalId: 'tenant_123_gsheets',
  workspaceId: 'proj_abc123',
})
 
// Step 2: Open the popup (browser environments)
const result = await client.connect.popup({
  token: session.token,
  connectUrl: session.connectUrl,
})
 
console.log('Connection created:', result.connection.id)

// Step 1: Create a connect token
const { token, connectUrl } = await client.connect.createToken({
  integrationName: 'google-sheets',
  connectionName: 'Google Sheets',
  externalId: 'tenant_123_gsheets',
  workspaceId: 'proj_abc123',
})
 
// Step 2: Open connectUrl in a browser window...
// The response contains: token, connectUrl, expiresAt

import { WeavzClient, WeavzError } from '@weavz/sdk'
 
const client = new WeavzClient({ apiKey: 'wvz_your_key' })
 
try {
  await client.actions.execute('slack', 'send_channel_message', {
    workspaceId: 'proj_abc123',
    input: { channel: 'invalid', text: 'Hello!' },
  })
} catch (err) {
  if (err instanceof WeavzError) {
    console.error(err.message)   // Human-readable error message
    console.error(err.code)      // Machine-readable error code (e.g., "ACTION_FAILED")
    console.error(err.status)    // HTTP status code (e.g., 400)
    console.error(err.details)   // Additional error details (if available)
  }
}

// Typed integration inputs (generated from integration schemas)
import type { SlackSendChannelMessageInput } from '@weavz/sdk'
 
const input: SlackSendChannelMessageInput = {
  channel: '#general',
  text: 'Typed input!',
}
 
await client.actions.execute('slack', 'send_channel_message', {
  workspaceId: 'proj_abc123',
  input,
})

import type {
  WeavzClient,
  WeavzError,
  InputPartial,
  WorkspaceIntegration,
  McpServer,
  McpServerTool,
  Connection,
  Workspace,
  TriggerSource,
} from '@weavz/sdk'

import type {
  // Slack
  SlackSendChannelMessageInput,
  SlackSendDirectMessageInput,
  // GitHub
  GithubCreateIssueInput,
  GithubCreatePullRequestInput,
  // Google Sheets
  GoogleSheetsInsertRowInput,
  GoogleSheetsReadRowsInput,
  // ... all integrations follow the same pattern
} from '@weavz/sdk'