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

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,74 @@ 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;
 };
-
-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>;
 }
 
 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;
+};
 
 type StructuredOutputFormat = {
     name?: string;
@@ -269,6 +200,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 +282,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 +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, 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 };
+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 };