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

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 {

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 {

package/dist/index.js

@@ -603,7 +603,7 @@ var AgentLoop = class {
   }
   async run(message) {
     let transition = {
-      nextStateId: "message_received",
+      nextStateId: "context_preparation",
       input: message
     };
     while (transition.nextStateId !== "idle") {
@@ -615,18 +615,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 +670,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 +723,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 +751,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 +771,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 +792,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 +820,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 +848,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 +889,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 +924,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()
     );
@@ -1079,10 +1113,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
+    };
   }
 };
 
@@ -1253,10 +1294,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
+    };
   }
 };
 
@@ -1428,9 +1483,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
+    };
   }
 };
 
@@ -1564,10 +1631,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 +2065,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);
   }
 };