@mozaik-ai/core 4.2.0-beta.4 → 4.2.0-beta.5

package/dist/index.mjs

@@ -402,11 +402,6 @@ var CreateAgentUseCase = class {
     const id = UuidGenerator.create();
     const manifest = { id, name, role: "agent" };
     const memory = this.memoryFactory.create();
-    const developerMessageItem = {
-      type: "developer_message",
-      text: instruction
-    };
-    memory.saveItem(developerMessageItem);
     const agentRecord = { id, manifest, tools, memory, handlers };
     const agent = Agent.create(agentRecord);
     await this.agentRepository.save(agent);
@@ -433,9 +428,206 @@ var InMemoryAgentRepository = class {
   }
 };
 
+// src/domain/agent/loop/specification.ts
+var LoopSpecification = class {
+  and(other) {
+    return new AndLoopSpecification(this, other);
+  }
+  or(other) {
+    return new OrLoopSpecification(this, other);
+  }
+  not() {
+    return new NotLoopSpecification(this);
+  }
+};
+var AndLoopSpecification = class extends LoopSpecification {
+  constructor(left, right) {
+    super();
+    this.left = left;
+    this.right = right;
+  }
+  isSatisfiedBy(agentLoop) {
+    return this.left.isSatisfiedBy(agentLoop) && this.right.isSatisfiedBy(agentLoop);
+  }
+};
+var OrLoopSpecification = class extends LoopSpecification {
+  constructor(left, right) {
+    super();
+    this.left = left;
+    this.right = right;
+  }
+  isSatisfiedBy(agentLoop) {
+    return this.left.isSatisfiedBy(agentLoop) || this.right.isSatisfiedBy(agentLoop);
+  }
+};
+var NotLoopSpecification = class extends LoopSpecification {
+  constructor(rule) {
+    super();
+    this.rule = rule;
+  }
+  isSatisfiedBy(agentLoop) {
+    return !this.rule.isSatisfiedBy(agentLoop);
+  }
+};
+var AwaitingInference = class extends LoopSpecification {
+  isSatisfiedBy(agentLoop) {
+    return agentLoop.loop.stateId === "awaiting_inference";
+  }
+};
+var AwaitingRequest = class extends LoopSpecification {
+  isSatisfiedBy(agentLoop) {
+    return agentLoop.loop.stateId === "awaiting_inference_request";
+  }
+};
+var AwaitingToolOutput = class extends LoopSpecification {
+  isSatisfiedBy(agentLoop) {
+    return agentLoop.loop.stateId === "awaiting_tool_output";
+  }
+};
+var ModelAnswered = class extends LoopSpecification {
+  isSatisfiedBy(agentLoop) {
+    const operations = agentLoop.loop.completedOperations;
+    const lastOperation = operations[operations.length - 1];
+    if ((lastOperation == null ? void 0 : lastOperation.type) !== "inference") {
+      return false;
+    }
+    return lastOperation.result.items.some((item) => item.type === "model_message");
+  }
+};
+
+// src/domain/agent/loop/action.ts
+var LoopAction = class {
+};
+var RequestPreparationAction = class extends LoopAction {
+  constructor(request) {
+    super();
+    this.request = request;
+  }
+  execute(agentLoop) {
+    return {
+      type: "inference",
+      request: this.request
+    };
+  }
+};
+var InferenceAction = class extends LoopAction {
+  execute(agentLoop) {
+    const request = agentLoop.loop.request;
+    if (!request) {
+      return { type: "wait", reason: "no request" };
+    }
+    return { type: "inference", request };
+  }
+};
+var ToolUseAction = class extends LoopAction {
+  execute(agentLoop) {
+    if (!agentLoop.loop.pending) {
+      return { type: "wait" };
+    }
+    const pendingOperation = agentLoop.loop.pending;
+    if (pendingOperation.type === "tool_execution") {
+      return { type: "tool_use", call: pendingOperation.call };
+    }
+    return { type: "wait" };
+  }
+};
+var CompleteAction = class extends LoopAction {
+  constructor(reason) {
+    super();
+    this.reason = reason;
+  }
+  execute() {
+    return { type: "complete", reason: this.reason };
+  }
+};
+
+// src/domain/agent/loop/rule.ts
+var LoopRule = class _LoopRule {
+  constructor(id, condition, action, priority) {
+    this._id = id;
+    this._priority = priority;
+    this._condition = condition;
+    this._action = action;
+  }
+  get id() {
+    return this._id;
+  }
+  get priority() {
+    return this._priority;
+  }
+  get condition() {
+    return this._condition;
+  }
+  get action() {
+    return this._action;
+  }
+  static create(spec) {
+    var _a;
+    const priority = (_a = spec.priority) != null ? _a : 0;
+    const id = crypto.randomUUID();
+    return new _LoopRule(id, spec.when, spec.then, priority);
+  }
+  static rehydrate(spec) {
+    var _a;
+    const priority = (_a = spec.priority) != null ? _a : 0;
+    const rule = new _LoopRule(spec.id, spec.condition, spec.action, priority);
+    return rule;
+  }
+};
+var RuleBook = class _RuleBook {
+  constructor(rules) {
+    this.rules = rules;
+  }
+  addRule(rule) {
+    this.rules.push(rule);
+  }
+  removeRule(rule) {
+    this.rules = this.rules.filter((r) => r.id !== rule.id);
+  }
+  getRules() {
+    return this.rules;
+  }
+  static create(loopRuleParams) {
+    const rules = loopRuleParams.map((param) => LoopRule.create(param));
+    return new _RuleBook(rules);
+  }
+  static rehydrate(record) {
+    const rules = record.rules.map((rule) => LoopRule.rehydrate(rule));
+    return new _RuleBook(rules);
+  }
+  record() {
+    return {
+      rules: this.rules.map((rule) => ({
+        id: rule.id,
+        priority: rule.priority,
+        condition: rule.condition,
+        action: rule.action
+      }))
+    };
+  }
+};
+var defaultRules = (request) => [
+  {
+    when: new AwaitingRequest(),
+    then: new RequestPreparationAction(request)
+  },
+  {
+    when: new AwaitingInference(),
+    then: new InferenceAction()
+  },
+  {
+    when: new AwaitingToolOutput(),
+    then: new ToolUseAction()
+  },
+  {
+    when: new ModelAnswered(),
+    then: new CompleteAction("completed")
+  }
+];
+
 // src/domain/agent/loop/loop.ts
 var Loop = class _Loop {
-  constructor(loopId, agentId, subject, createdAt, state, inferenceRequest, pendingOperation, transitionHistory, operationHistory, rules) {
+  constructor(loopId, agentId, subject, createdAt, state, inferenceRequest, pendingOperation, transitionHistory, operationHistory, ruleBook) {
     this.loopId = loopId;
     this.agentId = agentId;
     this.subject = subject;
@@ -445,7 +637,7 @@ var Loop = class _Loop {
     this.pendingOperation = pendingOperation;
     this.transitionHistory = transitionHistory;
     this.operationHistory = operationHistory;
-    this.loopRules = rules;
+    this._ruleBook = ruleBook;
   }
   get id() {
     return this.loopId;
@@ -465,8 +657,11 @@ var Loop = class _Loop {
   get request() {
     return this.inferenceRequest;
   }
-  get rules() {
-    return this.loopRules;
+  get ruleBook() {
+    return this._ruleBook;
+  }
+  getSubject() {
+    return this.subject;
   }
   getAgentId() {
     return this.agentId;
@@ -482,7 +677,7 @@ var Loop = class _Loop {
       pendingOperation: this.pendingOperation,
       transitionHistory: [...this.transitionHistory],
       operationHistory: [...this.operationHistory],
-      rules: [...this.rules]
+      ruleBook: this.ruleBook.record()
     };
   }
   moveToIdle(reason, transitionId) {
@@ -621,8 +816,9 @@ var Loop = class _Loop {
       throw new Error(`Cannot ${intent} a loop that is already ${this.state}`);
     }
   }
-  static create(id, agentId, subject, rules) {
+  static create(agentId, subject, ruleBook) {
     const createdAt = SystemClock.now();
+    const id = UuidGenerator.create();
     return new _Loop(
       id,
       agentId,
@@ -633,7 +829,7 @@ var Loop = class _Loop {
       void 0,
       [],
       [],
-      rules
+      ruleBook
     );
   }
   static rehydrate(record) {
@@ -647,7 +843,7 @@ var Loop = class _Loop {
       record.pendingOperation,
       [...record.transitionHistory],
       [...record.operationHistory],
-      [...record.rules]
+      RuleBook.rehydrate(record.ruleBook)
     );
   }
 };
@@ -657,10 +853,18 @@ var CreateAgentLoopUseCase = class {
   constructor(loopRepository) {
     this.loopRepository = loopRepository;
   }
-  async execute(subject, agentId, rules) {
-    const loop = Loop.create(UuidGenerator.create(), agentId, subject, rules);
-    await this.loopRepository.save(loop);
-    return loop;
+  async execute(params) {
+    if ("rules" in params) {
+      const ruleBook = RuleBook.create(params.rules);
+      const loop = Loop.create(params.agentId, params.subject, ruleBook);
+      await this.loopRepository.save(loop);
+      return loop;
+    } else {
+      const ruleBook = RuleBook.create(defaultRules(params.request));
+      const loop = Loop.create(params.agentId, params.subject, ruleBook);
+      await this.loopRepository.save(loop);
+      return loop;
+    }
   }
 };
 
@@ -2196,7 +2400,7 @@ var supportedModels = [
 var RuleEngine = class {
   decide(agent, loop) {
     const agentLoop = { agent, loop };
-    const satisfiedRules = loop.rules.filter((rule) => rule.condition.isSatisfiedBy(agentLoop));
+    const satisfiedRules = loop.ruleBook.getRules().filter((rule) => rule.condition.isSatisfiedBy(agentLoop));
     if (satisfiedRules.length === 0) {
       return void 0;
     }
@@ -2235,203 +2439,16 @@ var RunLoopUseCase = class {
   }
 };
 
-// src/domain/agent/loop/specification.ts
-var LoopSpecification = class {
-  and(other) {
-    return new AndLoopSpecification(this, other);
-  }
-  or(other) {
-    return new OrLoopSpecification(this, other);
-  }
-  not() {
-    return new NotLoopSpecification(this);
-  }
-};
-var AndLoopSpecification = class extends LoopSpecification {
-  constructor(left, right) {
-    super();
-    this.left = left;
-    this.right = right;
-  }
-  isSatisfiedBy(agentLoop) {
-    return this.left.isSatisfiedBy(agentLoop) && this.right.isSatisfiedBy(agentLoop);
-  }
-};
-var OrLoopSpecification = class extends LoopSpecification {
-  constructor(left, right) {
-    super();
-    this.left = left;
-    this.right = right;
-  }
-  isSatisfiedBy(agentLoop) {
-    return this.left.isSatisfiedBy(agentLoop) || this.right.isSatisfiedBy(agentLoop);
-  }
-};
-var NotLoopSpecification = class extends LoopSpecification {
-  constructor(rule) {
-    super();
-    this.rule = rule;
-  }
-  isSatisfiedBy(agentLoop) {
-    return !this.rule.isSatisfiedBy(agentLoop);
-  }
-};
-var Idle = class extends LoopSpecification {
-  isSatisfiedBy(agentLoop) {
-    return agentLoop.loop.stateId === "idle";
-  }
-};
-var AwaitingInference = class extends LoopSpecification {
-  isSatisfiedBy(agentLoop) {
-    return agentLoop.loop.stateId === "awaiting_inference";
-  }
-};
-var AwaitingInferenceRequest = class extends LoopSpecification {
-  isSatisfiedBy(agentLoop) {
-    return agentLoop.loop.stateId === "awaiting_inference_request";
-  }
-};
-var AwaitingToolOutput = class extends LoopSpecification {
-  isSatisfiedBy(agentLoop) {
-    return agentLoop.loop.stateId === "awaiting_tool_output";
-  }
-};
-var Stopped = class extends LoopSpecification {
-  isSatisfiedBy(agentLoop) {
-    return agentLoop.loop.stateId === "stopped";
-  }
-};
-var Completed = class extends LoopSpecification {
-  isSatisfiedBy(agentLoop) {
-    return agentLoop.loop.stateId === "completed";
-  }
-};
-var ModelAnswered = class extends LoopSpecification {
-  isSatisfiedBy(agentLoop) {
-    const operations = agentLoop.loop.completedOperations;
-    const lastOperation = operations[operations.length - 1];
-    if ((lastOperation == null ? void 0 : lastOperation.type) !== "inference") {
-      return false;
-    }
-    return lastOperation.result.items.some((item) => item.type === "model_message");
-  }
-};
-
-// src/application/use-cases/loop-state.ts
-var LoopStateUseCase = class {
-  execute(loopStateId) {
-    if (loopStateId === "idle") {
-      return new Idle();
-    }
-    if (loopStateId === "awaiting_inference_request") {
-      return new AwaitingInferenceRequest();
-    }
-    if (loopStateId === "awaiting_inference") {
-      return new AwaitingInference();
-    }
-    if (loopStateId === "awaiting_tool_output") {
-      return new AwaitingToolOutput();
-    }
-    if (loopStateId === "stopped") {
-      return new Stopped();
-    }
-    if (loopStateId === "completed") {
-      return new Completed();
-    }
-    throw new Error(`Invalid loop state: ${loopStateId}`);
-  }
-};
-
-// src/domain/agent/loop/action.ts
-var LoopAction = class {
-};
-var InferenceAction = class extends LoopAction {
-  execute(agentLoop) {
-    const request = agentLoop.loop.request;
-    if (!request) {
-      return { type: "wait", reason: "no request" };
-    }
-    return { type: "inference", request };
-  }
-};
-var ToolUseAction = class extends LoopAction {
-  execute(agentLoop) {
-    if (!agentLoop.loop.pending) {
-      return { type: "wait" };
-    }
-    const pendingOperation = agentLoop.loop.pending;
-    if (pendingOperation.type === "tool_execution") {
-      return { type: "tool_use", call: pendingOperation.call };
-    }
-    return { type: "wait" };
-  }
-};
-var CompleteAction = class extends LoopAction {
-  constructor(reason) {
-    super();
-    this.reason = reason;
-  }
-  execute() {
-    return { type: "complete", reason: this.reason };
-  }
-};
-var WaitAction = class extends LoopAction {
-  constructor(reason) {
-    super();
-    this.reason = reason;
-  }
-  execute() {
-    return { type: "wait", reason: this.reason };
-  }
-};
-
-// src/domain/agent/loop/rule.ts
-var LoopRule = class _LoopRule {
-  constructor(id, condition, action, priority) {
-    this._id = id;
-    this._priority = priority;
-    this._condition = condition;
-    this._action = action;
-  }
-  get id() {
-    return this._id;
-  }
-  get priority() {
-    return this._priority;
-  }
-  get condition() {
-    return this._condition;
-  }
-  get action() {
-    return this._action;
-  }
-  static create(spec) {
-    var _a;
-    const priority = (_a = spec.priority) != null ? _a : 0;
-    const id = crypto.randomUUID();
-    return new _LoopRule(id, spec.when, spec.then, priority);
-  }
-  static rehydrate(spec) {
-    var _a;
-    const priority = (_a = spec.priority) != null ? _a : 0;
-    const rule = new _LoopRule(spec.id, spec.condition, spec.action, priority);
-    return rule;
-  }
-};
-
 // src/infrastructure/memory/runtime-memory.ts
 var RuntimeMemory = class {
   constructor(context) {
     this.context = context;
   }
-  getContext() {
-    return this.context;
+  remember(items, participantId) {
+    throw new Error("Method not implemented.");
   }
-  saveItem(item) {
-    this.context.items.push(item);
-  }
-  saveItems(items) {
-    this.context.items.push(...items);
+  recall(topic, participantId) {
+    throw new Error("Method not implemented.");
   }
 };
 
@@ -2529,8 +2546,7 @@ function defineAgentModule(config) {
     return await createAgentUseCase.execute(config2.name, config2.instruction, config2.tools, config2.handlers);
   }
   async function createLoop(params) {
-    const rules = params.rules.map((rule) => LoopRule.create(rule));
-    return await createLoopUseCase.execute(params.subject, params.agentId, rules);
+    return await createLoopUseCase.execute(params);
   }
   const directiveExecutionStrategyResolver = new DirectiveExecutionStrategyResolver({
     inference: new InferenceExecutionStrategy(inferenceRunner),
@@ -2542,35 +2558,10 @@ function defineAgentModule(config) {
   async function runLoop(loopId) {
     return await runLoopUseCase.execute(loopId);
   }
-  const getLoopStateUseCase = new LoopStateUseCase();
-  function state(loopStateId) {
-    return getLoopStateUseCase.execute(loopStateId);
-  }
-  function modelAnswered() {
-    return new ModelAnswered();
-  }
-  function runInference() {
-    return new InferenceAction();
-  }
-  function toolUse() {
-    return new ToolUseAction();
-  }
-  function complete(reason) {
-    return new CompleteAction(reason != null ? reason : "completed");
-  }
-  function wait(reason) {
-    return new WaitAction(reason != null ? reason : "waiting");
-  }
   return {
     createAgent,
     createLoop,
-    runLoop,
-    state,
-    modelAnswered,
-    runInference,
-    toolUse,
-    complete,
-    wait
+    runLoop
   };
 }
 export {