@mozaik-ai/core 3.13.0 → 3.14.0

package/dist/index.d.ts

@@ -1,10 +1,6 @@
-import OpenAI from 'openai';
-import Anthropic from '@anthropic-ai/sdk';
-
 declare abstract class ContextItem {
     abstract readonly type: string;
     getType(): string;
-    abstract toJSON(): any;
 }
 
 declare class ModelContext {
@@ -22,7 +18,6 @@ declare class ModelContext {
         projectId: string;
         items: ContextItem[];
     }): ModelContext;
-    toJSON(): any;
 }
 
 declare abstract class ItemContent {
@@ -37,7 +32,6 @@ declare class InputText extends ItemContent {
     static rehydrate(data: {
         text: string;
     }): InputText;
-    toJSON(): any[];
 }
 
 declare class UserMessageItem extends ContextItem {
@@ -49,7 +43,6 @@ declare class UserMessageItem extends ContextItem {
     static rehydrate(data: {
         text: string;
     }): UserMessageItem;
-    toJSON(): any;
 }
 
 declare class DeveloperMessageItem extends ContextItem {
@@ -57,7 +50,6 @@ declare class DeveloperMessageItem extends ContextItem {
     readonly role = "developer";
     readonly content: InputText;
     private constructor();
-    toJSON(): any;
     static create(text: string): DeveloperMessageItem;
     static rehydrate(data: {
         text: string;
@@ -71,7 +63,6 @@ declare class OutputText extends ItemContent {
     static rehydrate(data: {
         text: string;
     }): OutputText;
-    toJSON(): any[];
 }
 
 declare class ModelMessageItem extends ContextItem {
@@ -82,7 +73,6 @@ declare class ModelMessageItem extends ContextItem {
     static rehydrate(data: {
         text: string;
     }): ModelMessageItem;
-    toJSON(): any;
 }
 
 declare class FunctionCallItem extends ContextItem {
@@ -96,7 +86,6 @@ declare class FunctionCallItem extends ContextItem {
         name: string;
         args: string;
     }): FunctionCallItem;
-    toJSON(): any;
 }
 
 declare class SummaryText extends ItemContent {
@@ -106,7 +95,6 @@ declare class SummaryText extends ItemContent {
     static rehydrate(data: {
         text: string;
     }): SummaryText;
-    toJSON(): Record<string, any>;
 }
 
 declare class ReasoningItem extends ContextItem {
@@ -120,28 +108,6 @@ declare class ReasoningItem extends ContextItem {
         encryptedContent: string | undefined;
         summary: SummaryText[];
     }): ReasoningItem;
-    toJSON(): any;
-}
-
-interface ReasoningEffort<Effort extends string> {
-    setReasoningEffort(effort: Effort): void;
-    getReasoningEffort(): Effort;
-}
-
-interface StreamingCapability {
-    setStreaming(streaming: boolean): void;
-    getStreaming(): boolean;
-}
-
-type StructuredOutputFormat = {
-    name?: string;
-    schema: Record<string, any>;
-    strict?: boolean;
-};
-interface StructuredOutputCapability {
-    setStructuredOutput(format: StructuredOutputFormat | undefined): void;
-    getStructuredOutput(): StructuredOutputFormat | undefined;
-    hasStructuredOutput(): boolean;
 }
 
 interface FunctionTool {
@@ -154,26 +120,6 @@ interface FunctionTool {
 }
 type Tool = FunctionTool;
 
-interface ToolCallingCapability {
-    setTools(tools: Tool[]): void;
-    getTools(): Tool[];
-}
-
-type ModelSpecification = {
-    name: string;
-    provider: string;
-    supportReasoningEffort: boolean;
-    defaultReasoningEffort: string | undefined;
-    supportStreaming: boolean;
-    contextWindowSize: number;
-    maxOutputTokens: number;
-    supportFunctionCalling: boolean;
-    supportStructuredOutput: boolean;
-};
-interface GenerativeModel extends ReasoningEffort<string>, ToolCallingCapability, StreamingCapability, StructuredOutputCapability {
-    readonly specification: ModelSpecification;
-}
-
 declare class FunctionCallOutputItem extends ContextItem {
     readonly type = "function_call_output";
     readonly callId: string;
@@ -184,134 +130,6 @@ declare class FunctionCallOutputItem extends ContextItem {
         callId: string;
         output: InputText;
     }): FunctionCallOutputItem;
-    toJSON(): any;
-}
-
-interface ModelContextRepository {
-    save(context: ModelContext): Promise<void>;
-    get(id: string): Promise<ModelContext>;
-    getByProjectId(projectId: string): Promise<ModelContext[]>;
-}
-
-type OpenAIReasoningEffortType = "xhigh" | "high" | "medium" | "low" | "none";
-
-declare class Gpt54Nano implements GenerativeModel {
-    readonly specification: {
-        name: string;
-        provider: string;
-        supportReasoningEffort: boolean;
-        defaultReasoningEffort: OpenAIReasoningEffortType;
-        supportStreaming: boolean;
-        contextWindowSize: number;
-        maxOutputTokens: number;
-        supportFunctionCalling: boolean;
-        supportStructuredOutput: boolean;
-    };
-    private tools;
-    private streaming;
-    private structuredOutput;
-    private readonly effort;
-    setStreaming(streaming: boolean): void;
-    getStreaming(): boolean;
-    setTools(tools: Tool[]): void;
-    getTools(): Tool[];
-    setReasoningEffort(effort: OpenAIReasoningEffortType): void;
-    getReasoningEffort(): OpenAIReasoningEffortType;
-    setStructuredOutput(format: StructuredOutputFormat | undefined): void;
-    getStructuredOutput(): StructuredOutputFormat | undefined;
-    hasStructuredOutput(): boolean;
-}
-
-declare class Gpt54 implements GenerativeModel {
-    readonly specification: {
-        name: string;
-        provider: string;
-        supportReasoningEffort: boolean;
-        defaultReasoningEffort: OpenAIReasoningEffortType;
-        supportStreaming: boolean;
-        contextWindowSize: number;
-        maxOutputTokens: number;
-        supportFunctionCalling: boolean;
-        supportStructuredOutput: boolean;
-    };
-    private tools;
-    private streaming;
-    private structuredOutput;
-    private readonly effort;
-    setStreaming(streaming: boolean): void;
-    getStreaming(): boolean;
-    setTools(tools: Tool[]): void;
-    getTools(): Tool[];
-    setReasoningEffort(effort: OpenAIReasoningEffortType): void;
-    getReasoningEffort(): OpenAIReasoningEffortType;
-    setStructuredOutput(format: StructuredOutputFormat | undefined): void;
-    getStructuredOutput(): StructuredOutputFormat | undefined;
-    hasStructuredOutput(): boolean;
-}
-
-declare class Gpt54Mini implements GenerativeModel {
-    readonly specification: {
-        name: string;
-        provider: string;
-        supportReasoningEffort: boolean;
-        defaultReasoningEffort: OpenAIReasoningEffortType;
-        supportStreaming: boolean;
-        contextWindowSize: number;
-        maxOutputTokens: number;
-        supportFunctionCalling: boolean;
-        supportStructuredOutput: boolean;
-    };
-    private tools;
-    private streaming;
-    private structuredOutput;
-    private readonly effort;
-    setStreaming(streaming: boolean): void;
-    getStreaming(): boolean;
-    setReasoningEffort(effort: OpenAIReasoningEffortType): void;
-    getReasoningEffort(): OpenAIReasoningEffortType;
-    setTools(tools: Tool[]): void;
-    getTools(): Tool[];
-    setStructuredOutput(format: StructuredOutputFormat | undefined): void;
-    getStructuredOutput(): StructuredOutputFormat | undefined;
-    hasStructuredOutput(): boolean;
-}
-
-declare class InputTokenDetails {
-    readonly cached_tokens: number;
-    constructor(cached_tokens: number);
-}
-declare class OutputTokenDetails {
-    readonly reasoning_tokens: number;
-    constructor(reasoning_tokens: number);
-}
-declare class TokenUsage {
-    readonly inputTokens: number;
-    readonly outputTokens: number;
-    readonly totalTokens: number;
-    readonly inputTokenDetails: InputTokenDetails;
-    readonly outputTokenDetails: OutputTokenDetails;
-    constructor(inputTokens: number, outputTokens: number, totalTokens: number, inputTokenDetails: InputTokenDetails, outputTokenDetails: OutputTokenDetails);
-}
-
-declare class InMemoryModelContextRepository implements ModelContextRepository {
-    private readonly store;
-    private readonly projectIndex;
-    save(context: ModelContext): Promise<void>;
-    get(id: string): Promise<ModelContext>;
-    getByProjectId(projectId: string): Promise<ModelContext[]>;
-    private clone;
-}
-
-declare class SystemMessageItem extends ContextItem {
-    readonly type = "message";
-    readonly role = "system";
-    readonly content: InputText;
-    private constructor();
-    toJSON(): any;
-    static create(text: string): SystemMessageItem;
-    static rehydrate(data: {
-        text: string;
-    }): SystemMessageItem;
 }
 
 declare class SemanticEvent<T> {
@@ -335,29 +153,6 @@ declare class AgenticError extends Error {
     getEnvironment(): AgenticEnvironment | undefined;
 }
 
-interface AgenticEnvironmentOptions {
-    silent?: boolean;
-}
-declare class AgenticEnvironment {
-    protected subscribers: Participant[];
-    private name?;
-    private options?;
-    private showLogs?;
-    constructor(name?: string, opts?: AgenticEnvironmentOptions);
-    subscribe(participant: Participant): void;
-    unsubscribe(participant: Participant): void;
-    deliverFunctionCall(source: Participant, item: FunctionCallItem): void;
-    deliverModelMessage(source: Participant, item: ModelMessageItem): void;
-    deliverReasoning(source: Participant, item: ReasoningItem): void;
-    deliverFunctionCallOutput(source: Participant, item: FunctionCallOutputItem): void;
-    deliverMessage(source: Participant, message: string): void;
-    deliverSemanticEvent(source: Participant, item: SemanticEvent<unknown>): void;
-    deliverError(source: Participant, error: AgenticError): void;
-    private getListeningParticipants;
-    private deliverToSubscribers;
-    private handleError;
-}
-
 type ParticipantClassConstructor = new (...args: any[]) => Participant;
 declare abstract class Participant {
     private environments;
@@ -390,37 +185,57 @@ declare abstract class Participant {
     abstract onParticipantError(source: Participant, error: AgenticError): void;
 }
 
-declare class Gpt55 implements GenerativeModel {
-    readonly specification: {
-        name: string;
-        provider: string;
-        supportReasoningEffort: boolean;
-        defaultReasoningEffort: OpenAIReasoningEffortType;
-        supportStreaming: boolean;
-        contextWindowSize: number;
-        maxOutputTokens: number;
-        supportFunctionCalling: boolean;
-        supportStructuredOutput: boolean;
-    };
-    private tools;
-    private streaming;
-    private structuredOutput;
-    private readonly effort;
-    setStreaming(streaming: boolean): void;
-    getStreaming(): boolean;
-    setTools(tools: Tool[]): void;
-    getTools(): Tool[];
-    setReasoningEffort(effort: OpenAIReasoningEffortType): void;
-    getReasoningEffort(): OpenAIReasoningEffortType;
-    setStructuredOutput(format: StructuredOutputFormat | undefined): void;
-    getStructuredOutput(): StructuredOutputFormat | undefined;
-    hasStructuredOutput(): boolean;
+interface AgenticEnvironmentOptions {
+    silent?: boolean;
+}
+declare class AgenticEnvironment {
+    protected subscribers: Participant[];
+    private name?;
+    private options?;
+    private showLogs?;
+    constructor(name?: string, opts?: AgenticEnvironmentOptions);
+    subscribe(participant: Participant): void;
+    unsubscribe(participant: Participant): void;
+    deliverFunctionCall(source: Participant, item: FunctionCallItem): void;
+    deliverModelMessage(source: Participant, item: ModelMessageItem): void;
+    deliverReasoning(source: Participant, item: ReasoningItem): void;
+    deliverFunctionCallOutput(source: Participant, item: FunctionCallOutputItem): void;
+    deliverMessage(source: Participant, message: string): void;
+    deliverSemanticEvent(source: Participant, item: SemanticEvent<unknown>): void;
+    deliverError(source: Participant, error: AgenticError): void;
+    private getListeningParticipants;
+    private deliverToSubscribers;
+    private handleError;
 }
 
-declare class InferenceRequest {
-    readonly model: GenerativeModel;
-    readonly context: ModelContext;
-    constructor(model: GenerativeModel, context: ModelContext);
+type InferenceParams<TModel extends string> = {
+    model: TModel;
+    maxOutputTokens?: number;
+    reasoningEffort?: string;
+    tools?: Tool[];
+    streaming?: boolean;
+    structuredOutput?: StructuredOutputFormat;
+    context: ModelContext;
+    caller: Participant;
+    environment: AgenticEnvironment;
+    signal?: AbortSignal;
+};
+
+declare class InputTokenDetails {
+    readonly cached_tokens: number;
+    constructor(cached_tokens: number);
+}
+declare class OutputTokenDetails {
+    readonly reasoning_tokens: number;
+    constructor(reasoning_tokens: number);
+}
+declare class TokenUsage {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly totalTokens: number;
+    readonly inputTokenDetails: InputTokenDetails;
+    readonly outputTokenDetails: OutputTokenDetails;
+    constructor(inputTokens: number, outputTokens: number, totalTokens: number, inputTokenDetails: InputTokenDetails, outputTokenDetails: OutputTokenDetails);
 }
 
 declare class InferenceResponse {
@@ -429,378 +244,138 @@ declare class InferenceResponse {
     constructor(contextItems: ContextItem[], tokenUsage: TokenUsage | undefined);
 }
 
-interface Endpoint {
-    infer(request: InferenceRequest): Promise<InferenceResponse>;
-    stream(request: InferenceRequest): AsyncIterable<SemanticEvent<unknown>>;
-}
-
-declare class OpenAIResponses implements Endpoint {
-    private readonly client;
-    constructor();
-    infer(inferenceRequest: InferenceRequest): Promise<InferenceResponse>;
-    stream(inferenceRequest: InferenceRequest, signal?: AbortSignal): AsyncIterable<SemanticEvent<unknown>>;
-    private buildRequest;
-    extractTokenUsage(response: OpenAI.Responses.Response): TokenUsage | undefined;
-    mapContextToRequest(context: ModelContext): any[];
-    extractContextItems(response: any): ContextItem[];
+interface InferenceEndpointMapper {
+    toRequest(inferenceParams: InferenceParams<ModelName>): any;
+    toResponse(response: any): InferenceResponse;
 }
 
-declare class AnthropicMessages implements Endpoint {
-    private readonly client;
-    constructor();
-    infer(inferenceRequest: InferenceRequest): Promise<InferenceResponse>;
-    stream(inferenceRequest: InferenceRequest, signal?: AbortSignal): AsyncIterable<SemanticEvent<unknown>>;
-    private buildRequest;
-    extractTokenUsage(response: Anthropic.Messages.Message): TokenUsage | undefined;
-    mapContextToRequest(context: ModelContext): {
-        messages: any[];
-        system?: string;
-    };
-    extractContextItems(response: Anthropic.Messages.Message): ContextItem[];
-    private addContentBlock;
-}
-
-type AnthropicReasoningEffortType = "high" | "medium" | "low" | "none";
-
-declare class ClaudeOpus48 implements GenerativeModel {
-    readonly specification: {
-        name: string;
-        provider: string;
-        supportReasoningEffort: boolean;
-        defaultReasoningEffort: AnthropicReasoningEffortType;
-        supportStreaming: boolean;
-        contextWindowSize: number;
-        maxOutputTokens: number;
-        supportFunctionCalling: boolean;
-        supportStructuredOutput: boolean;
-    };
-    private tools;
-    private streaming;
-    private structuredOutput;
-    private readonly effort;
-    setStreaming(streaming: boolean): void;
-    getStreaming(): boolean;
-    setTools(tools: Tool[]): void;
-    getTools(): Tool[];
-    setReasoningEffort(effort: AnthropicReasoningEffortType): void;
-    getReasoningEffort(): AnthropicReasoningEffortType;
-    setStructuredOutput(format: StructuredOutputFormat | undefined): void;
-    getStructuredOutput(): StructuredOutputFormat | undefined;
-    hasStructuredOutput(): boolean;
+interface Endpoint {
+    endpointMapper: InferenceEndpointMapper;
+    infer(requestParams: InferenceParams<ModelName>): Promise<InferenceResponse>;
+    stream(requestParams: InferenceParams<ModelName>, signal?: AbortSignal): AsyncIterable<SemanticEvent<unknown>>;
 }
 
-declare class ClaudeOpus47 implements GenerativeModel {
-    readonly specification: {
-        name: string;
-        provider: string;
-        supportReasoningEffort: boolean;
-        defaultReasoningEffort: AnthropicReasoningEffortType;
-        supportStreaming: boolean;
-        contextWindowSize: number;
-        maxOutputTokens: number;
-        supportFunctionCalling: boolean;
-        supportStructuredOutput: boolean;
-    };
-    private tools;
-    private streaming;
-    private structuredOutput;
-    private readonly effort;
-    setStreaming(streaming: boolean): void;
-    getStreaming(): boolean;
-    setTools(tools: Tool[]): void;
-    getTools(): Tool[];
-    setReasoningEffort(effort: AnthropicReasoningEffortType): void;
-    getReasoningEffort(): AnthropicReasoningEffortType;
-    setStructuredOutput(format: StructuredOutputFormat | undefined): void;
-    getStructuredOutput(): StructuredOutputFormat | undefined;
-    hasStructuredOutput(): boolean;
-}
+type ModelName = "gpt-5.4" | "gpt-5.4-mini" | "gpt-5.4-nano" | "gpt-5.5" | "claude-haiku-4-5" | "claude-sonnet-4-6" | "claude-opus-4-7" | "claude-opus-4-8" | "gemini-3.5-flash" | "gemini-3.1-pro-preview" | "deepseek-v4-flash" | "deepseek-v4-pro";
 
-declare class ClaudeSonnet46 implements GenerativeModel {
-    readonly specification: {
-        name: string;
-        provider: string;
-        supportReasoningEffort: boolean;
-        defaultReasoningEffort: AnthropicReasoningEffortType;
-        supportStreaming: boolean;
-        contextWindowSize: number;
-        maxOutputTokens: number;
-        supportFunctionCalling: boolean;
-        supportStructuredOutput: boolean;
-    };
-    private tools;
-    private streaming;
-    private structuredOutput;
-    setStreaming(streaming: boolean): void;
-    getStreaming(): boolean;
-    setTools(tools: Tool[]): void;
-    getTools(): Tool[];
-    private readonly effort;
-    setReasoningEffort(effort: AnthropicReasoningEffortType): void;
-    getReasoningEffort(): AnthropicReasoningEffortType;
-    setStructuredOutput(format: StructuredOutputFormat | undefined): void;
-    getStructuredOutput(): StructuredOutputFormat | undefined;
-    hasStructuredOutput(): boolean;
-}
+type StructuredOutputFormat = {
+    name?: string;
+    schema: Record<string, any>;
+    strict?: boolean;
+};
 
-declare class ClaudeHaiku45 implements GenerativeModel {
-    readonly specification: {
-        name: string;
-        provider: string;
-        supportReasoningEffort: boolean;
-        defaultReasoningEffort: AnthropicReasoningEffortType;
-        supportStreaming: boolean;
-        contextWindowSize: number;
-        maxOutputTokens: number;
-        supportFunctionCalling: boolean;
-        supportStructuredOutput: boolean;
-    };
-    private tools;
-    private streaming;
-    private structuredOutput;
-    private readonly effort;
-    setStreaming(streaming: boolean): void;
-    getStreaming(): boolean;
-    setTools(tools: Tool[]): void;
-    getTools(): Tool[];
-    setReasoningEffort(effort: AnthropicReasoningEffortType): void;
-    getReasoningEffort(): AnthropicReasoningEffortType;
-    setStructuredOutput(format: StructuredOutputFormat | undefined): void;
-    getStructuredOutput(): StructuredOutputFormat | undefined;
-    hasStructuredOutput(): boolean;
+interface ModelContextRepository {
+    save(context: ModelContext): Promise<void>;
+    get(id: string): Promise<ModelContext>;
+    getByProjectId(projectId: string): Promise<ModelContext[]>;
 }
 
-/**
- * DeepSeek V4 reasoning levels. `"none"` selects non-thinking mode
- * (`thinking: { type: "disabled" }`); any other value enables thinking
- * mode and is forwarded as the `reasoning_effort` request parameter.
- */
-type DeepSeekReasoningEffortType = "max" | "high" | "medium" | "low" | "none";
-
-declare class DeepSeekV4Flash implements GenerativeModel {
-    readonly specification: {
-        name: string;
-        provider: string;
-        supportReasoningEffort: boolean;
-        defaultReasoningEffort: DeepSeekReasoningEffortType;
-        supportStreaming: boolean;
-        contextWindowSize: number;
-        maxOutputTokens: number;
-        supportFunctionCalling: boolean;
-        supportStructuredOutput: boolean;
-    };
-    private tools;
-    private streaming;
-    private structuredOutput;
-    private readonly effort;
-    setStreaming(streaming: boolean): void;
-    getStreaming(): boolean;
-    setTools(tools: Tool[]): void;
-    getTools(): Tool[];
-    setReasoningEffort(effort: DeepSeekReasoningEffortType): void;
-    getReasoningEffort(): DeepSeekReasoningEffortType;
-    setStructuredOutput(format: StructuredOutputFormat | undefined): void;
-    getStructuredOutput(): StructuredOutputFormat | undefined;
-    hasStructuredOutput(): boolean;
+interface McpServerConfig {
+    /** The MCP server URL, e.g. https://api.githubcopilot.com/mcp/ */
+    url: string;
+    /** Bearer token sent as `Authorization: Bearer <token>` (e.g. a GitHub token). */
+    authToken?: string;
+    /** Extra headers merged into every request (overridden by `authToken` for Authorization). */
+    headers?: Record<string, string>;
+    /** Client name reported to the server (defaults to "mozaik"). */
+    name?: string;
 }
-
-declare class DeepSeekV4Pro implements GenerativeModel {
-    readonly specification: {
-        name: string;
-        provider: string;
-        supportReasoningEffort: boolean;
-        defaultReasoningEffort: DeepSeekReasoningEffortType;
-        supportStreaming: boolean;
-        contextWindowSize: number;
-        maxOutputTokens: number;
-        supportFunctionCalling: boolean;
-        supportStructuredOutput: boolean;
-    };
-    private tools;
-    private streaming;
-    private structuredOutput;
-    private readonly effort;
-    setStreaming(streaming: boolean): void;
-    getStreaming(): boolean;
-    setTools(tools: Tool[]): void;
-    getTools(): Tool[];
-    setReasoningEffort(effort: DeepSeekReasoningEffortType): void;
-    getReasoningEffort(): DeepSeekReasoningEffortType;
-    setStructuredOutput(format: StructuredOutputFormat | undefined): void;
-    getStructuredOutput(): StructuredOutputFormat | undefined;
-    hasStructuredOutput(): boolean;
+interface McpToolSpec {
+    name: string;
+    description: string;
+    /** JSON Schema for the tool's arguments (maps 1:1 to FunctionTool.parameters). */
+    inputSchema: Record<string, any>;
 }
-
 /**
- * Native Gemini adapter on the `@google/genai` SDK (`generateContent` /
- * `generateContentStream`). Unlike an OpenAI-compat shim this maps our
- * domain context to Gemini's native `contents`/`parts` shape, system
- * instruction, `functionDeclarations`, and `thinkingConfig`, and reads
- * thought parts + native usage metadata back out. Another `ModelRuntime`
- * — no runner or port changes.
+ * A thin wrapper over the MCP TypeScript SDK using the Streamable HTTP transport — what
+ * remote MCP servers (e.g. GitHub's `api.githubcopilot.com/mcp/`) speak. One client per
+ * server; lazily connects on first use. Infrastructure-only: the domain never sees this.
  */
-declare class GeminiGenerateContent implements Endpoint {
+declare class McpClient {
+    private readonly config;
     private readonly client;
-    constructor();
-    infer(inferenceRequest: InferenceRequest): Promise<InferenceResponse>;
-    stream(inferenceRequest: InferenceRequest, signal?: AbortSignal): AsyncIterable<SemanticEvent<unknown>>;
-    private buildRequest;
-    extractTokenUsage(response: any): TokenUsage | undefined;
-    mapContextToRequest(context: ModelContext): {
-        contents: any[];
-        systemInstruction?: string;
-    };
-    extractContextItems(response: any): ContextItem[];
-    private parseResponse;
-    private addPart;
+    private readonly transport;
+    private connected;
+    constructor(config: McpServerConfig);
+    connect(): Promise<void>;
+    /** The tools this server exposes. */
+    listTools(): Promise<McpToolSpec[]>;
+    /** Call a tool by name; returns its text output. Throws if the server flags an error. */
+    callTool(name: string, args: Record<string, any>): Promise<string>;
+    close(): Promise<void>;
+}
+
+/** The slice of an MCP client the registry needs — lets tests inject a fake. */
+interface McpClientLike {
+    listTools(): Promise<Array<{
+        name: string;
+        description: string;
+        inputSchema: Record<string, any>;
+    }>>;
+    callTool(name: string, args: Record<string, any>): Promise<string>;
+    close(): Promise<void>;
 }
-
 /**
- * Gemini reasoning levels, forwarded as the `reasoning_effort` request
- * parameter on the OpenAI-compatible endpoint. `"none"` only disables
- * thinking on Gemini 2.5 models; Gemini 3.x always thinks, so for those
- * the adapter simply omits `reasoning_effort` when set to `"none"` and
- * lets the model use its default thinking level.
+ * Connects to one or more MCP servers and exposes their tools as mozaik `FunctionTool`s.
+ * Each tool's `invoke()` proxies the call back to its MCP server. Because they are plain
+ * FunctionTools, every provider mapper and the existing function-call loop handle them
+ * with no changes — MCP support adds no new tool type and touches no provider code.
+ *
+ * `strict` is false: MCP servers publish arbitrary JSON Schemas that won't always satisfy
+ * a provider's strict function-calling mode.
  */
-type GeminiReasoningEffortType = "high" | "medium" | "low" | "minimal" | "none";
-
-declare class Gemini35Flash implements GenerativeModel {
-    readonly specification: {
-        name: string;
-        provider: string;
-        supportReasoningEffort: boolean;
-        defaultReasoningEffort: GeminiReasoningEffortType;
-        supportStreaming: boolean;
-        contextWindowSize: number;
-        maxOutputTokens: number;
-        supportFunctionCalling: boolean;
-        supportStructuredOutput: boolean;
-    };
-    private tools;
-    private streaming;
-    private structuredOutput;
-    private readonly effort;
-    setStreaming(streaming: boolean): void;
-    getStreaming(): boolean;
-    setTools(tools: Tool[]): void;
-    getTools(): Tool[];
-    setReasoningEffort(effort: GeminiReasoningEffortType): void;
-    getReasoningEffort(): GeminiReasoningEffortType;
-    setStructuredOutput(format: StructuredOutputFormat | undefined): void;
-    getStructuredOutput(): StructuredOutputFormat | undefined;
-    hasStructuredOutput(): boolean;
+declare class McpToolRegistry {
+    private readonly servers;
+    private readonly createClient;
+    private readonly clients;
+    constructor(servers: McpServerConfig[], createClient?: (config: McpServerConfig) => McpClientLike);
+    /** Discover every tool across the configured servers, as FunctionTools ready to pass to a model. */
+    discoverTools(): Promise<FunctionTool[]>;
+    /** Close all underlying MCP connections. */
+    close(): Promise<void>;
 }
 
-declare class Gemini31Pro implements GenerativeModel {
-    readonly specification: {
-        name: string;
-        provider: string;
-        supportReasoningEffort: boolean;
-        defaultReasoningEffort: GeminiReasoningEffortType;
-        supportStreaming: boolean;
-        contextWindowSize: number;
-        maxOutputTokens: number;
-        supportFunctionCalling: boolean;
-        supportStructuredOutput: boolean;
-    };
-    private tools;
-    private streaming;
-    private structuredOutput;
-    private readonly effort;
-    setStreaming(streaming: boolean): void;
-    getStreaming(): boolean;
-    setTools(tools: Tool[]): void;
-    getTools(): Tool[];
-    setReasoningEffort(effort: GeminiReasoningEffortType): void;
-    getReasoningEffort(): GeminiReasoningEffortType;
-    setStructuredOutput(format: StructuredOutputFormat | undefined): void;
-    getStructuredOutput(): StructuredOutputFormat | undefined;
-    hasStructuredOutput(): boolean;
+declare class InMemoryModelContextRepository implements ModelContextRepository {
+    private readonly store;
+    private readonly projectIndex;
+    save(context: ModelContext): Promise<void>;
+    get(id: string): Promise<ModelContext>;
+    getByProjectId(projectId: string): Promise<ModelContext[]>;
+    private clone;
 }
 
-/**
- * Optional connection config. When omitted, the `openai` SDK reads
- * `OPENAI_API_KEY` and `OPENAI_BASE_URL` from the environment, so the
- * default-constructed runtime targets whatever `OPENAI_BASE_URL` points
- * at (real OpenAI when unset). Provider presets (e.g. DeepSeek) pass an
- * explicit base URL + credential.
- */
-interface OpenAICompatibleConfig {
-    baseURL?: string;
-    apiKey?: string;
-    /**
-     * Extra request-body fields merged into every `chat.completions`
-     * call. This is how provider-specific quirks are handled **without
-     * a per-provider subclass in mozaik** — the consumer supplies the
-     * vendor-only fields (e.g. DeepSeek's `{ thinking: { type } }`,
-     * safety flags, routing hints). Standard fields the runtime already
-     * sets (`model`, `messages`, `tools`, `reasoning_effort`) take
-     * precedence and are not overwritten.
-     */
-    extraBody?: Record<string, unknown>;
-}
-/**
- * Generic adapter for any **OpenAI Chat Completions**-compatible
- * endpoint — real OpenAI, DeepSeek, Xiaomi MiMo, OpenRouter, vLLM,
- * Ollama, etc. It speaks `/chat/completions` (not the Responses API),
- * which is the dialect third-party OpenAI-compatible providers expose.
- *
- * The base URL and credential are configurable; everything else (the
- * `ModelContext` ⇄ chat-message conversion, tool-call round-trip, token
- * usage extraction) is provider-agnostic. Provider-specific request
- * shaping (e.g. DeepSeek's `thinking` field) is supplied by the
- * consumer via {@link OpenAICompatibleConfig.extraBody} — mozaik stays
- * generic and gains no per-provider subclasses.
- *
- * Was `DeepSeekChatCompletions`; generalized so consumers can point it
- * at any OpenAI-compatible endpoint.
- */
-declare class OpenAIChatCompletions implements Endpoint {
-    private readonly client;
-    private readonly extraBody;
-    constructor(config?: OpenAICompatibleConfig);
-    infer(inferenceRequest: InferenceRequest): Promise<InferenceResponse>;
-    stream(inferenceRequest: InferenceRequest, signal?: AbortSignal): AsyncIterable<SemanticEvent<unknown>>;
-    buildRequest(inferenceRequest: InferenceRequest): any;
-    extractTokenUsage(response: any): TokenUsage | undefined;
-    mapContextToRequest(context: ModelContext): any[];
-    extractContextItems(response: any): ContextItem[];
+declare class SystemMessageItem extends ContextItem {
+    readonly type = "message";
+    readonly role = "system";
+    readonly content: InputText;
+    private constructor();
+    static create(text: string): SystemMessageItem;
+    static rehydrate(data: {
+        text: string;
+    }): SystemMessageItem;
 }
 
-type InferenceParams = {
-    model: string;
-    reasoningEffort?: string;
-    tools?: Tool[];
-    streaming?: boolean;
-    structuredOutput?: StructuredOutputFormat;
-    context: ModelContext;
-    caller: Participant;
-    environment: AgenticEnvironment;
-    signal?: AbortSignal;
-};
-
 declare class BaseParticipant extends Participant {
-    onFunctionCall(item: FunctionCallItem): void;
-    onExternalFunctionCall(source: Participant, item: FunctionCallItem): void;
-    onFunctionCallOutput(item: FunctionCallOutputItem): void;
-    onExternalFunctionCallOutput(source: Participant, item: FunctionCallOutputItem): void;
-    onReasoning(item: ReasoningItem): void;
-    onExternalReasoning(source: Participant, item: ReasoningItem): void;
-    onModelMessage(item: ModelMessageItem): void;
-    onExternalModelMessage(source: Participant, item: ModelMessageItem): void;
-    onMessage(message: string): void;
+    onFunctionCall(_item: FunctionCallItem): void;
+    onExternalFunctionCall(_source: Participant, _item: FunctionCallItem): void;
+    onFunctionCallOutput(_item: FunctionCallOutputItem): void;
+    onExternalFunctionCallOutput(_source: Participant, _item: FunctionCallOutputItem): void;
+    onReasoning(_item: ReasoningItem): void;
+    onExternalReasoning(_source: Participant, _item: ReasoningItem): void;
+    onModelMessage(_item: ModelMessageItem): void;
+    onExternalModelMessage(_source: Participant, _item: ModelMessageItem): void;
+    onMessage(_message: string): void;
     onJoined(): void;
     onLeft(): void;
-    onParticipantJoined(participant: Participant): void;
-    onParticipantLeft(participant: Participant): void;
-    onInternalEvent(item: SemanticEvent<unknown>): void;
-    onExternalEvent(source: Participant, item: SemanticEvent<unknown>): void;
-    onError(error: AgenticError): void;
-    onParticipantError(source: Participant, error: AgenticError): void;
+    onParticipantJoined(_participant: Participant): void;
+    onParticipantLeft(_participant: Participant): void;
+    onInternalEvent(_item: SemanticEvent<unknown>): void;
+    onExternalEvent(_source: Participant, _item: SemanticEvent<unknown>): void;
+    onError(_error: AgenticError): void;
+    onParticipantError(_source: Participant, _error: AgenticError): void;
 }
 
-declare const runInference: (inferenceParams: InferenceParams) => void;
+declare const runInference: (inferenceParams: InferenceParams<ModelName>) => void;
 declare const executeFunctionCall: (environment: AgenticEnvironment, functionCallItem: FunctionCallItem, tool: Tool, caller: Participant) => void;
 declare const sendMessage: (environment: AgenticEnvironment, message: string, caller: Participant) => void;
 
-export { AgenticEnvironment, AgenticError, AnthropicMessages, BaseParticipant, ClaudeHaiku45, ClaudeOpus47, ClaudeOpus48, ClaudeSonnet46, ContextItem, DeepSeekV4Flash, DeepSeekV4Pro, DeveloperMessageItem, type Endpoint, FunctionCallItem, FunctionCallOutputItem, Gemini31Pro, Gemini35Flash, GeminiGenerateContent, type GenerativeModel, Gpt54, Gpt54Mini, Gpt54Nano, Gpt55, InMemoryModelContextRepository, InferenceRequest, InferenceResponse, InputTokenDetails, ModelContext, type ModelContextRepository, ModelMessageItem, OpenAIChatCompletions, OpenAIResponses, OutputTokenDetails, Participant, ReasoningItem, SemanticEvent, type StructuredOutputCapability, type StructuredOutputFormat, SystemMessageItem, TokenUsage, type Tool, UserMessageItem, executeFunctionCall, runInference, sendMessage };
+export { AgenticEnvironment, AgenticError, BaseParticipant, ContextItem, DeveloperMessageItem, type Endpoint, FunctionCallItem, FunctionCallOutputItem, InMemoryModelContextRepository, type InferenceParams, InferenceResponse, InputTokenDetails, McpClient, type McpServerConfig, McpToolRegistry, type McpToolSpec, ModelContext, type ModelContextRepository, ModelMessageItem, type ModelName, OutputTokenDetails, Participant, ReasoningItem, SemanticEvent, type StructuredOutputFormat, SystemMessageItem, TokenUsage, type Tool, UserMessageItem, executeFunctionCall, runInference, sendMessage };