@mozaik-ai/core 4.0.3 → 4.0.4

package/README.md

@@ -218,18 +218,18 @@ Participants never poll. Custom events go through `sendEvent(event, senderId)` w
 
 Producer is the agent whose loop is running:
 
-| Event                      | Published when                                     | Payload                                                  |
-| -------------------------- | -------------------------------------------------- | -------------------------------------------------------- |
-| `context_update.started`   | The loop begins appending the user message         | Received message plus `loopId`                           |
-| `context_update.completed` | Context is ready for inference                     | `InferenceInput` plus `loopId`                           |
-| `inference.started`        | The model call begins                              | `InferenceInput`                                         |
-| `inference.stream`         | Each streaming chunk (only when `streaming: true`) | The inner provider event                                 |
-| `inference.completed`      | The model call finished                            | `InferenceOutput` (`items`, `tokenUsage`, `rowResponse`) |
-| `function_call.started`    | A tool is about to run                             | `{ call, inferenceInput }`                               |
-| `function_call.completed`  | The tool returned                                  | `FunctionCallOutputItem`                                 |
-| `model.answer`             | The assistant message is committed                 | `{ answer: ModelMessageItem }`                           |
-| `interception.started`     | An `InterceptionHandler` matched a transition      | The pending `LoopTransition`                             |
-| `interception.finished`    | The handler returned (possibly rewritten)          | The transition that will execute                         |
+| Event                        | Published when                                     | Payload                                                  |
+| ---------------------------- | -------------------------------------------------- | -------------------------------------------------------- |
+| `message_received.started`   | The loop begins appending the user message         | Received message plus `loopId`                           |
+| `message_received.completed` | Context is ready for inference                     | `InferenceInput` plus `loopId`                           |
+| `inference.started`          | The model call begins                              | `InferenceInput`                                         |
+| `inference.stream`           | Each streaming chunk (only when `streaming: true`) | The inner provider event                                 |
+| `inference.completed`        | The model call finished                            | `InferenceOutput` (`items`, `tokenUsage`, `rowResponse`) |
+| `function_call.started`      | A tool is about to run                             | `{ call, inferenceInput }`                               |
+| `function_call.completed`    | The tool returned                                  | `FunctionCallOutputItem`                                 |
+| `model.answer`               | The assistant message is committed                 | `{ answer: ModelMessageItem }`                           |
+| `interception.started`       | An `InterceptionHandler` matched a transition      | The pending `LoopTransition`                             |
+| `interception.finished`      | The handler returned (possibly rewritten)          | The transition that will execute                         |
 
 ### Streaming
 
@@ -345,13 +345,13 @@ Three things to note:
 
 ## The agent loop
 
