@mozaik-ai/core 4.2.0-beta.1 → 4.2.0-beta.3

package/dist/index.d.mts

@@ -59,6 +59,7 @@ interface FunctionTool {
     strict: boolean;
     invoke: (args: any) => Promise<any> | any;
 }
+type Tool = FunctionTool;
 
 type SpaceRecord = {
     id: string;
@@ -102,4 +103,342 @@ declare function defineRuntime<TSharedState extends SharedState>(): {
     sendMessageTool: FunctionTool;
 };
 
-export { Participant, type SharedState, type SituationContext, type SituationHandler, type SituationProcessor, SituationSpecification, SpaceEvent, defineRuntime };
+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;
+}
+interface ToolUseRequest {
+    readonly type: "tool_use_request";
+    readonly requestId: string;
+    readonly toolName: string;
+    readonly toolArguments: string;
+}
+interface ToolUseResult {
+    readonly type: "tool_use_result";
+    readonly requestId: string;
+    readonly result: InputText;
+}
+type ContextItem = MessageItem | ReasoningItem | ToolUseRequest | ToolUseResult;
+type ModelOutputItem = ModelMessageItem | ToolUseRequest | ReasoningItem;
+type Context = {
+    readonly items: ContextItem[];
+};
+
+interface InferenceEndpointMapper {
+    toRequest(inferenceRequest: InferenceRequest): any;
+    toResponse(response: any): InferenceResult;
+}
+
+interface Endpoint {
+    endpointMapper: InferenceEndpointMapper;
+    infer(requestParams: InferenceRequest): Promise<InferenceResult>;
+    stream(requestParams: InferenceRequest): AsyncIterable<SpaceEvent>;
+}
+
+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;
+};
+
+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);
+}
+
+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>;
+}
+
+interface Memory {
+    getContext(): Context;
+    saveItem(item: ContextItem): void;
+    saveItems(items: ContextItem[]): void;
+}
+
+type AgentRecord = {
+    id: string;
+    manifest: ParticipantManifest;
+    tools: Tool[];
+    memory: Memory;
+    handlers: SituationHandler[];
+};
+
+declare class Agent extends Participant {
+    private memory;
+    private tools;
+    constructor(manifest: ParticipantManifest, tools: Tool[], memory: Memory, handlers: SituationHandler[]);
+    getTools(): Tool[];
+    getMemory(): Memory;
+    static create({ manifest, tools, memory, handlers, }: {
+        manifest: ParticipantManifest;
+        tools: Tool[];
+        memory: Memory;
+        handlers: SituationHandler[];
+    }): Agent;
+    static rehydrate(record: AgentRecord): Agent;
+}
+
+interface AgentRepository {
+    save(agent: Agent): Promise<void>;
+    exists(id: string): Promise<boolean>;
+    findById(id: string): Promise<Agent | undefined>;
+    findAll(): Promise<Agent[]>;
+}
+
+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;
+};
+type PendingToolExecution = {
+    id: string;
+    type: "tool_execution";
+    requestedAt: Date;
+    call: ToolUseRequest;
+};
+type PendingOperation = PendingInference | PendingToolExecution;
+
+interface LoopTransition {
+    readonly occurredAt: Date;
+    readonly previousState: LoopStateId;
+    readonly nextState: LoopStateId;
+    readonly reason: string;
+    readonly operationId?: string;
+}
+
+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;
+}
+
+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;
+};
+
+declare abstract class LoopAction {
+    abstract execute(agentLoop: AgentLoop): LoopControlDirective;
+}
+
+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;
+}
+
+interface LoopRecord {
+    id: string;
+    agentId: string;
+    subject: string;
+    createdAt: Date;
+    state: LoopStateId;
+    inferenceRequest?: InferenceRequest;
+    pendingOperation?: PendingOperation;
+    transitionHistory: LoopTransition[];
+    operationHistory: CompletedOperation[];
+    rules: LoopRule[];
+}
+
+type LoopStateId = "idle" | "awaiting_inference_request" | "awaiting_inference" | "awaiting_tool_output" | "stopped" | "completed";
+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 loopRules;
+    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 rules(): readonly LoopRule[];
+    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(id: string, agentId: string, subject: string, rules: LoopRule[]): 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>;
+}
+
+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<AgentRecord>;
+    createLoop: (params: {
+        subject: string;
+        agentId: string;
+        rules: CreateLoopRuleParams[];
+    }) => Promise<Loop>;
+    runLoop: (loopId: string) => Promise<Loop>;
+    state: (loopStateId: LoopStateId) => LoopSpecification;
+    modelAnswered: () => LoopSpecification;
+    runInference: () => LoopAction;
+    toolUse: () => LoopAction;
+    complete: (reason?: string) => LoopAction;
+    wait: (reason?: string) => LoopAction;
+};
+
+export { type AgentModuleConfig, type AgentRepository, type GenerativeModel, type InferenceRunner, type InferenceRunnerConfig, type LoopRepository, Participant, type SharedState, type SituationContext, type SituationHandler, type SituationProcessor, SituationSpecification, SpaceEvent, type Tool, type ToolUseRunner, defineAgentModule, defineRuntime };

