@mozaik-ai/core 4.0.0-beta.5 → 4.0.0-beta.7

package/dist/index.mjs

@@ -314,6 +314,16 @@ var SemanticEvent = class _SemanticEvent {
     return new _SemanticEvent(type, producerId, occurredAt, payload);
   }
 };
+var ParticipantJoinedEvent = class extends SemanticEvent {
+  static init(manifest) {
+    return SemanticEvent.create("participant.joined", manifest.id, manifest);
+  }
+};
+var ParticipantLeftEvent = class extends SemanticEvent {
+  static init(manifest) {
+    return SemanticEvent.create("participant.left", manifest.id, manifest);
+  }
+};
 var MessageSentEvent = class extends SemanticEvent {
   static init(producerId, message) {
     return SemanticEvent.create("message.sent", producerId, { message });
@@ -472,9 +482,11 @@ var RuntimeService = class {
   }
   join(participant) {
     this.state.addParticipant(participant);
+    this.publish(ParticipantJoinedEvent.init(participant.getManifest()));
   }
   leave(participant) {
     this.state.removeParticipant(participant);
+    this.publish(ParticipantLeftEvent.init(participant.getManifest()));
   }
   publish(event) {
     for (const participant of this.state.getParticipants()) {
@@ -538,28 +550,43 @@ function createSendMessage(resolveRuntime) {
 }
 
 // src/domain/agentic-environment/loop/agent-loop.ts
-var AgentLoop = class {
-  constructor(stateExecutor, transitionResolver, loopVisitor) {
+var AgentLoop = class _AgentLoop {
+  constructor(loopId, stateExecutor, transitionResolver, interceptionHandler) {
+    this.loopId = loopId;
     this.stateExecutor = stateExecutor;
     this.transitionResolver = transitionResolver;
-    this.loopVisitor = loopVisitor;
+    this.interceptionHandler = interceptionHandler;
   }
-  async run(message) {
+  async run(message, loopVisitor) {
     let transition = {
-      nextStateId: "context_preparation",
+      nextStateId: "context_update",
       input: message
     };
     while (transition.nextStateId !== "idle") {
-      const execution = await this.stateExecutor.execute(transition, this.loopVisitor);
-      transition = this.transitionResolver.resolve(execution);
+      const isInterceptionSatisfied = this.interceptionHandler.isSatisfiedBy(transition);
+      if (isInterceptionSatisfied) {
+        loopVisitor.visitInterceptionStarted(transition);
+        transition = await this.interceptionHandler.handle(transition);
+        loopVisitor.visitInterceptionFinished(transition);
+      } else {
+        const execution = await this.stateExecutor.execute(transition, loopVisitor);
+        transition = this.transitionResolver.resolve(execution);
+      }
     }
   }
+  getLoopId() {
+    return this.loopId;
+  }
+  static create(stateExecutor, transitionResolver, interceptionHandler) {
+    const loopId = crypto.randomUUID();
+    return new _AgentLoop(loopId, stateExecutor, transitionResolver, interceptionHandler);
+  }
 };
 
 // src/domain/agentic-environment/loop/state-executor.ts
 var LoopStateExecutor = class {
-  constructor(contextPreparationState, inferenceState, inferenceStreamingState, functionCallState, modelMessageState) {
-    this.contextPreparationState = contextPreparationState;
+  constructor(contextUpdateState, inferenceState, inferenceStreamingState, functionCallState, modelMessageState) {
+    this.contextUpdateState = contextUpdateState;
     this.inferenceState = inferenceState;
     this.inferenceStreamingState = inferenceStreamingState;
     this.functionCallState = functionCallState;
@@ -567,8 +594,8 @@ var LoopStateExecutor = class {
   }
   async execute(transition, loopVisitor) {
     switch (transition.nextStateId) {
-      case "context_preparation":
-        return await this.contextPreparationState.run(transition.input, loopVisitor);
+      case "context_update":
+        return await this.contextUpdateState.run(transition.input, loopVisitor);
       case "inference":
         return await this.inferenceState.run(transition.input, loopVisitor);
       case "inference_streaming":
@@ -613,19 +640,19 @@ var FunctionCallState = class {
   }
 };
 
-// src/application/states/context-preparation.ts
-var ContextPreparationState = class {
+// src/application/states/context-update.ts
+var ContextUpdateState = class {
   constructor() {
-    this.id = "context_preparation";
+    this.id = "context_update";
   }
   async run(input, loopVisitor) {
-    loopVisitor.visitContextPreparationStarted(input);
+    loopVisitor.visitContextUpdateStarted(input);
     const userMessage = UserMessageItem.create(input.content);
     const output = {
       ...input.input,
       context: input.input.context.addContextItems([userMessage])
     };
-    loopVisitor.visitContextPreparationCompleted(output);
+    loopVisitor.visitContextUpdateCompleted(output);
     return {
       stateId: this.id,
       input,
@@ -666,7 +693,7 @@ var TransitionResolver = class {
 // src/domain/agentic-environment/loop/transition-specification.ts
 var MessageReceivedSpecification = class {
   isSatisfiedBy(execution) {
-    return execution.stateId === "context_preparation";
+    return execution.stateId === "context_update";
   }
 };
 function isInferenceExecution(execution) {
@@ -699,7 +726,7 @@ var ContextPreparationToInferenceRule = class {
     this.specification = new MessageReceivedSpecification();
   }
   createTransition(execution) {
-    if (execution.stateId !== "context_preparation") {
+    if (execution.stateId !== "context_update") {
       throw new Error("Expected context_preparation execution");
     }
     const nextStateId = execution.output.streaming ? "inference_streaming" : "inference";
@@ -787,47 +814,47 @@ var ModelMessageToIdleRule = class {
 
 // src/domain/agentic-environment/loop/event-publisher-visitor.ts
 var EventPublisherLoopVisitor = class {
-  constructor(agentId, runtime) {
+  constructor(agentId, loopId, runtime) {
     this.agentId = agentId;
+    this.loopId = loopId;
     this.runtime = runtime;
   }
-  visitContextPreparationStarted(input) {
-    console.log("Visiting message received started: ", input);
-    this.publish("context_preparation.started", input);
+  visitContextUpdateStarted(input) {
+    this.publish("context_update.started", { ...input, loopId: this.loopId });
   }
-  visitContextPreparationCompleted(output) {
-    console.log("Visiting message received completed: ", output);
-    this.publish("context_preparation.completed", output);
+  visitContextUpdateCompleted(output) {
+    this.publish("context_update.completed", { ...output, loopId: this.loopId });
   }
   visitInferenceStarted(input) {
-    console.log("Visiting inference started: ", input);
     this.publish("inference.started", input);
   }
   visitInferenceEvent(event) {
     this.publish("inference.stream", event);
   }
   visitInferenceCompleted(output) {
-    console.log("Visiting inference completed: ", output);
     this.publish("inference.completed", output);
   }
   visitFunctionCallStarted(input) {
-    console.log("Visiting function call started: ", input);
     this.publish("function_call.started", input);
   }
   visitFunctionCallCompleted(output) {
-    console.log("Visiting function call completed: ", output);
     this.publish("function_call.completed", output);
   }
   visitModelAnswer(input) {
-    console.log("Visiting model answer: ", input.answer);
     this.publish("model.answer", input);
   }
+  visitInterceptionStarted(transition) {
+    this.publish("interception.started", transition);
+  }
+  visitInterceptionFinished(transition) {
+    this.publish("interception.finished", transition);
+  }
   publish(type, payload) {
     this.runtime.publish({
       type,
       producerId: this.agentId,
       occurredAt: /* @__PURE__ */ new Date(),
-      payload
+      payload: { ...payload, loopId: this.loopId }
     });
   }
 };
@@ -861,7 +888,7 @@ var InferenceStreamingState = class {
 
 // src/application/use-cases/run-loop.ts
 function createRunLoop(resolveRuntime) {
-  return function runLoop(agentId, message, inferenceInput) {
+  return function runLoop(agentId, message, inferenceInput, interceptionHandler) {
     const runtime = resolveRuntime();
     const inferenceRunner = runtime.getInferenceRunner();
     const functionCallRunner = runtime.getFunctionCallRunner();
@@ -874,21 +901,21 @@ function createRunLoop(resolveRuntime) {
       new ModelMessageToIdleRule()
     ]);
     const stateExecutor = new LoopStateExecutor(
-      new ContextPreparationState(),
+      new ContextUpdateState(),
       new InferenceState(inferenceRunner),
       new InferenceStreamingState(inferenceRunner),
       new FunctionCallState(functionCallRunner),
       new ModelMessageState()
     );
-    const agentLoop = new AgentLoop(
-      stateExecutor,
-      transitionResolver,
-      new EventPublisherLoopVisitor(agentId, runtime)
+    const agentLoop = AgentLoop.create(stateExecutor, transitionResolver, interceptionHandler);
+    const loopVisitor = new EventPublisherLoopVisitor(agentId, agentLoop.getLoopId(), runtime);
+    agentLoop.run(
+      {
+        content: message,
+        input: inferenceInput
+      },
+      loopVisitor
     );
-    agentLoop.run({
-      content: message,
-      input: inferenceInput
-    });
   };
 }
 
@@ -2154,6 +2181,7 @@ export {
   Agent,
   AnthropicMessages,
   ContextItem,
+  DefaultInferenceRunner,
   DeveloperMessageItem,
   FunctionCallItem,
   FunctionCallOutputItem,