@mozaik-ai/core 3.0.0 → 3.0.1

package/dist/index.d.mts

@@ -323,4 +323,87 @@ declare class InMemoryContextRepository implements ContextRepository {
     private clone;
 }
 
-export { type Action, type AsyncAction, type AsyncRule, BaseCondition, type Condition, Context, ContextItem, type ContextRepository, DeveloperMessage, FunctionCall, FunctionCallOutput, type GenerativeModel, Gpt54, Gpt54Mini, Gpt54Nano, If, InMemoryContextRepository, InferenceRequest, InferenceResponse, InputTokenDetails, Loop, ModelMessage, OpenAIResponses, OutputTokenDetails, Reasoning, TokenUsage, type Tool, UserMessage };
+declare enum HookId {
+    BEFORE_INFERENCE = "BEFORE_INFERENCE",
+    AFTER_INFERENCE = "AFTER_INFERENCE",
+    BEFORE_FUNCTION_CALL = "BEFORE_FUNCTION_CALL",
+    AFTER_FUNCTION_CALL = "AFTER_FUNCTION_CALL",
+    BEFORE_MODEL_MESSAGE = "BEFORE_MODEL_MESSAGE",
+    AFTER_MODEL_MESSAGE = "AFTER_MODEL_MESSAGE"
+}
+
+interface TransitionRecord {
+    fromState: StateId;
+    toState: StateId;
+    timestamp: Date;
+    duration: number;
+    error: Error | null;
+}
+
+declare enum StateId {
+    INFERENCE_PENDING = "INFERENCE_PENDING",
+    FUNCTION_CALL_PENDING = "FUNCTION_CALL_PENDING",
+    MODEL_MESSAGE_RECEIVED = "MODEL_MESSAGE_RECEIVED"
+}
+
+declare enum ExecutionStatus {
+    RUNNING = 0,
+    COMPLETED = 1,
+    FAILED = 2
+}
+declare class Execution {
+    executionId: string;
+    currentStateId: StateId;
+    previousStateId: StateId | null;
+    status: ExecutionStatus;
+    stepCount: number;
+    retryCounts: Map<StateId, number>;
+    history: TransitionRecord[];
+    constructor(executionId: string, currentStateId: StateId, previousStateId: StateId | null, status: ExecutionStatus, stepCount: number, retryCounts: Map<StateId, number>, history: TransitionRecord[]);
+    isTerminal(): boolean;
+    static create(): Execution;
+}
+
+interface RuntimeContext {
+    execution: Execution;
+    userMessage: UserMessage;
+    inferenceRequest?: InferenceRequest;
+    model: GenerativeModel & ReasoningEffort<string> & ToolCallingCapability;
+    context: Context;
+    inferenceResponse?: InferenceResponse;
+    functionCallOutput?: FunctionCallOutput;
+    modelMessage?: ModelMessage;
+}
+
+declare class AgentRuntime {
+    private hooksRegistry;
+    private stateHandlerRegistry;
+    constructor();
+    onInferencePending(context: RuntimeContext): Promise<void>;
+    onFunctionCallPending(context: RuntimeContext): Promise<void>;
+    onModelMessageReceived(context: RuntimeContext): Promise<void>;
+    on(hookId: HookId, callback: (data: any) => Promise<void>): Promise<void>;
+    start(userMessage: UserMessage, model: GenerativeModel & ReasoningEffort<string> & ToolCallingCapability, context: Context): Promise<void>;
+}
+
+interface InferenceVisitor {
+    onStart(context: RuntimeContext): Promise<void>;
+    afterInference(inferenceResponse: InferenceResponse): Promise<void>;
+}
+
+declare class Agent {
+    private readonly runtime;
+    private visitor;
+    constructor(runtime: AgentRuntime);
+    beforeInference(context: RuntimeContext): Promise<void>;
+    afterInference(context: RuntimeContext): Promise<void>;
+    beforeFunctionCall(context: RuntimeContext): Promise<void>;
+    afterFunctionCall(context: RuntimeContext): Promise<void>;
+    beforeModelMessage(context: RuntimeContext): Promise<void>;
+    afterModelMessage(context: RuntimeContext): Promise<void>;
+    onStart(context: RuntimeContext): Promise<void>;
+    setInferenceVisitor(visitor: InferenceVisitor): void;
+    run(userMessage: string, model: GenerativeModel & ReasoningEffort<string> & ToolCallingCapability, context: Context): Promise<void>;
+}
+
+export { type Action, Agent, AgentRuntime, type AsyncAction, type AsyncRule, BaseCondition, type Condition, Context, ContextItem, type ContextRepository, DeveloperMessage, FunctionCall, FunctionCallOutput, type GenerativeModel, Gpt54, Gpt54Mini, Gpt54Nano, If, InMemoryContextRepository, InferenceRequest, InferenceResponse, type InferenceVisitor, InputTokenDetails, Loop, ModelMessage, OpenAIResponses, OutputTokenDetails, Reasoning, TokenUsage, type Tool, UserMessage };

