npm install @weavz/sdk

import { WeavzClient } from '@weavz/sdk'
 
const client = new WeavzClient({
  apiKey: 'wvz_your_api_key',
})
 
// Execute an action
const result = await client.actions.execute('slack', 'send_channel_message', {
  workspaceId: '550e8400-e29b-41d4-a716-446655440000',
  integrationAlias: 'office_slack',
  input: { channel: '#general', text: 'Hello from Weavz!' },
})
 
if ('approval' in result) {
  console.log('Approval required:', result.approval.id)
} else {
  console.log('Message sent:', result.output)
}

const client = new WeavzClient({
  apiKey: 'wvz_your_api_key',
  baseUrl: 'https://api.weavz.io',  // Default
  timeout: 310_000,                 // Request timeout in milliseconds
  maxRetries: 2,                    // Retry count for transient failures
  headers: { 'X-App-Version': '1.0.0' },
  userAgent: 'my-product/1.0.0',
})

// 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)

const { workspace } = await client.workspaces.create({
  name: 'Production',
  slug: 'production',
})
 
await client.workspaces.addIntegration(workspace.id, {
  integrationName: 'slack',
  alias: 'customer_slack',
  connectionStrategy: 'per_user',
})

// 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: '550e8400-e29b-41d4-a716-446655440000',
  externalId: 'tenant_123_openai',
})
 
// Delete a connection
await client.connections.delete(connection.id)

const result = await client.actions.execute('github', 'create_issue', {
  workspaceId: '550e8400-e29b-41d4-a716-446655440000',
  integrationAlias: 'github_prod',
  input: {
    repository: 'my-org/my-repo',
    title: 'Bug Report',
    body: 'Something went wrong',
    labels: 'bug',
  },
})
 
if ('approval' in result) {
  console.log('Approval required:', result.approval.id)
} else {
  console.log('Issue created:', result.output)
}

const workspaceId = '550e8400-e29b-41d4-a716-446655440000'
 
// Add built-ins to the workspace once. MCP servers sync workspace integrations automatically.
await client.workspaces.addIntegration(workspaceId, {
  integrationName: 'datetime',
  alias: 'datetime',
})
await client.workspaces.addIntegration(workspaceId, {
  integrationName: 'hash-encode',
  alias: 'hash',
})
 
// Create a Code Mode MCP server for broad agent workspaces
const { server, mcpEndpoint } = await client.mcpServers.create({
  name: 'AI Agent Workspace',
  mode: 'CODE',
  workspaceId,
  authMode: 'oauth_and_bearer',
  endUserAccess: 'restricted',
  settings: { codeMode: { approvalWaitSeconds: 30 } },
})
 
// Give a known end user programmatic bearer MCP access
const { bearerToken, mcpEndpoint: userEndpoint } = await client.mcpServers.createBearerToken(
  server.id,
  {
    endUserId: 'user_123',
    scopes: ['mcp:tools', 'mcp:code'],
    expiresIn: 60 * 60 * 24 * 30,
  },
)
 
// Run Code Mode from your own harness
const run = await client.mcpServers.executeCode(server.id, `
  const parsed = await weavz.datetime.parse_date({ dateString: "2026-05-18" })
  const digest = await weavz.hash.hash({ text: parsed.iso, algorithm: "sha256", encoding: "hex" })
  return { parsed, digest }
`)
 
// If Human Gates pauses the run, approve it and fetch the stored result.
const approvedRun = await client.mcpServers.executeCode(server.id, {
  approvalId: 'apr_9b36d3f761d84bb2b6f9a0c4b9d1f7e0',
  waitForApprovalSeconds: 30,
})
 
// Use Tool Mode when you want a small explicit surface instead of Code Mode.
await client.workspaces.addIntegration(workspaceId, {
  integrationName: 'slack',
  alias: 'office_slack',
  enabledActions: ['send_channel_message'],
})
const { server: toolServer } = await client.mcpServers.create({
  name: 'Focused Slack Tools',
  mode: 'TOOLS',
  workspaceId,
  authMode: 'oauth',
})

// Enable a trigger
const { triggerSource } = await client.triggers.enable({
  integrationName: 'github',
  triggerName: 'new_push',
  workspaceId: '550e8400-e29b-41d4-a716-446655440000',
  callbackUrl: 'https://yourapp.com/webhooks/github',
  integrationAlias: 'github_prod',
})
 
// 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: '550e8400-e29b-41d4-a716-446655440000',
  integrationName: 'slack',
  integrationAlias: 'office_slack',
  actionName: 'send_channel_message',
  values: { channel: '#general' },
  enforcedKeys: ['channel'],
})
 
// List partials for a workspace
const { partials } = await client.partials.list({ workspaceId: '550e8400-e29b-41d4-a716-446655440000' })
 
// Set as default for this action scope
await client.partials.setDefault(partial.id, true)
 
