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

package/dist/index.d.mts

@@ -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,94 +119,86 @@ 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;
+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>;
 }
-declare class AgenticError extends Error {
-    private source?;
-    private environment?;
-    constructor({ message, stack, source, enviornment }: AgenticErrorOpts);
-    getSource(): Participant | undefined;
-    getEnvironment(): AgenticEnvironment | undefined;
+
+interface FunctionCallRunner {
+    run(call: FunctionCallItem, tool: Tool): Promise<FunctionCallOutputItem>;
 }
 
-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;
-    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;
+type InferenceInput = {
+    model: string;
     maxOutputTokens?: number;
     reasoningEffort?: string;
     tools?: Tool[];
     streaming?: boolean;
     structuredOutput?: StructuredOutputFormat;
     context: ModelContext;
-    caller: Participant;
-    environment: AgenticEnvironment;
-    signal?: AbortSignal;
 };
+type InferenceItem = FunctionCallItem | ReasoningItem | ModelMessageItem;
+type InferenceOutput = {
+    items: InferenceItem[];
+    rowResponse: any;
+};
+interface InferenceRunner {
+    run(request: InferenceInput): Promise<InferenceOutput>;
+}
+
+interface InferenceEndpointMapper {
+    toRequest(inferenceInput: InferenceInput): any;
+    toResponse(response: any): InferenceOutput;
+}
+
+interface Endpoint {
+    endpointMapper: InferenceEndpointMapper;
+    infer(requestParams: InferenceInput): Promise<InferenceOutput>;
+    stream(requestParams: InferenceInput): AsyncIterable<SemanticEvent>;
+}
+
+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;
+};
+
+type StructuredOutputFormat = {
+    name?: string;
+    schema: Record<string, any>;
+    strict?: boolean;
+};
+
+interface ModelContextRepository {
+    save(context: ModelContext): Promise<void>;
+    get(id: string): Promise<ModelContext>;
+    getByProjectId(projectId: string): Promise<ModelContext[]>;
+}
 
 declare class InputTokenDetails {
     readonly cached_tokens: number;
@@ -238,44 +217,69 @@ declare class TokenUsage {
     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);
+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;
 }
-
-interface InferenceEndpointMapper {
-    toRequest(inferenceParams: InferenceParams<ModelName>): any;
-    toResponse(response: any): InferenceResponse;
+interface McpToolSpec {
+    name: string;
+    description: string;
+    /** JSON Schema for the tool's arguments (maps 1:1 to FunctionTool.parameters). */
+    inputSchema: Record<string, any>;
 }
-
-interface Endpoint {
-    endpointMapper: InferenceEndpointMapper;
-    infer(requestParams: InferenceParams<ModelName>): Promise<InferenceResponse>;
-    stream(requestParams: InferenceParams<ModelName>, signal?: AbortSignal): AsyncIterable<SemanticEvent<unknown>>;
+/**
+ * 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 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 StructuredOutputFormat = {
-    name?: string;
-    schema: Record<string, any>;
-    strict?: boolean;
-};
-
-interface ModelContextRepository {
-    save(context: ModelContext): Promise<void>;
-    get(id: string): Promise<ModelContext>;
-    getByProjectId(projectId: string): Promise<ModelContext[]>;
+/** 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>;
 }
-
-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;
+/**
+ * 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>;
 }
 
 declare class SystemMessageItem extends ContextItem {
@@ -289,28 +293,133 @@ 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, ModelContext, type ModelContextRepository, ModelMessageItem, type ModelName, OutputTokenDetails, Participant, ReasoningItem, SemanticEvent, type StructuredOutputFormat, SystemMessageItem, TokenUsage, type Tool, UserMessageItem, executeFunctionCall, runInference, sendMessage };
+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();
+    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[];
+}
+
+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;
+    runLoop: (agentId: string, message: string, inferenceInput: InferenceInput) => 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 };