@mozaik-ai/core 3.14.0 → 4.0.0-beta.10

package/dist/index.d.ts

@@ -3,59 +3,23 @@ declare abstract class ContextItem {
     getType(): string;
 }
 
-declare class ModelContext {
-    readonly id: string;
-    readonly projectId: string;
-    readonly items: ContextItem[];
-    constructor(id: string, projectId: string, items: ContextItem[]);
-    addContextItem(item: ContextItem): ModelContext;
-    applyModelOutput(items: ContextItem[]): ModelContext;
-    getItems(): ContextItem[];
-    getLastItem(): ContextItem;
-    static create(projectId: string): ModelContext;
+declare class FunctionCallItem extends ContextItem {
+    readonly type = "function_call";
+    readonly callId: string;
+    readonly name: string;
+    readonly args: string;
+    private constructor();
     static rehydrate(data: {
-        id: string;
-        projectId: string;
-        items: ContextItem[];
-    }): ModelContext;
+        callId: string;
+        name: string;
+        args: string;
+    }): FunctionCallItem;
 }
 
 declare abstract class ItemContent {
     abstract readonly type: string;
 }
 
-declare class InputText extends ItemContent {
-    readonly text: string;
-    readonly type = "input_text";
-    private constructor();
-    static create(text: string): InputText;
-    static rehydrate(data: {
-        text: string;
-    }): InputText;
-}
-
-declare class UserMessageItem extends ContextItem {
-    readonly type = "message";
-    readonly role = "user";
-    readonly content: InputText;
-    private constructor();
-    static create(text: string): UserMessageItem;
-    static rehydrate(data: {
-        text: string;
-    }): UserMessageItem;
-}
-
-declare class DeveloperMessageItem extends ContextItem {
-    readonly type = "message";
-    readonly role = "developer";
-    readonly content: InputText;
-    private constructor();
-    static create(text: string): DeveloperMessageItem;
-    static rehydrate(data: {
-        text: string;
-    }): DeveloperMessageItem;
-}
-
 declare class OutputText extends ItemContent {
     readonly text: string;
     readonly type = "output_text";
@@ -75,17 +39,14 @@ declare class ModelMessageItem extends ContextItem {
     }): ModelMessageItem;
 }
 
-declare class FunctionCallItem extends ContextItem {
-    readonly type = "function_call";
-    readonly callId: string;
-    readonly name: string;
-    readonly args: string;
+declare class InputText extends ItemContent {
+    readonly text: string;
+    readonly type = "input_text";
     private constructor();
+    static create(text: string): InputText;
     static rehydrate(data: {
-        callId: string;
-        name: string;
-        args: string;
-    }): FunctionCallItem;
+        text: string;
+    }): InputText;
 }
 
 declare class SummaryText extends ItemContent {
@@ -110,15 +71,41 @@ declare class ReasoningItem extends ContextItem {
     }): ReasoningItem;
 }
 
-interface FunctionTool {
-    type: "function";
-    name: string;
-    description: string;
-    parameters: Record<string, any>;
-    strict: boolean;
-    invoke: (args: any) => Promise<any>;
+declare class ModelContext {
+    readonly id: string;
+    readonly items: ContextItem[];
+    constructor(id: string, items: ContextItem[]);
+    getItems(): ContextItem[];
+    addContextItems(contextItems: ContextItem[]): ModelContext;
+    addItem(item: ContextItem): ModelContext;
+    static create(): ModelContext;
+    static rehydrate(data: {
+        id: string;
+        items: ContextItem[];
+    }): ModelContext;
+}
+
+declare class UserMessageItem extends ContextItem {
+    readonly type = "message";
+    readonly role = "user";
+    readonly content: InputText;
+    private constructor();
+    static create(text: string): UserMessageItem;
+    static rehydrate(data: {
+        text: string;
+    }): UserMessageItem;
+}
+
+declare class DeveloperMessageItem extends ContextItem {
+    readonly type = "message";
+    readonly role = "developer";
+    readonly content: InputText;
+    private constructor();
+    static create(text: string): DeveloperMessageItem;
+    static rehydrate(data: {
+        text: string;
+    }): DeveloperMessageItem;
 }
-type Tool = FunctionTool;
 
 declare class FunctionCallOutputItem extends ContextItem {
     readonly type = "function_call_output";
@@ -132,130 +119,185 @@ declare class FunctionCallOutputItem extends ContextItem {
     }): FunctionCallOutputItem;
 }
 