package/dist/index.d.ts

@@ -323,4 +323,87 @@ declare class InMemoryContextRepository implements ContextRepository {
     private clone;
 }
 
-export { type Action, type AsyncAction, type AsyncRule, BaseCondition, type Condition, Context, ContextItem, type ContextRepository, DeveloperMessage, FunctionCall, FunctionCallOutput, type GenerativeModel, Gpt54, Gpt54Mini, Gpt54Nano, If, InMemoryContextRepository, InferenceRequest, InferenceResponse, InputTokenDetails, Loop, ModelMessage, OpenAIResponses, OutputTokenDetails, Reasoning, TokenUsage, type Tool, UserMessage };
+declare enum HookId {
+    BEFORE_INFERENCE = "BEFORE_INFERENCE",
+    AFTER_INFERENCE = "AFTER_INFERENCE",
+    BEFORE_FUNCTION_CALL = "BEFORE_FUNCTION_CALL",
+    AFTER_FUNCTION_CALL = "AFTER_FUNCTION_CALL",
+    BEFORE_MODEL_MESSAGE = "BEFORE_MODEL_MESSAGE",
+    AFTER_MODEL_MESSAGE = "AFTER_MODEL_MESSAGE"
+}
+
+interface TransitionRecord {
+    fromState: StateId;
+    toState: StateId;
+    timestamp: Date;
+    duration: number;
+    error: Error | null;
+}
+
+declare enum StateId {
+    INFERENCE_PENDING = "INFERENCE_PENDING",
+    FUNCTION_CALL_PENDING = "FUNCTION_CALL_PENDING",
+    MODEL_MESSAGE_RECEIVED = "MODEL_MESSAGE_RECEIVED"
+}
+
+declare enum ExecutionStatus {
+    RUNNING = 0,
+    COMPLETED = 1,
+    FAILED = 2
+}
+declare class Execution {
+    executionId: string;
+    currentStateId: StateId;
+    previousStateId: StateId | null;
+    status: ExecutionStatus;
+    stepCount: number;
+    retryCounts: Map<StateId, number>;
+    history: TransitionRecord[];
+    constructor(executionId: string, currentStateId: StateId, previousStateId: StateId | null, status: ExecutionStatus, stepCount: number, retryCounts: Map<StateId, number>, history: TransitionRecord[]);
+    isTerminal(): boolean;
+    static create(): Execution;
+}
+
+interface RuntimeContext {
+    execution: Execution;
+    userMessage: UserMessage;
+    inferenceRequest?: InferenceRequest;
+    model: GenerativeModel & ReasoningEffort<string> & ToolCallingCapability;
+    context: Context;
+    inferenceResponse?: InferenceResponse;
+    functionCallOutput?: FunctionCallOutput;
+    modelMessage?: ModelMessage;
+}
+
+declare class AgentRuntime {
+    private hooksRegistry;
+    private stateHandlerRegistry;
+    constructor();
+    onInferencePending(context: RuntimeContext): Promise<void>;
+    onFunctionCallPending(context: RuntimeContext): Promise<void>;
+    onModelMessageReceived(context: RuntimeContext): Promise<void>;
+    on(hookId: HookId, callback: (data: any) => Promise<void>): Promise<void>;
+    start(userMessage: UserMessage, model: GenerativeModel & ReasoningEffort<string> & ToolCallingCapability, context: Context): Promise<void>;
+}
+
+interface InferenceVisitor {
+    onStart(context: RuntimeContext): Promise<void>;
+    afterInference(inferenceResponse: InferenceResponse): Promise<void>;
+}
+
+declare class Agent {
+    private readonly runtime;
+    private visitor;
+    constructor(runtime: AgentRuntime);
+    beforeInference(context: RuntimeContext): Promise<void>;
+    afterInference(context: RuntimeContext): Promise<void>;
+    beforeFunctionCall(context: RuntimeContext): Promise<void>;
+    afterFunctionCall(context: RuntimeContext): Promise<void>;
+    beforeModelMessage(context: RuntimeContext): Promise<void>;
+    afterModelMessage(context: RuntimeContext): Promise<void>;
+    onStart(context: RuntimeContext): Promise<void>;
+    setInferenceVisitor(visitor: InferenceVisitor): void;
+    run(userMessage: string, model: GenerativeModel & ReasoningEffort<string> & ToolCallingCapability, context: Context): Promise<void>;
+}
+
+export { type Action, Agent, AgentRuntime, type AsyncAction, type AsyncRule, BaseCondition, type Condition, Context, ContextItem, type ContextRepository, DeveloperMessage, FunctionCall, FunctionCallOutput, type GenerativeModel, Gpt54, Gpt54Mini, Gpt54Nano, If, InMemoryContextRepository, InferenceRequest, InferenceResponse, type InferenceVisitor, InputTokenDetails, Loop, ModelMessage, OpenAIResponses, OutputTokenDetails, Reasoning, TokenUsage, type Tool, UserMessage };

