@mozaik-ai/core 2.13.8 → 3.0.1

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,
@@ -54,7 +56,7 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/core/context-runtime/context.ts
+// src/domain/model-context/context.ts
 var Context = class _Context {
   constructor(id, projectId, items) {
     this.projectId = projectId;
@@ -90,19 +92,19 @@ var Context = class _Context {
   }
 };
 
-// src/core/context-runtime/context-item.ts
+// src/domain/model-context/context-item/context-item.ts
 var ContextItem = class {
   getType() {
     return this.type;
   }
 };
 
-// src/core/context-runtime/content.ts
-var Content = class {
+// src/domain/model-context/context-item/item-content/item-content.ts
+var ItemContent = class {
 };
 
-// src/core/context-runtime/content/input-text.ts
-var InputText = class _InputText extends Content {
+// src/domain/model-context/context-item/item-content/input-text.ts
+var InputText = class _InputText extends ItemContent {
   constructor(text) {
     super();
     this.text = text;
@@ -124,7 +126,7 @@ var InputText = class _InputText extends Content {
   }
 };
 
-// src/core/context-runtime/input/user-message.ts
+// src/domain/model-context/context-item/client-item/user-message.ts
 var UserMessage = class _UserMessage extends ContextItem {
   constructor(content) {
     super();
@@ -149,7 +151,7 @@ var UserMessage = class _UserMessage extends ContextItem {
   }
 };
 
-// src/core/context-runtime/input/developer-message.ts
+// src/domain/model-context/context-item/client-item/developer-message.ts
 var DeveloperMessage = class _DeveloperMessage extends ContextItem {
   constructor(content) {
     super();
@@ -174,8 +176,8 @@ var DeveloperMessage = class _DeveloperMessage extends ContextItem {
   }
 };
 
-// src/core/context-runtime/content/output-text.ts
-var OutputText = class _OutputText extends Content {
+// src/domain/model-context/context-item/item-content/output-text.ts
+var OutputText = class _OutputText extends ItemContent {
   constructor(text) {
     super();
     this.text = text;
@@ -194,7 +196,7 @@ var OutputText = class _OutputText extends Content {
   }
 };
 
-// src/core/context-runtime/output/model-message.ts
+// src/domain/model-context/context-item/model-item/model-message.ts
 var ModelMessage = class _ModelMessage extends ContextItem {
   constructor(content) {
     super();
@@ -215,7 +217,7 @@ var ModelMessage = class _ModelMessage extends ContextItem {
   }
 };
 
-// src/core/context-runtime/output/function-call.ts
+// src/domain/model-context/context-item/model-item/function-call.ts
 var FunctionCall = class _FunctionCall extends ContextItem {
   constructor(callId, name, args) {
     super();
@@ -237,7 +239,7 @@ var FunctionCall = class _FunctionCall extends ContextItem {
   }
 };
 
-// src/core/context-runtime/output/reasoning.ts
+// src/domain/model-context/context-item/model-item/reasoning.ts
 var Reasoning = class _Reasoning extends ContextItem {
   constructor(content, encryptedContent, summary = []) {
     super();
@@ -260,7 +262,7 @@ var Reasoning = class _Reasoning extends ContextItem {
   }
 };
 
-// src/core/context-runtime/input/function-call-output.ts
+// src/domain/model-context/context-item/client-item/function-call-output.ts
 var FunctionCallOutput = class _FunctionCallOutput extends ContextItem {
   constructor(callId, output) {
     super();
@@ -284,7 +286,7 @@ var FunctionCallOutput = class _FunctionCallOutput extends ContextItem {
   }
 };
 
-// src/core/generative-model/inference-response.ts
+// src/domain/generative-model/inference-response.ts
 var InferenceResponse = class {
   constructor(contextItems, tokenUsage) {
     this.contextItems = contextItems;
@@ -292,7 +294,7 @@ var InferenceResponse = class {
   }
 };
 
-// src/core/generative-model/token-usage.ts
+// src/domain/generative-model/token-usage.ts
 var InputTokenDetails = class {
   constructor(cached_tokens) {
     this.cached_tokens = cached_tokens;
@@ -313,7 +315,7 @@ var TokenUsage = class {
   }
 };
 
-// src/providers/openai/runtime/openai-responses.ts
+// src/infrastructure/providers/openai/runtime/openai-responses.ts
 var import_openai = __toESM(require("openai"));
 var OpenAIResponses = class {
   constructor() {
@@ -380,7 +382,7 @@ var OpenAIResponses = class {
   }
 };
 
-// src/core/generative-model/inference-request.ts
+// src/domain/generative-model/inference-request.ts
 var InferenceRequest = class {
   constructor(model, context) {
     this.model = model;
@@ -388,7 +390,7 @@ var InferenceRequest = class {
   }
 };
 
-// src/providers/openai/reasoning-effort.ts
+// src/infrastructure/providers/openai/reasoning-effort.ts
 var OpenAIReasoningEffort = class {
   constructor(reasoningEffort) {
     this.reasoningEffort = reasoningEffort;
@@ -404,7 +406,7 @@ var OpenAIReasoningEffort = class {
   }
 };
 
-// src/providers/openai/models/gpt-5-4-nano.ts
+// src/infrastructure/providers/openai/models/gpt-5-4-nano.ts
 var Gpt54Nano = class {
   constructor() {
     this.specification = {
@@ -435,7 +437,7 @@ var Gpt54Nano = class {
   }
 };
 
-// src/providers/openai/models/gpt-5-4.ts
+// src/infrastructure/providers/openai/models/gpt-5-4.ts
 var Gpt54 = class {
   constructor() {
     this.specification = {
@@ -466,7 +468,7 @@ var Gpt54 = class {
   }
 };
 
-// src/providers/openai/models/gpt-5-4-mini.ts
+// src/infrastructure/providers/openai/models/gpt-5-4-mini.ts
 var Gpt54Mini = class {
   constructor() {
     this.specification = {
@@ -497,7 +499,7 @@ var Gpt54Mini = class {
   }
 };
 
-// src/core/context-engine/condition/condition.ts
+// src/domain/agent-loop/rules/condition/condition.ts
 var BaseCondition = class {
   and(other) {
     return new AndCondition(this, other);
@@ -539,7 +541,7 @@ var OrCondition = class extends BaseCondition {
   }
 };
 
-// src/core/context-engine/rule/rule.ts
+// src/domain/agent-loop/rules/rule/rule.ts
 var If = class {
   constructor({ condition, action }) {
     this.condition = condition;
@@ -565,7 +567,7 @@ var Loop = class {
   }
 };
 
-// src/memory/in-memory-context-repository.ts
+// src/infrastructure/repository/in-memory-context-repository.ts
 var InMemoryContextRepository = class {
   constructor() {
     this.store = /* @__PURE__ */ new Map();
@@ -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,