@mozaik-ai/core 3.10.3 → 3.11.0

package/dist/index.js

@@ -32,9 +32,13 @@ var index_exports = {};
 __export(index_exports, {
   Agent: () => Agent,
   AgenticEnvironment: () => AgenticEnvironment,
+  AnthropicMessages: () => AnthropicMessages,
   BaseAgent: () => BaseAgent,
   BaseHuman: () => BaseHuman,
   BaseObserver: () => BaseObserver,
+  ClaudeHaiku45: () => ClaudeHaiku45,
+  ClaudeOpus47: () => ClaudeOpus47,
+  ClaudeSonnet46: () => ClaudeSonnet46,
   ContextItem: () => ContextItem,
   DefaultFunctionCallRunner: () => DefaultFunctionCallRunner,
   DeveloperMessageItem: () => DeveloperMessageItem,
@@ -46,11 +50,14 @@ __export(index_exports, {
   Gpt55: () => Gpt55,
   Human: () => Human,
   InMemoryModelContextRepository: () => InMemoryModelContextRepository,
+  InferenceRequest: () => InferenceRequest,
+  InferenceResponse: () => InferenceResponse,
   InputTokenDetails: () => InputTokenDetails,
   ModelContext: () => ModelContext,
   ModelMessageItem: () => ModelMessageItem,
   Observer: () => Observer,
   OpenAIInferenceRunner: () => OpenAIInferenceRunner,
+  OpenAIResponses: () => OpenAIResponses,
   OutputTokenDetails: () => OutputTokenDetails,
   Participant: () => Participant,
   ReasoningItem: () => ReasoningItem,
@@ -749,19 +756,171 @@ var BaseHuman = class extends Human {
   }
 };
 
+// src/domain/generative-model/inference-request.ts
+var InferenceRequest = class {
+  constructor(model, context) {
+    this.model = model;
+    this.context = context;
+  }
+};
+
 // src/application/runners/openai-inference-runner.ts
-var import_openai = __toESM(require("openai"));
 var OpenAIInferenceRunner = class {
+  constructor(runtime) {
+    this.runtime = runtime;
+  }
   async *run(context, model, signal) {
-    const input = this.mapContextToRequest(context);
-    const specification = model.specification;
-    let request = {
+    const request = new InferenceRequest(model, context);
+    if (model.getStreaming() && this.isStreamingRuntime(this.runtime)) {
+      yield* this.runtime.stream(request, signal);
+      return;
+    }
+    const response = await this.runtime.infer(request);
+    for (const item of response.contextItems) {
+      if (signal == null ? void 0 : signal.aborted) {
+        break;
+      }
+      yield item;
+    }
+  }
+  isStreamingRuntime(runtime) {
+    return typeof runtime.stream === "function";
+  }
+};
+
+// src/application/runners/function-call-runner.ts
+var DefaultFunctionCallRunner = class {
+  constructor(tools) {
+    this.tools = tools;
+  }
+  async *run(call, signal) {
+    const tool = this.tools.find((t) => t.name === call.name);
+    if (!tool) throw new Error(`Unknown tool: ${call.name}`);
+    const result = await tool.invoke(JSON.parse(call.args));
+    yield FunctionCallOutputItem.create(call.callId, JSON.stringify(result));
+  }
+};
+
+// src/infrastructure/providers/openai/models/gpt-5-5.ts
+var Gpt55 = class {
+  constructor() {
+    this.specification = {
+      name: "gpt-5.5",
+      supportReasoningEffort: true,
+      defaultReasoningEffort: "none",
+      supportStreaming: true,
+      contextWindowSize: 105e4,
+      maxOutputTokens: 128e3,
+      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;
+  }
+  getTools() {
+    return this.tools;
+  }
+  setReasoningEffort(effort) {
+    this.effort.setReasoningEffort(effort);
+  }
+  getReasoningEffort() {
+    return this.effort.getReasoningEffort();
+  }
+};
+
+// 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) {
+  }
+  onFunctionCallOutput(item) {
+  }
+  onExternalFunctionCallOutput(source, item) {
+  }
+  onReasoning(item) {
+  }
+  onExternalReasoning(source, item) {
+  }
+  onModelMessage(item) {
+  }
+  onExternalModelMessage(source, item) {
+  }
+  onMessage(message) {
+  }
+  onJoined() {
+  }
+  onLeft() {
+  }
+  onParticipantJoined(participant) {
+  }
+  onParticipantLeft(participant) {
+  }
+  onInternalEvent(item) {
+  }
+  onExternalEvent(source, item) {
+  }
+};
+
+// src/domain/generative-model/inference-response.ts
+var InferenceResponse = class {
+  constructor(contextItems, tokenUsage) {
+    this.contextItems = contextItems;
+    this.tokenUsage = tokenUsage;
+  }
+};
+
+// src/infrastructure/providers/openai/runtime/openai-responses.ts
+var import_openai = __toESM(require("openai"));
+var OpenAIResponses = class {
+  constructor() {
+    this.client = new import_openai.default();
+  }
+  async infer(inferenceRequest) {
+    const request = this.buildRequest(inferenceRequest);
+    const response = await this.client.responses.create(request);
+    const contextItems = this.extractContextItems(response);
+    const tokenUsage = this.extractTokenUsage(response);
+    return new InferenceResponse(contextItems, tokenUsage);
+  }
+  async *stream(inferenceRequest, signal) {
+    const specification = inferenceRequest.model.specification;
+    if (!specification.supportStreaming) {
+      throw new Error("Streaming is not supported for this model");
+    }
+    const request = { ...this.buildRequest(inferenceRequest), stream: true };
+    const response = await this.client.responses.create(request);
+    for await (const event of response) {
+      if (signal == null ? void 0 : signal.aborted) {
+        break;
+      }
+      yield new SemanticEvent(event.type, event);
+    }
+  }
+  buildRequest(inferenceRequest) {
+    const specification = inferenceRequest.model.specification;
+    const input = this.mapContextToRequest(inferenceRequest.context);
+    const request = {
       model: specification.name,
-      input,
-      stream: model.getStreaming()
+      input
     };
-    if (specification.supportFunctionCalling && model.getTools().length > 0) {
-      request.tools = model.getTools().map((tool) => {
+    if (specification.supportFunctionCalling && inferenceRequest.model.getTools().length > 0) {
+      request.tools = inferenceRequest.model.getTools().map((tool) => {
         return {
           type: tool.type,
           name: tool.name,
@@ -772,31 +931,10 @@ var OpenAIInferenceRunner = class {
     }
     if (specification.supportReasoningEffort) {
       request.reasoning = {
-        effort: model.getReasoningEffort()
+        effort: inferenceRequest.model.getReasoningEffort()
       };
     }
-    if (!specification.supportStreaming && model.getStreaming()) {
-      throw new Error("Streaming is not supported for this model");
-    }
-    const openai = new import_openai.default();
-    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;
-      }
-    }
+    return request;
   }
   extractTokenUsage(response) {
     if (!response.usage) {
@@ -832,34 +970,181 @@ var OpenAIInferenceRunner = class {
   }
 };
 
-// src/application/runners/function-call-runner.ts
-var DefaultFunctionCallRunner = class {
-  constructor(tools) {
-    this.tools = tools;
+// src/infrastructure/providers/anthropic/runtime/anthropic-messages.ts
+var import_sdk = __toESM(require("@anthropic-ai/sdk"));
+var AnthropicMessages = class {
+  constructor() {
+    this.client = new import_sdk.default();
   }
-  async *run(call, signal) {
-    const tool = this.tools.find((t) => t.name === call.name);
-    if (!tool) throw new Error(`Unknown tool: ${call.name}`);
-    const result = await tool.invoke(JSON.parse(call.args));
-    yield FunctionCallOutputItem.create(call.callId, JSON.stringify(result));
+  async infer(inferenceRequest) {
+    const { messages, system } = this.mapContextToRequest(inferenceRequest.context);
+    const specification = inferenceRequest.model.specification;
+    const request = {
+      model: specification.name,
+      max_tokens: specification.maxOutputTokens,
+      messages
+    };
+    if (system) {
+      request.system = system;
+    }
+    if (specification.supportFunctionCalling && inferenceRequest.model.getTools().length > 0) {
+      request.tools = inferenceRequest.model.getTools().map((tool) => {
+        return {
+          name: tool.name,
+          description: tool.description,
+          input_schema: tool.parameters
+        };
+      });
+    }
+    if (specification.supportReasoningEffort) {
+      const effort = inferenceRequest.model.getReasoningEffort();
+      const budgets = { low: 1024, medium: 4096, high: 8192 };
+      const budget = budgets[effort];
+      if (budget !== void 0) {
+        request.thinking = {
+          type: "enabled",
+          budget_tokens: Math.min(budget, specification.maxOutputTokens - 1)
+        };
+      }
+    }
+    const response = await this.client.messages.create(request);
+    const contextItems = this.extractContextItems(response);
+    const tokenUsage = this.extractTokenUsage(response);
+    return new InferenceResponse(contextItems, tokenUsage);
+  }
+  extractTokenUsage(response) {
+    var _a, _b;
+    if (!response.usage) {
+      return void 0;
+    }
+    return new TokenUsage(
+      response.usage.input_tokens,
+      response.usage.output_tokens,
+      response.usage.input_tokens + response.usage.output_tokens,
+      new InputTokenDetails(
+        ((_a = response.usage.cache_creation_input_tokens) != null ? _a : 0) + ((_b = response.usage.cache_read_input_tokens) != null ? _b : 0)
+      ),
+      new OutputTokenDetails(0)
+    );
+  }
+  mapContextToRequest(context) {
+    const messages = [];
+    const system = [];
+    for (const item of context.getItems()) {
+      if (item instanceof DeveloperMessageItem || item instanceof SystemMessageItem) {
+        system.push(item.content.text);
+        continue;
+      }
+      if (item instanceof UserMessageItem) {
+        this.addContentBlock(messages, "user", { type: "text", text: item.content.text });
+        continue;
+      }
+      if (item instanceof ModelMessageItem) {
+        this.addContentBlock(messages, "assistant", { type: "text", text: item.content.text });
+        continue;
+      }
+      if (item instanceof FunctionCallItem) {
+        let input;
+        try {
+          input = JSON.parse(item.args);
+        } catch (e) {
+          input = item.args;
+        }
+        this.addContentBlock(messages, "assistant", {
+          type: "tool_use",
+          id: item.callId,
+          name: item.name,
+          input
+        });
+        continue;
+      }
+      if (item instanceof FunctionCallOutputItem) {
+        this.addContentBlock(messages, "user", {
+          type: "tool_result",
+          tool_use_id: item.callId,
+          content: item.output.text
+        });
+      }
+    }
+    return {
+      messages,
+      system: system.length > 0 ? system.join("\n\n") : void 0
+    };
+  }
+  extractContextItems(response) {
+    var _a;
+    const items = [];
+    for (const block of response.content) {
+      if (block.type === "text") {
+        items.push(ModelMessageItem.rehydrate({ text: block.text }));
+        continue;
+      }
+      if (block.type === "tool_use") {
+        items.push(
+          FunctionCallItem.rehydrate({
+            callId: block.id,
+            name: block.name,
+            args: JSON.stringify((_a = block.input) != null ? _a : {})
+          })
+        );
+        continue;
+      }
+      if (block.type === "thinking") {
+        items.push(
+          ReasoningItem.rehydrate({
+            content: block.thinking ? InputText.rehydrate({ text: block.thinking }) : void 0,
+            encryptedContent: void 0,
+            summary: []
+          })
+        );
+      }
+    }
+    return items;
+  }
+  addContentBlock(messages, role, block) {
+    const lastMessage = messages[messages.length - 1];
+    if ((lastMessage == null ? void 0 : lastMessage.role) === role) {
+      lastMessage.content.push(block);
+      return;
+    }
+    messages.push({
+      role,
+      content: [block]
+    });
   }
 };
 
-// src/infrastructure/providers/openai/models/gpt-5-5.ts
-var Gpt55 = class {
+// src/infrastructure/providers/anthropic/reasoning-effort.ts
+var AnthropicReasoningEffort = class {
+  constructor(reasoningEffort) {
+    this.reasoningEffort = reasoningEffort;
+  }
+  setReasoningEffort(effort) {
+    this.reasoningEffort = effort;
+  }
+  getReasoningEffort() {
+    if (!this.reasoningEffort) {
+      throw new Error("Reasoning effort not supported");
+    }
+    return this.reasoningEffort;
+  }
+};
+
+// src/infrastructure/providers/anthropic/models/claude-4-7-opus.ts
+var ClaudeOpus47 = class {
   constructor() {
     this.specification = {
-      name: "gpt-5.5",
+      name: "claude-opus-4-7",
       supportReasoningEffort: true,
       defaultReasoningEffort: "none",
       supportStreaming: true,
-      contextWindowSize: 105e4,
-      maxOutputTokens: 128e3,
+      contextWindowSize: 2e5,
+      maxOutputTokens: 32e3,
       supportFunctionCalling: true
     };
     this.tools = [];
     this.streaming = false;
-    this.effort = new OpenAIReasoningEffort(
+    this.effort = new AnthropicReasoningEffort(
       this.specification.defaultReasoningEffort
     );
   }
@@ -883,50 +1168,92 @@ var Gpt55 = class {
   }
 };
 
-// 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) {
+// src/infrastructure/providers/anthropic/models/claude-4-6-sonnet.ts
+var ClaudeSonnet46 = class {
+  constructor() {
+    this.specification = {
+      name: "claude-sonnet-4-6",
+      supportReasoningEffort: true,
+      defaultReasoningEffort: "none",
+      supportStreaming: true,
+      contextWindowSize: 2e5,
+      maxOutputTokens: 64e3,
+      supportFunctionCalling: true
+    };
+    this.tools = [];
+    this.streaming = false;
+    this.effort = new AnthropicReasoningEffort(
+      this.specification.defaultReasoningEffort
+    );
   }
-  onFunctionCallOutput(item) {
+  setStreaming(streaming) {
+    this.streaming = streaming;
   }
-  onExternalFunctionCallOutput(source, item) {
+  getStreaming() {
+    return this.streaming;
   }
-  onReasoning(item) {
+  setTools(tools) {
+    this.tools = tools;
   }
-  onExternalReasoning(source, item) {
+  getTools() {
+    return this.tools;
   }
-  onModelMessage(item) {
+  setReasoningEffort(effort) {
+    this.effort.setReasoningEffort(effort);
   }
-  onExternalModelMessage(source, item) {
+  getReasoningEffort() {
+    return this.effort.getReasoningEffort();
   }
-  onMessage(message) {
+};
+
+// src/infrastructure/providers/anthropic/models/claude-4-5-haiku.ts
+var ClaudeHaiku45 = class {
+  constructor() {
+    this.specification = {
+      name: "claude-haiku-4-5",
+      supportReasoningEffort: true,
+      defaultReasoningEffort: "none",
+      supportStreaming: true,
+      contextWindowSize: 2e5,
+      maxOutputTokens: 64e3,
+      supportFunctionCalling: true
+    };
+    this.tools = [];
+    this.streaming = false;
+    this.effort = new AnthropicReasoningEffort(
+      this.specification.defaultReasoningEffort
+    );
   }
-  onJoined() {
+  setStreaming(streaming) {
+    this.streaming = streaming;
   }
-  onLeft() {
+  getStreaming() {
+    return this.streaming;
   }
-  onParticipantJoined(participant) {
+  setTools(tools) {
+    this.tools = tools;
   }
-  onParticipantLeft(participant) {
+  getTools() {
+    return this.tools;
   }
-  onInternalEvent(item) {
+  setReasoningEffort(effort) {
+    this.effort.setReasoningEffort(effort);
   }
-  onExternalEvent(source, item) {
+  getReasoningEffort() {
+    return this.effort.getReasoningEffort();
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Agent,
   AgenticEnvironment,
+  AnthropicMessages,
   BaseAgent,
   BaseHuman,
   BaseObserver,
+  ClaudeHaiku45,
+  ClaudeOpus47,
+  ClaudeSonnet46,
   ContextItem,
   DefaultFunctionCallRunner,
   DeveloperMessageItem,
@@ -938,11 +1265,14 @@ var BaseObserver = class extends Observer {
   Gpt55,
   Human,
   InMemoryModelContextRepository,
+  InferenceRequest,
+  InferenceResponse,
   InputTokenDetails,
   ModelContext,
   ModelMessageItem,
   Observer,
   OpenAIInferenceRunner,
+  OpenAIResponses,
   OutputTokenDetails,
   Participant,
   ReasoningItem,