-`runLoop(agentId, message, inferenceInput, interceptionHandler?)` drives one agent turn as a state machine. It starts at `context_update` and runs until `idle`. Tool execution and the follow-up inference live inside the loop — you do not call a separate function-call runner.
+`runLoop(agentId, message, inferenceInput, interceptionHandler?)` drives one agent turn as a state machine. It starts at `message_received` and runs until `idle`. Tool execution and the follow-up inference live inside the loop — you do not call a separate function-call runner.
 
 Each step: optionally intercept the pending transition, execute the state, then resolve the next transition.
 
 ```mermaid
 flowchart TD
-    Start([runLoop]) --> CU[context_update]
+    Start([runLoop]) --> CU[message_received]
     CU --> INF[inference]
     INF -->|function_call item| FC[function_call]
     INF -->|assistant message| MM[model_message]
@@ -361,7 +361,7 @@ flowchart TD
 
 | State                 | What it does                                                                                     |
 | --------------------- | ------------------------------------------------------------------------------------------------ |
-| `context_update`      | Appends the user message to the agent's context.                                                 |
+| `message_received`    | Appends the user message to the agent's context.                                                 |
 | `inference`           | Calls the model and waits for the full response.                                                 |
 | `inference_streaming` | Same call, streaming; each chunk is published as `inference.stream`.                             |
 | `function_call`       | Runs the matching tool, writes the call and output back into context, then returns to inference. |

package/dist/index.d.mts

@@ -204,7 +204,7 @@ interface InterceptionParams {
     pendingTransition: LoopTransition;
 }
 
-type LoopStateId = "context_update" | "inference" | "inference_streaming" | "function_call" | "model_message" | "idle";
+type LoopStateId = "message_received" | "inference" | "inference_streaming" | "function_call" | "model_message" | "idle";
 type ReceivedMessage = {
     content: string;
     input: InferenceInput;
@@ -216,7 +216,7 @@ interface ModelMessageParams {
     answer: ModelMessageItem;
 }
 interface LoopStateContract {
-    context_update: {
+    message_received: {
         input: ReceivedMessage;
         output: InferenceInput;
     };

package/dist/index.d.ts

@@ -204,7 +204,7 @@ interface InterceptionParams {
     pendingTransition: LoopTransition;
 }
 
-type LoopStateId = "context_update" | "inference" | "inference_streaming" | "function_call" | "model_message" | "idle";
+type LoopStateId = "message_received" | "inference" | "inference_streaming" | "function_call" | "model_message" | "idle";
 type ReceivedMessage = {
     content: string;
     input: InferenceInput;
@@ -216,7 +216,7 @@ interface ModelMessageParams {
     answer: ModelMessageItem;
 }
 interface LoopStateContract {
-    context_update: {
+    message_received: {
         input: ReceivedMessage;
         output: InferenceInput;
     };

package/dist/index.js

@@ -624,7 +624,7 @@ var AgentLoop = class _AgentLoop {
   async run(message, loopVisitor) {
     var _a;
     let transition = {
-      nextStateId: "context_update",
+      nextStateId: "message_received",
       input: message
     };
     while (transition.nextStateId !== "idle") {
@@ -649,8 +649,8 @@ var AgentLoop = class _AgentLoop {
 
 // src/domain/agentic-environment/loop/state-executor.ts
 var LoopStateExecutor = class {
-  constructor(contextUpdateState, inferenceState, inferenceStreamingState, functionCallState, modelMessageState) {
-    this.contextUpdateState = contextUpdateState;
+  constructor(messageReceivedState, inferenceState, inferenceStreamingState, functionCallState, modelMessageState) {
+    this.messageReceivedState = messageReceivedState;
     this.inferenceState = inferenceState;
     this.inferenceStreamingState = inferenceStreamingState;
     this.functionCallState = functionCallState;
@@ -658,8 +658,8 @@ var LoopStateExecutor = class {
   }
   async execute(transition, loopVisitor) {
     switch (transition.nextStateId) {
-      case "context_update":
-        return await this.contextUpdateState.run(transition.input, loopVisitor);
+      case "message_received":
+        return await this.messageReceivedState.run(transition.input, loopVisitor);
       case "inference":
         return await this.inferenceState.run(transition.input, loopVisitor);
       case "inference_streaming":
@@ -704,19 +704,19 @@ var FunctionCallState = class {
   }
 };
 
-// src/application/states/context-update.ts
-var ContextUpdateState = class {
+// src/application/states/message-received.ts
+var MessageReceivedState = class {
   constructor() {
-    this.id = "context_update";
+    this.id = "message_received";
   }
   async run(input, loopVisitor) {
-    loopVisitor.visitContextUpdateStarted(input);
+    loopVisitor.visitMessageReceivedStarted(input);
     const userMessage = UserMessageItem.create(input.content);
     const output = {
       ...input.input,
       context: input.input.context.addContextItems([userMessage])
     };
-    loopVisitor.visitContextUpdateCompleted(output);
+    loopVisitor.visitMessageReceivedCompleted(output);
     return {
       stateId: this.id,
       input,
@@ -757,7 +757,7 @@ var TransitionResolver = class {
 // src/domain/agentic-environment/loop/transition-specification.ts
 var MessageReceivedSpecification = class {
   isSatisfiedBy(execution) {
-    return execution.stateId === "context_update";
+    return execution.stateId === "message_received";
   }
 };
 function isInferenceExecution(execution) {
@@ -790,7 +790,7 @@ var ContextPreparationToInferenceRule = class {
     this.specification = new MessageReceivedSpecification();
   }
   createTransition(execution) {
-    if (execution.stateId !== "context_update") {
+    if (execution.stateId !== "message_received") {
       throw new Error("Expected context_preparation execution");
     }
     const nextStateId = execution.output.streaming ? "inference_streaming" : "inference";
@@ -885,11 +885,11 @@ var EventPublisherLoopVisitor = class {
     this.runtime = runtime;
     this.cloud = (0, import_cloud_sdk.createCloudClient)();
   }
-  visitContextUpdateStarted(input) {
-    this.publish("context_update.started", input);
+  visitMessageReceivedStarted(input) {
+    this.publish("message_received.started", input);
   }
-  visitContextUpdateCompleted(output) {
-    this.publish("context_update.completed", output);
+  visitMessageReceivedCompleted(output) {
+    this.publish("message_received.completed", output);
   }
   visitInferenceStarted(input) {
     this.publish("inference.started", input);
@@ -985,7 +985,7 @@ function createRunLoop(resolveRuntime) {
       new ModelMessageToIdleRule()
     ]);
     const stateExecutor = new LoopStateExecutor(
-      new ContextUpdateState(),
+      new MessageReceivedState(),
       new InferenceState(inferenceRunner),
       new InferenceStreamingState(inferenceRunner),
       new FunctionCallState(functionCallRunner),