list_assistants

Instructions

Implementation Reference

• src/tools/assistant.ts:18-29 (handler)

  The tool handler for 'list_assistants' - calls vapiClient.assistants.list() and maps results through transformAssistantOutput.

  ) => {
    server.tool(
      'list_assistants',
      'Lists all Vapi assistants',
      {},
      createToolHandler(async () => {
        //   console.log('list_assistants');
        const assistants = await vapiClient.assistants.list({ limit: 10 });
        //   console.log('assistants', assistants);
        return assistants.map(transformAssistantOutput);
      })
    );

• src/tools/utils.ts:44-72 (helper)

  createToolHandler wraps the actual handler with auth check and error handling.

  export function createToolHandler<T>(
    handler: (params: T) => Promise<any>
  ): (params: T) => Promise<ToolResponse> {
    return async (params: T) => {
      // Check auth first
      if (!hasValidToken()) {
        // Start auth if not already in progress
        if (!isAuthInProgress()) {
          try {
            await startAuthFlow();
          } catch (error) {
            // Ignore - we'll show the auth URL below
          }
        }
        const url = getAuthUrl();
        if (url) {
          return createAuthRequiredResponse(url);
        }
        return createErrorResponse('Authentication required. Please use vapi_login tool first.');
      }
  
      try {
        const result = await handler(params);
        return createSuccessResponse(result);
      } catch (error) {
        return createErrorResponse(error);
      }
    };
  }

• src/tools/index.ts:9-14 (registration)

  Registers all tools including assistant tools (which contains list_assistants).

  export const registerAllTools = (server: McpServer, vapiClient: VapiClient) => {
    registerAssistantTools(server, vapiClient);
    registerCallTools(server, vapiClient);
    registerPhoneNumberTools(server, vapiClient);
    registerToolTools(server, vapiClient);
  };

• src/transformers/index.ts:133-156 (helper)

  Transforms the raw assistant data from the Vapi API into a structured output.

  export function transformAssistantOutput(
    assistant: Vapi.Assistant
  ): z.infer<typeof AssistantOutputSchema> {
    return {
      id: assistant.id,
      createdAt: assistant.createdAt,
      updatedAt: assistant.updatedAt,
      name: assistant.name || 'Vapi Assistant',
      llm: {
        provider: assistant.model?.provider || 'openai',
        model: assistant.model?.model || 'gpt-4o-mini',
      },
      voice: {
        provider: assistant.voice?.provider || '11labs',
        voiceId: getAssistantVoiceId(assistant.voice),
        model: getAssistantVoiceModel(assistant.voice) || 'eleven_turbo_v2_5',
      },
      transcriber: {
        provider: assistant.transcriber?.provider || 'deepgram',
        model: getAssistantTranscriberModel(assistant.transcriber) || 'nova-3',
      },
      toolIds: assistant.model?.toolIds || [],
    };
  }

• src/schemas/index.ts:179-195 (schema)

  Zod schema defining the output shape for assistant data (used by transformAssistantOutput).

  export const AssistantOutputSchema = BaseResponseSchema.extend({
    name: z.string(),
    llm: z.object({
      provider: z.string(),
      model: z.string(),
    }),
    voice: z.object({
      provider: z.string(),
      voiceId: z.string(),
      model: z.string().optional(),
    }),
    transcriber: z.object({
      provider: z.string(),
      model: z.string(),
    }),
    toolIds: z.array(z.string()).optional(),
  });