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

package/dist/index.d.mts

@@ -129,6 +129,46 @@ interface FunctionTool {
 }
 type Tool = FunctionTool;
 
+type SituationContext$1<TEvent extends SemanticEvent = SemanticEvent> = {
+    readonly event: TEvent;
+    readonly participant: Participant;
+};
+declare abstract class SituationSpecification<TEvent extends SemanticEvent = SemanticEvent> {
+    abstract isSatisfiedBy(situationContext: SituationContext$1<TEvent>): boolean;
+    and(other: SituationSpecification<TEvent>): SituationSpecification<TEvent>;
+    or(other: SituationSpecification<TEvent>): SituationSpecification<TEvent>;
+    not(): SituationSpecification<TEvent>;
+}
+
+interface SituationHandler {
+    readonly specification: SituationSpecification;
+    readonly processor: SituationProcessor;
+}
+type SituationContext<TEvent extends SemanticEvent = SemanticEvent> = {
+    readonly event: TEvent;
+    readonly participant: Participant;
+};
+interface SituationProcessor {
+    apply(context: SituationContext): void | Promise<void>;
+}
+
+type ParticipantRole = "agent" | "human";
+type ParticipantManifest = {
+    readonly id: string;
+    readonly name: string;
+    readonly role: ParticipantRole;
+    readonly capabilities?: readonly string[];
+};
+declare abstract class Participant {
+    private readonly manifest;
+    private handlers;
+    protected constructor(manifest: ParticipantManifest, handlers: SituationHandler[]);
+    getManifest(): ParticipantManifest;
+    getId(): string;
+    getHandlers(): SituationHandler[];
+    setHandlers(handlers: SituationHandler[]): void;
+}
+
 declare class SemanticEvent<TType extends string = string, TPayload = unknown> {
     readonly type: TType;
     readonly producerId: string;
@@ -141,6 +181,71 @@ declare class SemanticEvent<TType extends string = string, TPayload = unknown> {
 interface FunctionCallRunner {
     run(call: FunctionCallItem, tool: Tool): Promise<FunctionCallOutputItem>;
 }
+interface FunctionCallParams {
+    call: FunctionCallItem;
+    inferenceInput: InferenceInput;
+}
+
+type LoopStateId = "context_update" | "inference" | "inference_streaming" | "function_call" | "model_message" | "idle";
+type ReceivedMessage = {
+    content: string;
+    input: InferenceInput;
+};
+interface FunctionCallExecutionOutput {
+    item: FunctionCallOutputItem;
+}
+interface ModelMessageParams {
+    answer: ModelMessageItem;
+}
+interface LoopStateContract {
+    context_update: {
+        input: ReceivedMessage;
+        output: InferenceInput;
+    };
+    inference: {
+        input: InferenceInput;
+        output: InferenceOutput;
+    };
+    inference_streaming: {
+        input: InferenceInput;
+        output: InferenceOutput;
+    };
+    function_call: {
+        input: FunctionCallParams;
+        output: FunctionCallExecutionOutput;
+    };
+    model_message: {
+        input: ModelMessageParams;
+        output: void;
+    };
+    interception: {
+        input: InterceptionParams;
+        output: InterceptionOutput;
+    };
+    idle: {
+        input: undefined;
+        output: void;
+    };
+}
+type InterceptionOutput = {
+    type: "continue";
+    transition: LoopTransition;
+} | {
+    type: "pause";
+    pendingTransition: LoopTransition;
+} | {
+    type: "stop";
+    reason?: string;
+};
+interface InterceptionParams {
+    pendingTransition: LoopTransition;
+}
+type LoopTransition<TStateId extends LoopStateId = LoopStateId> = {
+    [K in TStateId]: {
+        nextStateId: K;
+        input: LoopStateContract[K]["input"];
+    };
+}[TStateId];
 
 type InferenceInput = {
     model: string;
@@ -189,6 +294,11 @@ type ModelSpecification = {
     supportsStructuredOutput: boolean;
 };
 
+interface RequestValidationRule {
+    readonly name: string;
+    isValid(inferenceInput: InferenceInput, model: ModelSpecification): boolean;
+}
+
 type StructuredOutputFormat = {
     name?: string;
     schema: Record<string, any>;
@@ -294,46 +404,6 @@ declare class SystemMessageItem extends ContextItem {
     }): SystemMessageItem;
 }
 
-type SituationContext$1<TEvent extends SemanticEvent = SemanticEvent> = {
-    readonly event: TEvent;
-    readonly participant: Participant;
-};
-declare abstract class SituationSpecification<TEvent extends SemanticEvent = SemanticEvent> {
-    abstract isSatisfiedBy(situationContext: SituationContext$1<TEvent>): boolean;
-    and(other: SituationSpecification<TEvent>): SituationSpecification<TEvent>;
-    or(other: SituationSpecification<TEvent>): SituationSpecification<TEvent>;
-    not(): SituationSpecification<TEvent>;
-}
-
-interface SituationHandler {
-    readonly specification: SituationSpecification;
-    readonly processor: SituationProcessor;
-}
-type SituationContext<TEvent extends SemanticEvent = SemanticEvent> = {
-    readonly event: TEvent;
-    readonly participant: Participant;
-};
-interface SituationProcessor {
-    apply(context: SituationContext): void | Promise<void>;
-}
-
-type ParticipantRole = "agent" | "human";
-type ParticipantManifest = {
-    readonly id: string;
-    readonly name: string;
-    readonly role: ParticipantRole;
-    readonly capabilities?: readonly string[];
-};
-declare abstract class Participant {
-    private readonly manifest;
-    private handlers;
-    protected constructor(manifest: ParticipantManifest, handlers: SituationHandler[]);
-    getManifest(): ParticipantManifest;
-    getId(): string;
-    getHandlers(): SituationHandler[];
-    setHandlers(handlers: SituationHandler[]): void;
-}
-
 declare class Memory {
     private readonly context;
     private constructor();
@@ -389,6 +459,11 @@ declare abstract class RuntimeState {
     getParticipants(): readonly Participant[];
 }
 
+interface InterceptionHandler {
+    isSatisfiedBy(transition: LoopTransition): boolean;
+    handle(transition: LoopTransition): Promise<LoopTransition>;
+}
+
 declare class EventProcessor {
     process(event: SemanticEvent, consumer: Participant): void;
 }
@@ -422,7 +497,7 @@ declare function defineRuntime<TRuntimeState extends RuntimeState>(): {
     leave: (participant: Participant) => void;
     sendMessage: (message: string, senderId: string) => void;
     sendEvent: (event: SemanticEvent, senderId: string) => void;
-    runLoop: (agentId: string, message: string, inferenceInput: InferenceInput) => void;
+    runLoop: (agentId: string, message: string, inferenceInput: InferenceInput, interceptionHandler: InterceptionHandler) => void;
 };
 
 declare const supportedModels: GenerativeModel[];
@@ -526,4 +601,18 @@ declare class GeminiGenerateContent implements Endpoint {
     stream(inferenceInput: InferenceInput): AsyncIterable<SemanticEvent>;
 }
 
-export { Agent, AnthropicMessages, ContextItem, DeveloperMessageItem, type Endpoint, FunctionCallItem, FunctionCallOutputItem, GeminiGenerateContent, Human, type InferenceInput, type InferenceOutput, type InferenceRunner, type InferenceRunnerConfig, InputTokenDetails, McpClient, type McpServerConfig, McpToolRegistry, type McpToolSpec, ModelContext, type ModelContextRepository, ModelMessageItem, OpenAIChatCompletions, OpenAIResponses, OutputTokenDetails, Participant, ReasoningItem, RuntimeState, SemanticEvent, type SituationContext, type SituationHandler, type SituationProcessor, SituationSpecification, type StructuredOutputFormat, SystemMessageItem, TokenUsage, type Tool, UserMessageItem, createAgent, createHuman, defineRuntime, supportedModels };
+declare class InferenceInputValidator {
+    private readonly rules;
+    constructor(rules?: RequestValidationRule[]);
+    validate(inferenceInput: InferenceInput, model: ModelSpecification): void;
+}
+
+declare class DefaultInferenceRunner implements InferenceRunner {
+    private readonly supportedModels;
+    private readonly requestValidator;
+    constructor(supportedModels: GenerativeModel[], requestValidator: InferenceInputValidator);
+    run(input: InferenceInput): Promise<InferenceOutput>;
+    stream(input: InferenceInput): AsyncGenerator<SemanticEvent>;
+}
+
+export { Agent, AnthropicMessages, ContextItem, DefaultInferenceRunner, DeveloperMessageItem, type Endpoint, FunctionCallItem, FunctionCallOutputItem, GeminiGenerateContent, Human, type InferenceInput, type InferenceOutput, type InferenceRunner, type InferenceRunnerConfig, InputTokenDetails, McpClient, type McpServerConfig, McpToolRegistry, type McpToolSpec, ModelContext, type ModelContextRepository, ModelMessageItem, OpenAIChatCompletions, OpenAIResponses, OutputTokenDetails, Participant, ReasoningItem, RuntimeState, SemanticEvent, type SituationContext, type SituationHandler, type SituationProcessor, SituationSpecification, type StructuredOutputFormat, SystemMessageItem, TokenUsage, type Tool, UserMessageItem, createAgent, createHuman, defineRuntime, supportedModels };

package/dist/index.d.ts

@@ -129,6 +129,46 @@ interface FunctionTool {
 }
 type Tool = FunctionTool;
 
+type SituationContext$1<TEvent extends SemanticEvent = SemanticEvent> = {
+    readonly event: TEvent;
+    readonly participant: Participant;
+};
+declare abstract class SituationSpecification<TEvent extends SemanticEvent = SemanticEvent> {
+    abstract isSatisfiedBy(situationContext: SituationContext$1<TEvent>): boolean;
+    and(other: SituationSpecification<TEvent>): SituationSpecification<TEvent>;
+    or(other: SituationSpecification<TEvent>): SituationSpecification<TEvent>;
+    not(): SituationSpecification<TEvent>;
+}
+
+interface SituationHandler {
+    readonly specification: SituationSpecification;
+    readonly processor: SituationProcessor;
+}
+type SituationContext<TEvent extends SemanticEvent = SemanticEvent> = {
+    readonly event: TEvent;
+    readonly participant: Participant;
+};
+interface SituationProcessor {
+    apply(context: SituationContext): void | Promise<void>;
+}
+
+type ParticipantRole = "agent" | "human";
+type ParticipantManifest = {
+    readonly id: string;
+    readonly name: string;
+    readonly role: ParticipantRole;
+    readonly capabilities?: readonly string[];
+};
+declare abstract class Participant {
+    private readonly manifest;
+    private handlers;
+    protected constructor(manifest: ParticipantManifest, handlers: SituationHandler[]);
+    getManifest(): ParticipantManifest;
+    getId(): string;
+    getHandlers(): SituationHandler[];
+    setHandlers(handlers: SituationHandler[]): void;
+}
+
 declare class SemanticEvent<TType extends string = string, TPayload = unknown> {
     readonly type: TType;
     readonly producerId: string;
@@ -141,6 +181,71 @@ declare class SemanticEvent<TType extends string = string, TPayload = unknown> {
 interface FunctionCallRunner {
     run(call: FunctionCallItem, tool: Tool): Promise<FunctionCallOutputItem>;
 }
+interface FunctionCallParams {
+    call: FunctionCallItem;
+    inferenceInput: InferenceInput;
+}
+
+type LoopStateId = "context_update" | "inference" | "inference_streaming" | "function_call" | "model_message" | "idle";
+type ReceivedMessage = {
+    content: string;
+    input: InferenceInput;
+};
+interface FunctionCallExecutionOutput {
+    item: FunctionCallOutputItem;
+}
+interface ModelMessageParams {
+    answer: ModelMessageItem;
+}
+interface LoopStateContract {
+    context_update: {
+        input: ReceivedMessage;
+        output: InferenceInput;
+    };
+    inference: {
+        input: InferenceInput;
+        output: InferenceOutput;
+    };
+    inference_streaming: {
+        input: InferenceInput;
+        output: InferenceOutput;
+    };
+    function_call: {
+        input: FunctionCallParams;
+        output: FunctionCallExecutionOutput;
+    };
+    model_message: {
+        input: ModelMessageParams;
+        output: void;
+    };
+    interception: {
+        input: InterceptionParams;
+        output: InterceptionOutput;
+    };
+    idle: {
+        input: undefined;
+        output: void;
+    };
+}
+type InterceptionOutput = {
+    type: "continue";
+    transition: LoopTransition;
+} | {
+    type: "pause";
+    pendingTransition: LoopTransition;
+} | {
+    type: "stop";
+    reason?: string;
+};
+interface InterceptionParams {
+    pendingTransition: LoopTransition;
+}
+type LoopTransition<TStateId extends LoopStateId = LoopStateId> = {
+    [K in TStateId]: {
+        nextStateId: K;
+        input: LoopStateContract[K]["input"];
+    };
+}[TStateId];
 
 type InferenceInput = {
     model: string;
@@ -189,6 +294,11 @@ type ModelSpecification = {
     supportsStructuredOutput: boolean;
 };
 
+interface RequestValidationRule {
+    readonly name: string;
+    isValid(inferenceInput: InferenceInput, model: ModelSpecification): boolean;
+}
+
 type StructuredOutputFormat = {
     name?: string;
     schema: Record<string, any>;
@@ -294,46 +404,6 @@ declare class SystemMessageItem extends ContextItem {
     }): SystemMessageItem;
 }
 
-type SituationContext$1<TEvent extends SemanticEvent = SemanticEvent> = {
-    readonly event: TEvent;
-    readonly participant: Participant;
-};
-declare abstract class SituationSpecification<TEvent extends SemanticEvent = SemanticEvent> {
-    abstract isSatisfiedBy(situationContext: SituationContext$1<TEvent>): boolean;
-    and(other: SituationSpecification<TEvent>): SituationSpecification<TEvent>;
-    or(other: SituationSpecification<TEvent>): SituationSpecification<TEvent>;
-    not(): SituationSpecification<TEvent>;
-}
-
-interface SituationHandler {
-    readonly specification: SituationSpecification;
-    readonly processor: SituationProcessor;
-}
-type SituationContext<TEvent extends SemanticEvent = SemanticEvent> = {
-    readonly event: TEvent;
-    readonly participant: Participant;
-};
-interface SituationProcessor {
-    apply(context: SituationContext): void | Promise<void>;
-}
-
-type ParticipantRole = "agent" | "human";
-type ParticipantManifest = {
-    readonly id: string;
-    readonly name: string;
-    readonly role: ParticipantRole;
-    readonly capabilities?: readonly string[];
-};
-declare abstract class Participant {
-    private readonly manifest;
-    private handlers;
-    protected constructor(manifest: ParticipantManifest, handlers: SituationHandler[]);
-    getManifest(): ParticipantManifest;
-    getId(): string;
-    getHandlers(): SituationHandler[];
-    setHandlers(handlers: SituationHandler[]): void;
-}
-
 declare class Memory {
     private readonly context;
     private constructor();
@@ -389,6 +459,11 @@ declare abstract class RuntimeState {
     getParticipants(): readonly Participant[];
 }
 
+interface InterceptionHandler {
+    isSatisfiedBy(transition: LoopTransition): boolean;
+    handle(transition: LoopTransition): Promise<LoopTransition>;
+}
+
 declare class EventProcessor {
     process(event: SemanticEvent, consumer: Participant): void;
 }
@@ -422,7 +497,7 @@ declare function defineRuntime<TRuntimeState extends RuntimeState>(): {
     leave: (participant: Participant) => void;
     sendMessage: (message: string, senderId: string) => void;
     sendEvent: (event: SemanticEvent, senderId: string) => void;
-    runLoop: (agentId: string, message: string, inferenceInput: InferenceInput) => void;
+    runLoop: (agentId: string, message: string, inferenceInput: InferenceInput, interceptionHandler: InterceptionHandler) => void;
 };
 
 declare const supportedModels: GenerativeModel[];
@@ -526,4 +601,18 @@ declare class GeminiGenerateContent implements Endpoint {
     stream(inferenceInput: InferenceInput): AsyncIterable<SemanticEvent>;
 }
 
-export { Agent, AnthropicMessages, ContextItem, DeveloperMessageItem, type Endpoint, FunctionCallItem, FunctionCallOutputItem, GeminiGenerateContent, Human, type InferenceInput, type InferenceOutput, type InferenceRunner, type InferenceRunnerConfig, InputTokenDetails, McpClient, type McpServerConfig, McpToolRegistry, type McpToolSpec, ModelContext, type ModelContextRepository, ModelMessageItem, OpenAIChatCompletions, OpenAIResponses, OutputTokenDetails, Participant, ReasoningItem, RuntimeState, SemanticEvent, type SituationContext, type SituationHandler, type SituationProcessor, SituationSpecification, type StructuredOutputFormat, SystemMessageItem, TokenUsage, type Tool, UserMessageItem, createAgent, createHuman, defineRuntime, supportedModels };
+declare class InferenceInputValidator {
+    private readonly rules;
+    constructor(rules?: RequestValidationRule[]);
+    validate(inferenceInput: InferenceInput, model: ModelSpecification): void;
+}
+
+declare class DefaultInferenceRunner implements InferenceRunner {
+    private readonly supportedModels;
+    private readonly requestValidator;
+    constructor(supportedModels: GenerativeModel[], requestValidator: InferenceInputValidator);
+    run(input: InferenceInput): Promise<InferenceOutput>;
+    stream(input: InferenceInput): AsyncGenerator<SemanticEvent>;
+}
+
+export { Agent, AnthropicMessages, ContextItem, DefaultInferenceRunner, DeveloperMessageItem, type Endpoint, FunctionCallItem, FunctionCallOutputItem, GeminiGenerateContent, Human, type InferenceInput, type InferenceOutput, type InferenceRunner, type InferenceRunnerConfig, InputTokenDetails, McpClient, type McpServerConfig, McpToolRegistry, type McpToolSpec, ModelContext, type ModelContextRepository, ModelMessageItem, OpenAIChatCompletions, OpenAIResponses, OutputTokenDetails, Participant, ReasoningItem, RuntimeState, SemanticEvent, type SituationContext, type SituationHandler, type SituationProcessor, SituationSpecification, type StructuredOutputFormat, SystemMessageItem, TokenUsage, type Tool, UserMessageItem, createAgent, createHuman, defineRuntime, supportedModels };

package/dist/index.js

@@ -33,6 +33,7 @@ __export(index_exports, {
   Agent: () => Agent,
   AnthropicMessages: () => AnthropicMessages,
   ContextItem: () => ContextItem,
+  DefaultInferenceRunner: () => DefaultInferenceRunner,
   DeveloperMessageItem: () => DeveloperMessageItem,
   FunctionCallItem: () => FunctionCallItem,
   FunctionCallOutputItem: () => FunctionCallOutputItem,
@@ -377,6 +378,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 });
@@ -535,9 +546,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()) {
@@ -601,28 +614,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;
@@ -630,8 +658,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":
@@ -676,19 +704,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,
@@ -729,7 +757,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) {
@@ -762,7 +790,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";
@@ -850,47 +878,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 }
     });
   }
 };
@@ -924,7 +952,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();
@@ -937,21 +965,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
-    });
   };
 }
 
@@ -2218,6 +2246,7 @@ var NotSituationSpecification = class extends SituationSpecification {
   Agent,
   AnthropicMessages,
   ContextItem,
+  DefaultInferenceRunner,
   DeveloperMessageItem,
   FunctionCallItem,
   FunctionCallOutputItem,