-declare class SemanticEvent<T> {
-    readonly type: string;
-    readonly data: T;
-    constructor(type: string, data: T);
-    getType(): string;
+interface FunctionTool {
+    type: "function";
+    name: string;
+    description: string;
+    parameters: Record<string, any>;
+    strict: boolean;
+    invoke: (args: any) => Promise<any>;
 }
+type Tool = FunctionTool;
 
-interface AgenticErrorOpts {
-    message: string;
-    stack?: string;
-    source?: Participant;
-    enviornment?: AgenticEnvironment;
+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>;
 }
-declare class AgenticError extends Error {
-    private source?;
-    private environment?;
-    constructor({ message, stack, source, enviornment }: AgenticErrorOpts);
-    getSource(): Participant | undefined;
-    getEnvironment(): AgenticEnvironment | undefined;
+
+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 ParticipantClassConstructor = new (...args: any[]) => Participant;
+type ParticipantRole = "agent" | "human";
+type ParticipantManifest = {
+    readonly id: string;
+    readonly name: string;
+    readonly role: ParticipantRole;
+    readonly capabilities?: readonly string[];
+};
 declare abstract class Participant {
-    private environments;
-    protected listens: ParticipantClassConstructor[];
-    private active;
-    join(environment: AgenticEnvironment): void;
-    leave(environment: AgenticEnvironment): void;
-    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;
-    abstract onLeft(): Promise<void> | void;
-    abstract onFunctionCall(item: FunctionCallItem): Promise<void> | void;
-    abstract onExternalFunctionCall(source: Participant, item: FunctionCallItem): Promise<void> | void;
-    abstract onFunctionCallOutput(item: FunctionCallOutputItem): Promise<void> | void;
-    abstract onExternalFunctionCallOutput(source: Participant, item: FunctionCallOutputItem): Promise<void> | void;
-    abstract onReasoning(item: ReasoningItem): Promise<void> | void;
-    abstract onExternalReasoning(source: Participant, item: ReasoningItem): Promise<void> | void;
-    abstract onModelMessage(item: ModelMessageItem): Promise<void> | void;
-    abstract onExternalModelMessage(source: Participant, item: ModelMessageItem): Promise<void> | void;
-    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;
-    abstract onError(error: AgenticError): void;
-    abstract onParticipantError(source: Participant, error: AgenticError): void;
-}
-
-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 InferenceParams<TModel extends string> = {
-    model: TModel;
+    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;
+    readonly occurredAt: Date;
+    readonly payload: TPayload;
+    constructor(type: TType, producerId: string, occurredAt: Date, payload: TPayload);
+    static create<TType extends string = string, TPayload = unknown>(type: TType, producerId: string, payload: TPayload): SemanticEvent<TType, TPayload>;
+}
+
+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;
     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 {
-    readonly contextItems: ContextItem[];
-    readonly tokenUsage?: TokenUsage;
-    constructor(contextItems: ContextItem[], tokenUsage: TokenUsage | undefined);
+type InferenceItem = FunctionCallItem | ReasoningItem | ModelMessageItem;
+type InferenceOutput = {
+    items: InferenceItem[];
+    rowResponse: any;
+};
+interface InferenceRunner {
+    run(request: InferenceInput): Promise<InferenceOutput>;
+    stream(request: InferenceInput): AsyncGenerator<SemanticEvent>;
 }
 
 interface InferenceEndpointMapper {
-    toRequest(inferenceParams: InferenceParams<ModelName>): any;
-    toResponse(response: any): InferenceResponse;
+    toRequest(inferenceInput: InferenceInput): any;
+    toResponse(response: any): InferenceOutput;
 }
 
 interface Endpoint {
     endpointMapper: InferenceEndpointMapper;
-    infer(requestParams: InferenceParams<ModelName>): Promise<InferenceResponse>;
-    stream(requestParams: InferenceParams<ModelName>, signal?: AbortSignal): AsyncIterable<SemanticEvent<unknown>>;
+    infer(requestParams: InferenceInput): Promise<InferenceOutput>;
+    stream(requestParams: InferenceInput): AsyncIterable<SemanticEvent>;
 }
 
-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";
+type GenerativeModel = {
+    endpoint: Endpoint;
+    specification: ModelSpecification;
+};
+type ModelSpecification = {
+    name: string;
+    provider: string;
+    supportsReasoningEffort: boolean;
+    supportedReasoningEfforts: string[];
+    supportsStreaming: boolean;
+    contextWindowSize: number;
+    supportedContextItemTypes: string[];
+    maxOutputTokens: number;
+    supportsFunctionCalling: boolean;
+    supportsStructuredOutput: boolean;
+};
+
+interface RequestValidationRule {
+    readonly name: string;
+    isValid(inferenceInput: InferenceInput, model: ModelSpecification): boolean;
+}
 
 type StructuredOutputFormat = {
     name?: string;
@@ -269,6 +311,23 @@ interface ModelContextRepository {
     getByProjectId(projectId: string): Promise<ModelContext[]>;
 }
 
+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);
+}
+
 interface McpServerConfig {
     /** The MCP server URL, e.g. https://api.githubcopilot.com/mcp/ */
     url: string;
@@ -334,15 +393,6 @@ declare class McpToolRegistry {
     close(): Promise<void>;
 }
 
-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";
@@ -354,28 +404,215 @@ declare class SystemMessageItem extends ContextItem {
     }): SystemMessageItem;
 }
 
-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;
-}
-
-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, 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 };
+declare class Memory {
+    private readonly context;
+    private constructor();
+    getContext(): ModelContext;
+    static create(): Memory;
+}
+
+declare class Agent extends Participant {
+    private memory;
+    private developerMessage;
+    private tools;
+    constructor(manifest: ParticipantManifest, developerMessage: string, tools: Tool[], memory: Memory, handlers: SituationHandler[]);
+    static create({ name, instruction, tools, capabilities, handlers, }: {
+        instruction: string;
+        tools: Tool[];
+        name: string;
+        capabilities: readonly string[];
+        handlers: SituationHandler[];
+    }): Agent;
+    getTools(): Tool[];
+    getDeveloperMessage(): string;
+    getMemory(): Memory;
+}
+
+declare function createAgent({ name, capabilities, instruction, tools, handlers, }: {
+    name: string;
+    capabilities: readonly string[];
+    instruction: string;
+    tools: Tool[];
+    handlers: SituationHandler[];
+}): Agent;
+
+declare class Human extends Participant {
+    constructor(manifest: ParticipantManifest, handlers: SituationHandler[]);
+    static create({ name, capabilities, handlers, }: {
+        name: string;
+        capabilities: readonly string[];
+        handlers: SituationHandler[];
+    }): Human;
+}
+
+declare function createHuman({ name, capabilities, handlers, }: {
+    name: string;
+    capabilities: readonly string[];
+    handlers: SituationHandler[];
+}): Human;
+
+declare abstract class RuntimeState {
+    participants: Map<string, Participant>;
+    addParticipant(participant: Participant): void;
+    removeParticipant(participant: Participant): void;
+    getParticipant(id: string): Participant | undefined;
+    getParticipants(): readonly Participant[];
+}
+
+interface InterceptionHandler {
+    isSatisfiedBy(transition: LoopTransition): boolean;
+    handle(transition: LoopTransition): Promise<LoopTransition>;
+}
+
+declare class EventProcessor {
+    process(event: SemanticEvent, consumer: Participant): void;
+}
+
+declare class RuntimeService<TRuntimeState extends RuntimeState> {
+    readonly state: TRuntimeState;
+    private readonly processor;
+    private readonly inferenceRunner;
+    private readonly functionCallRunner;
+    constructor(state: TRuntimeState, processor: EventProcessor, inferenceRunner: InferenceRunner, functionCallRunner: FunctionCallRunner);
+    join(participant: Participant): void;
+    leave(participant: Participant): void;
+    publish(event: SemanticEvent): void;
+    getParticipant(id: string): Participant | undefined;
+    getInferenceRunner(): InferenceRunner;
+    getFunctionCallRunner(): FunctionCallRunner;
+}
+
+type InferenceRunnerConfig = {
+    supportedModels?: GenerativeModel[];
+    runner?: InferenceRunner;
+};
+declare function defineRuntime<TRuntimeState extends RuntimeState>(): {
+    initializeRuntime: (config: {
+        state: TRuntimeState;
+        inferenceRunnerConfig?: InferenceRunnerConfig;
+    }) => RuntimeService<TRuntimeState>;
+    resolveRuntime: () => RuntimeService<TRuntimeState>;
+    resolveParticipant: (id: string) => Participant;
+    join: (participant: Participant) => void;
+    leave: (participant: Participant) => void;
+    sendMessage: (message: string, senderId: string) => void;
+    sendEvent: (event: SemanticEvent, senderId: string) => void;
+    runLoop: (agentId: string, message: string, inferenceInput: InferenceInput, interceptionHandler?: InterceptionHandler) => void;
+};
+
+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>;
+}
+
+export { Agent, AnthropicMessages, ContextItem, DefaultInferenceRunner, DeveloperMessageItem, type Endpoint, FunctionCallItem, FunctionCallOutputItem, GeminiGenerateContent, Human, type InferenceInput, type InferenceOutput, type InferenceRunner, type InferenceRunnerConfig, InputTokenDetails, 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 };