package/dist/index.d.ts

@@ -59,6 +59,7 @@ interface FunctionTool {
     strict: boolean;
     invoke: (args: any) => Promise<any> | any;
 }
+type Tool = FunctionTool;
 
 type SpaceRecord = {
     id: string;
@@ -102,4 +103,342 @@ declare function defineRuntime<TSharedState extends SharedState>(): {
     sendMessageTool: FunctionTool;
 };
 
-export { Participant, type SharedState, type SituationContext, type SituationHandler, type SituationProcessor, SituationSpecification, SpaceEvent, defineRuntime };
+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;
+}
+interface ToolUseRequest {
+    readonly type: "tool_use_request";
+    readonly requestId: string;
+    readonly toolName: string;
+    readonly toolArguments: string;
+}
+interface ToolUseResult {
+    readonly type: "tool_use_result";
+    readonly requestId: string;
+    readonly result: InputText;
+}
+type ContextItem = MessageItem | ReasoningItem | ToolUseRequest | ToolUseResult;
+type ModelOutputItem = ModelMessageItem | ToolUseRequest | ReasoningItem;
+type Context = {
+    readonly items: ContextItem[];
+};
+
+interface InferenceEndpointMapper {
+    toRequest(inferenceRequest: InferenceRequest): any;
+    toResponse(response: any): InferenceResult;
+}
+
+interface Endpoint {
+    endpointMapper: InferenceEndpointMapper;
+    infer(requestParams: InferenceRequest): Promise<InferenceResult>;
+    stream(requestParams: InferenceRequest): AsyncIterable<SpaceEvent>;
+}
+
+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;
+};
+
+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);
+}
+
+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>;
+}
+
+interface Memory {
+    getContext(): Context;
+    saveItem(item: ContextItem): void;
+    saveItems(items: ContextItem[]): void;
+}
+
+type AgentRecord = {
+    id: string;
+    manifest: ParticipantManifest;
+    tools: Tool[];
+    memory: Memory;
+    handlers: SituationHandler[];
+};
+
+declare class Agent extends Participant {
+    private memory;
+    private tools;
+    constructor(manifest: ParticipantManifest, tools: Tool[], memory: Memory, handlers: SituationHandler[]);
+    getTools(): Tool[];
+    getMemory(): Memory;
+    static create({ manifest, tools, memory, handlers, }: {
+        manifest: ParticipantManifest;
+        tools: Tool[];
+        memory: Memory;
+        handlers: SituationHandler[];
+    }): Agent;
+    static rehydrate(record: AgentRecord): Agent;
+}
+
+interface AgentRepository {
+    save(agent: Agent): Promise<void>;
+    exists(id: string): Promise<boolean>;
+    findById(id: string): Promise<Agent | undefined>;
+    findAll(): Promise<Agent[]>;
+}
+
+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;
+};
+type PendingToolExecution = {
+    id: string;
+    type: "tool_execution";
+    requestedAt: Date;
+    call: ToolUseRequest;
+};
+type PendingOperation = PendingInference | PendingToolExecution;
+
+interface LoopTransition {
+    readonly occurredAt: Date;
+    readonly previousState: LoopStateId;
+    readonly nextState: LoopStateId;
+    readonly reason: string;
+    readonly operationId?: string;
+}
+
+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;
+}
+
+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;
+};
+
+declare abstract class LoopAction {
+    abstract execute(agentLoop: AgentLoop): LoopControlDirective;
+}
+
+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;
+}
+
+interface LoopRecord {
+    id: string;
+    agentId: string;
+    subject: string;
+    createdAt: Date;
+    state: LoopStateId;
+    inferenceRequest?: InferenceRequest;
+    pendingOperation?: PendingOperation;
+    transitionHistory: LoopTransition[];
+    operationHistory: CompletedOperation[];
+    rules: LoopRule[];
+}
+
+type LoopStateId = "idle" | "awaiting_inference_request" | "awaiting_inference" | "awaiting_tool_output" | "stopped" | "completed";
+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 loopRules;
+    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 rules(): readonly LoopRule[];
+    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(id: string, agentId: string, subject: string, rules: LoopRule[]): 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>;
+}
+
+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<AgentRecord>;
+    createLoop: (params: {
+        subject: string;
+        agentId: string;
+        rules: CreateLoopRuleParams[];
+    }) => Promise<Loop>;
+    runLoop: (loopId: string) => Promise<Loop>;
+    state: (loopStateId: LoopStateId) => LoopSpecification;
+    modelAnswered: () => LoopSpecification;
+    runInference: () => LoopAction;
+    toolUse: () => LoopAction;
+    complete: (reason?: string) => LoopAction;
+    wait: (reason?: string) => LoopAction;
+};
+
+export { type AgentModuleConfig, type AgentRepository, type GenerativeModel, type InferenceRunner, type InferenceRunnerConfig, type LoopRepository, Participant, type SharedState, type SituationContext, type SituationHandler, type SituationProcessor, SituationSpecification, SpaceEvent, type Tool, type ToolUseRunner, defineAgentModule, defineRuntime };