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

package/dist/index.d.mts

@@ -158,6 +158,7 @@ type InferenceOutput = {
 };
 interface InferenceRunner {
     run(request: InferenceInput): Promise<InferenceOutput>;
+    stream(request: InferenceInput): AsyncGenerator<SemanticEvent>;
 }
 
 interface InferenceEndpointMapper {
@@ -330,6 +331,7 @@ declare abstract class Participant {
     getManifest(): ParticipantManifest;
     getId(): string;
     getHandlers(): SituationHandler[];
+    setHandlers(handlers: SituationHandler[]): void;
 }
 
 declare class Memory {
@@ -406,8 +408,8 @@ declare class RuntimeService<TRuntimeState extends RuntimeState> {
 }
 
 type InferenceRunnerConfig = {
-    supportedModels: GenerativeModel[];
-    runner: InferenceRunner;
+    supportedModels?: GenerativeModel[];
+    runner?: InferenceRunner;
 };
 declare function defineRuntime<TRuntimeState extends RuntimeState>(): {
     initializeRuntime: (config: {
@@ -427,8 +429,9 @@ declare const supportedModels: GenerativeModel[];
 
 declare class OpenAIResponses implements Endpoint {
     endpointMapper: InferenceEndpointMapper;
-    private readonly client;
+    private _client?;
     constructor(endpointMapper?: InferenceEndpointMapper);
+    private get client();
     infer(inferenceInput: InferenceInput): Promise<InferenceOutput>;
     stream(inferenceInput: InferenceInput): AsyncIterable<SemanticEvent>;
 }
@@ -472,9 +475,11 @@ interface OpenAICompatibleConfig {
  */
 declare class OpenAIChatCompletions implements Endpoint {
     endpointMapper: InferenceEndpointMapper;
-    private readonly client;
+    private _client?;
+    private readonly clientConfig;
     private readonly extraBody;
     constructor(endpointMapper?: InferenceEndpointMapper, config?: OpenAICompatibleConfig);
+    private get client();
     private buildRequest;
     infer(inferenceInput: InferenceInput): Promise<InferenceOutput>;
     stream(inferenceInput: InferenceInput): AsyncIterable<SemanticEvent>;
@@ -491,8 +496,10 @@ interface AnthropicConnectionConfig {
  */
 declare class AnthropicMessages implements Endpoint {
     endpointMapper: InferenceEndpointMapper;
-    private readonly client;
+    private _client?;
+    private readonly clientConfig;
     constructor(endpointMapper?: InferenceEndpointMapper, config?: AnthropicConnectionConfig);
+    private get client();
     infer(inferenceInput: InferenceInput): Promise<InferenceOutput>;
     stream(inferenceInput: InferenceInput): AsyncIterable<SemanticEvent>;
 }
@@ -511,10 +518,12 @@ interface GeminiConnectionConfig {
  */
 declare class GeminiGenerateContent implements Endpoint {
     endpointMapper: InferenceEndpointMapper;
-    private readonly client;
+    private _client?;
+    private readonly clientConfig;
     constructor(endpointMapper?: InferenceEndpointMapper, config?: GeminiConnectionConfig);
+    private get client();
     infer(inferenceInput: InferenceInput): Promise<InferenceOutput>;
     stream(inferenceInput: InferenceInput): AsyncIterable<SemanticEvent>;
 }
 
-export { AnthropicMessages, ContextItem, DeveloperMessageItem, type Endpoint, FunctionCallItem, FunctionCallOutputItem, GeminiGenerateContent, type InferenceInput, type InferenceOutput, InputTokenDetails, McpClient, type McpServerConfig, McpToolRegistry, type McpToolSpec, ModelContext, type ModelContextRepository, ModelMessageItem, OpenAIChatCompletions, OpenAIResponses, OutputTokenDetails, Participant, ReasoningItem, RuntimeState, SemanticEvent, type StructuredOutputFormat, SystemMessageItem, TokenUsage, type Tool, UserMessageItem, createAgent, createHuman, defineRuntime, supportedModels };
+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 };

package/dist/index.d.ts

@@ -158,6 +158,7 @@ type InferenceOutput = {
 };
 interface InferenceRunner {
     run(request: InferenceInput): Promise<InferenceOutput>;
+    stream(request: InferenceInput): AsyncGenerator<SemanticEvent>;
 }
 
 interface InferenceEndpointMapper {
@@ -330,6 +331,7 @@ declare abstract class Participant {
     getManifest(): ParticipantManifest;
     getId(): string;
     getHandlers(): SituationHandler[];
+    setHandlers(handlers: SituationHandler[]): void;
 }
 
 declare class Memory {
@@ -406,8 +408,8 @@ declare class RuntimeService<TRuntimeState extends RuntimeState> {
 }
 
 type InferenceRunnerConfig = {
-    supportedModels: GenerativeModel[];
-    runner: InferenceRunner;
+    supportedModels?: GenerativeModel[];
+    runner?: InferenceRunner;
 };
 declare function defineRuntime<TRuntimeState extends RuntimeState>(): {
     initializeRuntime: (config: {
@@ -427,8 +429,9 @@ declare const supportedModels: GenerativeModel[];
 
 declare class OpenAIResponses implements Endpoint {
     endpointMapper: InferenceEndpointMapper;
-    private readonly client;
+    private _client?;
     constructor(endpointMapper?: InferenceEndpointMapper);
+    private get client();
     infer(inferenceInput: InferenceInput): Promise<InferenceOutput>;
     stream(inferenceInput: InferenceInput): AsyncIterable<SemanticEvent>;
 }
@@ -472,9 +475,11 @@ interface OpenAICompatibleConfig {
  */
 declare class OpenAIChatCompletions implements Endpoint {
     endpointMapper: InferenceEndpointMapper;
-    private readonly client;
+    private _client?;
+    private readonly clientConfig;
     private readonly extraBody;
     constructor(endpointMapper?: InferenceEndpointMapper, config?: OpenAICompatibleConfig);
+    private get client();
     private buildRequest;
     infer(inferenceInput: InferenceInput): Promise<InferenceOutput>;
     stream(inferenceInput: InferenceInput): AsyncIterable<SemanticEvent>;
@@ -491,8 +496,10 @@ interface AnthropicConnectionConfig {
  */
 declare class AnthropicMessages implements Endpoint {
     endpointMapper: InferenceEndpointMapper;
-    private readonly client;
+    private _client?;
+    private readonly clientConfig;
     constructor(endpointMapper?: InferenceEndpointMapper, config?: AnthropicConnectionConfig);
+    private get client();
     infer(inferenceInput: InferenceInput): Promise<InferenceOutput>;
     stream(inferenceInput: InferenceInput): AsyncIterable<SemanticEvent>;
 }
@@ -511,10 +518,12 @@ interface GeminiConnectionConfig {
  */
 declare class GeminiGenerateContent implements Endpoint {
     endpointMapper: InferenceEndpointMapper;
-    private readonly client;
+    private _client?;
+    private readonly clientConfig;
     constructor(endpointMapper?: InferenceEndpointMapper, config?: GeminiConnectionConfig);
+    private get client();
     infer(inferenceInput: InferenceInput): Promise<InferenceOutput>;
     stream(inferenceInput: InferenceInput): AsyncIterable<SemanticEvent>;
 }
 
-export { AnthropicMessages, ContextItem, DeveloperMessageItem, type Endpoint, FunctionCallItem, FunctionCallOutputItem, GeminiGenerateContent, type InferenceInput, type InferenceOutput, InputTokenDetails, McpClient, type McpServerConfig, McpToolRegistry, type McpToolSpec, ModelContext, type ModelContextRepository, ModelMessageItem, OpenAIChatCompletions, OpenAIResponses, OutputTokenDetails, Participant, ReasoningItem, RuntimeState, SemanticEvent, type StructuredOutputFormat, SystemMessageItem, TokenUsage, type Tool, UserMessageItem, createAgent, createHuman, defineRuntime, supportedModels };
+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 };

package/dist/index.js

@@ -30,12 +30,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  Agent: () => Agent,
   AnthropicMessages: () => AnthropicMessages,
   ContextItem: () => ContextItem,
   DeveloperMessageItem: () => DeveloperMessageItem,
   FunctionCallItem: () => FunctionCallItem,
   FunctionCallOutputItem: () => FunctionCallOutputItem,
   GeminiGenerateContent: () => GeminiGenerateContent,
+  Human: () => Human,
   InputTokenDetails: () => InputTokenDetails,
   McpClient: () => McpClient,
   McpToolRegistry: () => McpToolRegistry,
@@ -48,6 +50,7 @@ __export(index_exports, {
   ReasoningItem: () => ReasoningItem,
   RuntimeState: () => RuntimeState,
   SemanticEvent: () => SemanticEvent,
+  SituationSpecification: () => SituationSpecification,
   SystemMessageItem: () => SystemMessageItem,
   TokenUsage: () => TokenUsage,
   UserMessageItem: () => UserMessageItem,
@@ -413,6 +416,9 @@ var Participant = class {
   getHandlers() {
     return this.handlers;
   }
+  setHandlers(handlers) {
+    this.handlers = handlers;
+  }
 };
 
 // src/domain/agentic-environment/participant/memory.ts
@@ -603,7 +609,7 @@ var AgentLoop = class {
   }
   async run(message) {
     let transition = {
-      nextStateId: "message_received",
+      nextStateId: "context_preparation",
       input: message
     };
     while (transition.nextStateId !== "idle") {
@@ -615,18 +621,21 @@ var AgentLoop = class {
 
 // src/domain/agentic-environment/loop/state-executor.ts
 var LoopStateExecutor = class {
-  constructor(messageReceivedState, inferenceState, functionCallState, modelMessageState) {
-    this.messageReceivedState = messageReceivedState;
+  constructor(contextPreparationState, inferenceState, inferenceStreamingState, functionCallState, modelMessageState) {
+    this.contextPreparationState = contextPreparationState;
     this.inferenceState = inferenceState;
+    this.inferenceStreamingState = inferenceStreamingState;
     this.functionCallState = functionCallState;
     this.modelMessageState = modelMessageState;
   }
   async execute(transition, loopVisitor) {
     switch (transition.nextStateId) {
-      case "message_received":
-        return await this.messageReceivedState.run(transition.input, loopVisitor);
+      case "context_preparation":
+        return await this.contextPreparationState.run(transition.input, loopVisitor);
       case "inference":
         return await this.inferenceState.run(transition.input, loopVisitor);
+      case "inference_streaming":
+        return await this.inferenceStreamingState.run(transition.input, loopVisitor);
       case "function_call":
         return await this.functionCallState.run(transition.input, loopVisitor);
       case "model_message":
@@ -667,19 +676,19 @@ var FunctionCallState = class {
   }
 };
 
-// src/application/states/message-received.ts
-var MessageReceivedState = class {
+// src/application/states/context-preparation.ts
+var ContextPreparationState = class {
   constructor() {
-    this.id = "message_received";
+    this.id = "context_preparation";
   }
   async run(input, loopVisitor) {
-    loopVisitor.visitMessageReceivedStarted(input);
+    loopVisitor.visitContextPreparationStarted(input);
     const userMessage = UserMessageItem.create(input.content);
     const output = {
       ...input.input,
       context: input.input.context.addContextItems([userMessage])
     };
-    loopVisitor.visitMessageReceivedCompleted(output);
+    loopVisitor.visitContextPreparationCompleted(output);
     return {
       stateId: this.id,
       input,
@@ -720,17 +729,20 @@ var TransitionResolver = class {
 // src/domain/agentic-environment/loop/transition-specification.ts
 var MessageReceivedSpecification = class {
   isSatisfiedBy(execution) {
-    return execution.stateId === "message_received";
+    return execution.stateId === "context_preparation";
   }
 };
+function isInferenceExecution(execution) {
+  return execution.stateId === "inference" || execution.stateId === "inference_streaming";
+}
 var InferenceProducedFunctionCallSpecification = class {
   isSatisfiedBy(execution) {
-    return execution.stateId === "inference" && execution.output.items.some((item) => item.type === "function_call");
+    return isInferenceExecution(execution) && execution.output.items.some((item) => item.type === "function_call");
   }
 };
 var InferenceProducedModelMessageSpecification = class {
   isSatisfiedBy(execution) {
-    return execution.stateId === "inference" && execution.output.items.some((item) => item.type === "message" && item.role === "assistant");
+    return isInferenceExecution(execution) && execution.output.items.some((item) => item.type === "message" && item.role === "assistant");
   }
 };
 var FunctionCallCompletedSpecification = class {
@@ -745,16 +757,17 @@ var ModelMessageCompletedSpecification = class {
 };
 
 // src/domain/agentic-environment/loop/transition-rule.ts
-var MessageReceivedToInferenceRule = class {
+var ContextPreparationToInferenceRule = class {
   constructor() {
     this.specification = new MessageReceivedSpecification();
   }
   createTransition(execution) {
-    if (execution.stateId !== "message_received") {
-      throw new Error("Expected message_received execution");
+    if (execution.stateId !== "context_preparation") {
+      throw new Error("Expected context_preparation execution");
     }
+    const nextStateId = execution.output.streaming ? "inference_streaming" : "inference";
     return {
-      nextStateId: "inference",
+      nextStateId,
       input: execution.output
     };
   }
@@ -764,7 +777,7 @@ var InferenceToFunctionCallRule = class {
     this.specification = new InferenceProducedFunctionCallSpecification();
   }
   createTransition(execution) {
-    if (execution.stateId !== "inference" || !execution.output.items.some((item) => item.type === "function_call")) {
+    if (execution.stateId !== "inference" && execution.stateId !== "inference_streaming" || !execution.output.items.some((item) => item.type === "function_call")) {
       throw new Error("Expected inference function-call output");
     }
     const functionCallItem = execution.output.items.find((item) => item.type === "function_call");
@@ -785,7 +798,7 @@ var InferenceToModelMessageRule = class {
     this.specification = new InferenceProducedModelMessageSpecification();
   }
   createTransition(execution) {
-    if (execution.stateId !== "inference" || !execution.output.items.some((item) => item.type === "message" && item.role === "assistant")) {
+    if (execution.stateId !== "inference" && execution.stateId !== "inference_streaming" || !execution.output.items.some((item) => item.type === "message" && item.role === "assistant")) {
       throw new Error("Expected inference model-message output");
     }
     const modelMessageItem = execution.output.items.find(
@@ -813,7 +826,7 @@ var FunctionCallToInferenceRule = class {
     const previousRequest = execution.input.inferenceInput;
     previousRequest.context.addContextItems([execution.input.call, execution.output.item]);
     return {
-      nextStateId: "inference",
+      nextStateId: previousRequest.streaming ? "inference_streaming" : "inference",
       input: {
         ...previousRequest
       }
@@ -841,20 +854,19 @@ var EventPublisherLoopVisitor = class {
     this.agentId = agentId;
     this.runtime = runtime;
   }
-  visitMessageReceivedStarted(input) {
+  visitContextPreparationStarted(input) {
     console.log("Visiting message received started: ", input);
-    this.publish("message_received.started", input);
+    this.publish("context_preparation.started", input);
   }
-  visitMessageReceivedCompleted(output) {
+  visitContextPreparationCompleted(output) {
     console.log("Visiting message received completed: ", output);
-    this.publish("message_received.completed", output);
+    this.publish("context_preparation.completed", output);
   }
   visitInferenceStarted(input) {
     console.log("Visiting inference started: ", input);
     this.publish("inference.started", input);
   }
   visitInferenceEvent(event) {
-    console.log("Visiting inference event: ", event);
     this.publish("inference.stream", event);
   }
   visitInferenceCompleted(output) {
@@ -883,6 +895,33 @@ var EventPublisherLoopVisitor = class {
   }
 };
 
+// src/application/states/inference-streaming.ts
+var InferenceStreamingState = class {
+  constructor(inferenceRunner) {
+    this.inferenceRunner = inferenceRunner;
+    this.id = "inference_streaming";
+  }
+  async run(input, loopVisitor) {
+    loopVisitor.visitInferenceStarted(input);
+    let output = void 0;
+    for await (const event of this.inferenceRunner.stream(input)) {
+      loopVisitor.visitInferenceEvent(event);
+      if (event.type === "inference.output") {
+        output = event.payload;
+      }
+    }
+    if (!output) {
+      throw new Error("Inference output not found");
+    }
+    loopVisitor.visitInferenceCompleted(output);
+    return {
+      stateId: "inference_streaming",
+      input,
+      output
+    };
+  }
+};
+
 // src/application/use-cases/run-loop.ts
 function createRunLoop(resolveRuntime) {
   return function runLoop(agentId, message, inferenceInput) {
@@ -891,15 +930,16 @@ function createRunLoop(resolveRuntime) {
     const functionCallRunner = runtime.getFunctionCallRunner();
     const transitionResolver = new TransitionResolver([
       // High-priority interception rules would go first.
-      new MessageReceivedToInferenceRule(),
+      new ContextPreparationToInferenceRule(),
       new InferenceToFunctionCallRule(),
       new InferenceToModelMessageRule(),
       new FunctionCallToInferenceRule(),
       new ModelMessageToIdleRule()
     ]);
     const stateExecutor = new LoopStateExecutor(
-      new MessageReceivedState(),
+      new ContextPreparationState(),
       new InferenceState(inferenceRunner),
+      new InferenceStreamingState(inferenceRunner),
       new FunctionCallState(functionCallRunner),
       new ModelMessageState()
     );
@@ -1070,7 +1110,14 @@ var import_sdk = __toESM(require("@anthropic-ai/sdk"));
 var AnthropicMessages = class {
   constructor(endpointMapper = new AnthropicMessagesMapper(), config = {}) {
     this.endpointMapper = endpointMapper;
-    this.client = new import_sdk.default({ baseURL: config.baseURL, apiKey: config.apiKey });
+    this.clientConfig = config;
+  }
+  get client() {
+    var _a;
+    return (_a = this._client) != null ? _a : this._client = new import_sdk.default({
+      baseURL: this.clientConfig.baseURL,
+      apiKey: this.clientConfig.apiKey
+    });
   }
   async infer(inferenceInput) {
     const request = this.endpointMapper.toRequest(inferenceInput);
@@ -1079,10 +1126,17 @@ var AnthropicMessages = class {
   }
   async *stream(inferenceInput) {
     const request = this.endpointMapper.toRequest(inferenceInput);
-    const stream = await this.client.messages.create(request);
+    const stream = this.client.messages.stream(request);
     for await (const event of stream) {
       yield event;
     }
+    const output = this.endpointMapper.toResponse(await stream.finalMessage());
+    yield {
+      type: "inference.output",
+      producerId: request.model,
+      occurredAt: /* @__PURE__ */ new Date(),
+      payload: output
+    };
   }
 };
 
@@ -1244,7 +1298,10 @@ var OpenAIResponsesMapper = class {
 var OpenAIResponses = class {
   constructor(endpointMapper = new OpenAIResponsesMapper()) {
     this.endpointMapper = endpointMapper;
-    this.client = new import_openai.default();
+  }
+  get client() {
+    var _a;
+    return (_a = this._client) != null ? _a : this._client = new import_openai.default();
   }
   async infer(inferenceInput) {
     const request = this.endpointMapper.toRequest(inferenceInput);
@@ -1253,10 +1310,24 @@ var OpenAIResponses = class {
   }
   async *stream(inferenceInput) {
     const request = this.endpointMapper.toRequest(inferenceInput);
-    const response = await this.client.responses.create(request);
-    for await (const event of response) {
+    const stream = await this.client.responses.create({ ...request, stream: true });
+    let completedResponse = void 0;
+    for await (const event of stream) {
+      if (event.type === "response.completed") {
+        completedResponse = event.response;
+      }
       yield event;
     }
+    if (!completedResponse) {
+      throw new Error("Stream ended without a completed response");
+    }
+    const output = this.endpointMapper.toResponse(completedResponse);
+    yield {
+      type: "inference.output",
+      payload: output,
+      occurredAt: /* @__PURE__ */ new Date(),
+      producerId: inferenceInput.model
+    };
   }
 };
 
@@ -1413,11 +1484,14 @@ var GeminiGenerateContentMapper = class {
 // src/infrastructure/providers/gemini/endpoints/gemini-generate-content.ts
 var GeminiGenerateContent = class {
   constructor(endpointMapper = new GeminiGenerateContentMapper(), config = {}) {
-    var _a;
     this.endpointMapper = endpointMapper;
-    this.client = new import_genai.GoogleGenAI({
-      apiKey: (_a = config.apiKey) != null ? _a : process.env.GEMINI_API_KEY,
-      ...config.baseURL ? { httpOptions: { baseUrl: config.baseURL } } : {}
+    this.clientConfig = config;
+  }
+  get client() {
+    var _a, _b;
+    return (_b = this._client) != null ? _b : this._client = new import_genai.GoogleGenAI({
+      apiKey: (_a = this.clientConfig.apiKey) != null ? _a : process.env.GEMINI_API_KEY,
+      ...this.clientConfig.baseURL ? { httpOptions: { baseUrl: this.clientConfig.baseURL } } : {}
     });
   }
   async infer(inferenceInput) {
@@ -1428,9 +1502,21 @@ var GeminiGenerateContent = class {
   async *stream(inferenceInput) {
     const request = this.endpointMapper.toRequest(inferenceInput);
     const stream = await this.client.models.generateContentStream(request);
+    let lastEvent = void 0;
     for await (const chunk of stream) {
+      lastEvent = chunk;
       yield chunk;
     }
+    if (!lastEvent) {
+      throw new Error("Last event not found");
+    }
+    const output = this.endpointMapper.toResponse(lastEvent);
+    yield {
+      type: "inference.output",
+      producerId: request.model,
+      occurredAt: /* @__PURE__ */ new Date(),
+      payload: output
+    };
   }
 };
 
@@ -1547,12 +1633,16 @@ var OpenAIChatCompletions = class {
   constructor(endpointMapper = new OpenAIChatCompletionsMapper(), config = {}) {
     var _a;
     this.endpointMapper = endpointMapper;
-    this.client = new import_openai2.default({
-      baseURL: config.baseURL,
-      apiKey: config.apiKey
-    });
+    this.clientConfig = config;
     this.extraBody = (_a = config.extraBody) != null ? _a : {};
   }
+  get client() {
+    var _a;
+    return (_a = this._client) != null ? _a : this._client = new import_openai2.default({
+      baseURL: this.clientConfig.baseURL,
+      apiKey: this.clientConfig.apiKey
+    });
+  }
   buildRequest(inferenceInput) {
     return {
       ...this.extraBody,
@@ -1564,10 +1654,17 @@ var OpenAIChatCompletions = class {
     return this.endpointMapper.toResponse(response);
   }
   async *stream(inferenceInput) {
-    const stream = await this.client.chat.completions.create(this.buildRequest(inferenceInput));
-    for await (const event of stream) {
-      yield event;
+    const stream = this.client.chat.completions.stream(this.buildRequest(inferenceInput));
+    for await (const chunk of stream) {
+      yield chunk;
     }
+    const output = this.endpointMapper.toResponse(await stream.finalChatCompletion());
+    yield {
+      type: "inference.output",
+      payload: output,
+      occurredAt: /* @__PURE__ */ new Date(),
+      producerId: inferenceInput.model
+    };
   }
 };
 
@@ -1991,13 +2088,13 @@ var DefaultInferenceRunner = class {
     this.requestValidator.validate(input, generativeModel.specification);
     return await generativeModel.endpoint.infer(input);
   }
-  async streamInference(input) {
+  async *stream(input) {
     const generativeModel = this.supportedModels.find((model) => model.specification.name === input.model);
     if (!generativeModel) {
       throw new Error(`Unsupported model: ${input.model}`);
     }
     this.requestValidator.validate(input, generativeModel.specification);
-    return await generativeModel.endpoint.stream(input);
+    yield* generativeModel.endpoint.stream(input);
   }
 };
 
@@ -2074,14 +2171,58 @@ function defineRuntime() {
     runLoop
   };
 }
+
+// src/domain/agentic-environment/situation/situation-specification.ts
+var SituationSpecification = class {
+  and(other) {
+    return new AndSituationSpecification(this, other);
+  }
+  or(other) {
+    return new OrSituationSpecification(this, other);
+  }
+  not() {
+    return new NotSituationSpecification(this);
+  }
+};
+var AndSituationSpecification = class extends SituationSpecification {
+  constructor(left, right) {
+    super();
+    this.left = left;
+    this.right = right;
+  }
+  isSatisfiedBy(situationContext) {
+    return this.left.isSatisfiedBy(situationContext) && this.right.isSatisfiedBy(situationContext);
+  }
+};
+var OrSituationSpecification = class extends SituationSpecification {
+  constructor(left, right) {
+    super();
+    this.left = left;
+    this.right = right;
+  }
+  isSatisfiedBy(situationContext) {
+    return this.left.isSatisfiedBy(situationContext) || this.right.isSatisfiedBy(situationContext);
+  }
+};
+var NotSituationSpecification = class extends SituationSpecification {
+  constructor(rule) {
+    super();
+    this.rule = rule;
+  }
+  isSatisfiedBy(situationContext) {
+    return !this.rule.isSatisfiedBy(situationContext);
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Agent,
   AnthropicMessages,
   ContextItem,
   DeveloperMessageItem,
   FunctionCallItem,
   FunctionCallOutputItem,
   GeminiGenerateContent,
+  Human,
   InputTokenDetails,
   McpClient,
   McpToolRegistry,
@@ -2094,6 +2235,7 @@ function defineRuntime() {
   ReasoningItem,
   RuntimeState,
   SemanticEvent,
+  SituationSpecification,
   SystemMessageItem,
   TokenUsage,
   UserMessageItem,