@mozaik-ai/core 4.0.0-beta.1 → 4.0.0-beta.10

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 });
@@ -353,6 +363,9 @@ var Participant = class {
   getHandlers() {
     return this.handlers;
   }
+  setHandlers(handlers) {
+    this.handlers = handlers;
+  }
 };
 
 // src/domain/agentic-environment/participant/memory.ts
@@ -469,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()) {
@@ -535,38 +550,57 @@ 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) {
+    var _a;
     let transition = {
-      nextStateId: "message_received",
+      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 = (_a = this.interceptionHandler) == null ? void 0 : _a.isSatisfiedBy(transition);
+      if (isInterceptionSatisfied && this.interceptionHandler) {
+        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(messageReceivedState, inferenceState, functionCallState, modelMessageState) {
-    this.messageReceivedState = messageReceivedState;
+  constructor(contextUpdateState, inferenceState, inferenceStreamingState, functionCallState, modelMessageState) {
+    this.contextUpdateState = contextUpdateState;
     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_update":
+        return await this.contextUpdateState.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":
@@ -607,19 +641,19 @@ var FunctionCallState = class {
   }
 };
 
-// src/application/states/message-received.ts
-var MessageReceivedState = class {
+// src/application/states/context-update.ts
+var ContextUpdateState = class {
   constructor() {
-    this.id = "message_received";
+    this.id = "context_update";
   }
   async run(input, loopVisitor) {
-    loopVisitor.visitMessageReceivedStarted(input);
+    loopVisitor.visitContextUpdateStarted(input);
     const userMessage = UserMessageItem.create(input.content);
     const output = {
       ...input.input,
       context: input.input.context.addContextItems([userMessage])
     };
-    loopVisitor.visitMessageReceivedCompleted(output);
+    loopVisitor.visitContextUpdateCompleted(output);
     return {
       stateId: this.id,
       input,
@@ -660,17 +694,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_update";
   }
 };
+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 {
@@ -685,16 +722,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_update") {
+      throw new Error("Expected context_preparation execution");
     }
+    const nextStateId = execution.output.streaming ? "inference_streaming" : "inference";
     return {
-      nextStateId: "inference",
+      nextStateId,
       input: execution.output
     };
   }
@@ -704,7 +742,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");
@@ -725,7 +763,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(
@@ -753,7 +791,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
       }
@@ -776,82 +814,110 @@ var ModelMessageToIdleRule = class {
 };
 
 // src/domain/agentic-environment/loop/event-publisher-visitor.ts
+import { createCloudClient } from "@mozaik-ai/cloud-sdk";
 var EventPublisherLoopVisitor = class {
-  constructor(agentId, runtime) {
+  constructor(agentId, loopId, runtime) {
     this.agentId = agentId;
+    this.loopId = loopId;
     this.runtime = runtime;
+    this.cloud = createCloudClient();
   }
-  visitMessageReceivedStarted(input) {
-    console.log("Visiting message received started: ", input);
-    this.publish("message_received.started", input);
+  visitContextUpdateStarted(input) {
+    this.publish("context_update.started", { ...input, loopId: this.loopId });
   }
-  visitMessageReceivedCompleted(output) {
-    console.log("Visiting message received completed: ", output);
-    this.publish("message_received.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) {
-    console.log("Visiting inference event: ", 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
-    });
+    const event = new SemanticEvent(type, this.agentId, /* @__PURE__ */ new Date(), payload);
+    this.runtime.publish(event);
+    if (this.cloud.enabled) {
+      this.cloud.send(event);
+    }
+  }
+};
+
+// 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) {
+  return function runLoop(agentId, message, inferenceInput, interceptionHandler) {
     const runtime = resolveRuntime();
     const inferenceRunner = runtime.getInferenceRunner();
     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 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
-    });
   };
 }
 
@@ -1010,7 +1076,14 @@ import Anthropic from "@anthropic-ai/sdk";
 var AnthropicMessages = class {
   constructor(endpointMapper = new AnthropicMessagesMapper(), config = {}) {
     this.endpointMapper = endpointMapper;
-    this.client = new Anthropic({ baseURL: config.baseURL, apiKey: config.apiKey });
+    this.clientConfig = config;
+  }
+  get client() {
+    var _a;
+    return (_a = this._client) != null ? _a : this._client = new Anthropic({
+      baseURL: this.clientConfig.baseURL,
+      apiKey: this.clientConfig.apiKey
+    });
   }
   async infer(inferenceInput) {
     const request = this.endpointMapper.toRequest(inferenceInput);
@@ -1019,10 +1092,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
+    };
   }
 };
 
@@ -1184,7 +1264,10 @@ var OpenAIResponsesMapper = class {
 var OpenAIResponses = class {
   constructor(endpointMapper = new OpenAIResponsesMapper()) {
     this.endpointMapper = endpointMapper;
-    this.client = new OpenAI();
+  }
+  get client() {
+    var _a;
+    return (_a = this._client) != null ? _a : this._client = new OpenAI();
   }
   async infer(inferenceInput) {
     const request = this.endpointMapper.toRequest(inferenceInput);
@@ -1193,10 +1276,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
+    };
   }
 };
 
@@ -1353,11 +1450,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 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 GoogleGenAI({
+      apiKey: (_a = this.clientConfig.apiKey) != null ? _a : process.env.GEMINI_API_KEY,
+      ...this.clientConfig.baseURL ? { httpOptions: { baseUrl: this.clientConfig.baseURL } } : {}
     });
   }
   async infer(inferenceInput) {
@@ -1368,9 +1468,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
+    };
   }
 };
 
