@band-ai/sdk 0.1.2

package/dist/CodexAdapter-A1k_LMdZ.d.ts

@@ -0,0 +1,1278 @@
+import { S as SimpleAdapter } from './simpleAdapter-9OE_p6QW.js';
+import { A as AdapterToolsProtocol, c as MessagingTools, T as ToolExecutor, f as ToolSchemaProvider, H as HistoryConverter, a as AgentToolsProtocol } from './protocols-DrhzOH6K.js';
+import { H as HistoryProvider, P as PlatformMessage } from './types-7jVzOeOP.js';
+import { L as Logger } from './logger-CABQOnlR.js';
+import { C as CustomToolDef } from './customTools-BzF0IISO.js';
+import { m as ToolModelMessage, n as ToolModelSchema, M as MetadataMap } from './dtos-DUpbIu8k.js';
+import { s as GoogleADKMessages, q as GoogleADKHistoryConverter, e as A2ASessionState, A as A2AAuth, G as GatewaySessionState, a as A2AGatewayAdapterOptions, n as ParlantMessages, P as ParlantHistoryConverter, t as OpencodeSessionState, O as OpencodeHistoryConverter } from './opencode-DthQQUsZ.js';
+import { c as createThenvoiMcpBackend } from './backends-C4n6cKOf.js';
+import { M as McpToolRegistration } from './claude-CcnQ5OUC.js';
+
+type GenericAdapterHandler = (args: {
+    message: PlatformMessage;
+    tools: AdapterToolsProtocol;
+    history: HistoryProvider;
+    participantsMessage: string | null;
+    contactsMessage: string | null;
+    isSessionBootstrap: boolean;
+    roomId: string;
+    agentName: string;
+    agentDescription: string;
+}) => Promise<void>;
+declare class GenericAdapter extends SimpleAdapter<HistoryProvider> {
+    private readonly handler;
+    constructor(handler: GenericAdapterHandler);
+    onMessage(message: PlatformMessage, tools: AdapterToolsProtocol, history: HistoryProvider, participantsMessage: string | null, contactsMessage: string | null, context: {
+        isSessionBootstrap: boolean;
+        roomId: string;
+    }): Promise<void>;
+}
+
+interface ToolCall {
+    id: string;
+    name: string;
+    input: MetadataMap;
+    inputParseError?: string;
+}
+interface ToolResult {
+    toolCallId: string;
+    name: string;
+    output: unknown;
+    isError?: boolean;
+}
+interface ToolCallingResponse {
+    text?: string;
+    toolCalls?: ToolCall[];
+}
+interface ToolRound {
+    toolCalls: ToolCall[];
+    toolResults: ToolResult[];
+}
+interface ToolCallingModelRequest {
+    systemPrompt?: string;
+    messages: ToolModelMessage[];
+    tools: ToolModelSchema[];
+    toolRounds?: ToolRound[];
+}
+interface ToolCallingModel {
+    complete(request: ToolCallingModelRequest): Promise<ToolCallingResponse>;
+}
+
+interface ToolCallingAdapterOptions {
+    model: ToolCallingModel;
+    toolFormat: "openai" | "anthropic";
+    systemPrompt?: string;
+    includeMemoryTools?: boolean;
+    maxToolRounds?: number;
+    enableExecutionReporting?: boolean;
+    customTools?: CustomToolDef[];
+    logger?: Logger;
+}
+type ToolCallingTools = MessagingTools & ToolExecutor & ToolSchemaProvider;
+declare class ToolCallingAdapter extends SimpleAdapter<HistoryProvider, ToolCallingTools> {
+    private readonly model;
+    private readonly toolFormat;
+    private readonly systemPrompt?;
+    private readonly includeMemoryTools;
+    private readonly maxToolRounds;
+    private readonly enableExecutionReporting;
+    private readonly customTools;
+    private readonly customToolIndex;
+    private readonly logger;
+    constructor(options: ToolCallingAdapterOptions);
+    onMessage(message: PlatformMessage, tools: ToolCallingTools, history: HistoryProvider, participantsMessage: string | null, contactsMessage: string | null, _context: {
+        isSessionBootstrap: boolean;
+        roomId: string;
+    }): Promise<void>;
+    private buildMessages;
+    private reportExecutionEvent;
+}
+declare function runSingleToolRound(model: ToolCallingModel, request: ToolCallingModelRequest): Promise<ToolCallingResponse>;
+
+interface VercelAISDKToolDefinition {
+    description?: string;
+    inputSchema: Record<string, unknown>;
+}
+type VercelAISDKGenerateText = (params: Record<string, unknown>) => Promise<Record<string, unknown>>;
+type VercelAISDKToolFactory = (definition: VercelAISDKToolDefinition) => unknown;
+interface VercelAISDKToolCallingModelOptions {
+    model: unknown;
+    generateText?: VercelAISDKGenerateText;
+    toolFactory?: VercelAISDKToolFactory;
+}
+declare class VercelAISDKToolCallingModel implements ToolCallingModel {
+    private readonly model;
+    private readonly generateTextOverride?;
+    private readonly toolFactoryOverride?;
+    private readonly runtimeLoader;
+    constructor(options: VercelAISDKToolCallingModelOptions);
+    complete(request: ToolCallingModelRequest): Promise<ToolCallingResponse>;
+}
+
+interface VercelAISDKAdapterOptions extends Omit<ToolCallingAdapterOptions, "toolFormat" | "model">, VercelAISDKToolCallingModelOptions {
+}
+declare class VercelAISDKAdapter extends ToolCallingAdapter {
+    constructor(options: VercelAISDKAdapterOptions);
+}
+
+interface OpenAIChatCompletionResponseLike {
+    choices?: Array<{
+        message?: {
+            content?: unknown;
+            tool_calls?: unknown;
+        };
+    }>;
+}
+interface OpenAIClientLike {
+    chat: {
+        completions: {
+            create(params: Record<string, unknown>): Promise<OpenAIChatCompletionResponseLike>;
+        };
+    };
+}
+type OpenAIClientFactory = (input: {
+    apiKey?: string;
+}) => Promise<OpenAIClientLike>;
+interface OpenAIToolCallingModelOptions {
+    model: string;
+    apiKey?: string;
+    clientFactory?: OpenAIClientFactory;
+}
+declare class OpenAIToolCallingModel implements ToolCallingModel {
+    private readonly model;
+    private readonly apiKey?;
+    private readonly clientFactory?;
+    private readonly clientLoader;
+    constructor(options: OpenAIToolCallingModelOptions);
+    complete(request: ToolCallingModelRequest): Promise<ToolCallingResponse>;
+    private getClient;
+}
+
+interface OpenAIAdapterOptions extends Omit<ToolCallingAdapterOptions, "toolFormat" | "model"> {
+    model?: ToolCallingModel;
+    openAIModel?: string;
+    apiKey?: string;
+    clientFactory?: OpenAIClientFactory;
+}
+declare class OpenAIAdapter extends ToolCallingAdapter {
+    constructor(options?: OpenAIAdapterOptions);
+}
+
+interface AnthropicMessageResponseLike {
+    content?: unknown;
+}
+interface AnthropicClientLike {
+    messages: {
+        create(params: Record<string, unknown>): Promise<AnthropicMessageResponseLike>;
+    };
+}
+type AnthropicClientFactory = (input: {
+    apiKey?: string;
+}) => Promise<AnthropicClientLike>;
+interface AnthropicToolCallingModelOptions {
+    model: string;
+    apiKey?: string;
+    maxTokens?: number;
+    clientFactory?: AnthropicClientFactory;
+}
+declare class AnthropicToolCallingModel implements ToolCallingModel {
+    private readonly model;
+    private readonly apiKey?;
+    private readonly maxTokens;
+    private readonly clientFactory?;
+    private readonly clientLoader;
+    constructor(options: AnthropicToolCallingModelOptions);
+    complete(request: ToolCallingModelRequest): Promise<ToolCallingResponse>;
+    private getClient;
+}
+
+interface AnthropicAdapterOptions extends Omit<ToolCallingAdapterOptions, "toolFormat" | "model"> {
+    model?: ToolCallingModel;
+    anthropicModel?: string;
+    apiKey?: string;
+    maxTokens?: number;
+    clientFactory?: AnthropicClientFactory;
+}
+declare class AnthropicAdapter extends ToolCallingAdapter {
+    constructor(options?: AnthropicAdapterOptions);
+}
+
+interface GeminiGenerateResponseLike {
+    text?: string;
+    functionCalls?: Array<{
+        id?: string;
+        name?: string;
+        args?: Record<string, unknown>;
+    }>;
+}
+interface GeminiClientLike {
+    models: {
+        generateContent(params: Record<string, unknown>): Promise<GeminiGenerateResponseLike>;
+    };
+}
+type GeminiClientFactory = (input: {
+    apiKey?: string;
+}) => Promise<GeminiClientLike>;
+interface GeminiToolCallingModelOptions {
+    model: string;
+    apiKey?: string;
+    clientFactory?: GeminiClientFactory;
+    partFactory?: {
+        createPartFromFunctionCall: (name: string, args: Record<string, unknown>) => unknown;
+        createPartFromFunctionResponse: (id: string, name: string, response: Record<string, unknown>) => unknown;
+    };
+}
+declare class GeminiToolCallingModel implements ToolCallingModel {
+    private readonly model;
+    private readonly apiKey?;
+    private readonly clientFactory?;
+    private readonly clientLoader;
+    private readonly partFactoryLoader;
+    private createPartFromFunctionCall;
+    private createPartFromFunctionResponse;
+    constructor(options: GeminiToolCallingModelOptions);
+    complete(request: ToolCallingModelRequest): Promise<ToolCallingResponse>;
+    private toGeminiTools;
+    private toGeminiContents;
+    private toBaseContent;
+    private toToolCalls;
+    private getClient;
+    private ensurePartFactories;
+}
+
+interface GeminiAdapterOptions extends Omit<ToolCallingAdapterOptions, "toolFormat" | "model"> {
+    model?: ToolCallingModel;
+    geminiModel?: string;
+    apiKey?: string;
+    clientFactory?: GeminiClientFactory;
+}
+declare class GeminiAdapter extends ToolCallingAdapter {
+    constructor(options?: GeminiAdapterOptions);
+}
+
+interface GoogleAdkFunctionCallLike {
+    id?: string;
+    name?: string;
+    args?: unknown;
+}
+interface GoogleAdkFunctionResponseLike {
+    id?: string;
+    name?: string;
+    response?: unknown;
+}
+interface GoogleAdkRunnerLike {
+    sessionService: {
+        createSession(params: {
+            appName: string;
+            userId: string;
+            sessionId: string;
+        }): Promise<unknown>;
+    };
+    runAsync(params: {
+        userId: string;
+        sessionId: string;
+        newMessage: {
+            role: "user";
+            parts: Array<{
+                text: string;
+            }>;
+        };
+    }): AsyncIterable<unknown>;
+}
+interface GoogleAdkSdkLike {
+    createAgent(params: {
+        name: string;
+        model: string;
+        instruction: string;
+        tools: unknown[];
+    }): unknown;
+    createFunctionTool(params: {
+        name: string;
+        description: string;
+        parameters?: Record<string, unknown>;
+        execute(input: unknown): Promise<unknown>;
+    }): unknown;
+    createRunner(params: {
+        agent: unknown;
+        appName: string;
+    }): GoogleAdkRunnerLike;
+    isFinalResponse(event: unknown): boolean;
+    getFunctionCalls(event: unknown): GoogleAdkFunctionCallLike[];
+    getFunctionResponses(event: unknown): GoogleAdkFunctionResponseLike[];
+    stringifyContent(event: unknown): string;
+}
+interface GoogleADKAdapterOptions {
+    model?: string;
+    systemPrompt?: string;
+    customSection?: string;
+    enableExecutionReporting?: boolean;
+    enableMemoryTools?: boolean;
+    historyConverter?: GoogleADKHistoryConverter;
+    additionalTools?: CustomToolDef[];
+    maxHistoryMessages?: number;
+    maxTranscriptChars?: number;
+    logger?: Logger;
+    sdkFactory?: () => Promise<GoogleAdkSdkLike>;
+}
+declare class GoogleADKAdapter extends SimpleAdapter<GoogleADKMessages, AdapterToolsProtocol> {
+    private readonly model;
+    private readonly systemPromptOverride?;
+    private readonly customSection;
+    private readonly enableExecutionReporting;
+    private readonly enableMemoryTools;
+    private readonly customTools;
+    private readonly maxHistoryMessages;
+    private readonly maxTranscriptChars;
+    private readonly logger;
+    private readonly historyConverterInstance;
+    private readonly sdkLoader;
+    private readonly roomHistory;
+    private readonly roomSessions;
+    private systemPrompt;
+    constructor(options?: GoogleADKAdapterOptions);
+    onStarted(agentName: string, agentDescription: string): Promise<void>;
+    onMessage(message: PlatformMessage, tools: AdapterToolsProtocol, history: GoogleADKMessages, participantsMessage: string | null, contactsMessage: string | null, context: {
+        isSessionBootstrap: boolean;
+        roomId: string;
+    }): Promise<void>;
+    onCleanup(roomId: string): Promise<void>;
+    private buildAgent;
+    private buildTools;
+    private buildPlatformTool;
+    private buildCustomTool;
+    private buildPrompt;
+    private formatIncomingMessage;
+    private reportExecutionEvent;
+}
+
+interface LangGraphGraph {
+    invoke?(input: Record<string, unknown>, config?: Record<string, unknown>): Promise<unknown>;
+    streamEvents?(input: Record<string, unknown>, config?: Record<string, unknown>, options?: Record<string, unknown>): AsyncIterable<unknown>;
+}
+interface LangGraphAdapterOptions {
+    llm?: unknown;
+    checkpointer?: unknown;
+    graph?: LangGraphGraph;
+    graphFactory?: (tools: unknown[]) => LangGraphGraph | Promise<LangGraphGraph>;
+    additionalTools?: unknown[];
+    systemPrompt?: string;
+    customSection?: string;
+    recursionLimit?: number;
+    maxHistoryMessages?: number;
+    emitExecutionEvents?: boolean;
+    includeMemoryTools?: boolean;
+    logger?: Logger;
+}
+declare class LangGraphAdapter extends SimpleAdapter<HistoryProvider, AdapterToolsProtocol> {
+    private readonly llm?;
+    private readonly checkpointer?;
+    private readonly graph?;
+    private readonly graphFactory?;
+    private readonly additionalTools;
+    private readonly systemPromptOverride?;
+    private readonly customSection;
+    private readonly recursionLimit;
+    private readonly maxHistoryMessages;
+    private readonly emitExecutionEvents;
+    private readonly includeMemoryTools;
+    private readonly logger;
+    private readonly sdkLoader;
+    private renderedSystemPrompt;
+    private readonly bootstrappedRooms;
+    constructor(options: LangGraphAdapterOptions);
+    onStarted(agentName: string, agentDescription: string): Promise<void>;
+    onMessage(message: PlatformMessage, tools: AdapterToolsProtocol, history: HistoryProvider, participantsMessage: string | null, contactsMessage: string | null, context: {
+        isSessionBootstrap: boolean;
+        roomId: string;
+    }): Promise<void>;
+    onCleanup(roomId: string): Promise<void>;
+    private resolveGraph;
+    private buildMessages;
+    private forwardStreamEvents;
+}
+
+interface A2AMessageSendParams {
+    message: {
+        kind: "message";
+        messageId: string;
+        role: "user";
+        parts: Array<{
+            kind: "text";
+            text: string;
+        }>;
+        contextId?: string;
+        taskId?: string;
+    };
+}
+interface A2AClientLike {
+    sendMessage(params: A2AMessageSendParams): Promise<unknown>;
+    sendMessageStream(params: A2AMessageSendParams): AsyncIterable<unknown>;
+    resubscribeTask?(params: {
+        id: string;
+    }): AsyncIterable<unknown>;
+}
+interface A2AAdapterOptions {
+    remoteUrl: string;
+    auth?: A2AAuth;
+    streaming?: boolean;
+    clientFactory?: A2AClientFactory;
+    maxStreamEvents?: number;
+    logger?: Logger;
+}
+type A2AClientFactory = (input: {
+    remoteUrl: string;
+    authHeaders: Record<string, string>;
+}) => Promise<A2AClientLike>;
+declare class A2AAdapter extends SimpleAdapter<A2ASessionState, MessagingTools> {
+    private readonly remoteUrl;
+    private readonly authHeaders;
+    private readonly streaming;
+    private readonly clientFactory?;
+    private readonly maxStreamEvents;
+    private readonly logger;
+    private client;
+    private readonly contexts;
+    private readonly tasks;
+    private readonly taskSenders;
+    constructor(options: A2AAdapterOptions);
+    onStarted(agentName: string, agentDescription: string): Promise<void>;
+    onMessage(message: PlatformMessage, tools: MessagingTools, history: A2ASessionState, _participantsMessage: string | null, _contactsMessage: string | null, context: {
+        isSessionBootstrap: boolean;
+        roomId: string;
+    }): Promise<void>;
+    onCleanup(roomId: string): Promise<void>;
+    private handleEvent;
+    private handleTaskEvent;
+    private handleStatusUpdateEvent;
+    private trackTask;
+    private clearTaskTracking;
+    private handleStateTransition;
+    private emitTaskEvent;
+    private toSendParams;
+    private rehydrateFromHistory;
+    private createClient;
+}
+
+declare class A2AGatewayAdapter extends SimpleAdapter<GatewaySessionState, MessagingTools> {
+    private readonly thenvoiRest;
+    private readonly gatewayUrl;
+    private readonly host;
+    private readonly port;
+    private readonly authToken?;
+    private readonly allowUnauthenticatedLoopback;
+    private readonly responseTimeoutMs;
+    private readonly peerPageSize;
+    private readonly maxPeerPages;
+    private readonly serverFactory;
+    private readonly peersBySlug;
+    private readonly peersById;
+    private readonly contextToRoom;
+    private readonly roomParticipants;
+    private readonly pendingByRoom;
+    private readonly pendingByTask;
+    private server;
+    constructor(options: A2AGatewayAdapterOptions);
+    onStarted(agentName: string, agentDescription: string): Promise<void>;
+    onMessage(message: PlatformMessage, _tools: MessagingTools, history: GatewaySessionState, _participantsMessage: string | null, _contactsMessage: string | null, context: {
+        isSessionBootstrap: boolean;
+        roomId: string;
+    }): Promise<void>;
+    onCleanup(roomId: string): Promise<void>;
+    stopGatewayServer(): Promise<void>;
+    onRuntimeStop(): Promise<void>;
+    private refreshPeers;
+    private handleGatewayRequest;
+    private cancelPendingTask;
+    private registerPending;
+    private resolvePendingForMessage;
+    private resolveGatewayPeer;
+    private resolveCanonicalPeerId;
+    private getOrCreateRoom;
+    private emitContextEvent;
+    private rehydrate;
+    private removePending;
+    private finalizePending;
+    private forgetRoom;
+    private resetState;
+}
+
+interface ParlantClientLike {
+    customers: {
+        create(params: {
+            id?: string;
+            name: string;
+            metadata?: Record<string, string | undefined>;
+        }, requestOptions?: {
+            headers?: Record<string, string>;
+        }): Promise<{
+            id: string;
+        }>;
+    };
+    sessions: {
+        create(params: {
+            agentId: string;
+            customerId?: string;
+            title?: string;
+            metadata?: Record<string, unknown>;
+        }, requestOptions?: {
+            headers?: Record<string, string>;
+        }): Promise<{
+            id: string;
+        }>;
+        createEvent(sessionId: string, params: {
+            kind: "message" | "status" | "tool" | "custom";
+            source: "customer" | "customer_ui" | "human_agent" | "human_agent_on_behalf_of_ai_agent" | "ai_agent" | "system";
+            message?: string;
+            data?: unknown;
+            moderation?: "auto" | "paranoid" | "none";
+            metadata?: Record<string, unknown>;
+        }, requestOptions?: {
+            headers?: Record<string, string>;
+        }): Promise<{
+            id: string;
+            offset: number;
+        }>;
+        listEvents(sessionId: string, params?: {
+            minOffset?: number;
+            source?: string;
+            kinds?: string;
+            waitForData?: number;
+        }, requestOptions?: {
+            headers?: Record<string, string>;
+        }): Promise<Array<Record<string, unknown>>>;
+    };
+}
+interface ParlantAdapterOptions {
+    environment: string;
+    baseUrl?: string;
+    agentId: string;
+    apiKey?: string;
+    headers?: Record<string, string>;
+    systemPrompt?: string;
+    customSection?: string;
+    includeBaseInstructions?: boolean;
+    responseTimeoutSeconds?: number;
+    maxHistoryMessages?: number;
+    historyConverter?: ParlantHistoryConverter;
+    clientFactory?: ParlantClientFactory;
+    logger?: Logger;
+}
+type ParlantClientFactory = () => Promise<ParlantClientLike>;
+declare class ParlantAdapter extends SimpleAdapter<ParlantMessages, MessagingTools> {
+    private readonly environment;
+    private readonly baseUrl?;
+    private readonly agentId;
+    private readonly apiKey?;
+    private readonly headers;
+    private readonly systemPromptOverride?;
+    private readonly customSection?;
+    private readonly includeBaseInstructions;
+    private readonly responseTimeoutSeconds;
+    private readonly maxHistoryMessages;
+    private readonly clientFactory?;
+    private readonly logger;
+    private readonly clientLoader;
+    private lastInitFailure;
+    private systemPrompt;
+    private readonly roomSessions;
+    private readonly roomCustomers;
+    private readonly bootstrappedRooms;
+    private readonly roomSessionInitPromises;
+    private readonly roomBootstrapInitPromises;
+    constructor(options: ParlantAdapterOptions);
+    onStarted(agentName: string, agentDescription: string): Promise<void>;
+    onMessage(message: PlatformMessage, tools: MessagingTools, history: ParlantMessages, participantsMessage: string | null, contactsMessage: string | null, context: {
+        isSessionBootstrap: boolean;
+        roomId: string;
+    }): Promise<void>;
+    onCleanup(roomId: string): Promise<void>;
+    private getOrCreateSession;
+    private ensureBootstrapHistory;
+    private getOrCreateCustomer;
+    private injectHistory;
+    private waitForAiResponse;
+    private requestOptions;
+    private ensureClient;
+    private createClient;
+}
+
+interface LettaMessage {
+    role: "user" | "assistant";
+    content: string;
+    sender: string;
+    senderType: string;
+}
+type LettaMessages = LettaMessage[];
+declare class LettaHistoryConverter implements HistoryConverter<LettaMessages> {
+    convert(raw: Array<Record<string, unknown>>): LettaMessages;
+}
+
+interface LettaResponseMessage {
+    id?: string;
+    date?: string;
+    message_type: string;
+    content?: string | Array<{
+        text: string;
+    }>;
+    reasoning?: string;
+    tool_call?: {
+        name: string;
+        arguments: string;
+        tool_call_id: string;
+    };
+    tool_return?: string;
+    status?: string;
+    tool_call_id?: string;
+}
+interface LettaResponse {
+    messages: LettaResponseMessage[];
+    stop_reason: {
+        stop_reason: string;
+    };
+    usage?: Record<string, unknown>;
+}
+interface LettaAgentCreateParams {
+    name?: string;
+    model?: string;
+    embedding?: string;
+    system?: string;
+    memory_blocks?: Array<{
+        label: string;
+        value: string;
+    }>;
+    tools?: string[];
+    include_base_tools?: boolean;
+    context_window_limit?: number;
+}
+interface LettaToolReturn {
+    status: "success" | "error";
+    tool_call_id: string;
+    tool_return: string;
+}
+interface LettaToolReturnCreate {
+    type: "tool_return";
+    tool_returns: LettaToolReturn[];
+}
+interface LettaMessageCreateParams {
+    messages?: Array<{
+        role: string;
+        content: string;
+        tool_call_id?: string;
+    } | LettaToolReturnCreate>;
+    input?: string;
+    client_tools?: Array<{
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    }>;
+    max_steps?: number;
+}
+interface LettaRequestOptions {
+    signal?: AbortSignal | null;
+}
+interface LettaClientLike {
+    agents: {
+        create(params: LettaAgentCreateParams, options?: LettaRequestOptions): Promise<{
+            id: string;
+        }>;
+        delete?(agentId: string): Promise<void>;
+        messages: {
+            create(agentId: string, params: LettaMessageCreateParams, options?: LettaRequestOptions): Promise<LettaResponse>;
+        };
+    };
+}
+type LettaClientFactory = () => Promise<LettaClientLike>;
+interface LettaAdapterOptions {
+    model?: string;
+    lettaApiKey?: string;
+    lettaBaseUrl?: string;
+    lettaAgentId?: string;
+    embedding?: string;
+    memoryBlocks?: Array<{
+        label: string;
+        value: string;
+    }>;
+    serverTools?: string[];
+    includeBaseTools?: boolean;
+    contextWindowLimit?: number;
+    maxToolRounds?: number;
+    responseTimeoutSeconds?: number;
+    systemPrompt?: string;
+    customSection?: string;
+    includeBaseInstructions?: boolean;
+    maxHistoryMessages?: number;
+    emitReasoningEvents?: boolean;
+    historyConverter?: LettaHistoryConverter;
+    clientFactory?: LettaClientFactory;
+    logger?: Logger;
+}
+declare class LettaAdapter extends SimpleAdapter<LettaMessages, AdapterToolsProtocol> {
+    private readonly model;
+    private readonly lettaApiKey?;
+    private readonly lettaBaseUrl?;
+    private readonly sharedLettaAgentId?;
+    private readonly embedding?;
+    private readonly memoryBlocks;
+    private readonly serverTools;
+    private readonly includeBaseTools;
+    private readonly contextWindowLimit?;
+    private readonly maxToolRounds;
+    private readonly responseTimeoutSeconds;
+    private readonly systemPromptOverride?;
+    private readonly customSection?;
+    private readonly includeBaseInstructions;
+    private readonly maxHistoryMessages;
+    private readonly emitReasoningEvents;
+    private readonly clientFactory?;
+    private readonly logger;
+    private readonly clientLoader;
+    private systemPrompt;
+    private readonly roomAgents;
+    private readonly bootstrappedRooms;
+    private readonly roomAgentInitPromises;
+    private readonly roomBootstrapInitPromises;
+    private readonly cleaningUpRooms;
+    private readonly roomAbortControllers;
+    private readonly roomBootstrapFailures;
+    constructor(options?: LettaAdapterOptions);
+    onStarted(agentName: string, agentDescription: string): Promise<void>;
+    onMessage(message: PlatformMessage, tools: AdapterToolsProtocol, history: LettaMessages, participantsMessage: string | null, contactsMessage: string | null, context: {
+        isSessionBootstrap: boolean;
+        roomId: string;
+    }): Promise<void>;
+    onCleanup(roomId: string): Promise<void>;
+    private getRoomAbortSignal;
+    private getOrCreateAgent;
+    private ensureBootstrapHistory;
+    private injectHistory;
+    private executeWithToolLoop;
+    private executeToolCalls;
+    private raceTimeout;
+    private timedMessageCreate;
+    private emitReasoning;
+    private ensureClient;
+    private createClient;
+}
+
+interface OpencodeClientLike {
+    createSession(input?: {
+        title?: string;
+    }): Promise<Record<string, unknown>>;
+    getSession(sessionId: string): Promise<Record<string, unknown>>;
+    promptAsync(sessionId: string, input: {
+        parts: Array<Record<string, unknown>>;
+        system?: string;
+        model?: Record<string, string>;
+        agent?: string;
+        variant?: string;
+    }): Promise<void>;
+    replyPermission(sessionId: string, permissionId: string, input: {
+        response: string;
+    }): Promise<void>;
+    replyQuestion(requestId: string, input: {
+        answers: string[][];
+    }): Promise<void>;
+    rejectQuestion(requestId: string): Promise<void>;
+    abortSession(sessionId: string): Promise<void>;
+    registerMcpServer(input: {
+        name: string;
+        url: string;
+    }): Promise<Record<string, unknown>>;
+    deregisterMcpServer(name: string): Promise<void>;
+    iterEvents(): AsyncIterable<Record<string, unknown>>;
+    close(): Promise<void>;
+}
+interface HttpOpencodeClientOptions {
+    baseUrl: string;
+    directory?: string;
+    workspace?: string;
+    timeoutMs?: number;
+}
+interface RequestResultLike<TData = unknown> {
+    data?: TData;
+    error?: unknown;
+    request: Request;
+    response: Response;
+}
+interface OpencodeEventStream {
+    stream: AsyncIterable<unknown>;
+}
+interface OpencodeSdkClientLike {
+    session: {
+        create(parameters?: Record<string, unknown>): Promise<RequestResultLike>;
+        get(parameters: Record<string, unknown>): Promise<RequestResultLike>;
+        promptAsync(parameters: Record<string, unknown>): Promise<RequestResultLike>;
+        abort(parameters: Record<string, unknown>): Promise<RequestResultLike>;
+    };
+    permission: {
+        reply(parameters: Record<string, unknown>): Promise<RequestResultLike>;
+    };
+    question: {
+        reply(parameters: Record<string, unknown>): Promise<RequestResultLike>;
+        reject(parameters: Record<string, unknown>): Promise<RequestResultLike>;
+    };
+    mcp: {
+        add(parameters: Record<string, unknown>): Promise<RequestResultLike>;
+        disconnect(parameters: Record<string, unknown>): Promise<RequestResultLike>;
+    };
+    event: {
+        subscribe(parameters?: Record<string, unknown>, options?: Record<string, unknown>): Promise<OpencodeEventStream>;
+    };
+}
+interface OpencodeServerHandle {
+    url: string;
+    close(): void;
+}
+interface LoadedOpencodeSdk {
+    createClient(config: Record<string, unknown>): OpencodeSdkClientLike;
+    createServer(options: Record<string, unknown>): Promise<OpencodeServerHandle>;
+}
+interface ClientRuntime {
+    baseUrl: string;
+    client: OpencodeSdkClientLike;
+    close(): void;
+}
+declare class HttpStatusError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(status: number, body: unknown);
+}
+declare abstract class SdkOpencodeClientBase implements OpencodeClientLike {
+    private readonly runtimePromise;
+    private readonly eventsAbortController;
+    private closed;
+    protected readonly directory?: string;
+    protected readonly workspace?: string;
+    protected constructor(options: {
+        directory?: string;
+        workspace?: string;
+    });
+    createSession(input?: {
+        title?: string;
+    }): Promise<Record<string, unknown>>;
+    getSession(sessionId: string): Promise<Record<string, unknown>>;
+    promptAsync(sessionId: string, input: {
+        parts: Array<Record<string, unknown>>;
+        system?: string;
+        model?: Record<string, string>;
+        agent?: string;
+        variant?: string;
+    }): Promise<void>;
+    replyPermission(_sessionId: string, permissionId: string, input: {
+        response: string;
+    }): Promise<void>;
+    replyQuestion(requestId: string, input: {
+        answers: string[][];
+    }): Promise<void>;
+    rejectQuestion(requestId: string): Promise<void>;
+    abortSession(sessionId: string): Promise<void>;
+    registerMcpServer(input: {
+        name: string;
+        url: string;
+    }): Promise<Record<string, unknown>>;
+    deregisterMcpServer(name: string): Promise<void>;
+    iterEvents(): AsyncIterable<Record<string, unknown>>;
+    close(): Promise<void>;
+    protected abstract createRuntime(): Promise<ClientRuntime>;
+    protected loadSdk(): Promise<LoadedOpencodeSdk>;
+    protected createSdkClient(sdk: LoadedOpencodeSdk, baseUrl: string): OpencodeSdkClientLike;
+    private getRuntime;
+    private scope;
+    private deleteMcpServer;
+}
+declare class HttpOpencodeClient extends SdkOpencodeClientBase {
+    private readonly baseUrl;
+    constructor(options: HttpOpencodeClientOptions);
+    protected createRuntime(): Promise<ClientRuntime>;
+}
+
+type OpencodeApprovalMode = "manual" | "auto_accept" | "auto_decline";
+type OpencodeQuestionMode = "manual" | "auto_reject";
+type OpencodeApprovalReply = "once" | "always" | "reject";
+interface OpencodeAdapterConfig {
+    baseUrl?: string;
+    directory?: string;
+    workspace?: string;
+    providerId?: string;
+    modelId?: string;
+    agent?: string;
+    variant?: string;
+    customSection?: string;
+    includeBaseInstructions?: boolean;
+    enableTaskEvents?: boolean;
+    enableExecutionReporting?: boolean;
+    enableMemoryTools?: boolean;
+    fallbackSendAgentText?: boolean;
+    turnTimeoutMs?: number;
+    approvalMode?: OpencodeApprovalMode;
+    approvalWaitTimeoutMs?: number;
+    approvalTimeoutReply?: OpencodeApprovalReply;
+    questionMode?: OpencodeQuestionMode;
+    questionWaitTimeoutMs?: number;
+    sessionTitlePrefix?: string;
+    mcpServerName?: string;
+}
+interface OpencodeAdapterOptions {
+    config?: OpencodeAdapterConfig;
+    customTools?: CustomToolDef[];
+    historyConverter?: OpencodeHistoryConverter;
+    clientFactory?: (config: Required<OpencodeAdapterConfig>) => OpencodeClientLike;
+    mcpBackendFactory?: typeof createThenvoiMcpBackend;
+    logger?: Logger;
+}
+declare class OpencodeAdapter extends SimpleAdapter<OpencodeSessionState, AdapterToolsProtocol> {
+    private readonly config;
+    private readonly customTools;
+    private readonly clientFactory;
+    private readonly mcpBackendFactory;
+    private readonly logger;
+    private readonly rooms;
+    private readonly roomBySession;
+    private client;
+    private eventTask;
+    private mcpBackend;
+    private systemPrompt;
+    constructor(options?: OpencodeAdapterOptions);
+    onStarted(agentName: string, agentDescription: string): Promise<void>;
+    onRuntimeStop(): Promise<void>;
+    onMessage(message: PlatformMessage, tools: AdapterToolsProtocol, history: OpencodeSessionState, participantsMessage: string | null, contactsMessage: string | null, context: {
+        isSessionBootstrap: boolean;
+        roomId: string;
+    }): Promise<void>;
+    onCleanup(roomId: string): Promise<void>;
+    private getOrCreateRoomState;
+    private ensureClientStarted;
+    private ensureMcpBackend;
+    private registerMcpBackend;
+    private shutdownClient;
+    private runEventLoop;
+    private handleEvent;
+    private roomStateForEvent;
+    private extractSessionId;
+    private handlePartUpdate;
+    private handlePartDelta;
+    private handlePermissionAsked;
+    private handleQuestionAsked;
+    private handleControlMessage;
+    private replyPermission;
+    private replyQuestion;
+    private rejectQuestion;
+    private expirePermission;
+    private expireQuestion;
+    private cancelPendingTimeout;
+    private ensureSession;
+    private beginTurn;
+    private watchTurnCompletion;
+    private releaseTurnWait;
+    private finishTurn;
+    private clearTurnState;
+    private emitSessionTaskEvent;
+    private deliverFallbackText;
+    private reportToolCall;
+    private reportToolResult;
+    private buildSessionTitle;
+    private buildModelPayload;
+    private buildPromptParts;
+    private parsePermissionReply;
+    private parseQuestionAnswers;
+    private formatQuestionPrompt;
+    private formatError;
+    private formatOpenCodeError;
+}
+
+type ClaudePermissionMode = "default" | "acceptEdits" | "bypassPermissions" | "plan" | "dontAsk";
+interface ClaudeAssistantTextBlock {
+    type?: string;
+    text?: string;
+}
+interface ClaudeAssistantMessage {
+    content: ClaudeAssistantTextBlock[];
+}
+interface ClaudeSDKMessageLike {
+    type: string;
+    session_id?: string;
+    subtype?: string;
+    result?: unknown;
+    summary?: string;
+    message?: ClaudeAssistantMessage;
+    [key: string]: unknown;
+}
+interface ClaudeQueryOptions {
+    model?: string;
+    permissionMode?: ClaudePermissionMode;
+    systemPrompt?: string;
+    allowDangerouslySkipPermissions?: boolean;
+    maxThinkingTokens?: number;
+    cwd?: string;
+    resume?: string;
+    mcpServers?: Record<string, unknown>;
+    allowedTools?: string[];
+}
+interface ClaudeSDKQueryParams {
+    prompt: string;
+    options?: ClaudeQueryOptions;
+}
+type ClaudeSDKQuery = (params: ClaudeSDKQueryParams) => AsyncIterable<ClaudeSDKMessageLike>;
+interface ClaudeSDKAdapterOptions {
+    model?: string;
+    customSection?: string;
+    includeBaseInstructions?: boolean;
+    maxThinkingTokens?: number;
+    permissionMode?: ClaudePermissionMode;
+    enableExecutionReporting?: boolean;
+    enableMemoryTools?: boolean;
+    enableMcpTools?: boolean;
+    additionalMcpTools?: McpToolRegistration[];
+    cwd?: string;
+    queryFn?: ClaudeSDKQuery;
+    logger?: Logger;
+}
+declare class ClaudeSDKAdapter extends SimpleAdapter<HistoryProvider, AdapterToolsProtocol> {
+    private readonly model;
+    private readonly customSection?;
+    private readonly includeBaseInstructions;
+    private readonly maxThinkingTokens?;
+    private readonly permissionMode;
+    private readonly enableExecutionReporting;
+    private readonly enableMemoryTools;
+    private readonly enableMcpTools;
+    private readonly additionalMcpTools;
+    private readonly cwd?;
+    private readonly queryFnOverride?;
+    private readonly logger;
+    private readonly sessionIds;
+    private readonly sessionInitLocks;
+    private readonly roomTools;
+    private mcpBridge;
+    private systemPrompt;
+    constructor(options?: ClaudeSDKAdapterOptions);
+    onStarted(agentName: string, agentDescription: string): Promise<void>;
+    onMessage(message: PlatformMessage, tools: AdapterToolsProtocol, history: HistoryProvider, participantsMessage: string | null, contactsMessage: string | null, context: {
+        isSessionBootstrap: boolean;
+        roomId: string;
+    }): Promise<void>;
+    private doMessage;
+    onCleanup(roomId: string): Promise<void>;
+    private reportSessionId;
+}
+
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type RequestId = number | string;
+type CodexApprovalPolicy = "never" | "on-request" | "on-failure" | "untrusted" | {
+    reject: {
+        sandbox_approval: boolean;
+        rules: boolean;
+        mcp_elicitations: boolean;
+    };
+};
+type CodexSandboxMode = "read-only" | "workspace-write" | "danger-full-access";
+type CodexReasoningSummary = "auto" | "concise" | "detailed" | "none";
+interface DynamicToolSpec {
+    name: string;
+    description: string;
+    inputSchema: JsonValue;
+}
+interface InitializeParams {
+    clientInfo: {
+        name: string;
+        title: string;
+        version: string;
+    };
+    capabilities: {
+        experimentalApi: boolean;
+        optOutNotificationMethods?: string[] | null;
+    } | null;
+}
+interface TextUserInput {
+    type: "text";
+    text: string;
+}
+interface LocalImageUserInput {
+    type: "local_image";
+    path: string;
+}
+type UserInput = TextUserInput | LocalImageUserInput;
+interface TurnStartParams {
+    threadId: string;
+    input: UserInput[];
+    cwd?: string | null;
+    approvalPolicy?: CodexApprovalPolicy | null;
+    model?: string | null;
+    effort?: "none" | "low" | "medium" | "high" | "xhigh" | null;
+    summary?: CodexReasoningSummary | null;
+}
+interface DynamicToolCallParams {
+    threadId: string;
+    turnId: string;
+    callId: string;
+    tool: string;
+    arguments: JsonValue;
+}
+interface DynamicToolCallOutputContentItem {
+    type: "inputText" | "inputImage";
+    text?: string;
+    imageUrl?: string;
+}
+interface DynamicToolCallResponse {
+    contentItems: DynamicToolCallOutputContentItem[];
+    success: boolean;
+}
+
+interface CodexRpcRequestEvent {
+    kind: "request";
+    id: RequestId;
+    method: string;
+    params: unknown;
+}
+interface CodexRpcNotificationEvent {
+    kind: "notification";
+    method: string;
+    params: unknown;
+}
+type CodexRpcEvent = CodexRpcRequestEvent | CodexRpcNotificationEvent;
+interface CodexClientLike {
+    connect(): Promise<void>;
+    initialize(params: InitializeParams): Promise<void>;
+    request<TResult>(method: string, params?: Record<string, unknown>): Promise<TResult>;
+    notify(method: string, params?: Record<string, unknown>): Promise<void>;
+    respond(requestId: RequestId, result: Record<string, unknown> | DynamicToolCallResponse): Promise<void>;
+    respondError(requestId: RequestId, code: number, message: string, data?: unknown): Promise<void>;
+    recvEvent(timeoutMs?: number): Promise<CodexRpcEvent>;
+    close(): Promise<void>;
+}
+declare class CodexJsonRpcError extends Error {
+    readonly code: number;
+    readonly data: unknown;
+    constructor(code: number, message: string, data?: unknown);
+}
+declare class CodexAppServerStdioClient implements CodexClientLike {
+    private readonly command;
+    private readonly cwd?;
+    private readonly env?;
+    private readonly logger;
+    private process;
+    private stdoutLines;
+    private events;
+    private waiters;
+    private pending;
+    private nextRequestId;
+    private closed;
+    constructor(options?: {
+        command?: readonly string[];
+        cwd?: string;
+        env?: Record<string, string>;
+        logger?: Logger;
+    });
+    connect(): Promise<void>;
+    initialize(params: InitializeParams): Promise<void>;
+    request<TResult>(method: string, params?: Record<string, unknown>): Promise<TResult>;
+    notify(method: string, params?: Record<string, unknown>): Promise<void>;
+    respond(requestId: RequestId, result: Record<string, unknown> | DynamicToolCallResponse): Promise<void>;
+    respondError(requestId: RequestId, code: number, message: string, data?: unknown): Promise<void>;
+    recvEvent(timeoutMs?: number): Promise<CodexRpcEvent>;
+    close(): Promise<void>;
+    private sendJson;
+    private handleLine;
+    private pushEvent;
+    private removeWaiter;
+    private failAll;
+}
+
+declare const CODEX_WEB_SEARCH_MODES: readonly ["disabled", "cached", "live"];
+type CodexWebSearchMode = (typeof CODEX_WEB_SEARCH_MODES)[number];
+declare const CODEX_REASONING_SUMMARIES: readonly ["auto", "concise", "detailed", "none"];
+declare const CODEX_REASONING_EFFORTS: readonly ["low", "medium", "high", "xhigh"];
+type CodexReasoningEffort = (typeof CODEX_REASONING_EFFORTS)[number];
+interface CodexAdapterConfig {
+    model?: string;
+    cwd?: string;
+    approvalPolicy?: CodexApprovalPolicy;
+    sandboxMode?: CodexSandboxMode;
+    reasoningEffort?: CodexReasoningEffort;
+    reasoningSummary?: CodexReasoningSummary;
+    networkAccessEnabled?: boolean;
+    webSearchMode?: CodexWebSearchMode;
+    skipGitRepoCheck?: boolean;
+    enableExecutionReporting?: boolean;
+    emitThoughtEvents?: boolean;
+    maxHistoryMessages?: number;
+    enableLocalCommands?: boolean;
+    includeBaseInstructions?: boolean;
+    debug?: boolean;
+    customSection?: string;
+    /**
+     * Full system prompt override.
+     * When set, this bypasses the default Thenvoi prompt template + customSection.
+     */
+    systemPrompt?: string;
+    experimentalApi?: boolean;
+    fallbackSendAgentText?: boolean;
+    clientName?: string;
+    clientTitle?: string;
+    clientVersion?: string;
+    turnTimeoutMs?: number;
+    codexCommand?: readonly string[];
+    codexEnv?: Record<string, string>;
+}
+interface CodexFactory {
+    (): Promise<CodexClientLike>;
+}
+interface CodexAdapterOptions {
+    config?: CodexAdapterConfig;
+    customTools?: CustomToolDef[];
+    includeMemoryTools?: boolean;
+    factory?: CodexFactory;
+    logger?: Logger;
+}
+declare class CodexAdapter extends SimpleAdapter<HistoryProvider, AgentToolsProtocol> {
+    private readonly baseConfig;
+    private readonly roomConfigOverrides;
+    private readonly customTools;
+    private readonly customToolIndex;
+    private readonly includeMemoryTools;
+    private readonly factoryOverride?;
+    private readonly logger;
+    private readonly debugEnabled;
+    private client;
+    private clientPromise;
+    private lastInitFailure;
+    private readonly roomThreadIds;
+    private readonly roomThreadInitPromises;
+    private readonly needsHistoryInjection;
+    private systemPrompt;
+    constructor(options?: CodexAdapterOptions);
+    onStarted(agentName: string, agentDescription: string): Promise<void>;
+    onMessage(message: PlatformMessage, tools: AgentToolsProtocol, history: HistoryProvider, participantsMessage: string | null, contactsMessage: string | null, context: {
+        isSessionBootstrap: boolean;
+        roomId: string;
+    }): Promise<void>;
+    onCleanup(roomId: string): Promise<void>;
+    onRuntimeStop(): Promise<void>;
+    private getConfig;
+    private ensureSystemPrompt;
+    private ensureClient;
+    private resetClient;
+    private debug;
+    private getOrCreateThread;
+    private buildThreadStartParams;
+    private buildThreadResumeParams;
+    private buildThreadConfigOverrides;
+    private buildDynamicTools;
+    private buildTurnInput;
+    private formatHistoryContext;
+    private sendThreadMappingEvent;
+    private handleServerRequest;
+    private emitItemCompletedEvents;
+    private extractToolItem;
+    private extractThoughtText;
+    private emitTurnOutcome;
+    private extractTurnError;
+    private currentMention;
+    private handleLocalCommand;
+    private safeSendEvent;
+}
+
+export { type DynamicToolSpec as $, A2AAdapter as A, OpencodeAdapter as B, CODEX_REASONING_EFFORTS as C, type OpencodeAdapterConfig as D, type OpencodeApprovalMode as E, type OpencodeApprovalReply as F, GeminiAdapter as G, type OpencodeQuestionMode as H, type ParlantAdapterOptions as I, type VercelAISDKAdapterOptions as J, type A2AClientFactory as K, LangGraphAdapter as L, type A2AClientLike as M, type AnthropicClientFactory as N, OpenAIAdapter as O, ParlantAdapter as P, AnthropicToolCallingModel as Q, type AnthropicToolCallingModelOptions as R, type ClaudeSDKQuery as S, type ToolCallingModel as T, type ClaudeSDKQueryParams as U, VercelAISDKAdapter as V, CodexAppServerStdioClient as W, type CodexClientLike as X, CodexJsonRpcError as Y, type DynamicToolCallParams as Z, type DynamicToolCallResponse as _, type A2AAdapterOptions as a, type GeminiClientFactory as a0, GeminiToolCallingModel as a1, type GeminiToolCallingModelOptions as a2, HttpOpencodeClient as a3, type HttpOpencodeClientOptions as a4, HttpStatusError as a5, type LettaAgentCreateParams as a6, type LettaClientFactory as a7, type LettaClientLike as a8, LettaHistoryConverter as a9, type LettaMessage as aa, type LettaMessageCreateParams as ab, type LettaMessages as ac, type LettaRequestOptions as ad, type LettaResponse as ae, type LettaResponseMessage as af, type OpenAIClientFactory as ag, OpenAIToolCallingModel as ah, type OpenAIToolCallingModelOptions as ai, type OpencodeClientLike as aj, type ParlantClientFactory as ak, type ParlantClientLike as al, type ToolCall as am, ToolCallingAdapter as an, type ToolCallingAdapterOptions as ao, type ToolCallingModelRequest as ap, type ToolCallingResponse as aq, type ToolResult as ar, type TurnStartParams as as, VercelAISDKToolCallingModel as at, type VercelAISDKToolCallingModelOptions as au, runSingleToolRound as av, A2AGatewayAdapter as b, AnthropicAdapter as c, type AnthropicAdapterOptions as d, CODEX_REASONING_SUMMARIES as e, CODEX_WEB_SEARCH_MODES as f, type ClaudePermissionMode as g, ClaudeSDKAdapter as h, type ClaudeSDKAdapterOptions as i, CodexAdapter as j, type CodexAdapterConfig as k, type CodexApprovalPolicy as l, type CodexReasoningEffort as m, type CodexReasoningSummary as n, type CodexSandboxMode as o, type CodexWebSearchMode as p, type GeminiAdapterOptions as q, GenericAdapter as r, type GenericAdapterHandler as s, GoogleADKAdapter as t, type GoogleADKAdapterOptions as u, type LangGraphAdapterOptions as v, type LangGraphGraph as w, LettaAdapter as x, type LettaAdapterOptions as y, type OpenAIAdapterOptions as z };