Integrations

const integrations = await client.integrations.elevenlabs.list();

integrations.forEach(int => {
  console.log(`${int.name} (${int.id})`);
});

const integration = await client.integrations.elevenlabs.create({
  name: 'My ElevenLabs Account',
  apiKey: 'your-elevenlabs-api-key',
});

console.log(`Created integration: ${integration.id}`);

const integration = await client.integrations.elevenlabs.get(integrationId);

await client.integrations.elevenlabs.update(integrationId, {
  name: 'Updated Name',
});

await client.integrations.elevenlabs.delete(integrationId);

const { agents, nextCursor, hasMore } = await client.integrations.elevenlabs.getAgents(
  integrationId,
  {
    search: 'support',
    pageSize: 20,
  }
);

agents.forEach(agent => {
  console.log(`${agent.name} (${agent.agentId})`);
  console.log(`  Tags: ${agent.tags.join(', ')}`);
});

// Paginate if needed
if (hasMore) {
  const nextPage = await client.integrations.elevenlabs.getAgents(integrationId, {
    cursor: nextCursor,
  });
}

interface ElevenLabsIntegration {
  id: UUID;
  name: string | null;
}

interface ElevenLabsAgent {
  agentId: string;
  name: string;
  tags: string[];
  createdAtUnixSecs: number;
  lastCallTimeUnixSecs: number | null;
}

// Your connectors
const myConnectors = await client.integrations.connectors.list();

// Public connectors
const publicConnectors = await client.integrations.connectors.listPublic();

const connector = await client.integrations.connectors.create({
  url: 'https://your-mcp-server.com',
  name: 'My MCP Server',
});

console.log(`Connector status: ${connector.status}`);

const connector = await client.integrations.connectors.get(connectorId);

console.log(`Status: ${connector.status}`);
console.log(`Tools available:`);
connector.knownTools.forEach(tool => {
  console.log(`  - ${tool.name}: ${tool.description}`);
});

await client.integrations.connectors.update(connectorId, {
  name: 'Updated Name',
  url: 'https://new-url.com',
});

await client.integrations.connectors.delete(connectorId);

type ConnectorStatus = 'SUCCESS' | 'AUTH_REQUIRED' | 'UNKNOWN' | 'UNKNOWN_ERROR';

interface Connector {
  id: UUID;
  name: string | null;
  description: string | null;
  url: string;
  status: ConnectorStatus;
  slug: string | null;
  logo: ImageInfo | null;
  knownTools: ConnectorTool[];
}

interface ConnectorTool {
  id: UUID;
  name: string;
  description: string | null;
  inputSchema: Record<string, unknown>;
}

await client.agents.update(agentId, {
  voiceCallConfig: {
    agentId: 'elevenlabs-agent-id',
    integrationId: integrationId,
  },
});

await client.agents.update(agentId, {
  mcpConfigs: [
    {
      connectorId: connectorId,
      toolWhitelist: ['search', 'lookup'],  // Only enable specific tools
    },
  ],
});

import { createWassistClient } from '@wassist/sdk';

const client = createWassistClient({
  baseUrl: 'https://api.wassist.app/api/v1/',
  authToken: process.env.WASSIST_TOKEN,
});

async function setupVoiceAgent() {
  // 1. Connect ElevenLabs
  const elevenLabs = await client.integrations.elevenlabs.create({
    name: 'Production Voice',
    apiKey: process.env.ELEVENLABS_API_KEY!,
  });
  
  // 2. List available ElevenLabs agents
  const { agents } = await client.integrations.elevenlabs.getAgents(elevenLabs.id);
  
  if (agents.length === 0) {
    throw new Error('No ElevenLabs agents found');
  }
  
  // 3. Create an agent with voice
  const agent = await client.onboarding.createFromElevenLabs({
    integrationId: elevenLabs.id,
    agentId: agents[0].agentId,
  });
  
  console.log(`Created voice agent: ${agent.name}`);
}

async function setupMCPIntegration() {
  // 1. Connect an MCP server
  const connector = await client.integrations.connectors.create({
    name: 'Database Access',
    url: 'https://my-mcp-server.com',
  });
  
  // 2. Wait for tools to be discovered
  if (connector.status !== 'SUCCESS') {
    console.log(`Connector status: ${connector.status}`);
    // May need authentication or retry
    return;
  }
  
  // 3. Add to an existing agent
  const agent = await client.agents.get('my-agent-id');
  
  await client.agents.update(agent.id, {
    mcpConfigs: [
      {
        connectorId: connector.id,
        toolWhitelist: connector.knownTools.map(t => t.name),
      },
    ],
  });
  
  console.log(`Added ${connector.knownTools.length} MCP tools to agent`);
}