@mozaik-ai/core 4.2.0-beta.9 → 4.2.0

package/dist/index.d.mts

@@ -1,8 +1,139 @@
-type SituationContext$1<TEvent extends SpaceEvent = SpaceEvent> = {
+declare abstract class ContextItem {
+    abstract readonly type: string;
+    getType(): string;
+}
+
+declare class FunctionCallItem extends ContextItem {
+    readonly type = "function_call";
+    readonly callId: string;
+    readonly name: string;
+    readonly args: string;
+    private constructor();
+    static rehydrate(data: {
+        callId: string;
+        name: string;
+        args: string;
+    }): FunctionCallItem;
+}
+
+declare abstract class ItemContent {
+    abstract readonly type: string;
+}
+
+declare class OutputText extends ItemContent {
+    readonly text: string;
+    readonly type = "output_text";
+    private constructor();
+    static rehydrate(data: {
+        text: string;
+    }): OutputText;
+}
+
+declare class ModelMessageItem extends ContextItem {
+    readonly type = "message";
+    readonly role = "assistant";
+    readonly content: OutputText;
+    private constructor();
+    static rehydrate(data: {
+        text: string;
+    }): ModelMessageItem;
+}
+
+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 SummaryText extends ItemContent {
+    readonly text: string;
+    readonly type = "summary_text";
+    private constructor();
+    static rehydrate(data: {
+        text: string;
+    }): SummaryText;
+}
+
+declare class ReasoningItem extends ContextItem {
+    readonly type = "reasoning";
+    readonly content: InputText | undefined;
+    readonly encryptedContent: string | undefined;
+    readonly summary: SummaryText[];
+    private constructor();
+    static rehydrate(data: {
+        content: InputText | undefined;
+        encryptedContent: string | undefined;
+        summary: SummaryText[];
+    }): ReasoningItem;
+}
+
+declare class ModelContext {
+    readonly id: string;
+    readonly items: ContextItem[];
+    constructor(id: string, items: ContextItem[]);
+    getItems(): ContextItem[];
+    addContextItems(contextItems: ContextItem[]): ModelContext;
+    addContextItem(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;
+}
+
+declare class FunctionCallOutputItem extends ContextItem {
+    readonly type = "function_call_output";
+    readonly callId: string;
+    readonly output: InputText;
+    private constructor();
+    static create(callId: string, output: string): FunctionCallOutputItem;
+    static rehydrate(data: {
+        callId: string;
+        output: InputText;
+    }): FunctionCallOutputItem;
+}
+
+interface FunctionTool {
+    type: "function";
+    name: string;
+    description: string;
+    parameters: Record<string, any>;
+    strict: boolean;
+    invoke: (args: any) => Promise<any>;
+}
+type Tool = FunctionTool;
+
+type SituationContext$1<TEvent extends SemanticEvent = SemanticEvent> = {
     readonly event: TEvent;
     readonly participant: Participant;
 };
-declare abstract class SituationSpecification<TEvent extends SpaceEvent = SpaceEvent> {
+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>;
@@ -13,7 +144,7 @@ interface SituationHandler {
     readonly specification: SituationSpecification;
     readonly processor: SituationProcessor;
 }
-type SituationContext<TEvent extends SpaceEvent = SpaceEvent> = {
+type SituationContext<TEvent extends SemanticEvent = SemanticEvent> = {
     readonly event: TEvent;
     readonly participant: Participant;
 };
@@ -21,139 +152,161 @@ interface SituationProcessor {
     apply(context: SituationContext): void | Promise<void>;
 }
 
-type ParticipantRole = "agent" | "external";
+type ParticipantRole = "agent" | "human";
 type ParticipantManifest = {
     readonly id: string;
     readonly name: string;
     readonly role: ParticipantRole;
     readonly capabilities?: readonly string[];
 };
-declare class Participant {
-    private manifest;
+declare abstract class Participant {
+    private readonly manifest;
     private handlers;
-    constructor(manifest: ParticipantManifest, handlers: SituationHandler[]);
+    protected constructor(manifest: ParticipantManifest, handlers: SituationHandler[]);
     getManifest(): ParticipantManifest;
-    setManifest(manifest: ParticipantManifest): void;
     getId(): string;
     getHandlers(): SituationHandler[];
     setHandlers(handlers: SituationHandler[]): void;
 }
 
-declare class SpaceEvent<TType extends string = string, TPayload = unknown> {
+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, occurredAt: Date, payload: TPayload): SpaceEvent<TType, TPayload>;
+    static create<TType extends string = string, TPayload = unknown>(type: TType, producerId: string, payload: TPayload): SemanticEvent<TType, TPayload>;
 }
 
-interface SharedState {
+interface FunctionCallRunner {
+    run(call: FunctionCallItem, tool: Tool): Promise<FunctionCallOutputItem>;
 }
-
-interface FunctionTool {
-    type: "function";
-    name: string;
-    description: string;
-    parameters: Record<string, any>;
-    strict: boolean;
-    invoke: (args: any) => Promise<any> | any;
+interface FunctionCallParams {
+    call: FunctionCallItem;
+    inferenceInput: InferenceInput;
 }
-type Tool = FunctionTool;
 
-type SpaceRecord = {
-    id: string;
-    name: string;
-    participants: Participant[];
-};
-declare class Space {
-    private readonly id;
-    private name;
-    private participants;
-    private events;
-    constructor(id: string, name: string, participants: Participant[], events?: SpaceEvent[]);
-    getId(): string;
-    getName(): string;
-    addParticipant(participant: Participant): SpaceEvent | undefined;
-    getParticipant(id: string): Participant | undefined;
-    removeParticipant(participant: Participant): SpaceEvent;
-    getParticipants(): Participant[];
-    sendMessage(participant: Participant, message: string, occurredAt: Date): SpaceEvent;
-    getEvents(): SpaceEvent[];
-    static create(name: string, participants?: Participant[]): Space;
-    get record(): SpaceRecord;
-    static rehydrate({ id, name, participants }: SpaceRecord): Space;
+interface InterceptionHandler {
+    isSatisfiedBy(transition: ExecutableTransition): boolean;
+    handle(transition: ExecutableTransition): Promise<ExecutableTransition>;
 }
-
-declare class RuntimeService<TSharedState extends SharedState> {
-    readonly state: TSharedState;
-    constructor(state: TSharedState);
+type InterceptionOutput = {
+    type: "continue";
+    transition: LoopTransition;
+} | {
+    type: "pause";
+    pendingTransition: LoopTransition;
+} | {
+    type: "stop";
+    reason?: string;
+};
+interface InterceptionParams {
+    pendingTransition: LoopTransition;
 }
 
-declare function defineRuntime<TSharedState extends SharedState>(): {
-    initializeRuntime: (config: {
-        state: TSharedState;
-    }) => RuntimeService<TSharedState>;
-    resolveRuntime: () => RuntimeService<TSharedState>;
-    createParticipant: (name: string, capabilities: readonly string[], handlers: SituationHandler[]) => Promise<Participant>;
-    createSpace: (name: string) => Promise<Space>;
-    join: (spaceId: string, participant: Participant) => Promise<void>;
-    leave: (spaceId: string, participantId: string) => Promise<void>;
-    sendMessage: (spaceId: string, participantId: string, message: string) => Promise<void>;
-    sendMessageTool: FunctionTool;
+type LoopStateId = "message_received" | "inference" | "inference_streaming" | "function_call" | "model_message" | "idle";
+type ReceivedMessage = {
+    content: string;
+    input: InferenceInput;
 };
+interface FunctionCallExecutionOutput {
+    item: FunctionCallOutputItem;
+}
+interface ModelMessageParams {
+    answer: ModelMessageItem;
+}
+interface LoopStateContract {
+    message_received: {
+        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 ExecutableLoopStateId = Exclude<LoopStateId, "idle">;
+type ExecutableTransition = LoopTransition<ExecutableLoopStateId>;
+type LoopStateExecution<TStateId extends ExecutableLoopStateId = ExecutableLoopStateId> = {
+    [K in TStateId]: {
+        stateId: K;
+        input: LoopStateContract[K]["input"];
+        output: LoopStateContract[K]["output"];
+    };
+}[TStateId];
+type LoopTransition<TStateId extends LoopStateId = LoopStateId> = {
+    [K in TStateId]: {
+        nextStateId: K;
+        input: LoopStateContract[K]["input"];
+    };
+}[TStateId];
 
-interface ItemContent {
-    readonly type: string;
-}
-interface InputText extends ItemContent {
-    readonly type: "input_text";
-    readonly text: string;
-}
-interface SummaryText {
-    readonly type: "summary_text";
-    readonly text: string;
-}
-interface ReasoningItem {
-    readonly type: "reasoning";
-    readonly content?: InputText;
-    readonly encryptedContent?: string;
-    readonly summary: SummaryText[];
-}
-interface MessageItem {
-    readonly type: "user_message" | "system_message" | "developer_message" | "model_message";
-    readonly text: string;
-}
-interface ModelMessageItem extends MessageItem {
-    readonly type: "model_message";
-    readonly text: string;
+declare class InputTokenDetails {
+    readonly cached_tokens: number;
+    constructor(cached_tokens: number);
 }
-interface ToolUseRequest {
-    readonly type: "tool_use_request";
-    readonly requestId: string;
-    readonly toolName: string;
-    readonly toolArguments: string;
+declare class OutputTokenDetails {
+    readonly reasoning_tokens: number;
+    constructor(reasoning_tokens: number);
 }
-interface ToolUseResult {
-    readonly type: "tool_use_result";
-    readonly requestId: string;
-    readonly result: InputText;
+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);
 }
-type ContextItem = MessageItem | ReasoningItem | ToolUseRequest | ToolUseResult;
-type ModelOutputItem = ModelMessageItem | ToolUseRequest | ReasoningItem;
-type Context = {
-    readonly items: ContextItem[];
+
+type InferenceInput = {
+    model: string;
+    maxOutputTokens?: number;
+    reasoningEffort?: string;
+    tools?: Tool[];
+    streaming?: boolean;
+    structuredOutput?: StructuredOutputFormat;
+    context: ModelContext;
 };
+type InferenceItem = FunctionCallItem | ReasoningItem | ModelMessageItem;
+type InferenceOutput = {
+    items: InferenceItem[];
+    tokenUsage: TokenUsage | undefined;
+    rowResponse: any;
+};
+interface InferenceRunner {
+    run(request: InferenceInput): Promise<InferenceOutput>;
+    stream(request: InferenceInput): AsyncGenerator<SemanticEvent>;
+}
 
 interface InferenceEndpointMapper {
-    toRequest(inferenceRequest: InferenceRequest): any;
-    toResponse(response: any): InferenceResult;
+    toRequest(inferenceInput: InferenceInput): any;
+    toResponse(response: any): InferenceOutput;
 }
 
 interface Endpoint {
     endpointMapper: InferenceEndpointMapper;
-    infer(requestParams: InferenceRequest): Promise<InferenceResult>;
-    stream(requestParams: InferenceRequest): AsyncIterable<SpaceEvent>;
+    infer(requestParams: InferenceInput): Promise<InferenceOutput>;
+    stream(requestParams: InferenceInput): AsyncIterable<SemanticEvent>;
 }
 
 type GenerativeModel = {
@@ -173,290 +326,312 @@ type ModelSpecification = {
     supportsStructuredOutput: boolean;
 };
 
+interface RequestValidationRule {
+    readonly name: string;
+    isValid(inferenceInput: InferenceInput, model: ModelSpecification): boolean;
+}
+
 type StructuredOutputFormat = {
     name?: string;
     schema: Record<string, any>;
     strict?: boolean;
 };
 
-declare class InputTokenDetails {
-    readonly cached_tokens: number;
-    constructor(cached_tokens: number);
+interface ModelContextRepository {
+    save(context: ModelContext): Promise<void>;
+    get(id: string): Promise<ModelContext>;
+    getByProjectId(projectId: string): Promise<ModelContext[]>;
 }
-declare class OutputTokenDetails {
-    readonly reasoning_tokens: number;
-    constructor(reasoning_tokens: number);
+
+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 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 McpToolSpec {
+    name: string;
+    description: string;
+    /** JSON Schema for the tool's arguments (maps 1:1 to FunctionTool.parameters). */
+    inputSchema: Record<string, any>;
+}
+/**
+ * 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 McpClient {
+    private readonly config;
+    private readonly client;
+    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>;
 }
 
-type InferenceRequest = {
-    model: string;
-    maxOutputTokens?: number;
-    reasoningEffort?: string;
-    tools?: Tool[];
-    streaming?: boolean;
-    structuredOutput?: StructuredOutputFormat;
-    context: Context;
-};
-type InferenceResult = {
-    items: ModelOutputItem[];
-    tokenUsage: TokenUsage | undefined;
-    rowResponse: any;
-};
-interface InferenceRunner {
-    run(request: InferenceRequest): Promise<InferenceResult>;
-    stream(request: InferenceRequest): AsyncGenerator<SpaceEvent>;
+/** 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>;
+}
+/**
+ * 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.
+ */
+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>;
 }
 
-interface Memory {
-    remember(items: ContextItem[], participantId: string): void;
-    recall(topic: string, participantId: string): 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 AgentRecord = {
-    id: string;
+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[];
-    memory: Memory;
-};
+    handlers: SituationHandler[];
+}): Agent;
 
-declare class Agent {
-    private _id;
-    private _name;
-    private _instruction;
-    private _memory;
-    private _tools;
-    constructor(id: string, name: string, instruction: string, tools: Tool[], memory: Memory);
-    get id(): string;
-    get name(): string;
-    get instruction(): string;
-    get tools(): Tool[];
-    get memory(): Memory;
-    static create({ name, instruction, tools, memory, }: {
+declare class Human extends Participant {
+    constructor(manifest: ParticipantManifest, handlers: SituationHandler[]);
+    static create({ name, capabilities, handlers, }: {
         name: string;
-        instruction: string;
-        tools: Tool[];
-        memory: Memory;
-    }): Agent;
-    static rehydrate(record: AgentRecord): Agent;
+        capabilities: readonly string[];
+        handlers: SituationHandler[];
+    }): Human;
 }
 
-interface AgentRepository {
-    save(agent: Agent): Promise<void>;
-    exists(id: string): Promise<boolean>;
-    findById(id: string): Promise<Agent | undefined>;
-    findAll(): Promise<Agent[]>;
+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[];
 }
 
-type CompletedOperation = {
-    type: "inference";
-    operationId: string;
-    requestedAt: Date;
-    completedAt: Date;
-    request: InferenceRequest;
-    result: InferenceResult;
-} | {
-    type: "tool_use";
-    operationId: string;
-    requestedAt: Date;
-    completedAt: Date;
-    call: ToolUseRequest;
-    result: ToolUseResult;
-};
-type PendingInference = {
-    id: string;
-    type: "inference";
-    requestedAt: Date;
-    request: InferenceRequest;
+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;
 };
-type PendingToolExecution = {
-    id: string;
-    type: "tool_execution";
-    requestedAt: Date;
-    call: ToolUseRequest;
+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;
 };
-type PendingOperation = PendingInference | PendingToolExecution;
 
-interface LoopTransition {
-    readonly occurredAt: Date;
-    readonly previousState: LoopStateId;
-    readonly nextState: LoopStateId;
-    readonly reason: string;
-    readonly operationId?: string;
+declare const supportedModels: GenerativeModel[];
+
+/**
+ * Optional connection config. When omitted, the `openai` SDK reads
+ * `OPENAI_API_KEY` and `OPENAI_BASE_URL` from the environment.
+ */
+interface OpenAIResponsesConfig {
+    baseURL?: string;
+    apiKey?: string;
+}
+declare class OpenAIResponses implements Endpoint {
+    endpointMapper: InferenceEndpointMapper;
+    private _client?;
+    private readonly clientConfig;
+    constructor(endpointMapper?: InferenceEndpointMapper, config?: OpenAIResponsesConfig);
+    private get client();
+    infer(inferenceInput: InferenceInput): Promise<InferenceOutput>;
+    stream(inferenceInput: InferenceInput): AsyncIterable<SemanticEvent>;
 }
 
-type AgentLoop = {
-    readonly agent: Agent;
-    readonly loop: Loop;
-};
-declare abstract class LoopSpecification {
-    abstract isSatisfiedBy(agentLoop: AgentLoop): boolean;
-    and(other: LoopSpecification): LoopSpecification;
-    or(other: LoopSpecification): LoopSpecification;
-    not(): LoopSpecification;
+/**
+ * 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>;
 }
 
-type LoopControlDirective = InferenceDirective | ToolUseDirective | WaitDirective | CompleteDirective;
-type InferenceDirective = {
-    type: "inference";
-    request: InferenceRequest;
-};
-type ToolUseDirective = {
-    type: "tool_use";
-    call: ToolUseRequest;
-};
-type WaitDirective = {
-    type: "wait";
-    reason: string;
-};
-type CompleteDirective = {
-    type: "complete";
-    reason: string;
-};
+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>;
+}
 
-declare abstract class LoopAction {
-    abstract execute(agentLoop: AgentLoop): LoopControlDirective;
+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>;
 }
 
-type CreateLoopRuleParams = {
-    readonly priority?: number;
-    readonly when: LoopSpecification;
-    readonly then: LoopAction;
-};
-type LoopRuleRecord = {
-    readonly id: string;
-    readonly priority: number;
-    readonly condition: LoopSpecification;
-    readonly action: LoopAction;
-};
-declare class LoopRule {
-    _id: string;
-    _priority: number;
-    _condition: LoopSpecification;
-    _action: LoopAction;
-    constructor(id: string, condition: LoopSpecification, action: LoopAction, priority: number);
-    get id(): string;
-    get priority(): number;
-    get condition(): LoopSpecification;
-    get action(): LoopAction;
-    static create(spec: CreateLoopRuleParams): LoopRule;
-    static rehydrate(spec: LoopRuleRecord): LoopRule;
-}
-type RuleBookRecord = {
-    readonly rules: LoopRuleRecord[];
-};
-declare class RuleBook {
-    private rules;
-    private constructor();
-    addRule(rule: LoopRule): void;
-    removeRule(rule: LoopRule): void;
-    getRules(): readonly LoopRule[];
-    static create(loopRuleParams: CreateLoopRuleParams[]): RuleBook;
-    static rehydrate(record: RuleBookRecord): RuleBook;
-    record(): RuleBookRecord;
-}
-
-interface LoopRecord {
-    id: string;
-    agentId: string;
-    subject: string;
-    createdAt: Date;
-    state: LoopStateId;
-    inferenceRequest?: InferenceRequest;
-    pendingOperation?: PendingOperation;
-    transitionHistory: LoopTransition[];
-    operationHistory: CompletedOperation[];
-    ruleBook: RuleBookRecord;
-}
-
-type LoopStateId = "idle" | "awaiting_inference_request" | "awaiting_inference" | "awaiting_tool_output" | "stopped" | "completed";
-type CreateLoopParams = {
-    subject: string;
-    agentId: string;
-    rules: CreateLoopRuleParams[];
-} | {
-    subject: string;
-    agentId: string;
-    request: InferenceRequest;
-};
-declare class Loop {
-    private readonly loopId;
-    private readonly agentId;
-    private readonly subject;
-    private readonly createdAt;
-    private state;
-    private pendingOperation;
-    private readonly transitionHistory;
-    private inferenceRequest;
-    private readonly operationHistory;
-    private readonly _ruleBook;
-    private constructor();
-    get id(): string;
-    get stateId(): LoopStateId;
-    get pending(): PendingOperation | undefined;
-    get history(): readonly LoopTransition[];
-    get completedOperations(): readonly CompletedOperation[];
-    get request(): InferenceRequest | undefined;
-    get ruleBook(): RuleBook;
-    getSubject(): string;
-    getAgentId(): string;
-    record(): LoopRecord;
-    moveToIdle(reason: string, transitionId: string): void;
-    moveToAwaitingInference(operation: PendingInference): void;
-    moveToAwaitingToolOutput(operation: Extract<PendingOperation, {
-        type: "tool_execution";
-    }>, occurredAt: Date): void;
-    requestInference(request: InferenceRequest): PendingInference;
-    requestToolUse(operationId: string, call: ToolUseRequest, requestedAt: Date): PendingToolExecution;
-    private transitionTo;
-    private assertIdle;
-    private assertAwaitingInferenceRequest;
-    receiveInferenceResult(operationId: string, result: InferenceResult): void;
-    receiveToolUseResult(operationId: string, result: ToolUseResult): void;
-    complete(reason: string): void;
-    stop(reason: string): void;
-    wait(reason: string): void;
-    private assertNotSettled;
-    static create(agentId: string, subject: string, ruleBook: RuleBook): Loop;
-    static rehydrate(record: LoopRecord): Loop;
-}
-
-interface LoopRepository {
-    save(loop: Loop): Promise<void>;
-    findById(id: string): Promise<Loop | undefined>;
-}
-
-interface ToolUseRunner {
-    run(request: ToolUseRequest, tool: Tool): Promise<ToolUseResult>;
+declare class InferenceInputValidator {
+    private readonly rules;
+    constructor(rules?: RequestValidationRule[]);
+    validate(inferenceInput: InferenceInput, model: ModelSpecification): void;
 }
 
-type InferenceRunnerConfig = {
-    supportedModels?: GenerativeModel[];
-    runner?: InferenceRunner;
-};
-type AgentModuleConfig = {
-    agentRepository?: AgentRepository;
-    agentLoopRepository?: LoopRepository;
-    inferenceRunnerConfig?: InferenceRunnerConfig;
-    toolRunner?: ToolUseRunner;
-};
-declare function defineAgentModule(config: AgentModuleConfig): {
-    createAgent: (config: {
-        name: string;
-        instruction: string;
-        tools: Tool[];
-        handlers: SituationHandler[];
-    }) => Promise<Agent>;
-    createLoop: (params: CreateLoopParams) => Promise<Loop>;
-    runLoop: (loopId: string) => Promise<Loop>;
-};
+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, type AgentModuleConfig, type AgentRepository, type GenerativeModel, type InferenceRunner, type InferenceRunnerConfig, type LoopRepository, type ModelMessageItem, Participant, type SharedState, type SituationContext, type SituationHandler, type SituationProcessor, SituationSpecification, SpaceEvent, type Tool, type ToolUseRequest, type ToolUseResult, type ToolUseRunner, defineAgentModule, defineRuntime };
+export { Agent, AnthropicMessages, ContextItem, DefaultInferenceRunner, DeveloperMessageItem, type Endpoint, type ExecutableLoopStateId, type ExecutableTransition, FunctionCallItem, FunctionCallOutputItem, GeminiGenerateContent, Human, type InferenceInput, type InferenceOutput, type InferenceRunner, type InferenceRunnerConfig, InputTokenDetails, type InterceptionHandler, type LoopStateExecution, type LoopTransition, 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 };