// Use partial with action execution. This uses the dynamic overload because the
// generated Slack type cannot know that the partial supplies `channel`.
const integrationName: string = 'slack'
const result = await client.actions.execute(integrationName, 'send_channel_message', {
  workspaceId: '550e8400-e29b-41d4-a716-446655440000',
  integrationAlias: 'office_slack',
  partialIds: [partial.id],
  input: { text: 'Hello!' }, // channel comes from the partial
})
 
if ('approval' in result) {
  console.log('Approval required:', result.approval.id)
} else {
  console.log('Message sent:', result.output)
}
 
// 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: '550e8400-e29b-41d4-a716-446655440000',
})
 
// Step 2: Open the popup (browser environments)
const result = await client.connect.popup({
  token: session.token,
  connectUrl: session.connectUrl,
})
 
console.log('Connection created:', result.connectionId)

// Step 1: Create a connect token
const { token, connectUrl } = await client.connect.createToken({
  integrationName: 'google-sheets',
  connectionName: 'Google Sheets',
  externalId: 'tenant_123_gsheets',
  workspaceId: '550e8400-e29b-41d4-a716-446655440000',
})
 
// Step 2: Open connectUrl in a browser window...
// The response contains: token, connectUrl, expiresAt
 
const status = await client.connect.wait(token)
if (status.status === 'COMPLETED') {
  console.log('Connection created:', status.connectionId)
}

import { WeavzClient, WeavzError } from '@weavz/sdk'
 
const client = new WeavzClient({ apiKey: 'wvz_your_key' })
 
try {
  await client.actions.execute('slack', 'send_channel_message', {
    workspaceId: '550e8400-e29b-41d4-a716-446655440000',
    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 { integrationActions, integrationNames, isKnownActionName } from '@weavz/sdk'
import type {
  ActionInput,
  ActionName,
  ActionPropertyName,
  IntegrationActionKey,
  IntegrationName,
  SlackSendChannelMessageInput,
} from '@weavz/sdk'
 
const input: SlackSendChannelMessageInput = {
  channel: '#general',
  text: 'Typed input!',
}
 
const integrationName: IntegrationName = 'slack'
const actionName: ActionName<'slack'> = 'send_channel_message'
const typedInput: ActionInput<'slack', 'send_channel_message'> = input
const propertyName: ActionPropertyName<'slack', 'send_channel_message'> = 'channel'
const actionKey: IntegrationActionKey = 'slack.send_channel_message'
 
console.log(integrationNames.includes(integrationName))
console.log(integrationActions.slack.includes(actionName))
 
await client.actions.execute('slack', 'send_channel_message', {
  workspaceId: '550e8400-e29b-41d4-a716-446655440000',
  input: typedInput,
})
 
const dynamicAction = 'send_channel_message'
if (isKnownActionName('slack', dynamicAction)) {
  await client.actions.execute('slack', dynamicAction, {
    workspaceId: '550e8400-e29b-41d4-a716-446655440000',
    input,
  })
}

import type {
  WeavzClient,
  WeavzError,
  InputPartial,
  WorkspaceIntegration,
  EndUser,
  ExecuteActionResponse,
  IntegrationMetadata,
} from '@weavz/sdk'

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

import {
  integrationActions,
  integrationNames,
  isKnownIntegrationName,
  isKnownActionName,
} from '@weavz/sdk'
import type { ActionInput } from '@weavz/sdk'
 
function listKnownActions(integrationName: string) {
  if (!isKnownIntegrationName(integrationName)) return []
  return integrationActions[integrationName]
}
 
const input: ActionInput<'http', 'send_request'> = {
  method: 'GET',
  url: 'https://api.example.com/health',
  headers: {},
  queryParams: {},
  authType: 'NONE',
}
 
await client.actions.execute('http', 'send_request', {
  workspaceId: '550e8400-e29b-41d4-a716-446655440000',
  input,
})
 
const { options } = await client.integrations.resolveOptions('slack', {
  actionName: 'send_channel_message',
  propertyName: 'channel',
  workspaceId: '550e8400-e29b-41d4-a716-446655440000',
  input: {},
})

import {
  WeavzClient,
  createMcpServerActionTools,
  toOpenAIResponsesTool,
  toAnthropicTool,
  toVercelAIToolSet,
} from '@weavz/sdk'
 
const client = new WeavzClient({ apiKey: process.env.WEAVZ_API_KEY! })
 
// Reuse the action tools configured on an MCP server
const tools = await createMcpServerActionTools(client, '660e8400-e29b-41d4-a716-446655440000')
 
// OpenAI Responses API tool definitions
const openaiTools = tools.map(toOpenAIResponsesTool)
 
// Anthropic tool definitions
const anthropicTools = tools.map(toAnthropicTool)
 
// Vercel AI SDK tools with built-in execution
import { tool, jsonSchema } from 'ai'
const aiSdkTools = toVercelAIToolSet(tools, { tool, jsonSchema })