@mozaik-ai/core 3.9.5 → 3.10.0

package/dist/index.mjs

@@ -234,110 +234,6 @@ var FunctionCallOutputItem = class _FunctionCallOutputItem extends ContextItem {
   }
 };
 
-// src/domain/generative-model/inference-response.ts
-var InferenceResponse = class {
-  constructor(contextItems, tokenUsage) {
-    this.contextItems = contextItems;
-    this.tokenUsage = tokenUsage;
-  }
-};
-
-// src/domain/generative-model/token-usage.ts
-var InputTokenDetails = class {
-  constructor(cached_tokens) {
-    this.cached_tokens = cached_tokens;
-  }
-};
-var OutputTokenDetails = class {
-  constructor(reasoning_tokens) {
-    this.reasoning_tokens = reasoning_tokens;
-  }
-};
-var TokenUsage = class {
-  constructor(inputTokens, outputTokens, totalTokens, inputTokenDetails, outputTokenDetails) {
-    this.inputTokens = inputTokens;
-    this.outputTokens = outputTokens;
-    this.totalTokens = totalTokens;
-    this.inputTokenDetails = inputTokenDetails;
-    this.outputTokenDetails = outputTokenDetails;
-  }
-};
-
-// src/infrastructure/providers/openai/runtime/openai-responses.ts
-import OpenAI from "openai";
-var OpenAIResponses = class {
-  constructor() {
-    this.client = new OpenAI();
-  }
-  async infer(inferenceRequest) {
-    const input = this.mapContextToRequest(inferenceRequest.context);
-    const specification = inferenceRequest.model.specification;
-    let request = {
-      model: specification.name,
-      input
-    };
-    if (specification.supportFunctionCalling && inferenceRequest.model.getTools().length > 0) {
-      request.tools = inferenceRequest.model.getTools().map((tool) => {
-        return {
-          type: tool.type,
-          name: tool.name,
-          description: tool.description,
-          parameters: tool.parameters
-        };
-      });
-    }
-    if (specification.supportReasoningEffort) {
-      request.reasoning = {
-        effort: inferenceRequest.model.getReasoningEffort()
-      };
-    }
-    const response = await this.client.responses.create(request);
-    const contextItems = this.extractContextItems(response);
-    const tokenUsage = this.extractTokenUsage(response);
-    return new InferenceResponse(contextItems, tokenUsage);
-  }
-  extractTokenUsage(response) {
-    if (!response.usage) {
-      return void 0;
-    }
-    return new TokenUsage(
-      response.usage.input_tokens,
-      response.usage.output_tokens,
-      response.usage.total_tokens,
-      new InputTokenDetails(response.usage.input_tokens_details.cached_tokens),
-      new OutputTokenDetails(response.usage.output_tokens_details.reasoning_tokens)
-    );
-  }
-  mapContextToRequest(context) {
-    return context.getItems().map((item) => item.toJSON());
-  }
-  extractContextItems(response) {
-    return response.output.map((item) => {
-      if (item.type === "message" && item.role === "assistant") {
-        return ModelMessageItem.rehydrate(item.content[0]);
-      }
-      if (item.type === "function_call") {
-        return FunctionCallItem.rehydrate({
-          callId: item.call_id,
-          name: item.name,
-          args: item.arguments
-        });
-      }
-      if (item.type === "reasoning") {
-        return ReasoningItem.rehydrate(item);
-      }
-    });
-  }
-};
-
-// src/domain/generative-model/inference-request.ts
-var InferenceRequest = class {
-  constructor(model, context) {
-    this.model = model;
-    this.context = context;
-  }
-};
-
 // src/infrastructure/providers/openai/reasoning-effort.ts
 var OpenAIReasoningEffort = class {
   constructor(reasoningEffort) {
@@ -370,6 +266,13 @@ var Gpt54Nano = class {
     this.effort = new OpenAIReasoningEffort(
       this.specification.defaultReasoningEffort
     );
+    this.streaming = false;
+  }
+  setStreaming(streaming) {
+    this.streaming = streaming;
+  }
+  getStreaming() {
+    return this.streaming;
   }
   setTools(tools) {
     this.tools = tools;
@@ -398,10 +301,17 @@ var Gpt54 = class {
       supportFunctionCalling: true
     };
     this.tools = [];
+    this.streaming = false;
     this.effort = new OpenAIReasoningEffort(
       this.specification.defaultReasoningEffort
     );
   }
+  setStreaming(streaming) {
+    this.streaming = streaming;
+  }
+  getStreaming() {
+    return this.streaming;
+  }
   setTools(tools) {
     this.tools = tools;
   }
@@ -432,6 +342,13 @@ var Gpt54Mini = class {
     this.effort = new OpenAIReasoningEffort(
       this.specification.defaultReasoningEffort
     );
+    this.streaming = false;
+  }
+  setStreaming(streaming) {
+    this.streaming = streaming;
+  }
+  getStreaming() {
+    return this.streaming;
   }
   setReasoningEffort(effort) {
     this.effort.setReasoningEffort(effort);
@@ -447,6 +364,27 @@ var Gpt54Mini = class {
   }
 };
 
+// src/domain/generative-model/token-usage.ts
+var InputTokenDetails = class {
+  constructor(cached_tokens) {
+    this.cached_tokens = cached_tokens;
+  }
+};
+var OutputTokenDetails = class {
+  constructor(reasoning_tokens) {
+    this.reasoning_tokens = reasoning_tokens;
+  }
+};
+var TokenUsage = class {
+  constructor(inputTokens, outputTokens, totalTokens, inputTokenDetails, outputTokenDetails) {
+    this.inputTokens = inputTokens;
+    this.outputTokens = outputTokens;
+    this.totalTokens = totalTokens;
+    this.inputTokenDetails = inputTokenDetails;
+    this.outputTokenDetails = outputTokenDetails;
+  }
+};
+
 // src/infrastructure/repository/in-memory-model-context-repository.ts
 var InMemoryModelContextRepository = class {
   constructor() {
@@ -514,7 +452,7 @@ var SystemMessageItem = class _SystemMessageItem extends ContextItem {
   }
 };
 
-// src/domain/agentic-environment/participant.ts
+// src/domain/agentic-environment/participants/participant.ts
 var Participant = class {
   constructor() {
     this.environments = [];
@@ -609,6 +547,15 @@ var AgenticEnvironment = class {
       subscriber.onMessage(message);
     }
   }
+  deliverSemanticEvent(source, item) {
+    for (const subscriber of this.subscribers) {
+      if (subscriber === source) {
+        subscriber.onInternalEvent(item);
+      } else {
+        subscriber.onExternalEvent(source, item);
+      }
+    }
+  }
   async start() {
     this.isActive = true;
     while (this.isActive) {
@@ -620,11 +567,25 @@ var AgenticEnvironment = class {
   }
 };
 
-// src/application/agent.ts
-var BaseAgentParticipant = class extends Participant {
-  constructor(inputSource, inferenceRunner, functionCallRunner) {
+// src/domain/agentic-environment/participants/agent.ts
+var Agent = class extends Participant {
+};
+
+// src/domain/model-context/semantic-event/semantic-event.ts
+var SemanticEvent = class {
+  constructor(type, data) {
+    this.type = type;
+    this.data = data;
+  }
+  getType() {
+    return this.type;
+  }
+};
+
+// src/application/participants/agent.ts
+var BaseAgent = class extends Agent {
+  constructor(inferenceRunner, functionCallRunner) {
     super();
-    this.inputSource = inputSource;
     this.inferenceRunner = inferenceRunner;
     this.functionCallRunner = functionCallRunner;
   }
@@ -654,41 +615,44 @@ var BaseAgentParticipant = class extends Participant {
   }
   onMessage(message) {
   }
+  onInternalEvent(item) {
+  }
+  onExternalEvent(source, item) {
+  }
   async executeFunctionCall(environment, functionCallItem, signal) {
     if (!this.isJoinedTo(environment)) return;
     const stream = this.functionCallRunner.run(functionCallItem, signal);
     for await (const item of stream) {
-      await environment.deliverFunctionCallOutput(this, item);
+      environment.deliverFunctionCallOutput(this, item);
     }
   }
   async runInference(environment, context, model, signal) {
     if (!this.isJoinedTo(environment)) return;
     const stream = this.inferenceRunner.run(context, model, signal);
     for await (const item of stream) {
-      if (item.type === "reasoning") {
-        await environment.deliverReasoning(this, item);
-      } else if (item.type === "function_call") {
-        await environment.deliverFunctionCall(this, item);
-      } else if (item.type === "message" && item.role === "assistant") {
-        await environment.deliverModelMessage(this, item);
+      if (item instanceof ReasoningItem) {
+        environment.deliverReasoning(this, item);
+      } else if (item instanceof FunctionCallItem) {
+        environment.deliverFunctionCall(this, item);
+      } else if (item instanceof ModelMessageItem) {
+        environment.deliverModelMessage(this, item);
+      } else if (item instanceof SemanticEvent) {
+        environment.deliverSemanticEvent(this, item);
       }
     }
   }
-  async streamInput(environment) {
-    if (!this.isJoinedTo(environment)) return;
-    const stream = this.inputSource.stream();
-    for await (const message of stream) {
-      await environment.deliverMessage(this, message);
-    }
-  }
 };
 
-// src/application/human.ts
-var BaseHumanParticipant = class extends Participant {
-  constructor(inputSource) {
-    super();
-    this.inputSource = inputSource;
+// src/domain/agentic-environment/participants/human.ts
+var Human = class extends Participant {
+  sendMessage(environment, message) {
+    if (!this.isJoinedTo(environment)) throw new Error("Not joined to environment");
+    environment.deliverMessage(this, message);
   }
+};
+
+// src/application/participants/human.ts
+var BaseHuman = class extends Human {
   onJoined() {
   }
   onLeft() {
@@ -715,29 +679,96 @@ var BaseHumanParticipant = class extends Participant {
   }
   onExternalModelMessage(source, item) {
   }
-  async streamInput(environment) {
-    if (!this.isJoinedTo(environment)) return;
-    const stream = this.inputSource.stream();
-    for await (const message of stream) {
-      await environment.deliverMessage(this, message);
-    }
+  onInternalEvent(item) {
+  }
+  onExternalEvent(source, item) {
   }
 };
 
-// src/application/openai-inference-runner.ts
+// src/application/runners/openai-inference-runner.ts
+import OpenAI from "openai";
 var OpenAIInferenceRunner = class {
-  constructor() {
-    this.runtime = new OpenAIResponses();
-  }
   async *run(context, model, signal) {
-    const response = await this.runtime.infer(new InferenceRequest(model, context));
-    for (const item of response.contextItems) {
-      yield item;
+    const input = this.mapContextToRequest(context);
+    const specification = model.specification;
+    let request = {
+      model: specification.name,
+      input,
+      stream: model.getStreaming()
+    };
+    if (specification.supportFunctionCalling && model.getTools().length > 0) {
+      request.tools = model.getTools().map((tool) => {
+        return {
+          type: tool.type,
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.parameters
+        };
+      });
+    }
+    if (specification.supportReasoningEffort) {
+      request.reasoning = {
+        effort: model.getReasoningEffort()
+      };
+    }
+    if (!specification.supportStreaming && model.getStreaming()) {
+      throw new Error("Streaming is not supported for this model");
+    }
+    const openai = new OpenAI();
+    const response = await openai.responses.create(request);
+    if (specification.supportStreaming && model.getStreaming()) {
+      for await (const event of response) {
+        if (signal == null ? void 0 : signal.aborted) {
+          break;
+        }
+        yield new SemanticEvent(event.type, event);
+      }
+    } else {
+      const contextItems = this.extractContextItems(response);
+      const tokenUsage = this.extractTokenUsage(response);
+      for (const item of contextItems) {
+        if (signal == null ? void 0 : signal.aborted) {
+          break;
+        }
+        yield item;
+      }
+    }
+  }
+  extractTokenUsage(response) {
+    if (!response.usage) {
+      return void 0;
     }
+    return new TokenUsage(
+      response.usage.input_tokens,
+      response.usage.output_tokens,
+      response.usage.total_tokens,
+      new InputTokenDetails(response.usage.input_tokens_details.cached_tokens),
+      new OutputTokenDetails(response.usage.output_tokens_details.reasoning_tokens)
+    );
+  }
+  mapContextToRequest(context) {
+    return context.getItems().map((item) => item.toJSON());
+  }
+  extractContextItems(response) {
+    return response.output.map((item) => {
+      if (item.type === "message" && item.role === "assistant") {
+        return ModelMessageItem.rehydrate(item.content[0]);
+      }
+      if (item.type === "function_call") {
+        return FunctionCallItem.rehydrate({
+          callId: item.call_id,
+          name: item.name,
+          args: item.arguments
+        });
+      }
+      if (item.type === "reasoning") {
+        return ReasoningItem.rehydrate(item);
+      }
+    });
   }
 };
 
-// src/application/function-call-runner.ts
+// src/application/runners/function-call-runner.ts
 var DefaultFunctionCallRunner = class {
   constructor(tools) {
     this.tools = tools;
@@ -763,10 +794,17 @@ var Gpt55 = class {
       supportFunctionCalling: true
     };
     this.tools = [];
+    this.streaming = false;
     this.effort = new OpenAIReasoningEffort(
       this.specification.defaultReasoningEffort
     );
   }
+  setStreaming(streaming) {
+    this.streaming = streaming;
+  }
+  getStreaming() {
+    return this.streaming;
+  }
   setTools(tools) {
     this.tools = tools;
   }
@@ -781,8 +819,12 @@ var Gpt55 = class {
   }
 };
 
-// src/application/observer.ts
-var BaseObserverParticipant = class extends Participant {
+// src/domain/agentic-environment/participants/observer.ts
+var Observer = class extends Participant {
+};
+
+// src/application/participants/observer.ts
+var BaseObserver = class extends Observer {
   onFunctionCall(item) {
   }
   onExternalFunctionCall(source, item) {
@@ -809,12 +851,17 @@ var BaseObserverParticipant = class extends Participant {
   }
   onParticipantLeft(participant) {
   }
+  onInternalEvent(item) {
+  }
+  onExternalEvent(source, item) {
+  }
 };
 export {
+  Agent,
   AgenticEnvironment,
-  BaseAgentParticipant,
-  BaseHumanParticipant,
-  BaseObserverParticipant,
+  BaseAgent,
+  BaseHuman,
+  BaseObserver,
   ContextItem,
   DefaultFunctionCallRunner,
   DeveloperMessageItem,
@@ -824,14 +871,13 @@ export {
   Gpt54Mini,
   Gpt54Nano,
   Gpt55,
+  Human,
   InMemoryModelContextRepository,
-  InferenceRequest,
-  InferenceResponse,
   InputTokenDetails,
   ModelContext,
   ModelMessageItem,
+  Observer,
   OpenAIInferenceRunner,
-  OpenAIResponses,
   OutputTokenDetails,
   Participant,
   ReasoningItem,