@@ -1487,12 +1599,16 @@ var OpenAIChatCompletions = class {
   constructor(endpointMapper = new OpenAIChatCompletionsMapper(), config = {}) {
     var _a;
     this.endpointMapper = endpointMapper;
-    this.client = new OpenAI2({
-      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 OpenAI2({
+      baseURL: this.clientConfig.baseURL,
+      apiKey: this.clientConfig.apiKey
+    });
+  }
   buildRequest(inferenceInput) {
     return {
       ...this.extraBody,
@@ -1504,10 +1620,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
+    };
   }
 };
 
@@ -1931,13 +2054,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);
   }
 };
 
@@ -1953,6 +2076,18 @@ var DefaultFunctionCallRunner = class {
   }
 };
 
+// src/application/use-cases/send-event.ts
+function createSendEvent(resolveRuntime) {
+  return function sendEvent(event, senderId) {
+    const runtime = resolveRuntime();
+    const participant = runtime.getParticipant(senderId);
+    if (!participant) {
+      throw new Error(`Participant ${senderId} not found`);
+    }
+    runtime.publish(event);
+  };
+}
+
 // src/define-runtime.ts
 function defineRuntime() {
   let runtime = null;
@@ -1989,6 +2124,7 @@ function defineRuntime() {
   const join = createJoin(resolveRuntime);
   const leave = createLeave(resolveRuntime);
   const sendMessage = createSendMessage(resolveRuntime);
+  const sendEvent = createSendEvent(resolveRuntime);
   const runLoop = createRunLoop(resolveRuntime);
   return {
     initializeRuntime,
@@ -1997,29 +2133,81 @@ function defineRuntime() {
     join,
     leave,
     sendMessage,
+    sendEvent,
     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);
+  }
+};
 export {
+  Agent,
+  AnthropicMessages,
   ContextItem,
+  DefaultInferenceRunner,
   DeveloperMessageItem,
   FunctionCallItem,
   FunctionCallOutputItem,
+  GeminiGenerateContent,
+  Human,
   InputTokenDetails,
   McpClient,
   McpToolRegistry,
   ModelContext,
   ModelMessageItem,
+  OpenAIChatCompletions,
+  OpenAIResponses,
   OutputTokenDetails,
   Participant,
   ReasoningItem,
   RuntimeState,
   SemanticEvent,
+  SituationSpecification,
   SystemMessageItem,
   TokenUsage,
   UserMessageItem,
   createAgent,
   createHuman,
-  defineRuntime
+  defineRuntime,
+  supportedModels
 };
 //# sourceMappingURL=index.mjs.map