@mozaik-ai/core 3.1.4 → 3.3.0

package/dist/index.js

@@ -33,8 +33,7 @@ __export(index_exports, {
   Agent: () => Agent,
   AgentRuntime: () => AgentRuntime,
   AgentSociety: () => AgentSociety,
-  BaseCondition: () => BaseCondition,
-  Context: () => Context,
+  BaseSpecification: () => BaseSpecification,
   ContextItem: () => ContextItem,
   DeveloperMessage: () => DeveloperMessage,
   FunctionCall: () => FunctionCall,
@@ -43,11 +42,12 @@ __export(index_exports, {
   Gpt54Mini: () => Gpt54Mini,
   Gpt54Nano: () => Gpt54Nano,
   If: () => If,
-  InMemoryContextRepository: () => InMemoryContextRepository,
+  InMemoryModelContextRepository: () => InMemoryModelContextRepository,
   InferenceRequest: () => InferenceRequest,
   InferenceResponse: () => InferenceResponse,
   InputTokenDetails: () => InputTokenDetails,
   Loop: () => Loop,
+  ModelContext: () => ModelContext,
   ModelMessage: () => ModelMessage,
   OpenAIResponses: () => OpenAIResponses,
   OutputTokenDetails: () => OutputTokenDetails,
@@ -57,14 +57,14 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/domain/model-context/context.ts
-var Context = class _Context {
+// src/domain/model-context/model-context.ts
+var ModelContext = class _ModelContext {
   constructor(id, projectId, items) {
     this.projectId = projectId;
     this.id = id;
     this.items = items;
   }
-  addItem(item) {
+  addContextItem(item) {
     this.items.push(item);
     return this;
   }
@@ -81,12 +81,18 @@ var Context = class _Context {
   getItems() {
     return this.items;
   }
+  getLastItem() {
+    if (this.items.length === 0) {
+      throw new Error("No items in context");
+    }
+    return this.items[this.items.length - 1];
+  }
   static create(projectId) {
     const id = crypto.randomUUID();
-    return new _Context(id, projectId, []);
+    return new _ModelContext(id, projectId, []);
   }
   static rehydrate(data) {
-    return new _Context(data.id, data.projectId, data.items);
+    return new _ModelContext(data.id, data.projectId, data.items);
   }
   toJSON() {
     return this.items.map((item) => item.toJSON());
@@ -500,19 +506,19 @@ var Gpt54Mini = class {
   }
 };
 
-// src/domain/agent-loop/rules/condition/condition.ts
-var BaseCondition = class {
+// src/domain/specification/specification/specification.ts
+var BaseSpecification = class {
   and(other) {
-    return new AndCondition(this, other);
+    return new AndSpecification(this, other);
   }
   or(other) {
-    return new OrCondition(this, other);
+    return new OrSpecification(this, other);
   }
   not() {
-    return new NotCondition(this);
+    return new NotSpecification(this);
   }
 };
-var AndCondition = class extends BaseCondition {
+var AndSpecification = class extends BaseSpecification {
   constructor(left, right) {
     super();
     this.left = left;
@@ -522,16 +528,16 @@ var AndCondition = class extends BaseCondition {
     return this.left.isSatisfiedBy(candidate) && this.right.isSatisfiedBy(candidate);
   }
 };
-var NotCondition = class extends BaseCondition {
-  constructor(condition) {
+var NotSpecification = class extends BaseSpecification {
+  constructor(specification) {
     super();
-    this.condition = condition;
+    this.specification = specification;
   }
   isSatisfiedBy(candidate) {
-    return !this.condition.isSatisfiedBy(candidate);
+    return !this.specification.isSatisfiedBy(candidate);
   }
 };
-var OrCondition = class extends BaseCondition {
+var OrSpecification = class extends BaseSpecification {
   constructor(left, right) {
     super();
     this.left = left;
@@ -542,34 +548,34 @@ var OrCondition = class extends BaseCondition {
   }
 };
 
-// src/domain/agent-loop/rules/rule/rule.ts
+// src/domain/specification/rule/rule.ts
 var If = class {
-  constructor({ condition, action }) {
-    this.condition = condition;
+  constructor({ specification, action }) {
+    this.specification = specification;
     this.action = action;
   }
   async apply(candidate) {
-    if (this.condition.isSatisfiedBy(candidate)) {
+    if (this.specification.isSatisfiedBy(candidate)) {
       return await this.action.apply(candidate);
     }
     return candidate;
   }
 };
 var Loop = class {
-  constructor({ condition, action }) {
-    this.condition = condition;
+  constructor({ specification, action }) {
+    this.specification = specification;
     this.action = action;
   }
   async apply(candidate) {
-    while (this.condition.isSatisfiedBy(candidate)) {
+    while (this.specification.isSatisfiedBy(candidate)) {
       candidate = await this.action.apply(candidate);
     }
     return candidate;
   }
 };
 
-// src/infrastructure/repository/in-memory-context-repository.ts
-var InMemoryContextRepository = class {
+// src/infrastructure/repository/in-memory-model-context-repository.ts
+var InMemoryModelContextRepository = class {
   constructor() {
     this.store = /* @__PURE__ */ new Map();
     this.projectIndex = /* @__PURE__ */ new Map();
@@ -602,7 +608,7 @@ var InMemoryContextRepository = class {
     return [...ids].map((id) => this.store.get(id)).filter((c) => Boolean(c)).map((c) => this.clone(c));
   }
   clone(context) {
-    return Context.rehydrate({
+    return ModelContext.rehydrate({
       id: context.id,
       projectId: context.projectId,
       items: [...context.getItems()]
@@ -667,12 +673,33 @@ var Fail = class {
   }
 };
 
+// src/domain/model-context/specifications/function-call-requested.ts
+var FunctionCallRequestedSpecification = class extends BaseSpecification {
+  isSatisfiedBy(context) {
+    if (context.getItems().length === 0) {
+      return false;
+    }
+    const lastItem = context.getItems()[context.getItems().length - 1];
+    return lastItem instanceof FunctionCall;
+  }
+};
+
+// src/domain/model-context/specifications/function-call-output-present.ts
+var FunctionCallOutputPresentSpecification = class extends BaseSpecification {
+  isSatisfiedBy(context) {
+    const lasteItem = context.getItems()[context.getItems().length - 1];
+    return lasteItem instanceof FunctionCallOutput;
+  }
+};
+
 // 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 */;
+    this.functionCallRequestedSpec = new FunctionCallRequestedSpecification();
+    this.functionCallOutputPresentSpec = new FunctionCallOutputPresentSpecification();
   }
   getDetails() {
     return {
@@ -682,15 +709,12 @@ var FunctionCallState = class {
     };
   }
   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");
+    if (!this.functionCallRequestedSpec.isSatisfiedBy(runtime.context)) {
+      throw new Error("Function call requested not found");
     }
   }
   next(runtime) {
-    const functionCallOutput = runtime.functionCallOutput;
-    if (!functionCallOutput) {
+    if (!this.functionCallOutputPresentSpec.isSatisfiedBy(runtime.context)) {
       return new Fail("Function call output not found");
     }
     return new GoTo("INFERENCE_PENDING" /* INFERENCE_PENDING */);
@@ -708,12 +732,24 @@ var Complete = class {
   }
 };
 
+// src/domain/model-context/specifications/model-responded.ts
+var ModelRespondedSpecification = 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";
+  }
+};
+
 // 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 */;
+    this.modelResponded = new ModelRespondedSpecification();
   }
   getDetails() {
     return {
@@ -723,15 +759,16 @@ var ModelMessageState = class {
     };
   }
   validateEntry(runtime) {
-    if (!runtime.modelMessage) {
-      throw new Error("Model message not found");
+    if (!this.modelResponded.isSatisfiedBy(runtime.context)) {
+      throw new Error("Model message is not present in the context");
     }
   }
   next(runtime) {
-    if (!runtime.modelMessage) {
-      return new Fail("Model message not found");
+    if (!this.modelResponded.isSatisfiedBy(runtime.context)) {
+      return new Fail("Model message is not present in the context");
     }
-    return new Complete(runtime.modelMessage.content.text);
+    const lastItem = runtime.context.getLastItem();
+    return new Complete(lastItem.content.text);
   }
 };
 
@@ -741,6 +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();
   }
   getDetails() {
     return {
@@ -750,25 +789,11 @@ var InferencePendingState = class {
     };
   }
   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");
-    }
-    const contextItems = inferenceResponse.contextItems;
-    if (contextItems.length === 0) {
-      return new Fail("No context items found");
-    }
-    const lastItem = contextItems[contextItems.length - 1];
-    if (lastItem instanceof FunctionCall) {
+    if (this.functionCallRequested.isSatisfiedBy(runtime.context)) {
       return new GoTo("FUNCTION_CALL_PENDING" /* FUNCTION_CALL_PENDING */);
-    }
-    if (lastItem instanceof ModelMessage) {
+    } else if (this.modelResponded.isSatisfiedBy(runtime.context)) {
       return new GoTo("MODEL_MESSAGE_RECEIVED" /* MODEL_MESSAGE_RECEIVED */);
     }
     return new Fail("Invalid response type");
@@ -856,27 +881,24 @@ var AgentRuntime = class {
     this.stateHandlerRegistry.registerHandler("MODEL_MESSAGE_RECEIVED" /* MODEL_MESSAGE_RECEIVED */, this.onModelMessageReceived);
     this.hooksRegistry.registerHandler("ON_ERROR" /* ON_ERROR */, this.onError);
   }
-  async onInferencePending(context) {
+  async onInferencePending(runtimeContext) {
     const openaiResponses = new OpenAIResponses();
-    const inferenceRequest = new InferenceRequest(context.model, context.context);
+    const inferenceRequest = new InferenceRequest(runtimeContext.model, runtimeContext.context);
     const inferenceResponse = await openaiResponses.infer(inferenceRequest);
-    context.inferenceResponse = inferenceResponse;
-    context.context.applyModelOutput(inferenceResponse.contextItems);
+    runtimeContext.inferenceResponse = inferenceResponse;
+    runtimeContext.context.applyModelOutput(inferenceResponse.contextItems);
     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);
+  async onFunctionCallPending(runtimeContext) {
+    const functionCall = runtimeContext.context.getLastItem();
+    const tool = runtimeContext.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;
-    context.context.addItem(FunctionCallOutput.create(functionCall.callId, JSON.stringify(functionCallOutput)));
+    runtimeContext.context.addContextItem(
+      FunctionCallOutput.create(functionCall.callId, JSON.stringify(functionCallOutput))
+    );
     return Promise.resolve();
   }
   async onError(context) {
@@ -1022,8 +1044,7 @@ var AgentSociety = class {
   Agent,
   AgentRuntime,
   AgentSociety,
-  BaseCondition,
-  Context,
+  BaseSpecification,
   ContextItem,
   DeveloperMessage,
   FunctionCall,
@@ -1032,11 +1053,12 @@ var AgentSociety = class {
   Gpt54Mini,
   Gpt54Nano,
   If,
-  InMemoryContextRepository,
+  InMemoryModelContextRepository,
   InferenceRequest,
   InferenceResponse,
   InputTokenDetails,
   Loop,
+  ModelContext,
   ModelMessage,
   OpenAIResponses,
   OutputTokenDetails,