@mozaik-ai/core 3.12.0 → 3.13.0

package/dist/index.d.mts

@@ -133,6 +133,17 @@ interface StreamingCapability {
     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 {
     type: "function";
     name: string;
@@ -150,14 +161,16 @@ interface ToolCallingCapability {
 
 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 {
+interface GenerativeModel extends ReasoningEffort<string>, ToolCallingCapability, StreamingCapability, StructuredOutputCapability {
     readonly specification: ModelSpecification;
 }
 
@@ -185,15 +198,18 @@ 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;
@@ -201,20 +217,26 @@ declare class Gpt54Nano implements GenerativeModel {
     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;
@@ -222,20 +244,26 @@ declare class Gpt54 implements GenerativeModel {
     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;
@@ -243,6 +271,9 @@ declare class Gpt54Mini implements GenerativeModel {
     getReasoningEffort(): OpenAIReasoningEffortType;
     setTools(tools: Tool[]): void;
     getTools(): Tool[];
+    setStructuredOutput(format: StructuredOutputFormat | undefined): void;
+    getStructuredOutput(): StructuredOutputFormat | undefined;
+    hasStructuredOutput(): boolean;
 }
 
 declare class InputTokenDetails {
@@ -290,11 +321,29 @@ declare class SemanticEvent<T> {
     getType(): string;
 }
 
+interface AgenticErrorOpts {
+    message: string;
+    stack?: string;
+    source?: Participant;
+    enviornment?: AgenticEnvironment;
+}
+declare class AgenticError extends Error {
+    private source?;
+    private environment?;
+    constructor({ message, stack, source, enviornment }: AgenticErrorOpts);
+    getSource(): Participant | undefined;
+    getEnvironment(): AgenticEnvironment | undefined;
+}
+
+interface AgenticEnvironmentOptions {
+    silent?: boolean;
+}
 declare class AgenticEnvironment {
     protected subscribers: Participant[];
     private name?;
-    private isActive;
-    constructor(name?: string);
+    private options?;
+    private showLogs?;
+    constructor(name?: string, opts?: AgenticEnvironmentOptions);
     subscribe(participant: Participant): void;
     unsubscribe(participant: Participant): void;
     deliverFunctionCall(source: Participant, item: FunctionCallItem): void;
@@ -303,21 +352,25 @@ declare class AgenticEnvironment {
     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;
-    start(): Promise<void>;
-    stop(): void;
+    private handleError;
 }
 
 type ParticipantClassConstructor = new (...args: any[]) => Participant;
 declare abstract class Participant {
     private environments;
     protected listens: ParticipantClassConstructor[];
+    private active;
     join(environment: AgenticEnvironment): void;
     leave(environment: AgenticEnvironment): void;
-    protected isJoinedTo(environment: AgenticEnvironment): boolean;
+    isJoinedTo(environment: AgenticEnvironment): boolean;
     getEnvironments(): AgenticEnvironment[];
     getListeners(): ParticipantClassConstructor[];
+    getEnvironmentState(environment: AgenticEnvironment): boolean | undefined;
+    markInactive(environment: AgenticEnvironment): void;
+    markActive(environment: AgenticEnvironment): void;
     abstract onParticipantJoined(participant: Participant): Promise<void> | void;
     abstract onParticipantLeft(participant: Participant): Promise<void> | void;
     abstract onJoined(): Promise<void> | void;
@@ -333,123 +386,25 @@ declare abstract class Participant {
     abstract onMessage(message: string): Promise<void> | void;
     abstract onInternalEvent(item: SemanticEvent<unknown>): Promise<void> | void;
     abstract onExternalEvent(source: Participant, item: SemanticEvent<unknown>): Promise<void> | void;
-}
-
-interface InferenceRunner {
-    run(context: ModelContext, model: GenerativeModel, signal?: AbortSignal): AsyncIterable<ReasoningItem | FunctionCallItem | ModelMessageItem | SemanticEvent<unknown>>;
-}
-
-interface FunctionCallRunner {
-    run(functionCallItem: FunctionCallItem, signal?: AbortSignal): AsyncIterable<FunctionCallOutputItem>;
-}
-
-declare abstract class Agent extends Participant {
-    abstract executeFunctionCall(environment: AgenticEnvironment, functionCallItem: FunctionCallItem, signal?: AbortSignal): Promise<void>;
-    abstract runInference(environment: AgenticEnvironment, context: ModelContext, model: GenerativeModel, signal?: AbortSignal): Promise<void>;
-}
-
-declare class BaseAgent extends Agent {
-    private inferenceRunner;
-    private functionCallRunner;
-    constructor(inferenceRunner: InferenceRunner, functionCallRunner: FunctionCallRunner);
-    onJoined(): void;
-    onLeft(): void;
-    onParticipantJoined(participant: Participant): void;
-    onParticipantLeft(participant: Participant): 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;
-    onInternalEvent(item: SemanticEvent<unknown>): void;
-    onExternalEvent(source: Participant, item: SemanticEvent<unknown>): void;
-    executeFunctionCall(environment: AgenticEnvironment, functionCallItem: FunctionCallItem, signal?: AbortSignal): Promise<void>;
-    runInference(environment: AgenticEnvironment, context: ModelContext, model: GenerativeModel, signal?: AbortSignal): Promise<void>;
-}
-
-declare abstract class Human extends Participant {
-    sendMessage(environment: AgenticEnvironment, message: string): void;
-}
-
-declare class BaseHuman extends Human {
-    onJoined(): void;
-    onLeft(): void;
-    onParticipantJoined(participant: Participant): void;
-    onParticipantLeft(participant: Participant): void;
-    onMessage(message: string): void;
-    onFunctionCall(item: FunctionCallItem): void;
-    onFunctionCallOutput(item: FunctionCallOutputItem): void;
-    onReasoning(item: ReasoningItem): void;
-    onModelMessage(item: ModelMessageItem): void;
-    onExternalFunctionCall(source: Participant, item: FunctionCallItem): void;
-    onExternalFunctionCallOutput(source: Participant, item: FunctionCallOutputItem): void;
-    onExternalReasoning(source: Participant, item: ReasoningItem): void;
-    onExternalModelMessage(source: Participant, item: ModelMessageItem): void;
-    onInternalEvent(item: SemanticEvent<unknown>): void;
-    onExternalEvent(source: Participant, item: SemanticEvent<unknown>): void;
-}
-
-declare class InferenceRequest {
-    readonly model: GenerativeModel & ReasoningEffort<string> & ToolCallingCapability;
-    readonly context: ModelContext;
-    constructor(model: GenerativeModel & ReasoningEffort<string> & ToolCallingCapability, context: ModelContext);
-}
-
-declare class InferenceResponse {
-    readonly contextItems: ContextItem[];
-    readonly tokenUsage?: TokenUsage;
-    constructor(contextItems: ContextItem[], tokenUsage: TokenUsage | undefined);
-}
-
-/**
- * Provider-agnostic port for a single round of inference.
- *
- * Lives in the domain layer; concrete adapters (OpenAI Responses,
- * Anthropic Messages, DeepSeek Chat Completions, …) live in the
- * infrastructure layer and are injected into application-layer runners
- * through their constructor. The application layer must depend on this
- * interface, never on a concrete provider client.
- */
-interface ModelRuntime {
-    infer(request: InferenceRequest): Promise<InferenceResponse>;
-}
-
-type InferenceItem = ReasoningItem | FunctionCallItem | ModelMessageItem | SemanticEvent<unknown>;
-/**
- * Provider-agnostic inference runner: it depends on
- * the {@link ModelRuntime} domain port and receives a concrete
- * infrastructure adapter (OpenAIResponses, AnthropicMessages, …)
- * through its constructor.
- */
-declare class DefaultInferenceRunner implements InferenceRunner {
-    private readonly runtime;
-    constructor(runtime: ModelRuntime);
-    run(context: ModelContext, model: GenerativeModel, signal?: AbortSignal): AsyncIterable<InferenceItem>;
-    private isStreamingRuntime;
-}
-
-declare class DefaultFunctionCallRunner implements FunctionCallRunner {
-    private readonly tools;
-    constructor(tools: Tool[]);
-    run(call: FunctionCallItem, signal?: AbortSignal): AsyncIterable<FunctionCallOutputItem>;
+    abstract onError(error: AgenticError): void;
+    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;
@@ -457,104 +412,44 @@ declare class Gpt55 implements GenerativeModel {
     getTools(): Tool[];
     setReasoningEffort(effort: OpenAIReasoningEffortType): void;
     getReasoningEffort(): OpenAIReasoningEffortType;
+    setStructuredOutput(format: StructuredOutputFormat | undefined): void;
+    getStructuredOutput(): StructuredOutputFormat | undefined;
+    hasStructuredOutput(): boolean;
 }
 
-declare abstract class Observer extends Participant {
+declare class InferenceRequest {
+    readonly model: GenerativeModel;
+    readonly context: ModelContext;
+    constructor(model: GenerativeModel, context: ModelContext);
 }
 
-declare class BaseObserver extends Observer {
-    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;
+declare class InferenceResponse {
+    readonly contextItems: ContextItem[];
+    readonly tokenUsage?: TokenUsage;
+    constructor(contextItems: ContextItem[], tokenUsage: TokenUsage | undefined);
 }
 
-/**
- * Optional streaming companion to {@link ModelRuntime}. Adapters whose
- * provider can stream a round implement this in addition to
- * `ModelRuntime`; runners delegate to `stream` only when the model has
- * streaming enabled and the injected runtime actually implements it.
- */
-interface StreamingRuntime {
-    stream(request: InferenceRequest, signal?: AbortSignal): AsyncIterable<ReasoningItem | FunctionCallItem | ModelMessageItem | SemanticEvent<unknown>>;
+interface Endpoint {
+    infer(request: InferenceRequest): Promise<InferenceResponse>;
+    stream(request: InferenceRequest): AsyncIterable<SemanticEvent<unknown>>;
 }
 
-declare class OpenAIResponses implements ModelRuntime, StreamingRuntime {
+declare class OpenAIResponses implements Endpoint {
     private readonly client;
     constructor();
     infer(inferenceRequest: InferenceRequest): Promise<InferenceResponse>;
-    stream(inferenceRequest: InferenceRequest, signal?: AbortSignal): AsyncIterable<ReasoningItem | FunctionCallItem | ModelMessageItem | SemanticEvent<unknown>>;
+    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[];
 }
 
-/**
- * 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 OpenAICompatibleChatCompletions implements ModelRuntime, StreamingRuntime {
-    private readonly client;
-    private readonly extraBody;
-    constructor(config?: OpenAICompatibleConfig);
-    infer(inferenceRequest: InferenceRequest): Promise<InferenceResponse>;
-    stream(inferenceRequest: InferenceRequest, signal?: AbortSignal): AsyncIterable<ReasoningItem | FunctionCallItem | ModelMessageItem | SemanticEvent<unknown>>;
-    buildRequest(inferenceRequest: InferenceRequest): any;
-    extractTokenUsage(response: any): TokenUsage | undefined;
-    mapContextToRequest(context: ModelContext): any[];
-    extractContextItems(response: any): ContextItem[];
-}
-
-declare class AnthropicMessages implements ModelRuntime, StreamingRuntime {
+declare class AnthropicMessages implements Endpoint {
     private readonly client;
     constructor();
     infer(inferenceRequest: InferenceRequest): Promise<InferenceResponse>;
-    stream(inferenceRequest: InferenceRequest, signal?: AbortSignal): AsyncIterable<ReasoningItem | FunctionCallItem | ModelMessageItem | SemanticEvent<unknown>>;
+    stream(inferenceRequest: InferenceRequest, signal?: AbortSignal): AsyncIterable<SemanticEvent<unknown>>;
     private buildRequest;
     extractTokenUsage(response: Anthropic.Messages.Message): TokenUsage | undefined;
     mapContextToRequest(context: ModelContext): {
@@ -570,15 +465,18 @@ 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;
@@ -586,20 +484,26 @@ declare class ClaudeOpus48 implements GenerativeModel {
     getTools(): Tool[];
     setReasoningEffort(effort: AnthropicReasoningEffortType): void;
     getReasoningEffort(): AnthropicReasoningEffortType;
+    setStructuredOutput(format: StructuredOutputFormat | undefined): void;
+    getStructuredOutput(): StructuredOutputFormat | undefined;
+    hasStructuredOutput(): boolean;
 }
 
 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;
@@ -607,20 +511,26 @@ declare class ClaudeOpus47 implements GenerativeModel {
     getTools(): Tool[];
     setReasoningEffort(effort: AnthropicReasoningEffortType): void;
     getReasoningEffort(): AnthropicReasoningEffortType;
+    setStructuredOutput(format: StructuredOutputFormat | undefined): void;
+    getStructuredOutput(): StructuredOutputFormat | undefined;
+    hasStructuredOutput(): boolean;
 }
 
 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;
@@ -628,20 +538,26 @@ declare class ClaudeSonnet46 implements GenerativeModel {
     private readonly effort;
     setReasoningEffort(effort: AnthropicReasoningEffortType): void;
     getReasoningEffort(): AnthropicReasoningEffortType;
+    setStructuredOutput(format: StructuredOutputFormat | undefined): void;
+    getStructuredOutput(): StructuredOutputFormat | undefined;
+    hasStructuredOutput(): 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;
@@ -649,6 +565,9 @@ declare class ClaudeHaiku45 implements GenerativeModel {
     getTools(): Tool[];
     setReasoningEffort(effort: AnthropicReasoningEffortType): void;
     getReasoningEffort(): AnthropicReasoningEffortType;
+    setStructuredOutput(format: StructuredOutputFormat | undefined): void;
+    getStructuredOutput(): StructuredOutputFormat | undefined;
+    hasStructuredOutput(): boolean;
 }
 
 /**
@@ -661,15 +580,18 @@ 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;
@@ -677,20 +599,26 @@ declare class DeepSeekV4Flash implements GenerativeModel {
     getTools(): Tool[];
     setReasoningEffort(effort: DeepSeekReasoningEffortType): void;
     getReasoningEffort(): DeepSeekReasoningEffortType;
+    setStructuredOutput(format: StructuredOutputFormat | undefined): void;
+    getStructuredOutput(): StructuredOutputFormat | undefined;
+    hasStructuredOutput(): boolean;
 }
 
 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;
@@ -698,6 +626,9 @@ declare class DeepSeekV4Pro implements GenerativeModel {
     getTools(): Tool[];
     setReasoningEffort(effort: DeepSeekReasoningEffortType): void;
     getReasoningEffort(): DeepSeekReasoningEffortType;
+    setStructuredOutput(format: StructuredOutputFormat | undefined): void;
+    getStructuredOutput(): StructuredOutputFormat | undefined;
+    hasStructuredOutput(): boolean;
 }
 
 /**
@@ -708,11 +639,11 @@ declare class DeepSeekV4Pro implements GenerativeModel {
  * thought parts + native usage metadata back out. Another `ModelRuntime`
  * — no runner or port changes.
  */
-declare class GeminiGenerateContent implements ModelRuntime, StreamingRuntime {
+declare class GeminiGenerateContent implements Endpoint {
     private readonly client;
     constructor();
     infer(inferenceRequest: InferenceRequest): Promise<InferenceResponse>;
-    stream(inferenceRequest: InferenceRequest, signal?: AbortSignal): AsyncIterable<ReasoningItem | FunctionCallItem | ModelMessageItem | SemanticEvent<unknown>>;
+    stream(inferenceRequest: InferenceRequest, signal?: AbortSignal): AsyncIterable<SemanticEvent<unknown>>;
     private buildRequest;
     extractTokenUsage(response: any): TokenUsage | undefined;
     mapContextToRequest(context: ModelContext): {
@@ -736,15 +667,18 @@ 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;
@@ -752,20 +686,26 @@ declare class Gemini35Flash implements GenerativeModel {
     getTools(): Tool[];
     setReasoningEffort(effort: GeminiReasoningEffortType): void;
     getReasoningEffort(): GeminiReasoningEffortType;
+    setStructuredOutput(format: StructuredOutputFormat | undefined): void;
+    getStructuredOutput(): StructuredOutputFormat | undefined;
+    hasStructuredOutput(): boolean;
 }
 
 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;
@@ -773,6 +713,94 @@ declare class Gemini31Pro implements GenerativeModel {
     getTools(): Tool[];
     setReasoningEffort(effort: GeminiReasoningEffortType): void;
     getReasoningEffort(): GeminiReasoningEffortType;
+    setStructuredOutput(format: StructuredOutputFormat | undefined): void;
+    getStructuredOutput(): StructuredOutputFormat | undefined;
+    hasStructuredOutput(): boolean;
+}
+
+/**
+ * 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[];
+}
+
+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;
+    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;
 }
 
-export { Agent, AgenticEnvironment, AnthropicMessages, BaseAgent, BaseHuman, BaseObserver, ClaudeHaiku45, ClaudeOpus47, ClaudeOpus48, ClaudeSonnet46, ContextItem, DeepSeekV4Flash, DeepSeekV4Pro, DefaultFunctionCallRunner, DefaultInferenceRunner, DeveloperMessageItem, FunctionCallItem, FunctionCallOutputItem, type FunctionCallRunner, Gemini31Pro, Gemini35Flash, GeminiGenerateContent, type GenerativeModel, Gpt54, Gpt54Mini, Gpt54Nano, Gpt55, Human, InMemoryModelContextRepository, InferenceRequest, InferenceResponse, type InferenceRunner, InputTokenDetails, ModelContext, type ModelContextRepository, ModelMessageItem, type ModelRuntime, Observer, OpenAICompatibleChatCompletions, OpenAIResponses, OutputTokenDetails, Participant, ReasoningItem, SemanticEvent, type StreamingRuntime, SystemMessageItem, TokenUsage, type Tool, UserMessageItem };
+declare const runInference: (inferenceParams: InferenceParams) => 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 };