@mozaik-ai/core 4.0.0-beta.1 → 4.0.0-beta.11

package/README.md

@@ -1,15 +1,23 @@
 <div align="center">
 <h1>Mozaik</h1>
-<p>TypeScript runtime for concurrent AI agents</p>
-
-<img width="150" height="150" alt="mozaik-avatar-dark" src="https://github.com/user-attachments/assets/e832c359-0581-42f7-96f3-d6e221c5af95" />
+<p>Mozaik is a TypeScript runtime for interoperable AI agents.</p>
 
 ![npm downloads](https://img.shields.io/npm/dt/@mozaik-ai/core) ![npm downloads weekly](https://img.shields.io/npm/dw/@mozaik-ai/core) ![npm version](https://img.shields.io/npm/v/@mozaik-ai/core)
 
-Mozaik is a TypeScript runtime for non-blocking AI agents that work independently, communicate through semantic events, and coordinate without predefined workflows.
+<img width="512" height="512" alt="agent-interoperability" src="https://github.com/user-attachments/assets/4b24bf27-afe2-4520-a396-5c46da6dab17" />
 
 </div>
 
+## Agent Interoperability
+
+Our main goal is to unlock agent interoperability across projects, so Mozaik is built around three core attributes:
+
+- **Concurrency** - Agents work independently without blocking one another.
+- **Awareness** - Agents understand other participants, events, and their shared environment.
+- **Adaptivity** - Agents change their behavior based on runtime state and emerging needs.
+
+Together, these capabilities free AI agents from specific harnesses, allowing them to work across projects - so every newly created agent adds value to the entire ecosystem.
+
 ---
 
 ## Installation

package/dist/index.d.mts

@@ -129,6 +129,46 @@ interface FunctionTool {
 }
 type Tool = FunctionTool;
 
+type SituationContext$1<TEvent extends SemanticEvent = SemanticEvent> = {
+    readonly event: TEvent;
+    readonly participant: Participant;
+};
+declare abstract class SituationSpecification<TEvent extends SemanticEvent = SemanticEvent> {
+    abstract isSatisfiedBy(situationContext: SituationContext$1<TEvent>): boolean;
+    and(other: SituationSpecification<TEvent>): SituationSpecification<TEvent>;
+    or(other: SituationSpecification<TEvent>): SituationSpecification<TEvent>;
+    not(): SituationSpecification<TEvent>;
+}
+
+interface SituationHandler {
+    readonly specification: SituationSpecification;
+    readonly processor: SituationProcessor;
+}
+type SituationContext<TEvent extends SemanticEvent = SemanticEvent> = {
+    readonly event: TEvent;
+    readonly participant: Participant;
+};
+interface SituationProcessor {
+    apply(context: SituationContext): void | Promise<void>;
+}
+
+type ParticipantRole = "agent" | "human";
+type ParticipantManifest = {
+    readonly id: string;
+    readonly name: string;
+    readonly role: ParticipantRole;
+    readonly capabilities?: readonly string[];
+};
+declare abstract class Participant {
+    private readonly manifest;
+    private handlers;
+    protected constructor(manifest: ParticipantManifest, handlers: SituationHandler[]);
+    getManifest(): ParticipantManifest;
+    getId(): string;
+    getHandlers(): SituationHandler[];
+    setHandlers(handlers: SituationHandler[]): void;
+}
+
 declare class SemanticEvent<TType extends string = string, TPayload = unknown> {
     readonly type: TType;
     readonly producerId: string;
@@ -141,6 +181,71 @@ declare class SemanticEvent<TType extends string = string, TPayload = unknown> {
 interface FunctionCallRunner {
     run(call: FunctionCallItem, tool: Tool): Promise<FunctionCallOutputItem>;
 }
+interface FunctionCallParams {
+    call: FunctionCallItem;
+    inferenceInput: InferenceInput;
+}
+
+type LoopStateId = "context_update" | "inference" | "inference_streaming" | "function_call" | "model_message" | "idle";
+type ReceivedMessage = {
+    content: string;
+    input: InferenceInput;
+};
+interface FunctionCallExecutionOutput {
+    item: FunctionCallOutputItem;
+}
+interface ModelMessageParams {
+    answer: ModelMessageItem;
+}
+interface LoopStateContract {
+    context_update: {
+        input: ReceivedMessage;
+        output: InferenceInput;
+    };
+    inference: {
+        input: InferenceInput;
+        output: InferenceOutput;
+    };
+    inference_streaming: {
+        input: InferenceInput;
+        output: InferenceOutput;
+    };
+    function_call: {
+        input: FunctionCallParams;
+        output: FunctionCallExecutionOutput;
+    };
+    model_message: {
+        input: ModelMessageParams;
+        output: void;
+    };
+    interception: {
+        input: InterceptionParams;
+        output: InterceptionOutput;
+    };
+    idle: {
+        input: undefined;
+        output: void;
+    };
+}
+type InterceptionOutput = {
+    type: "continue";
+    transition: LoopTransition;
+} | {
+    type: "pause";
+    pendingTransition: LoopTransition;
+} | {
+    type: "stop";
+    reason?: string;
+};
+interface InterceptionParams {
+    pendingTransition: LoopTransition;
+}
+type LoopTransition<TStateId extends LoopStateId = LoopStateId> = {
+    [K in TStateId]: {
+        nextStateId: K;
+        input: LoopStateContract[K]["input"];
+    };
+}[TStateId];
 
 type InferenceInput = {
     model: string;
@@ -158,6 +263,7 @@ type InferenceOutput = {
 };
 interface InferenceRunner {
     run(request: InferenceInput): Promise<InferenceOutput>;
+    stream(request: InferenceInput): AsyncGenerator<SemanticEvent>;
 }
 
 interface InferenceEndpointMapper {
@@ -188,6 +294,11 @@ type ModelSpecification = {
     supportsStructuredOutput: boolean;
 };
 
+interface RequestValidationRule {
+    readonly name: string;
+    isValid(inferenceInput: InferenceInput, model: ModelSpecification): boolean;
+}
+
 type StructuredOutputFormat = {
     name?: string;
     schema: Record<string, any>;
@@ -293,45 +404,6 @@ declare class SystemMessageItem extends ContextItem {
     }): SystemMessageItem;
 }
 
-type SituationContext$1<TEvent extends SemanticEvent = SemanticEvent> = {
-    readonly event: TEvent;
-    readonly participant: Participant;
-};
-declare abstract class SituationSpecification<TEvent extends SemanticEvent = SemanticEvent> {
-    abstract isSatisfiedBy(situationContext: SituationContext$1<TEvent>): boolean;
-    and(other: SituationSpecification<TEvent>): SituationSpecification<TEvent>;
-    or(other: SituationSpecification<TEvent>): SituationSpecification<TEvent>;
-    not(): SituationSpecification<TEvent>;
-}
-
-interface SituationHandler {
-    readonly specification: SituationSpecification;
-    readonly processor: SituationProcessor;
-}
-type SituationContext<TEvent extends SemanticEvent = SemanticEvent> = {
-    readonly event: TEvent;
-    readonly participant: Participant;
-};
-interface SituationProcessor {
-    apply(context: SituationContext): void | Promise<void>;
-}
-
-type ParticipantRole = "agent" | "human";
-type ParticipantManifest = {
-    readonly id: string;
-    readonly name: string;
-    readonly role: ParticipantRole;
-    readonly capabilities?: readonly string[];
-};
-declare abstract class Participant {
-    private readonly manifest;
-    private handlers;
-    protected constructor(manifest: ParticipantManifest, handlers: SituationHandler[]);
-    getManifest(): ParticipantManifest;
-    getId(): string;
-    getHandlers(): SituationHandler[];
-}
-
 declare class Memory {
     private readonly context;
     private constructor();
@@ -406,8 +478,8 @@ declare class RuntimeService<TRuntimeState extends RuntimeState> {
 }
 
 type InferenceRunnerConfig = {
-    supportedModels: GenerativeModel[];
-    runner: InferenceRunner;
+    supportedModels?: GenerativeModel[];
+    runner?: InferenceRunner;
 };
 declare function defineRuntime<TRuntimeState extends RuntimeState>(): {
     initializeRuntime: (config: {
@@ -419,7 +491,128 @@ declare function defineRuntime<TRuntimeState extends RuntimeState>(): {
     join: (participant: Participant) => void;
     leave: (participant: Participant) => void;
     sendMessage: (message: string, senderId: string) => void;
-    runLoop: (agentId: string, message: string, inferenceInput: InferenceInput) => void;
+    sendEvent: (event: SemanticEvent, senderId: string) => void;
+    runLoop: (agentId: string, message: string, inferenceInput: InferenceInput, interceptionHandler?: InterceptionHandler) => void;
 };
 
-export { ContextItem, DeveloperMessageItem, type Endpoint, FunctionCallItem, FunctionCallOutputItem, type InferenceInput, type InferenceOutput, InputTokenDetails, McpClient, type McpServerConfig, McpToolRegistry, type McpToolSpec, ModelContext, type ModelContextRepository, ModelMessageItem, OutputTokenDetails, Participant, ReasoningItem, RuntimeState, SemanticEvent, type StructuredOutputFormat, SystemMessageItem, TokenUsage, type Tool, UserMessageItem, createAgent, createHuman, defineRuntime };
+declare const supportedModels: GenerativeModel[];
+
+declare class OpenAIResponses implements Endpoint {
+    endpointMapper: InferenceEndpointMapper;
+    private _client?;
+    constructor(endpointMapper?: InferenceEndpointMapper);
+    private get client();
+    infer(inferenceInput: InferenceInput): Promise<InferenceOutput>;
+    stream(inferenceInput: InferenceInput): AsyncIterable<SemanticEvent>;
+}
+
+/**
+ * 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 {
+    endpointMapper: InferenceEndpointMapper;
+    private _client?;
+    private readonly clientConfig;
+    private readonly extraBody;
+    constructor(endpointMapper?: InferenceEndpointMapper, config?: OpenAICompatibleConfig);
+    private get client();
+    private buildRequest;
+    infer(inferenceInput: InferenceInput): Promise<InferenceOutput>;
+    stream(inferenceInput: InferenceInput): AsyncIterable<SemanticEvent>;
+}
+
+interface AnthropicConnectionConfig {
+    baseURL?: string;
+    apiKey?: string;
+}
+/**
+ * Native Anthropic adapter on the `@anthropic-ai/sdk` (`messages.create`).
+ * Maps domain context to Anthropic's `messages`/`content` blocks shape,
+ * system prompt, tools, adaptive thinking, and structured output config.
+ */
+declare class AnthropicMessages implements Endpoint {
+    endpointMapper: InferenceEndpointMapper;
+    private _client?;
+    private readonly clientConfig;
+    constructor(endpointMapper?: InferenceEndpointMapper, config?: AnthropicConnectionConfig);
+    private get client();
+    infer(inferenceInput: InferenceInput): Promise<InferenceOutput>;
+    stream(inferenceInput: InferenceInput): AsyncIterable<SemanticEvent>;
+}
+
+interface GeminiConnectionConfig {
+    baseURL?: string;
+    apiKey?: string;
+}
+/**
+ * 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.
+ */
+declare class GeminiGenerateContent implements Endpoint {
+    endpointMapper: InferenceEndpointMapper;
+    private _client?;
+    private readonly clientConfig;
+    constructor(endpointMapper?: InferenceEndpointMapper, config?: GeminiConnectionConfig);
+    private get client();
+    infer(inferenceInput: InferenceInput): Promise<InferenceOutput>;
+    stream(inferenceInput: InferenceInput): AsyncIterable<SemanticEvent>;
+}
+
+declare class InferenceInputValidator {
+    private readonly rules;
+    constructor(rules?: RequestValidationRule[]);
+    validate(inferenceInput: InferenceInput, model: ModelSpecification): void;
+}
+
+declare class DefaultInferenceRunner implements InferenceRunner {
+    private readonly supportedModels;
+    private readonly requestValidator;
+    constructor(supportedModels: GenerativeModel[], requestValidator: InferenceInputValidator);
+    run(input: InferenceInput): Promise<InferenceOutput>;
+    stream(input: InferenceInput): AsyncGenerator<SemanticEvent>;
+}
+
+interface InterceptionHandler {
+    isSatisfiedBy(transition: LoopTransition): boolean;
+    handle(transition: LoopTransition): Promise<LoopTransition>;
+}
+
+export { Agent, AnthropicMessages, ContextItem, DefaultInferenceRunner, DeveloperMessageItem, type Endpoint, FunctionCallItem, FunctionCallOutputItem, GeminiGenerateContent, Human, type InferenceInput, type InferenceOutput, type InferenceRunner, type InferenceRunnerConfig, InputTokenDetails, type InterceptionHandler, McpClient, type McpServerConfig, McpToolRegistry, type McpToolSpec, ModelContext, type ModelContextRepository, ModelMessageItem, OpenAIChatCompletions, OpenAIResponses, OutputTokenDetails, Participant, ReasoningItem, RuntimeState, SemanticEvent, type SituationContext, type SituationHandler, type SituationProcessor, SituationSpecification, type StructuredOutputFormat, SystemMessageItem, TokenUsage, type Tool, UserMessageItem, createAgent, createHuman, defineRuntime, supportedModels };

package/dist/index.d.ts

@@ -129,6 +129,46 @@ interface FunctionTool {
 }
 type Tool = FunctionTool;
 
+type SituationContext$1<TEvent extends SemanticEvent = SemanticEvent> = {
+    readonly event: TEvent;
+    readonly participant: Participant;
+};
+declare abstract class SituationSpecification<TEvent extends SemanticEvent = SemanticEvent> {
+    abstract isSatisfiedBy(situationContext: SituationContext$1<TEvent>): boolean;
+    and(other: SituationSpecification<TEvent>): SituationSpecification<TEvent>;
+    or(other: SituationSpecification<TEvent>): SituationSpecification<TEvent>;
+    not(): SituationSpecification<TEvent>;
+}
+
+interface SituationHandler {
+    readonly specification: SituationSpecification;
+    readonly processor: SituationProcessor;
+}
+type SituationContext<TEvent extends SemanticEvent = SemanticEvent> = {
+    readonly event: TEvent;
+    readonly participant: Participant;
+};
+interface SituationProcessor {
+    apply(context: SituationContext): void | Promise<void>;
+}
+
+type ParticipantRole = "agent" | "human";
+type ParticipantManifest = {
+    readonly id: string;
+    readonly name: string;
+    readonly role: ParticipantRole;
+    readonly capabilities?: readonly string[];
+};
+declare abstract class Participant {
+    private readonly manifest;
+    private handlers;
+    protected constructor(manifest: ParticipantManifest, handlers: SituationHandler[]);
+    getManifest(): ParticipantManifest;
+    getId(): string;
+    getHandlers(): SituationHandler[];
+    setHandlers(handlers: SituationHandler[]): void;
+}
+
 declare class SemanticEvent<TType extends string = string, TPayload = unknown> {
     readonly type: TType;
     readonly producerId: string;
@@ -141,6 +181,71 @@ declare class SemanticEvent<TType extends string = string, TPayload = unknown> {
 interface FunctionCallRunner {
     run(call: FunctionCallItem, tool: Tool): Promise<FunctionCallOutputItem>;
 }
+interface FunctionCallParams {
+    call: FunctionCallItem;
+    inferenceInput: InferenceInput;
+}
+
+type LoopStateId = "context_update" | "inference" | "inference_streaming" | "function_call" | "model_message" | "idle";
+type ReceivedMessage = {
+    content: string;
+    input: InferenceInput;
+};
+interface FunctionCallExecutionOutput {
+    item: FunctionCallOutputItem;
+}
+interface ModelMessageParams {
+    answer: ModelMessageItem;
+}
+interface LoopStateContract {
+    context_update: {
+        input: ReceivedMessage;
+        output: InferenceInput;
+    };
+    inference: {
+        input: InferenceInput;
+        output: InferenceOutput;
+    };
+    inference_streaming: {
+        input: InferenceInput;
+        output: InferenceOutput;
+    };
+    function_call: {
+        input: FunctionCallParams;
+        output: FunctionCallExecutionOutput;
+    };
+    model_message: {
+        input: ModelMessageParams;
+        output: void;
+    };
+    interception: {
+        input: InterceptionParams;
+        output: InterceptionOutput;
+    };
+    idle: {
+        input: undefined;
+        output: void;
+    };
+}
+type InterceptionOutput = {
+    type: "continue";
+    transition: LoopTransition;
+} | {
+    type: "pause";
+    pendingTransition: LoopTransition;
+} | {
+    type: "stop";
+    reason?: string;
+};
+interface InterceptionParams {
+    pendingTransition: LoopTransition;
+}
+type LoopTransition<TStateId extends LoopStateId = LoopStateId> = {
+    [K in TStateId]: {
+        nextStateId: K;
+        input: LoopStateContract[K]["input"];
+    };
+}[TStateId];
 
 type InferenceInput = {
     model: string;
@@ -158,6 +263,7 @@ type InferenceOutput = {
 };
 interface InferenceRunner {
     run(request: InferenceInput): Promise<InferenceOutput>;
+    stream(request: InferenceInput): AsyncGenerator<SemanticEvent>;
 }
 
 interface InferenceEndpointMapper {
@@ -188,6 +294,11 @@ type ModelSpecification = {
     supportsStructuredOutput: boolean;
 };
 
+interface RequestValidationRule {
+    readonly name: string;
+    isValid(inferenceInput: InferenceInput, model: ModelSpecification): boolean;
+}
+
 type StructuredOutputFormat = {
     name?: string;
     schema: Record<string, any>;
@@ -293,45 +404,6 @@ declare class SystemMessageItem extends ContextItem {
     }): SystemMessageItem;
 }
 
-type SituationContext$1<TEvent extends SemanticEvent = SemanticEvent> = {
-    readonly event: TEvent;
-    readonly participant: Participant;
-};
-declare abstract class SituationSpecification<TEvent extends SemanticEvent = SemanticEvent> {
-    abstract isSatisfiedBy(situationContext: SituationContext$1<TEvent>): boolean;
-    and(other: SituationSpecification<TEvent>): SituationSpecification<TEvent>;
-    or(other: SituationSpecification<TEvent>): SituationSpecification<TEvent>;
-    not(): SituationSpecification<TEvent>;
-}
-
-interface SituationHandler {
-    readonly specification: SituationSpecification;
-    readonly processor: SituationProcessor;
-}
-type SituationContext<TEvent extends SemanticEvent = SemanticEvent> = {
-    readonly event: TEvent;
-    readonly participant: Participant;
-};
-interface SituationProcessor {
-    apply(context: SituationContext): void | Promise<void>;
-}
-
-type ParticipantRole = "agent" | "human";
-type ParticipantManifest = {
-    readonly id: string;
-    readonly name: string;
-    readonly role: ParticipantRole;
-    readonly capabilities?: readonly string[];
-};
-declare abstract class Participant {
-    private readonly manifest;
-    private handlers;
-    protected constructor(manifest: ParticipantManifest, handlers: SituationHandler[]);
-    getManifest(): ParticipantManifest;
-    getId(): string;
-    getHandlers(): SituationHandler[];
-}
-
 declare class Memory {
     private readonly context;
     private constructor();
@@ -406,8 +478,8 @@ declare class RuntimeService<TRuntimeState extends RuntimeState> {
 }
 
 type InferenceRunnerConfig = {
-    supportedModels: GenerativeModel[];
-    runner: InferenceRunner;
+    supportedModels?: GenerativeModel[];
+    runner?: InferenceRunner;
 };
 declare function defineRuntime<TRuntimeState extends RuntimeState>(): {
     initializeRuntime: (config: {
@@ -419,7 +491,128 @@ declare function defineRuntime<TRuntimeState extends RuntimeState>(): {
     join: (participant: Participant) => void;
     leave: (participant: Participant) => void;
     sendMessage: (message: string, senderId: string) => void;
-    runLoop: (agentId: string, message: string, inferenceInput: InferenceInput) => void;
+    sendEvent: (event: SemanticEvent, senderId: string) => void;
+    runLoop: (agentId: string, message: string, inferenceInput: InferenceInput, interceptionHandler?: InterceptionHandler) => void;
 };
 
-export { ContextItem, DeveloperMessageItem, type Endpoint, FunctionCallItem, FunctionCallOutputItem, type InferenceInput, type InferenceOutput, InputTokenDetails, McpClient, type McpServerConfig, McpToolRegistry, type McpToolSpec, ModelContext, type ModelContextRepository, ModelMessageItem, OutputTokenDetails, Participant, ReasoningItem, RuntimeState, SemanticEvent, type StructuredOutputFormat, SystemMessageItem, TokenUsage, type Tool, UserMessageItem, createAgent, createHuman, defineRuntime };
+declare const supportedModels: GenerativeModel[];
+
+declare class OpenAIResponses implements Endpoint {
+    endpointMapper: InferenceEndpointMapper;
+    private _client?;
+    constructor(endpointMapper?: InferenceEndpointMapper);
+    private get client();
+    infer(inferenceInput: InferenceInput): Promise<InferenceOutput>;
+    stream(inferenceInput: InferenceInput): AsyncIterable<SemanticEvent>;
+}
+
+/**
+ * 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 {
+    endpointMapper: InferenceEndpointMapper;
+    private _client?;
+    private readonly clientConfig;
+    private readonly extraBody;
+    constructor(endpointMapper?: InferenceEndpointMapper, config?: OpenAICompatibleConfig);
+    private get client();
+    private buildRequest;
+    infer(inferenceInput: InferenceInput): Promise<InferenceOutput>;
+    stream(inferenceInput: InferenceInput): AsyncIterable<SemanticEvent>;
+}
+
+interface AnthropicConnectionConfig {
+    baseURL?: string;
+    apiKey?: string;
+}
+/**
+ * Native Anthropic adapter on the `@anthropic-ai/sdk` (`messages.create`).
+ * Maps domain context to Anthropic's `messages`/`content` blocks shape,
+ * system prompt, tools, adaptive thinking, and structured output config.
+ */
+declare class AnthropicMessages implements Endpoint {
+    endpointMapper: InferenceEndpointMapper;
+    private _client?;
+    private readonly clientConfig;
+    constructor(endpointMapper?: InferenceEndpointMapper, config?: AnthropicConnectionConfig);
+    private get client();
+    infer(inferenceInput: InferenceInput): Promise<InferenceOutput>;
+    stream(inferenceInput: InferenceInput): AsyncIterable<SemanticEvent>;
+}
+
+interface GeminiConnectionConfig {
+    baseURL?: string;
+    apiKey?: string;
+}
+/**
+ * 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.
+ */
+declare class GeminiGenerateContent implements Endpoint {
+    endpointMapper: InferenceEndpointMapper;
+    private _client?;
+    private readonly clientConfig;
+    constructor(endpointMapper?: InferenceEndpointMapper, config?: GeminiConnectionConfig);
+    private get client();
+    infer(inferenceInput: InferenceInput): Promise<InferenceOutput>;
+    stream(inferenceInput: InferenceInput): AsyncIterable<SemanticEvent>;
+}
+
+declare class InferenceInputValidator {
+    private readonly rules;
+    constructor(rules?: RequestValidationRule[]);
+    validate(inferenceInput: InferenceInput, model: ModelSpecification): void;
+}
+
+declare class DefaultInferenceRunner implements InferenceRunner {
+    private readonly supportedModels;
+    private readonly requestValidator;
+    constructor(supportedModels: GenerativeModel[], requestValidator: InferenceInputValidator);
+    run(input: InferenceInput): Promise<InferenceOutput>;
+    stream(input: InferenceInput): AsyncGenerator<SemanticEvent>;
+}
+
+interface InterceptionHandler {
+    isSatisfiedBy(transition: LoopTransition): boolean;
+    handle(transition: LoopTransition): Promise<LoopTransition>;
+}
+
+export { Agent, AnthropicMessages, ContextItem, DefaultInferenceRunner, DeveloperMessageItem, type Endpoint, FunctionCallItem, FunctionCallOutputItem, GeminiGenerateContent, Human, type InferenceInput, type InferenceOutput, type InferenceRunner, type InferenceRunnerConfig, InputTokenDetails, type InterceptionHandler, McpClient, type McpServerConfig, McpToolRegistry, type McpToolSpec, ModelContext, type ModelContextRepository, ModelMessageItem, OpenAIChatCompletions, OpenAIResponses, OutputTokenDetails, Participant, ReasoningItem, RuntimeState, SemanticEvent, type SituationContext, type SituationHandler, type SituationProcessor, SituationSpecification, type StructuredOutputFormat, SystemMessageItem, TokenUsage, type Tool, UserMessageItem, createAgent, createHuman, defineRuntime, supportedModels };