@mozaik-ai/core 3.3.1 → 3.3.4

package/dist/index.js

@@ -31,13 +31,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   Agent: () => Agent,
-  AgentRuntime: () => AgentRuntime,
   AgentSociety: () => AgentSociety,
   BaseSpecification: () => BaseSpecification,
   ContextItem: () => ContextItem,
-  DeveloperMessage: () => DeveloperMessage,
-  FunctionCall: () => FunctionCall,
-  FunctionCallOutput: () => FunctionCallOutput,
+  DeveloperMessageItem: () => DeveloperMessageItem,
+  FunctionCallItem: () => FunctionCallItem,
+  FunctionCallOutputItem: () => FunctionCallOutputItem,
   Gpt54: () => Gpt54,
   Gpt54Mini: () => Gpt54Mini,
   Gpt54Nano: () => Gpt54Nano,
@@ -48,12 +47,13 @@ __export(index_exports, {
   InputTokenDetails: () => InputTokenDetails,
   Loop: () => Loop,
   ModelContext: () => ModelContext,
-  ModelMessage: () => ModelMessage,
+  ModelMessageItem: () => ModelMessageItem,
   OpenAIResponses: () => OpenAIResponses,
   OutputTokenDetails: () => OutputTokenDetails,
-  Reasoning: () => Reasoning,
+  ReasoningItem: () => ReasoningItem,
+  SystemMessageItem: () => SystemMessageItem,
   TokenUsage: () => TokenUsage,
-  UserMessage: () => UserMessage
+  UserMessageItem: () => UserMessageItem
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -134,7 +134,7 @@ var InputText = class _InputText extends ItemContent {
 };
 
 // src/domain/model-context/context-item/client-item/user-message.ts
-var UserMessage = class _UserMessage extends ContextItem {
+var UserMessageItem = class _UserMessageItem extends ContextItem {
   constructor(content) {
     super();
     this.type = "message";
@@ -143,11 +143,11 @@ var UserMessage = class _UserMessage extends ContextItem {
   }
   static create(text) {
     const content = InputText.create(text);
-    return new _UserMessage(content);
+    return new _UserMessageItem(content);
   }
   static rehydrate(data) {
     const content = InputText.rehydrate(data);
-    return new _UserMessage(content);
+    return new _UserMessageItem(content);
   }
   toJSON() {
     return {
@@ -159,7 +159,7 @@ var UserMessage = class _UserMessage extends ContextItem {
 };
 
 // src/domain/model-context/context-item/client-item/developer-message.ts
-var DeveloperMessage = class _DeveloperMessage extends ContextItem {
+var DeveloperMessageItem = class _DeveloperMessageItem extends ContextItem {
   constructor(content) {
     super();
     this.type = "message";
@@ -175,11 +175,11 @@ var DeveloperMessage = class _DeveloperMessage extends ContextItem {
   }
   static create(text) {
     const content = InputText.create(text);
-    return new _DeveloperMessage(content);
+    return new _DeveloperMessageItem(content);
   }
   static rehydrate(data) {
     const content = InputText.rehydrate(data);
-    return new _DeveloperMessage(content);
+    return new _DeveloperMessageItem(content);
   }
 };
 
@@ -204,7 +204,7 @@ var OutputText = class _OutputText extends ItemContent {
 };
 
 // src/domain/model-context/context-item/model-item/model-message.ts
-var ModelMessage = class _ModelMessage extends ContextItem {
+var ModelMessageItem = class _ModelMessageItem extends ContextItem {
   constructor(content) {
     super();
     this.type = "message";
@@ -213,7 +213,7 @@ var ModelMessage = class _ModelMessage extends ContextItem {
   }
   static rehydrate(data) {
     const content = OutputText.rehydrate(data);
-    return new _ModelMessage(content);
+    return new _ModelMessageItem(content);
   }
   toJSON() {
     return {
@@ -225,7 +225,7 @@ var ModelMessage = class _ModelMessage extends ContextItem {
 };
 
 // src/domain/model-context/context-item/model-item/function-call.ts
-var FunctionCall = class _FunctionCall extends ContextItem {
+var FunctionCallItem = class _FunctionCallItem extends ContextItem {
   constructor(callId, name, args) {
     super();
     this.type = "function_call";
@@ -234,7 +234,7 @@ var FunctionCall = class _FunctionCall extends ContextItem {
     this.args = args;
   }
   static rehydrate(data) {
-    return new _FunctionCall(data.callId, data.name, data.args);
+    return new _FunctionCallItem(data.callId, data.name, data.args);
   }
   toJSON() {
     return {
@@ -247,7 +247,7 @@ var FunctionCall = class _FunctionCall extends ContextItem {
 };
 
 // src/domain/model-context/context-item/model-item/reasoning.ts
-var Reasoning = class _Reasoning extends ContextItem {
+var ReasoningItem = class _ReasoningItem extends ContextItem {
   constructor(content, encryptedContent, summary = []) {
     super();
     this.type = "reasoning";
@@ -256,7 +256,7 @@ var Reasoning = class _Reasoning extends ContextItem {
     this.summary = summary;
   }
   static rehydrate(data) {
-    return new _Reasoning(data.content, data.encryptedContent, data.summary);
+    return new _ReasoningItem(data.content, data.encryptedContent, data.summary);
   }
   toJSON() {
     var _a;
@@ -270,7 +270,7 @@ var Reasoning = class _Reasoning extends ContextItem {
 };
 
 // src/domain/model-context/context-item/client-item/function-call-output.ts
-var FunctionCallOutput = class _FunctionCallOutput extends ContextItem {
+var FunctionCallOutputItem = class _FunctionCallOutputItem extends ContextItem {
   constructor(callId, output) {
     super();
     this.type = "function_call_output";
@@ -279,10 +279,10 @@ var FunctionCallOutput = class _FunctionCallOutput extends ContextItem {
   }
   static create(callId, output) {
     const outputText = InputText.create(output);
-    return new _FunctionCallOutput(callId, outputText);
+    return new _FunctionCallOutputItem(callId, outputText);
   }
   static rehydrate(data) {
-    return new _FunctionCallOutput(data.callId, data.output);
+    return new _FunctionCallOutputItem(data.callId, data.output);
   }
   toJSON() {
     return {
@@ -373,17 +373,17 @@ var OpenAIResponses = class {
   extractContextItems(response) {
     return response.output.map((item) => {
       if (item.type === "message" && item.role === "assistant") {
-        return ModelMessage.rehydrate(item.content[0]);
+        return ModelMessageItem.rehydrate(item.content[0]);
       }
       if (item.type === "function_call") {
-        return FunctionCall.rehydrate({
+        return FunctionCallItem.rehydrate({
           callId: item.call_id,
           name: item.name,
           args: item.arguments
         });
       }
       if (item.type === "reasoning") {
-        return Reasoning.rehydrate(item);
+        return ReasoningItem.rehydrate(item);
       }
     });
   }
@@ -674,32 +674,32 @@ var Fail = class {
 };
 
 // src/domain/model-context/specifications/function-call-requested.ts
-var FunctionCallRequestedSpecification = class extends BaseSpecification {
+var FunctionCallRequestedSpec = class extends BaseSpecification {
   isSatisfiedBy(context) {
     if (context.getItems().length === 0) {
       return false;
     }
-    const lastItem = context.getItems()[context.getItems().length - 1];
-    return lastItem instanceof FunctionCall;
+    const lastItem = context.getLastItem();
+    return lastItem instanceof FunctionCallItem;
   }
 };
 
 // src/domain/model-context/specifications/function-call-output-present.ts
-var FunctionCallOutputPresentSpecification = class extends BaseSpecification {
+var FunctionCallOutputPresentSpec = class extends BaseSpecification {
   isSatisfiedBy(context) {
-    const lasteItem = context.getItems()[context.getItems().length - 1];
-    return lasteItem instanceof FunctionCallOutput;
+    const lasteItem = context.getLastItem();
+    return lasteItem instanceof FunctionCallOutputItem;
   }
 };
 
-// src/domain/agent-loop/state/function-call.ts
-var FunctionCallState = class {
+// src/domain/agent-loop/state/function-call-pending.ts
+var FunctionCallPendingState = 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 */;
-    this.functionCallRequestedSpec = new FunctionCallRequestedSpecification();
-    this.functionCallOutputPresentSpec = new FunctionCallOutputPresentSpecification();
+    this.functionCallRequestedSpec = new FunctionCallRequestedSpec();
+    this.functionCallOutputPresentSpec = new FunctionCallOutputPresentSpec();
   }
   getDetails() {
     return {
@@ -733,23 +733,23 @@ var Complete = class {
 };
 
 // src/domain/model-context/specifications/model-responded.ts
-var ModelRespondedSpecification = class extends BaseSpecification {
+var ModelRespondedSpec = class extends BaseSpecification {
   isSatisfiedBy(context) {
     if (context.getItems().length === 0) {
       return false;
     }
-    const lastItem = context.getItems()[context.getItems().length - 1];
-    return lastItem instanceof ModelMessage && lastItem.role === "assistant";
+    const lastItem = context.getLastItem();
+    return lastItem instanceof ModelMessageItem && lastItem.role === "assistant";
   }
 };
 
-// src/domain/agent-loop/state/model-message.ts
-var ModelMessageState = class {
+// src/domain/agent-loop/state/model-responded.ts
+var ModelRespondedState = 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 */;
-    this.modelResponded = new ModelRespondedSpecification();
+    this.id = "MODEL_RESPONDED" /* MODEL_RESPONDED */;
+    this.beforeHookId = "BEFORE_MODEL_RESPONDED" /* BEFORE_MODEL_RESPONDED */;
+    this.afterHookId = "AFTER_MODEL_RESPONDED" /* AFTER_MODEL_RESPONDED */;
+    this.modelRespondedSpec = new ModelRespondedSpec();
   }
   getDetails() {
     return {
@@ -759,12 +759,12 @@ var ModelMessageState = class {
     };
   }
   validateEntry(runtime) {
-    if (!this.modelResponded.isSatisfiedBy(runtime.context)) {
+    if (!this.modelRespondedSpec.isSatisfiedBy(runtime.context)) {
       throw new Error("Model message is not present in the context");
     }
   }
   next(runtime) {
-    if (!this.modelResponded.isSatisfiedBy(runtime.context)) {
+    if (!this.modelRespondedSpec.isSatisfiedBy(runtime.context)) {
       return new Fail("Model message is not present in the context");
     }
     const lastItem = runtime.context.getLastItem();
@@ -778,8 +778,8 @@ var InferencePendingState = class {
     this.id = "INFERENCE_PENDING" /* INFERENCE_PENDING */;
     this.beforeHookId = "BEFORE_INFERENCE" /* BEFORE_INFERENCE */;
     this.afterHookId = "AFTER_INFERENCE" /* AFTER_INFERENCE */;
-    this.functionCallRequested = new FunctionCallRequestedSpecification();
-    this.modelResponded = new ModelRespondedSpecification();
+    this.functionCallRequested = new FunctionCallRequestedSpec();
+    this.modelResponded = new ModelRespondedSpec();
   }
   getDetails() {
     return {
@@ -794,40 +794,48 @@ var InferencePendingState = class {
     if (this.functionCallRequested.isSatisfiedBy(runtime.context)) {
       return new GoTo("FUNCTION_CALL_PENDING" /* FUNCTION_CALL_PENDING */);
     } else if (this.modelResponded.isSatisfiedBy(runtime.context)) {
-      return new GoTo("MODEL_MESSAGE_RECEIVED" /* MODEL_MESSAGE_RECEIVED */);
+      return new GoTo("MODEL_RESPONDED" /* MODEL_RESPONDED */);
     }
     return new Fail("Invalid response type");
   }
 };
 
-// src/domain/agent-loop/loop.ts
+// src/domain/agent-loop/state/message-received.ts
+var MessageReceivedState = class {
+  constructor() {
+    this.id = "MESSAGE_RECEIVED" /* MESSAGE_RECEIVED */;
+    this.beforeHookId = "BEFORE_MESSAGE_RECEIVED" /* BEFORE_MESSAGE_RECEIVED */;
+    this.afterHookId = "AFTER_MESSAGE_RECEIVED" /* AFTER_MESSAGE_RECEIVED */;
+  }
+  getDetails() {
+    return {
+      before: this.beforeHookId,
+      stateId: this.id,
+      after: this.afterHookId
+    };
+  }
+  validateEntry(context) {
+  }
+  next(context) {
+    return new GoTo("INFERENCE_PENDING" /* INFERENCE_PENDING */);
+  }
+};
+
+// src/domain/agent-loop/agent-loop.ts
 var AgentLoop = class {
   constructor() {
     this.states = /* @__PURE__ */ new Map();
+    this.states.set("MESSAGE_RECEIVED" /* MESSAGE_RECEIVED */, new MessageReceivedState());
     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());
+    this.states.set("FUNCTION_CALL_PENDING" /* FUNCTION_CALL_PENDING */, new FunctionCallPendingState());
+    this.states.set("MODEL_RESPONDED" /* MODEL_RESPONDED */, new ModelRespondedState());
   }
-  validateEntry(runtime) {
+  getState(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);
+    return state;
   }
 };
 
@@ -876,11 +884,15 @@ var AgentRuntime = class {
   constructor() {
     this.hooksRegistry = new HooksRegistry();
     this.stateHandlerRegistry = new StateHandlerRegistry();
+    this.stateHandlerRegistry.registerHandler("MESSAGE_RECEIVED" /* MESSAGE_RECEIVED */, this.onMessageReceived);
     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);
+    this.stateHandlerRegistry.registerHandler("MODEL_RESPONDED" /* MODEL_RESPONDED */, this.onModelResponded);
     this.hooksRegistry.registerHandler("ON_ERROR" /* ON_ERROR */, this.onError);
   }
+  async onMessageReceived(runtimeContext) {
+    return Promise.resolve();
+  }
   async onInferencePending(runtimeContext) {
     const openaiResponses = new OpenAIResponses();
     const inferenceRequest = new InferenceRequest(runtimeContext.model, runtimeContext.context);
@@ -897,7 +909,7 @@ var AgentRuntime = class {
     }
     const functionCallOutput = await tool.invoke(functionCall.args);
     runtimeContext.context.addContextItem(
-      FunctionCallOutput.create(functionCall.callId, JSON.stringify(functionCallOutput))
+      FunctionCallOutputItem.create(functionCall.callId, JSON.stringify(functionCallOutput))
     );
     return Promise.resolve();
   }
@@ -909,7 +921,7 @@ var AgentRuntime = class {
     console.error(error);
     return Promise.resolve();
   }
-  async onModelMessageReceived(context) {
+  async onModelResponded(context) {
     return Promise.resolve();
   }
   async on(hookId, callback) {
@@ -927,9 +939,10 @@ var AgentRuntime = class {
     };
     while (!execution.isTerminal()) {
       console.log("Executing state", execution.currentStateId);
+      const state = loop.getState(runtimeContext);
       try {
-        loop.validateEntry(runtimeContext);
-        const stateDetails = loop.getStateDetails(runtimeContext);
+        state.validateEntry(runtimeContext);
+        const stateDetails = state.getDetails();
         if (stateDetails.before) {
           const handler = this.hooksRegistry.getHandler(stateDetails.before);
           await handler(runtimeContext);
@@ -947,7 +960,7 @@ var AgentRuntime = class {
         runtimeContext.error = error;
         await handler(runtimeContext);
       }
-      const transition = loop.next(runtimeContext);
+      const transition = state.next(runtimeContext);
       await transition.apply(runtimeContext);
     }
   }
@@ -955,16 +968,24 @@ var AgentRuntime = class {
 
 // src/application/agent.ts
 var Agent = class {
-  constructor(runtime) {
-    this.runtime = runtime;
+  constructor() {
+    this.runtime = new AgentRuntime();
+    this.runtime.on("BEFORE_MESSAGE_RECEIVED" /* BEFORE_MESSAGE_RECEIVED */, this.beforeMessageReceived);
+    this.runtime.on("AFTER_MESSAGE_RECEIVED" /* AFTER_MESSAGE_RECEIVED */, this.afterMessageReceived);
     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);
+    this.runtime.on("BEFORE_MODEL_RESPONDED" /* BEFORE_MODEL_RESPONDED */, this.beforeModelResponded);
+    this.runtime.on("AFTER_MODEL_RESPONDED" /* AFTER_MODEL_RESPONDED */, this.afterModelResponded);
     this.runtime.on("ON_ERROR" /* ON_ERROR */, this.onError);
   }
+  async beforeMessageReceived(context) {
+    return Promise.resolve();
+  }
+  async afterMessageReceived(context) {
+    return Promise.resolve();
+  }
   async beforeInference(context) {
     return Promise.resolve();
   }
@@ -987,10 +1008,10 @@ var Agent = class {
     }
     return Promise.resolve();
   }
-  async beforeModelMessage(context) {
+  async beforeModelResponded(context) {
     return Promise.resolve();
   }
-  async afterModelMessage(context) {
+  async afterModelResponded(context) {
     return Promise.resolve();
   }
   async onError(context) {
@@ -1010,7 +1031,7 @@ var Agent = class {
     this.functionCallVisitor = visitor;
   }
   async run(userMessage, model, context) {
-    const userMessageItem = UserMessage.create(userMessage);
+    const userMessageItem = UserMessageItem.create(userMessage);
     return this.runtime.start(userMessageItem, model, context);
   }
 };
@@ -1040,16 +1061,40 @@ var AgentSociety = class {
     this.isActive = false;
   }
 };
+
+// src/domain/model-context/context-item/client-item/system-message.ts
+var SystemMessageItem = class _SystemMessageItem extends ContextItem {
+  constructor(content) {
+    super();
+    this.type = "message";
+    this.role = "system";
+    this.content = content;
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      role: this.role,
+      content: this.content.toJSON()
+    };
+  }
+  static create(text) {
+    const content = InputText.create(text);
+    return new _SystemMessageItem(content);
+  }
+  static rehydrate(data) {
+    const content = InputText.rehydrate(data);
+    return new _SystemMessageItem(content);
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Agent,
-  AgentRuntime,
   AgentSociety,
   BaseSpecification,
   ContextItem,
-  DeveloperMessage,
-  FunctionCall,
-  FunctionCallOutput,
+  DeveloperMessageItem,
+  FunctionCallItem,
+  FunctionCallOutputItem,
   Gpt54,
   Gpt54Mini,
   Gpt54Nano,
@@ -1060,11 +1105,12 @@ var AgentSociety = class {
   InputTokenDetails,
   Loop,
   ModelContext,
-  ModelMessage,
+  ModelMessageItem,
   OpenAIResponses,
   OutputTokenDetails,
-  Reasoning,
+  ReasoningItem,
+  SystemMessageItem,
   TokenUsage,
-  UserMessage
+  UserMessageItem
 });
 //# sourceMappingURL=index.js.map