package/dist/index.js

@@ -30,6 +30,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  Agent: () => Agent,
+  AgentRuntime: () => AgentRuntime,
   BaseCondition: () => BaseCondition,
   Context: () => Context,
   ContextItem: () => ContextItem,
@@ -606,8 +608,355 @@ var InMemoryContextRepository = class {
     });
   }
 };
+
+// src/domain/agent-loop/execution.ts
+var Execution = class _Execution {
+  constructor(executionId, currentStateId, previousStateId, status, stepCount, retryCounts, history) {
+    this.executionId = executionId;
+    this.currentStateId = currentStateId;
+    this.previousStateId = previousStateId;
+    this.status = status;
+    this.stepCount = stepCount;
+    this.retryCounts = retryCounts;
+    this.history = history;
+  }
+  isTerminal() {
+    return this.status == 1 /* COMPLETED */ || this.status == 2 /* FAILED */;
+  }
+  static create() {
+    const executionId = crypto.randomUUID();
+    const currentStateId = "INFERENCE_PENDING" /* INFERENCE_PENDING */;
+    const previousStateId = null;
+    const status = 0 /* RUNNING */;
+    const stepCount = 0;
+    const retryCounts = /* @__PURE__ */ new Map();
+    const history = [];
+    return new _Execution(executionId, currentStateId, previousStateId, status, stepCount, retryCounts, history);
+  }
+};
+
+// src/domain/agent-loop/transition/go-to.ts
+var GoTo = class {
+  constructor(next) {
+    this.next = next;
+  }
+  async apply(context) {
+    const execution = context.execution;
+    execution.previousStateId = execution.currentStateId;
+    execution.currentStateId = this.next;
+    execution.stepCount++;
+    execution.history.push({
+      fromState: execution.previousStateId,
+      toState: execution.currentStateId,
+      timestamp: /* @__PURE__ */ new Date(),
+      duration: 0,
+      error: null
+    });
+  }
+};
+
+// src/domain/agent-loop/transition/fail.ts
+var Fail = class {
+  constructor(error) {
+    this.error = error;
+  }
+  async apply(context) {
+    const execution = context.execution;
+    execution.status = 2 /* FAILED */;
+  }
+};
+
+// src/domain/agent-loop/state/function-call.ts
+var FunctionCallState = class {
+  constructor() {
+    this.id = "FUNCTION_CALL_PENDING" /* FUNCTION_CALL_PENDING */;
+    this.beforeHookId = "BEFORE_FUNCTION_CALL" /* BEFORE_FUNCTION_CALL */;
+    this.afterHookId = "AFTER_FUNCTION_CALL" /* AFTER_FUNCTION_CALL */;
+  }
+  getDetails() {
+    return {
+      before: this.beforeHookId,
+      stateId: this.id,
+      after: this.afterHookId
+    };
+  }
+  validateEntry(runtime) {
+    var _a;
+    const functionCall = (_a = runtime.inferenceResponse) == null ? void 0 : _a.contextItems.find((item) => item.getType() === "function_call");
+    if (!functionCall || !(functionCall instanceof FunctionCall)) {
+      throw new Error("Function call not found");
+    }
+  }
+  next(runtime) {
+    const functionCallOutput = runtime.functionCallOutput;
+    if (!functionCallOutput) {
+      return new Fail("Function call output not found");
+    }
+    runtime.context.addItem(functionCallOutput);
+    return new GoTo("INFERENCE_PENDING" /* INFERENCE_PENDING */);
+  }
+};
+
+// src/domain/agent-loop/transition/complete.ts
+var Complete = class {
+  constructor(result) {
+    this.result = result;
+  }
+  async apply(context) {
+    const execution = context.execution;
+    execution.status = 1 /* COMPLETED */;
+  }
+};
+
+// src/domain/agent-loop/state/model-message.ts
+var ModelMessageState = class {
+  constructor() {
+    this.id = "MODEL_MESSAGE_RECEIVED" /* MODEL_MESSAGE_RECEIVED */;
+    this.beforeHookId = "BEFORE_MODEL_MESSAGE" /* BEFORE_MODEL_MESSAGE */;
+    this.afterHookId = "AFTER_MODEL_MESSAGE" /* AFTER_MODEL_MESSAGE */;
+  }
+  getDetails() {
+    return {
+      before: this.beforeHookId,
+      stateId: this.id,
+      after: this.afterHookId
+    };
+  }
+  validateEntry(runtime) {
+    if (!runtime.modelMessage) {
+      throw new Error("Model message not found");
+    }
+  }
+  next(runtime) {
+    if (!runtime.modelMessage) {
+      return new Fail("Model message not found");
+    }
+    return new Complete(runtime.modelMessage.content.text);
+  }
+};
+
+// src/domain/agent-loop/state/inference-pending.ts
+var InferencePendingState = class {
+  constructor() {
+    this.id = "INFERENCE_PENDING" /* INFERENCE_PENDING */;
+    this.beforeHookId = "BEFORE_INFERENCE" /* BEFORE_INFERENCE */;
+    this.afterHookId = "AFTER_INFERENCE" /* AFTER_INFERENCE */;
+  }
+  getDetails() {
+    return {
+      before: this.beforeHookId,
+      stateId: this.id,
+      after: this.afterHookId
+    };
+  }
+  validateEntry(runtime) {
+    const inferenceRequest = runtime.inferenceRequest;
+    if (!inferenceRequest) {
+      throw new Error("Inference request not found");
+    }
+  }
+  next(runtime) {
+    const inferenceResponse = runtime.inferenceResponse;
+    if (!inferenceResponse) {
+      return new Fail("Inference response not found");
+    }
+    if (inferenceResponse instanceof FunctionCall) {
+      return new GoTo("FUNCTION_CALL_PENDING" /* FUNCTION_CALL_PENDING */);
+    }
+    if (inferenceResponse instanceof ModelMessage) {
+      return new GoTo("MODEL_MESSAGE_RECEIVED" /* MODEL_MESSAGE_RECEIVED */);
+    }
+    return new Fail("Invalid response type");
+  }
+};
+
+// src/domain/agent-loop/loop.ts
+var AgentLoop = class {
+  constructor() {
+    this.states = /* @__PURE__ */ new Map();
+    this.states.set("INFERENCE_PENDING" /* INFERENCE_PENDING */, new InferencePendingState());
+    this.states.set("FUNCTION_CALL_PENDING" /* FUNCTION_CALL_PENDING */, new FunctionCallState());
+    this.states.set("MODEL_MESSAGE_RECEIVED" /* MODEL_MESSAGE_RECEIVED */, new ModelMessageState());
+  }
+  validateEntry(runtime) {
+    const state = this.states.get(runtime.execution.currentStateId);
+    if (!state) {
+      throw new Error(`State ${runtime.execution.currentStateId} not found`);
+    }
+    state.validateEntry(runtime);
+  }
+  getStateDetails(runtime) {
+    const state = this.states.get(runtime.execution.currentStateId);
+    if (!state) {
+      throw new Error(`State ${runtime.execution.currentStateId} not found`);
+    }
+    return state.getDetails();
+  }
+  next(runtime) {
+    const state = this.states.get(runtime.execution.currentStateId);
+    if (!state) {
+      throw new Error(`State ${runtime.execution.currentStateId} not found`);
+    }
+    return state.next(runtime);
+  }
+};
+
+// src/domain/agent-loop/hooks/hooks-registry.ts
+var HooksRegistry = class {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+  }
+  getHandler(hookId) {
+    const handler = this.handlers.get(hookId);
+    if (!handler) {
+      throw new Error(`Hook handler for hook ${hookId} not found`);
+    }
+    return handler;
+  }
+  registerHandler(hookId, handler) {
+    this.handlers.set(hookId, handler);
+  }
+  unregisterHandler(hookId) {
+    this.handlers.delete(hookId);
+  }
+};
+
+// src/domain/agent-loop/state/state-registry.ts
+var StateHandlerRegistry = class {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+  }
+  getHandler(stateId) {
+    const handler = this.handlers.get(stateId);
+    if (!handler) {
+      throw new Error(`Handler for state ${stateId} not found`);
+    }
+    return handler;
+  }
+  registerHandler(stateId, handler) {
+    this.handlers.set(stateId, handler);
+  }
+  unregisterHandler(stateId) {
+    this.handlers.delete(stateId);
+  }
+};
+
+// src/application/agent-runtime.ts
+var AgentRuntime = class {
+  constructor() {
+    this.hooksRegistry = new HooksRegistry();
+    this.stateHandlerRegistry = new StateHandlerRegistry();
+    this.stateHandlerRegistry.registerHandler("INFERENCE_PENDING" /* INFERENCE_PENDING */, this.onInferencePending);
+    this.stateHandlerRegistry.registerHandler("FUNCTION_CALL_PENDING" /* FUNCTION_CALL_PENDING */, this.onFunctionCallPending);
+    this.stateHandlerRegistry.registerHandler("MODEL_MESSAGE_RECEIVED" /* MODEL_MESSAGE_RECEIVED */, this.onModelMessageReceived);
+  }
+  async onInferencePending(context) {
+    const openaiResponses = new OpenAIResponses();
+    const inferenceRequest = new InferenceRequest(context.model, context.context);
+    const inferenceResponse = await openaiResponses.infer(inferenceRequest);
+    context.inferenceResponse = inferenceResponse;
+    return Promise.resolve();
+  }
+  async onFunctionCallPending(context) {
+    var _a;
+    const functionCall = (_a = context.inferenceResponse) == null ? void 0 : _a.contextItems.find((item) => item.getType() === "function_call");
+    if (!functionCall || !(functionCall instanceof FunctionCall)) {
+      throw new Error("Function call not found");
+    }
+    const tool = context.model.getTools().find((tool2) => tool2.name === functionCall.name);
+    if (!tool) {
+      throw new Error("Function not found");
+    }
+    const functionCallOutput = await tool.invoke(functionCall.args);
+    context.functionCallOutput = FunctionCallOutput.create(functionCall.callId, functionCallOutput);
+    return Promise.resolve();
+  }
+  async onModelMessageReceived(context) {
+    return Promise.resolve();
+  }
+  async on(hookId, callback) {
+    this.hooksRegistry.registerHandler(hookId, callback);
+  }
+  async start(userMessage, model, context) {
+    const execution = Execution.create();
+    const loop = new AgentLoop();
+    const runtimeContext = {
+      execution,
+      userMessage,
+      model,
+      context
+    };
+    while (!execution.isTerminal()) {
+      const transition = loop.next(runtimeContext);
+      await transition.apply(runtimeContext);
+      try {
+        const stateDetails = loop.getStateDetails(runtimeContext);
+        if (stateDetails.before) {
+          const handler = this.hooksRegistry.getHandler(stateDetails.before);
+          await handler(runtimeContext);
+        }
+        if (stateDetails.after) {
+          const handler = this.hooksRegistry.getHandler(stateDetails.after);
+          await handler(runtimeContext);
+        }
+      } catch (error) {
+        execution.status = 2 /* FAILED */;
+        break;
+      }
+    }
+  }
+};
+
+// src/application/agent.ts
+var Agent = class {
+  constructor(runtime) {
+    this.runtime = runtime;
+    this.runtime.on("BEFORE_INFERENCE" /* BEFORE_INFERENCE */, this.beforeInference);
+    this.runtime.on("AFTER_INFERENCE" /* AFTER_INFERENCE */, this.afterInference);
+    this.runtime.on("BEFORE_FUNCTION_CALL" /* BEFORE_FUNCTION_CALL */, this.beforeFunctionCall);
+    this.runtime.on("AFTER_FUNCTION_CALL" /* AFTER_FUNCTION_CALL */, this.afterFunctionCall);
+    this.runtime.on("BEFORE_MODEL_MESSAGE" /* BEFORE_MODEL_MESSAGE */, this.beforeModelMessage);
+    this.runtime.on("AFTER_MODEL_MESSAGE" /* AFTER_MODEL_MESSAGE */, this.afterModelMessage);
+  }
+  async beforeInference(context) {
+    return Promise.resolve();
+  }
+  async afterInference(context) {
+    const inferenceResponse = context.inferenceResponse;
+    if (inferenceResponse && this.visitor) {
+      await this.visitor.afterInference(inferenceResponse);
+    }
+    return Promise.resolve();
+  }
+  async beforeFunctionCall(context) {
+    return Promise.resolve();
+  }
+  async afterFunctionCall(context) {
+    return Promise.resolve();
+  }
+  async beforeModelMessage(context) {
+    return Promise.resolve();
+  }
+  async afterModelMessage(context) {
+    return Promise.resolve();
+  }
+  async onStart(context) {
+    var _a;
+    await ((_a = this.visitor) == null ? void 0 : _a.onStart(context));
+    return Promise.resolve();
+  }
+  setInferenceVisitor(visitor) {
+    this.visitor = visitor;
+  }
+  async run(userMessage, model, context) {
+    const userMessageItem = UserMessage.create(userMessage);
+    return this.runtime.start(userMessageItem, model, context);
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Agent,
+  AgentRuntime,
   BaseCondition,
   Context,
   ContextItem,