@teamlearners/clawops 0.1.0

package/dist/agent/index.d.cts

@@ -0,0 +1,821 @@
+import { z } from 'zod';
+
+/**
+ * MCP server configuration for stdio-based servers.
+ */
+interface MCPServerStdio {
+    type: 'stdio';
+    /** Command to execute. */
+    command: string;
+    /** Command arguments. */
+    args?: string[];
+    /** Environment variables. */
+    env?: Record<string, string>;
+    [key: string]: unknown;
+}
+/**
+ * Create a stdio MCP server configuration.
+ */
+declare function mcpServerStdio(options: {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}): MCPServerStdio;
+
+/**
+ * MCP server configuration for HTTP-based servers.
+ */
+interface MCPServerHTTP {
+    type: 'http';
+    /** Server URL. */
+    url: string;
+    /** Additional headers to send with requests. */
+    headers?: Record<string, string>;
+    [key: string]: unknown;
+}
+/**
+ * Create an HTTP MCP server configuration.
+ */
+declare function mcpServerHTTP(options: {
+    url: string;
+    headers?: Record<string, string>;
+}): MCPServerHTTP;
+
+/**
+ * CallSession represents an active phone call and provides methods to
+ * send audio, hang up, and listen for lifecycle events.
+ */
+type CallDirection = 'inbound' | 'outbound';
+type CallStatus = 'ringing' | 'active' | 'ended';
+type SessionEventType = 'ended' | 'dtmf' | 'speech';
+interface SessionEvent {
+    type: SessionEventType;
+    data?: unknown;
+}
+type SessionEventHandler = (event: SessionEvent) => void | Promise<void>;
+interface SendAudioFn {
+    (audio: Buffer): void;
+}
+interface ClearAudioFn {
+    (): void;
+}
+interface HangupFn {
+    (): void;
+}
+declare class CallSession {
+    readonly callId: string;
+    readonly fromNumber: string;
+    readonly toNumber: string;
+    readonly accountId: string;
+    readonly direction: CallDirection;
+    readonly startTime: Date;
+    readonly metadata: Record<string, unknown>;
+    private _status;
+    private _sendAudioFn;
+    private _clearAudioFn;
+    private _hangupFn;
+    private _handlers;
+    private _endedPromise;
+    private _resolveEnded;
+    constructor(options: {
+        callId: string;
+        fromNumber: string;
+        toNumber: string;
+        accountId: string;
+        direction: CallDirection;
+        metadata?: Record<string, unknown>;
+    });
+    get status(): CallStatus;
+    get duration(): number;
+    /** Bind transport functions (called internally by the agent). */
+    _bindTransport(send: SendAudioFn, clear: ClearAudioFn, hangup: HangupFn): void;
+    /** Send PCM16 or ulaw audio to the caller. */
+    sendAudio(audio: Buffer): void;
+    /** Clear any queued outbound audio. */
+    clearAudio(): void;
+    /** Hang up the call. */
+    hangup(): void;
+    /** Register an event handler. */
+    on(event: SessionEventType, handler: SessionEventHandler): void;
+    /** Wait for the call to end. */
+    wait(): Promise<void>;
+    /** Mark the session as ended (called internally). */
+    _markEnded(): void;
+    /** Emit an event to registered handlers. */
+    _emit(event: SessionEvent): void;
+}
+
+/**
+ * Tool registry for function-calling in voice agent pipelines.
+ * Uses Zod schemas for parameter validation.
+ */
+
+interface FunctionTool {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    required: string[];
+    handler: (args: Record<string, unknown>) => unknown | Promise<unknown>;
+}
+interface OpenAIToolDefinition {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: 'object';
+            properties: Record<string, unknown>;
+            required: string[];
+        };
+    };
+}
+/**
+ * Decorator / identity function for marking a function as a tool handler.
+ * In TypeScript, this simply returns the function as-is. Use with ToolRegistry.register().
+ */
+declare function functionTool<T extends (...args: unknown[]) => unknown>(fn: T): T;
+declare class ToolRegistry {
+    private _tools;
+    private _mcpTools;
+    /** Register a function tool. */
+    register(tool: FunctionTool): void;
+    /** Register tools discovered from MCP servers. */
+    registerMcpTools(tools: FunctionTool[]): void;
+    /** Clear all MCP-registered tools. */
+    clearMcpTools(): void;
+    /**
+     * Create a fork (shallow copy) of this registry.
+     * Useful for per-session tool isolation.
+     */
+    fork(): ToolRegistry;
+    /** Check if a tool is registered. */
+    has(name: string): boolean;
+    /** Get a tool by name. */
+    get(name: string): FunctionTool | undefined;
+    /** Convert all registered tools to OpenAI function-calling format. */
+    toOpenAITools(): OpenAIToolDefinition[];
+    /** Call a tool by name with the given arguments. */
+    call(name: string, args: Record<string, unknown>): Promise<unknown>;
+    /** Get the number of registered tools (including MCP). */
+    get size(): number;
+}
+/**
+ * Helper to convert a Zod object schema into a JSON Schema properties + required list.
+ */
+declare function zodToToolParams(schema: z.ZodObject<z.ZodRawShape>): {
+    parameters: Record<string, unknown>;
+    required: string[];
+};
+
+/**
+ * Base interfaces for the voice agent pipeline.
+ */
+
+/** Speech recognition event. */
+interface SpeechEvent {
+    type: 'interim' | 'final';
+    transcript: string;
+}
+/** Conversation message for LLM context. */
+interface ConversationMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+    name?: string;
+    tool_call_id?: string;
+}
+/** Tool call request from an LLM. */
+interface ToolCallRequest {
+    id: string;
+    name: string;
+    arguments: string;
+}
+/** LLM response chunk (for streaming). */
+interface LLMChunk {
+    type: 'text' | 'tool_call' | 'done';
+    text?: string;
+    toolCall?: ToolCallRequest;
+}
+/**
+ * Session interface for realtime (speech-to-speech) providers.
+ * Implementations: OpenAIRealtime, GeminiRealtime
+ */
+interface Session {
+    /** Start the realtime session with the call session and tools. */
+    start(callSession: CallSession, tools?: ToolRegistry): Promise<void>;
+    /** Feed raw audio into the session. */
+    feedAudio(audio: Buffer): void;
+    /** Stop the session. */
+    stop(): Promise<void>;
+}
+/**
+ * Speech-to-Text provider interface.
+ */
+interface STT {
+    /**
+     * Transcribe audio. Returns an async generator of speech events.
+     * The generator yields interim results and a final result.
+     */
+    transcribe(audioStream: AsyncIterable<Buffer>, options?: {
+        language?: string;
+        sampleRate?: number;
+    }): AsyncGenerator<SpeechEvent>;
+}
+/**
+ * LLM (Large Language Model) provider interface.
+ */
+interface LLM {
+    /**
+     * Generate a response from the LLM.
+     * Returns an async generator of response chunks.
+     */
+    generate(messages: ConversationMessage[], options?: {
+        tools?: ToolRegistry;
+        temperature?: number;
+        maxTokens?: number;
+    }): AsyncGenerator<LLMChunk>;
+}
+/**
+ * Text-to-Speech provider interface.
+ */
+interface TTS {
+    /**
+     * Synthesize text to audio.
+     * Returns an async generator of PCM16 audio chunks.
+     */
+    synthesize(text: string | AsyncIterable<string>, options?: {
+        voice?: string;
+        sampleRate?: number;
+    }): AsyncGenerator<Buffer>;
+}
+
+/**
+ * Tracing configuration for OpenTelemetry integration.
+ */
+interface TracingConfig {
+    /** Whether tracing is enabled. Default: false */
+    enabled: boolean;
+    /** Service name for traces. Default: 'clawops-agent' */
+    serviceName?: string;
+    /**
+     * Optional TracerProvider instance from @opentelemetry/api.
+     * If not provided, the global tracer provider will be used.
+     */
+    tracerProvider?: unknown;
+}
+/** Get the current tracing configuration. */
+declare function getTracingConfig(): TracingConfig;
+/** Set the tracing configuration. */
+declare function setTracingConfig(config: Partial<TracingConfig>): void;
+/** Reset tracing configuration to defaults. */
+declare function resetTracingConfig(): void;
+
+/**
+ * ClawOpsAgent - main agent class for handling voice calls.
+ */
+
+type AgentEventType = 'call.incoming' | 'call.ended' | 'call.outbound_ready' | 'call.ringing' | 'call.failed';
+type AgentEventHandler = (session: CallSession) => void | Promise<void>;
+interface ClawOpsAgentOptions {
+    /** ClawOps API key. Falls back to CLAWOPS_API_KEY env var. */
+    apiKey?: string;
+    /** Agent ID. Falls back to CLAWOPS_AGENT_ID env var. */
+    agentId?: string;
+    /** API base URL. */
+    baseUrl?: string;
+    /** Session factory: returns the session handler for each call. */
+    session?: Session | (() => Session);
+    /** Recording output directory. If set, calls are recorded. */
+    recordingDir?: string;
+    /** MCP server configurations. */
+    mcpServers?: Record<string, MCPServerStdio | MCPServerHTTP>;
+    /** Tracing configuration. */
+    tracing?: TracingConfig;
+}
+declare class ClawOpsAgent {
+    private _apiKey;
+    private _agentId;
+    private _baseUrl;
+    private _sessionFactory;
+    private _tools;
+    private _handlers;
+    private _controlWs;
+    private _mcpClient;
+    private _recordingDir;
+    private _activeSessions;
+    constructor(options?: ClawOpsAgentOptions);
+    /** Register a function tool. */
+    tool(tool: FunctionTool): this;
+    /** Register an event handler. */
+    on(event: AgentEventType, handler: AgentEventHandler): this;
+    /** Connect to the ClawOps platform and start listening for calls. */
+    connect(): Promise<void>;
+    /**
+     * Connect and block until disconnected.
+     * Convenience method for simple agent scripts.
+     */
+    serve(): Promise<void>;
+    /** Disconnect from the platform. */
+    disconnect(): Promise<void>;
+    /**
+     * Initiate an outbound call.
+     */
+    call(options: {
+        to: string;
+        from: string;
+        metadata?: Record<string, unknown>;
+    }): void;
+    private _handleIncoming;
+    private _handleEnded;
+    private _handleOutboundReady;
+    private _handleRinging;
+    private _handleFailed;
+    private _startCallSession;
+    private _emitEvent;
+}
+
+/**
+ * Audio codec utilities: PCM16 <-> ulaw conversion and resampling.
+ */
+declare const DECODE_TABLE: readonly number[];
+/**
+ * Convert PCM16 little-endian audio to ulaw.
+ */
+declare function pcm16ToUlaw(pcm: Buffer): Buffer;
+/**
+ * Convert ulaw audio to PCM16 little-endian.
+ */
+declare function ulawToPcm16(ulaw: Buffer): Buffer;
+/**
+ * Resample PCM16 audio using linear interpolation.
+ */
+declare function resamplePcm16(pcm: Buffer, fromRate: number, toRate: number): Buffer;
+
+/**
+ * AudioRecorder writes inbound and outbound audio to a WAV file.
+ */
+interface RecorderOptions {
+    /** Output directory for recordings. */
+    outputDir: string;
+    /** Sample rate of audio data. Default: 8000 */
+    sampleRate?: number;
+}
+declare class AudioRecorder {
+    private readonly _outputDir;
+    private readonly _sampleRate;
+    private _inboundChunks;
+    private _outboundChunks;
+    private _callId;
+    private _started;
+    constructor(options: RecorderOptions);
+    /** Start recording for a call. */
+    start(callId: string): void;
+    /** Write inbound (caller) PCM16 audio. */
+    writeInbound(pcm: Buffer): void;
+    /** Write raw outbound (agent) PCM16 audio. */
+    writeRawOutbound(pcm: Buffer): void;
+    /** Stop recording and write WAV files to disk. Returns file paths. */
+    stop(): {
+        inbound?: string;
+        outbound?: string;
+    };
+    private _writeWav;
+}
+
+/**
+ * OpenAI Realtime API session (speech-to-speech).
+ */
+
+interface OpenAIRealtimeOptions {
+    /** OpenAI API key. Falls back to OPENAI_API_KEY env var. */
+    apiKey?: string;
+    /** Model to use. Default: 'gpt-4o-realtime-preview' */
+    model?: string;
+    /** Voice ID. Default: 'alloy' */
+    voice?: string;
+    /** System prompt / instructions. */
+    instructions?: string;
+    /** Input audio format. Default: 'pcm16' */
+    inputAudioFormat?: string;
+    /** Output audio format. Default: 'pcm16' */
+    outputAudioFormat?: string;
+    /** Temperature for generation. */
+    temperature?: number;
+    /** Turn detection config. Set to null to disable. */
+    turnDetection?: Record<string, unknown> | null;
+}
+declare class OpenAIRealtime implements Session {
+    private _options;
+    private _ws;
+    private _callSession;
+    private _tools;
+    private _closed;
+    constructor(options?: OpenAIRealtimeOptions);
+    start(callSession: CallSession, tools?: ToolRegistry): Promise<void>;
+    feedAudio(audio: Buffer): void;
+    stop(): Promise<void>;
+    private _sendSessionUpdate;
+    private _handleMessage;
+    private _handleFunctionCall;
+}
+
+/**
+ * Google Gemini Realtime API session (speech-to-speech).
+ */
+
+interface GeminiRealtimeOptions {
+    /** Google API key. Falls back to GOOGLE_API_KEY env var. */
+    apiKey?: string;
+    /** Model to use. Default: 'gemini-2.0-flash-exp' */
+    model?: string;
+    /** Voice name. */
+    voice?: string;
+    /** System instruction. */
+    systemInstruction?: string;
+    /** Generation config overrides. */
+    generationConfig?: Record<string, unknown>;
+}
+declare class GeminiRealtime implements Session {
+    private _options;
+    private _ws;
+    private _callSession;
+    private _tools;
+    private _closed;
+    constructor(options?: GeminiRealtimeOptions);
+    start(callSession: CallSession, tools?: ToolRegistry): Promise<void>;
+    feedAudio(audio: Buffer): void;
+    stop(): Promise<void>;
+    private _sendSetup;
+    private _handleMessage;
+    private _handleToolCall;
+}
+
+/**
+ * PipelineSession orchestrates STT -> LLM -> TTS for a voice call.
+ */
+
+interface PipelineSessionOptions {
+    stt: STT;
+    llm: LLM;
+    tts: TTS;
+    /** System prompt for the LLM. */
+    systemPrompt?: string;
+    /** LLM temperature. */
+    temperature?: number;
+    /** Max tokens for LLM generation. */
+    maxTokens?: number;
+    /** Sample rate for audio. Default: 8000 */
+    sampleRate?: number;
+    /** Whether to interrupt TTS when user starts speaking. Default: true */
+    interruptOnSpeech?: boolean;
+}
+declare class PipelineSession implements Session {
+    private _stt;
+    private _llm;
+    private _tts;
+    private _systemPrompt;
+    private _temperature;
+    private _maxTokens;
+    private _sampleRate;
+    private _interruptOnSpeech;
+    private _callSession;
+    private _tools;
+    private _conversation;
+    private _audioBuffer;
+    private _running;
+    private _speaking;
+    constructor(options: PipelineSessionOptions);
+    start(callSession: CallSession, tools?: ToolRegistry): Promise<void>;
+    feedAudio(audio: Buffer): void;
+    stop(): Promise<void>;
+    private _runSttLoop;
+    private _createAudioStream;
+    private _handleUserSpeech;
+    private _handleToolCall;
+    private _synthesizeAndSend;
+}
+
+/**
+ * Deepgram STT (Speech-to-Text) provider.
+ */
+
+interface DeepgramSTTOptions {
+    /** Deepgram API key. Falls back to DEEPGRAM_API_KEY env var. */
+    apiKey?: string;
+    /** Model to use. Default: 'nova-2' */
+    model?: string;
+    /** Language code. Default: 'ko' */
+    language?: string;
+    /** Enable interim results. Default: true */
+    interimResults?: boolean;
+    /** Enable punctuation. Default: true */
+    punctuate?: boolean;
+    /** Enable smart formatting. Default: true */
+    smartFormat?: boolean;
+    /** Encoding. Default: 'linear16' */
+    encoding?: string;
+    /** Sample rate. Default: 8000 */
+    sampleRate?: number;
+    /** Number of channels. Default: 1 */
+    channels?: number;
+}
+declare class DeepgramSTT implements STT {
+    private _options;
+    constructor(options?: DeepgramSTTOptions);
+    transcribe(audioStream: AsyncIterable<Buffer>, options?: {
+        language?: string;
+        sampleRate?: number;
+    }): AsyncGenerator<SpeechEvent>;
+}
+
+/**
+ * ElevenLabs TTS (Text-to-Speech) provider.
+ */
+
+interface ElevenLabsTTSOptions {
+    /** ElevenLabs API key. Falls back to ELEVENLABS_API_KEY env var. */
+    apiKey?: string;
+    /** Voice ID. Default: '21m00Tcm4TlvDq8ikWAM' (Rachel) */
+    voiceId?: string;
+    /** Model ID. Default: 'eleven_multilingual_v2' */
+    modelId?: string;
+    /** Output format. Default: 'pcm_16000' */
+    outputFormat?: string;
+    /** Stability. Default: 0.5 */
+    stability?: number;
+    /** Similarity boost. Default: 0.75 */
+    similarityBoost?: number;
+    /** Style. Default: 0 */
+    style?: number;
+    /** Use speaker boost. Default: true */
+    useSpeakerBoost?: boolean;
+}
+declare class ElevenLabsTTS implements TTS {
+    private _options;
+    constructor(options?: ElevenLabsTTSOptions);
+    synthesize(text: string | AsyncIterable<string>, options?: {
+        voice?: string;
+        sampleRate?: number;
+    }): AsyncGenerator<Buffer>;
+    private _synthesizeSingle;
+    private _synthesizeStreaming;
+}
+
+/**
+ * OpenAI LLM provider for pipeline-based voice agents.
+ */
+
+interface OpenAILLMOptions {
+    /** OpenAI API key. Falls back to OPENAI_API_KEY env var. */
+    apiKey?: string;
+    /** Model to use. Default: 'gpt-4o' */
+    model?: string;
+    /** Default temperature. */
+    temperature?: number;
+    /** Default max tokens. */
+    maxTokens?: number;
+}
+declare class OpenAILLM implements LLM {
+    private _options;
+    constructor(options?: OpenAILLMOptions);
+    generate(messages: ConversationMessage[], options?: {
+        tools?: ToolRegistry;
+        temperature?: number;
+        maxTokens?: number;
+    }): AsyncGenerator<LLMChunk>;
+}
+
+/**
+ * Anthropic LLM provider for pipeline-based voice agents.
+ */
+
+interface AnthropicLLMOptions {
+    /** Anthropic API key. Falls back to ANTHROPIC_API_KEY env var. */
+    apiKey?: string;
+    /** Model to use. Default: 'claude-sonnet-4-20250514' */
+    model?: string;
+    /** Default temperature. */
+    temperature?: number;
+    /** Default max tokens. Default: 1024 */
+    maxTokens?: number;
+}
+declare class AnthropicLLM implements LLM {
+    private _options;
+    constructor(options?: AnthropicLLMOptions);
+    generate(messages: ConversationMessage[], options?: {
+        tools?: ToolRegistry;
+        temperature?: number;
+        maxTokens?: number;
+    }): AsyncGenerator<LLMChunk>;
+}
+
+/**
+ * Google Gemini LLM provider for pipeline-based voice agents.
+ */
+
+interface GeminiLLMOptions {
+    /** Google API key. Falls back to GOOGLE_API_KEY env var. */
+    apiKey?: string;
+    /** Model to use. Default: 'gemini-2.0-flash' */
+    model?: string;
+    /** Default temperature. */
+    temperature?: number;
+    /** Default max tokens. */
+    maxTokens?: number;
+}
+declare class GeminiLLM implements LLM {
+    private _options;
+    constructor(options?: GeminiLLMOptions);
+    generate(messages: ConversationMessage[], options?: {
+        tools?: ToolRegistry;
+        temperature?: number;
+        maxTokens?: number;
+    }): AsyncGenerator<LLMChunk>;
+}
+
+/**
+ * OpenAI-compatible LLM provider (works with any OpenAI-compatible API).
+ */
+
+interface OpenAICompatLLMOptions {
+    /** API key. */
+    apiKey?: string;
+    /** Base URL for the OpenAI-compatible API. */
+    baseUrl: string;
+    /** Model to use. */
+    model: string;
+    /** Default temperature. */
+    temperature?: number;
+    /** Default max tokens. */
+    maxTokens?: number;
+    /** Additional default headers. */
+    defaultHeaders?: Record<string, string>;
+}
+declare class OpenAICompatLLM implements LLM {
+    private _options;
+    constructor(options: OpenAICompatLLMOptions);
+    generate(messages: ConversationMessage[], options?: {
+        tools?: ToolRegistry;
+        temperature?: number;
+        maxTokens?: number;
+    }): AsyncGenerator<LLMChunk>;
+}
+
+/**
+ * Ollama LLM provider for pipeline-based voice agents.
+ * Uses the OpenAI-compatible API that Ollama exposes.
+ */
+
+interface OllamaLLMOptions {
+    /** Ollama server URL. Default: 'http://localhost:11434' */
+    baseUrl?: string;
+    /** Model to use. Default: 'llama3.1' */
+    model?: string;
+    /** Default temperature. */
+    temperature?: number;
+    /** Default max tokens. */
+    maxTokens?: number;
+}
+declare class OllamaLLM implements LLM {
+    private _inner;
+    constructor(options?: OllamaLLMOptions);
+    generate(messages: ConversationMessage[], options?: {
+        tools?: ToolRegistry;
+        temperature?: number;
+        maxTokens?: number;
+    }): AsyncGenerator<LLMChunk>;
+}
+
+interface MistralLLMOptions {
+    apiKey?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+}
+declare class MistralLLM implements LLM {
+    private _inner;
+    constructor(options?: MistralLLMOptions);
+    generate(messages: ConversationMessage[], options?: {
+        tools?: ToolRegistry;
+        temperature?: number;
+        maxTokens?: number;
+    }): AsyncGenerator<LLMChunk>;
+}
+
+interface GroqLLMOptions {
+    apiKey?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+}
+declare class GroqLLM implements LLM {
+    private _inner;
+    constructor(options?: GroqLLMOptions);
+    generate(messages: ConversationMessage[], options?: {
+        tools?: ToolRegistry;
+        temperature?: number;
+        maxTokens?: number;
+    }): AsyncGenerator<LLMChunk>;
+}
+
+interface PerplexityLLMOptions {
+    apiKey?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+}
+declare class PerplexityLLM implements LLM {
+    private _inner;
+    constructor(options?: PerplexityLLMOptions);
+    generate(messages: ConversationMessage[], options?: {
+        tools?: ToolRegistry;
+        temperature?: number;
+        maxTokens?: number;
+    }): AsyncGenerator<LLMChunk>;
+}
+
+interface TogetherLLMOptions {
+    apiKey?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+}
+declare class TogetherLLM implements LLM {
+    private _inner;
+    constructor(options?: TogetherLLMOptions);
+    generate(messages: ConversationMessage[], options?: {
+        tools?: ToolRegistry;
+        temperature?: number;
+        maxTokens?: number;
+    }): AsyncGenerator<LLMChunk>;
+}
+
+interface FireworksLLMOptions {
+    apiKey?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+}
+declare class FireworksLLM implements LLM {
+    private _inner;
+    constructor(options?: FireworksLLMOptions);
+    generate(messages: ConversationMessage[], options?: {
+        tools?: ToolRegistry;
+        temperature?: number;
+        maxTokens?: number;
+    }): AsyncGenerator<LLMChunk>;
+}
+
+interface DeepSeekLLMOptions {
+    apiKey?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+}
+declare class DeepSeekLLM implements LLM {
+    private _inner;
+    constructor(options?: DeepSeekLLMOptions);
+    generate(messages: ConversationMessage[], options?: {
+        tools?: ToolRegistry;
+        temperature?: number;
+        maxTokens?: number;
+    }): AsyncGenerator<LLMChunk>;
+}
+
+interface XaiLLMOptions {
+    apiKey?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+}
+declare class XaiLLM implements LLM {
+    private _inner;
+    constructor(options?: XaiLLMOptions);
+    generate(messages: ConversationMessage[], options?: {
+        tools?: ToolRegistry;
+        temperature?: number;
+        maxTokens?: number;
+    }): AsyncGenerator<LLMChunk>;
+}
+
+/**
+ * MCP (Model Context Protocol) client for discovering and calling tools.
+ */
+
+interface MCPServerConfig {
+    /** Server type discriminator. */
+    type: 'stdio' | 'http';
+    [key: string]: unknown;
+}
+declare class MCPClient {
+    private _servers;
+    private _clients;
+    /** Add an MCP server configuration. */
+    addServer(name: string, config: MCPServerConfig & Record<string, unknown>): void;
+    /** Connect to all configured MCP servers and discover tools. */
+    connect(): Promise<FunctionTool[]>;
+    /** Disconnect from all MCP servers. */
+    disconnect(): Promise<void>;
+    private _connectServer;
+}
+
+export { type AgentEventType, AnthropicLLM, type AnthropicLLMOptions, AudioRecorder, type CallDirection, CallSession, type CallStatus, ClawOpsAgent, type ClawOpsAgentOptions, type ConversationMessage, DECODE_TABLE, DeepSeekLLM, type DeepSeekLLMOptions, DeepgramSTT, type DeepgramSTTOptions, ElevenLabsTTS, type ElevenLabsTTSOptions, FireworksLLM, type FireworksLLMOptions, type FunctionTool, GeminiLLM, type GeminiLLMOptions, GeminiRealtime, type GeminiRealtimeOptions, GroqLLM, type GroqLLMOptions, type LLM, type LLMChunk, MCPClient, type MCPServerConfig, type MCPServerHTTP, type MCPServerStdio, MistralLLM, type MistralLLMOptions, OllamaLLM, type OllamaLLMOptions, OpenAICompatLLM, type OpenAICompatLLMOptions, OpenAILLM, type OpenAILLMOptions, OpenAIRealtime, type OpenAIRealtimeOptions, type OpenAIToolDefinition, PerplexityLLM, type PerplexityLLMOptions, PipelineSession, type PipelineSessionOptions, type RecorderOptions, type STT, type Session, type SessionEventType, type SpeechEvent, type TTS, TogetherLLM, type TogetherLLMOptions, ToolRegistry, type TracingConfig, XaiLLM, type XaiLLMOptions, functionTool, getTracingConfig, mcpServerHTTP, mcpServerStdio, pcm16ToUlaw, resamplePcm16, resetTracingConfig, setTracingConfig, ulawToPcm16, zodToToolParams };