@mozaik-ai/core 3.10.3 → 3.12.0

package/dist/index.js

@@ -32,25 +32,39 @@ var index_exports = {};
 __export(index_exports, {
   Agent: () => Agent,
   AgenticEnvironment: () => AgenticEnvironment,
+  AnthropicMessages: () => AnthropicMessages,
   BaseAgent: () => BaseAgent,
   BaseHuman: () => BaseHuman,
   BaseObserver: () => BaseObserver,
+  ClaudeHaiku45: () => ClaudeHaiku45,
+  ClaudeOpus47: () => ClaudeOpus47,
+  ClaudeOpus48: () => ClaudeOpus48,
+  ClaudeSonnet46: () => ClaudeSonnet46,
   ContextItem: () => ContextItem,
+  DeepSeekV4Flash: () => DeepSeekV4Flash,
+  DeepSeekV4Pro: () => DeepSeekV4Pro,
   DefaultFunctionCallRunner: () => DefaultFunctionCallRunner,
+  DefaultInferenceRunner: () => DefaultInferenceRunner,
   DeveloperMessageItem: () => DeveloperMessageItem,
   FunctionCallItem: () => FunctionCallItem,
   FunctionCallOutputItem: () => FunctionCallOutputItem,
+  Gemini31Pro: () => Gemini31Pro,
+  Gemini35Flash: () => Gemini35Flash,
+  GeminiGenerateContent: () => GeminiGenerateContent,
   Gpt54: () => Gpt54,
   Gpt54Mini: () => Gpt54Mini,
   Gpt54Nano: () => Gpt54Nano,
   Gpt55: () => Gpt55,
   Human: () => Human,
   InMemoryModelContextRepository: () => InMemoryModelContextRepository,
+  InferenceRequest: () => InferenceRequest,
+  InferenceResponse: () => InferenceResponse,
   InputTokenDetails: () => InputTokenDetails,
   ModelContext: () => ModelContext,
   ModelMessageItem: () => ModelMessageItem,
   Observer: () => Observer,
-  OpenAIInferenceRunner: () => OpenAIInferenceRunner,
+  OpenAICompatibleChatCompletions: () => OpenAICompatibleChatCompletions,
+  OpenAIResponses: () => OpenAIResponses,
   OutputTokenDetails: () => OutputTokenDetails,
   Participant: () => Participant,
   ReasoningItem: () => ReasoningItem,
@@ -326,10 +340,10 @@ var Gpt54Nano = class {
       supportFunctionCalling: true
     };
     this.tools = [];
+    this.streaming = false;
     this.effort = new OpenAIReasoningEffort(
       this.specification.defaultReasoningEffort
     );
-    this.streaming = false;
   }
   setStreaming(streaming) {
     this.streaming = streaming;
@@ -402,10 +416,10 @@ var Gpt54Mini = class {
       supportFunctionCalling: true
     };
     this.tools = [];
+    this.streaming = false;
     this.effort = new OpenAIReasoningEffort(
       this.specification.defaultReasoningEffort
     );
-    this.streaming = false;
   }
   setStreaming(streaming) {
     this.streaming = streaming;
@@ -519,6 +533,7 @@ var SystemMessageItem = class _SystemMessageItem extends ContextItem {
 var Participant = class {
   constructor() {
     this.environments = [];
+    this.listens = [];
   }
   join(environment) {
     if (this.isJoinedTo(environment)) {
@@ -540,13 +555,17 @@ var Participant = class {
   getEnvironments() {
     return this.environments;
   }
+  getListeners() {
+    return this.listens;
+  }
 };
 
 // src/domain/agentic-environment/agentic-environment.ts
 var AgenticEnvironment = class {
-  constructor() {
+  constructor(name) {
     this.subscribers = [];
     this.isActive = false;
+    this.name = name;
   }
   subscribe(participant) {
     this.subscribers.push(participant);
@@ -570,53 +589,53 @@ var AgenticEnvironment = class {
     }
   }
   deliverFunctionCall(source, item) {
-    for (const subscriber of this.subscribers) {
-      if (subscriber === source) {
-        subscriber.onFunctionCall(item);
-      } else {
-        subscriber.onExternalFunctionCall(source, item);
-      }
-    }
+    this.deliverToSubscribers(source, {
+      internal: (src) => src.onFunctionCall(item),
+      external: (sub) => sub.onExternalFunctionCall(source, item)
+    });
   }
   deliverModelMessage(source, item) {
-    for (const subscriber of this.subscribers) {
-      if (subscriber === source) {
-        subscriber.onModelMessage(item);
-      } else {
-        subscriber.onExternalModelMessage(source, item);
-      }
-    }
+    this.deliverToSubscribers(source, {
+      internal: (src) => src.onModelMessage(item),
+      external: (sub) => sub.onExternalModelMessage(source, item)
+    });
   }
   deliverReasoning(source, item) {
-    for (const subscriber of this.subscribers) {
-      if (subscriber === source) {
-        subscriber.onReasoning(item);
-      } else {
-        subscriber.onExternalReasoning(source, item);
-      }
-    }
+    this.deliverToSubscribers(source, {
+      internal: (src) => src.onReasoning(item),
+      external: (sub) => sub.onExternalReasoning(source, item)
+    });
   }
   deliverFunctionCallOutput(source, item) {
-    for (const subscriber of this.subscribers) {
-      if (subscriber === source) {
-        subscriber.onFunctionCallOutput(item);
-      } else {
-        subscriber.onExternalFunctionCallOutput(source, item);
-      }
-    }
+    this.deliverToSubscribers(source, {
+      internal: (src) => src.onFunctionCallOutput(item),
+      external: (sub) => sub.onExternalFunctionCallOutput(source, item)
+    });
   }
   deliverMessage(source, message) {
-    for (const subscriber of this.subscribers) {
-      if (subscriber === source) continue;
-      subscriber.onMessage(message);
-    }
+    this.deliverToSubscribers(source, {
+      external: (sub) => sub.onMessage(message)
+    });
   }
   deliverSemanticEvent(source, item) {
+    this.deliverToSubscribers(source, {
+      internal: (src) => src.onInternalEvent(item),
+      external: (sub) => sub.onExternalEvent(source, item)
+    });
+  }
+  getListeningParticipants(source) {
+    return this.subscribers.filter(
+      (sub) => sub !== source && (sub.getListeners().length === 0 || sub.getListeners().some((listener) => source instanceof listener))
+    );
+  }
+  deliverToSubscribers(source, handlers) {
+    var _a, _b;
+    const authorizedListeners = this.getListeningParticipants(source);
     for (const subscriber of this.subscribers) {
       if (subscriber === source) {
-        subscriber.onInternalEvent(item);
-      } else {
-        subscriber.onExternalEvent(source, item);
+        (_a = handlers == null ? void 0 : handlers.internal) == null ? void 0 : _a.call(handlers, subscriber);
+      } else if (authorizedListeners.includes(subscriber)) {
+        (_b = handlers == null ? void 0 : handlers.external) == null ? void 0 : _b.call(handlers, subscriber);
       }
     }
   }
@@ -749,86 +768,35 @@ var BaseHuman = class extends Human {
   }
 };
 
-// src/application/runners/openai-inference-runner.ts
-var import_openai = __toESM(require("openai"));
-var OpenAIInferenceRunner = class {
+// src/domain/generative-model/inference-request.ts
+var InferenceRequest = class {
+  constructor(model, context) {
+    this.model = model;
+    this.context = context;
+  }
+};
+
+// src/application/runners/inference-runner.ts
+var DefaultInferenceRunner = class {
+  constructor(runtime) {
+    this.runtime = runtime;
+  }
   async *run(context, model, signal) {
-    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 request = new InferenceRequest(model, context);
+    if (model.getStreaming() && this.isStreamingRuntime(this.runtime)) {
+      yield* this.runtime.stream(request, signal);
+      return;
     }
-    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;
+    const response = await this.runtime.infer(request);
+    for (const item of response.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);
-      }
-    });
+  isStreamingRuntime(runtime) {
+    return typeof runtime.stream === "function";
   }
 };
 
@@ -920,29 +888,938 @@ var BaseObserver = class extends Observer {
   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
+    };
+    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()
+      };
+    }
+    return request;
+  }
+  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/infrastructure/providers/openai/runtime/openai-compatible-chat-completions.ts
+var import_openai2 = __toESM(require("openai"));
+var OpenAICompatibleChatCompletions = class {
+  constructor(config = {}) {
+    var _a;
+    this.client = new import_openai2.default({
+      baseURL: config.baseURL,
+      apiKey: config.apiKey
+    });
+    this.extraBody = (_a = config.extraBody) != null ? _a : {};
+  }
+  async infer(inferenceRequest) {
+    const response = await this.client.chat.completions.create(this.buildRequest(inferenceRequest));
+    const contextItems = this.extractContextItems(response);
+    const tokenUsage = this.extractTokenUsage(response);
+    return new InferenceResponse(contextItems, tokenUsage);
+  }
+  async *stream(inferenceRequest, signal) {
+    var _a;
+    const stream = await this.client.chat.completions.create({
+      ...this.buildRequest(inferenceRequest),
+      stream: true
+    });
+    for await (const event of stream) {
+      if (signal == null ? void 0 : signal.aborted) {
+        break;
+      }
+      yield new SemanticEvent((_a = event.object) != null ? _a : "chat.completion.chunk", event);
+    }
+  }
+  buildRequest(inferenceRequest) {
+    const specification = inferenceRequest.model.specification;
+    const request = {
+      ...this.extraBody,
+      model: specification.name,
+      messages: this.mapContextToRequest(inferenceRequest.context)
+    };
+    if (specification.supportFunctionCalling && inferenceRequest.model.getTools().length > 0) {
+      request.tools = inferenceRequest.model.getTools().map((tool) => {
+        return {
+          type: "function",
+          function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters
+          }
+        };
+      });
+    }
+    if (specification.supportReasoningEffort) {
+      request.reasoning_effort = inferenceRequest.model.getReasoningEffort();
+    }
+    return request;
+  }
+  extractTokenUsage(response) {
+    var _a, _b, _c, _d;
+    if (!response.usage) {
+      return void 0;
+    }
+    return new TokenUsage(
+      response.usage.prompt_tokens,
+      response.usage.completion_tokens,
+      response.usage.total_tokens,
+      new InputTokenDetails((_b = (_a = response.usage.prompt_tokens_details) == null ? void 0 : _a.cached_tokens) != null ? _b : 0),
+      new OutputTokenDetails((_d = (_c = response.usage.completion_tokens_details) == null ? void 0 : _c.reasoning_tokens) != null ? _d : 0)
+    );
+  }
+  mapContextToRequest(context) {
+    var _a;
+    const messages = [];
+    for (const item of context.getItems()) {
+      if (item instanceof DeveloperMessageItem || item instanceof SystemMessageItem) {
+        messages.push({ role: "system", content: item.content.text });
+        continue;
+      }
+      if (item instanceof UserMessageItem) {
+        messages.push({ role: "user", content: item.content.text });
+        continue;
+      }
+      if (item instanceof ModelMessageItem) {
+        messages.push({ role: "assistant", content: item.content.text });
+        continue;
+      }
+      if (item instanceof FunctionCallItem) {
+        const toolCall = {
+          id: item.callId,
+          type: "function",
+          function: { name: item.name, arguments: item.args }
+        };
+        const last = messages[messages.length - 1];
+        if ((last == null ? void 0 : last.role) === "assistant") {
+          last.tool_calls = (_a = last.tool_calls) != null ? _a : [];
+          last.tool_calls.push(toolCall);
+        } else {
+          messages.push({ role: "assistant", content: null, tool_calls: [toolCall] });
+        }
+        continue;
+      }
+      if (item instanceof FunctionCallOutputItem) {
+        messages.push({ role: "tool", tool_call_id: item.callId, content: item.output.text });
+      }
+    }
+    return messages;
+  }
+  extractContextItems(response) {
+    var _a, _b, _c;
+    const items = [];
+    const message = (_b = (_a = response.choices) == null ? void 0 : _a[0]) == null ? void 0 : _b.message;
+    if (!message) {
+      return items;
+    }
+    if (message.reasoning_content) {
+      items.push(
+        ReasoningItem.rehydrate({
+          content: InputText.rehydrate({ text: message.reasoning_content }),
+          encryptedContent: void 0,
+          summary: []
+        })
+      );
+    }
+    if (message.content) {
+      items.push(ModelMessageItem.rehydrate({ text: message.content }));
+    }
+    for (const toolCall of (_c = message.tool_calls) != null ? _c : []) {
+      items.push(
+        FunctionCallItem.rehydrate({
+          callId: toolCall.id,
+          name: toolCall.function.name,
+          args: toolCall.function.arguments
+        })
+      );
+    }
+    return items;
+  }
+};
+
+// 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 infer(inferenceRequest) {
+    const response = await this.client.messages.create(this.buildRequest(inferenceRequest));
+    const contextItems = this.extractContextItems(response);
+    const tokenUsage = this.extractTokenUsage(response);
+    return new InferenceResponse(contextItems, tokenUsage);
+  }
+  async *stream(inferenceRequest, signal) {
+    const stream = await this.client.messages.create({
+      ...this.buildRequest(inferenceRequest),
+      stream: true
+    });
+    for await (const event of stream) {
+      if (signal == null ? void 0 : signal.aborted) {
+        break;
+      }
+      yield new SemanticEvent(event.type, event);
+    }
+  }
+  buildRequest(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)
+        };
+      }
+    }
+    return request;
+  }
+  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/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-8-opus.ts
+var ClaudeOpus48 = class {
+  constructor() {
+    this.specification = {
+      name: "claude-opus-4-8",
+      supportReasoningEffort: true,
+      defaultReasoningEffort: "none",
+      supportStreaming: true,
+      contextWindowSize: 2e5,
+      maxOutputTokens: 32e3,
+      supportFunctionCalling: true
+    };
+    this.tools = [];
+    this.streaming = false;
+    this.effort = new AnthropicReasoningEffort(
+      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/infrastructure/providers/anthropic/models/claude-4-7-opus.ts
+var ClaudeOpus47 = class {
+  constructor() {
+    this.specification = {
+      name: "claude-opus-4-7",
+      supportReasoningEffort: true,
+      defaultReasoningEffort: "none",
+      supportStreaming: true,
+      contextWindowSize: 2e5,
+      maxOutputTokens: 32e3,
+      supportFunctionCalling: true
+    };
+    this.tools = [];
+    this.streaming = false;
+    this.effort = new AnthropicReasoningEffort(
+      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/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
+    );
+  }
+  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/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
+    );
+  }
+  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/infrastructure/providers/deepseek/reasoning-effort.ts
+var DeepSeekReasoningEffort = 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/deepseek/models/deepseek-v4-flash.ts
+var DeepSeekV4Flash = class {
+  constructor() {
+    this.specification = {
+      name: "deepseek-v4-flash",
+      supportReasoningEffort: true,
+      defaultReasoningEffort: "high",
+      supportStreaming: true,
+      contextWindowSize: 1e6,
+      maxOutputTokens: 384e3,
+      supportFunctionCalling: true
+    };
+    this.tools = [];
+    this.streaming = false;
+    this.effort = new DeepSeekReasoningEffort(
+      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/infrastructure/providers/deepseek/models/deepseek-v4-pro.ts
+var DeepSeekV4Pro = class {
+  constructor() {
+    this.specification = {
+      name: "deepseek-v4-pro",
+      supportReasoningEffort: true,
+      defaultReasoningEffort: "high",
+      supportStreaming: true,
+      contextWindowSize: 1e6,
+      maxOutputTokens: 384e3,
+      supportFunctionCalling: true
+    };
+    this.tools = [];
+    this.streaming = false;
+    this.effort = new DeepSeekReasoningEffort(
+      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/infrastructure/providers/gemini/runtime/gemini-generate-content.ts
+var import_genai = require("@google/genai");
+var GeminiGenerateContent = class {
+  constructor() {
+    this.client = new import_genai.GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
+  }
+  async infer(inferenceRequest) {
+    const response = await this.client.models.generateContent(this.buildRequest(inferenceRequest));
+    const contextItems = this.extractContextItems(response);
+    const tokenUsage = this.extractTokenUsage(response);
+    return new InferenceResponse(contextItems, tokenUsage);
+  }
+  async *stream(inferenceRequest, signal) {
+    const stream = await this.client.models.generateContentStream(this.buildRequest(inferenceRequest));
+    for await (const chunk of stream) {
+      if (signal == null ? void 0 : signal.aborted) {
+        break;
+      }
+      yield new SemanticEvent("generate_content_chunk", chunk);
+    }
+  }
+  buildRequest(inferenceRequest) {
+    const specification = inferenceRequest.model.specification;
+    const { contents, systemInstruction } = this.mapContextToRequest(inferenceRequest.context);
+    const config = {};
+    if (systemInstruction) {
+      config.systemInstruction = systemInstruction;
+    }
+    if (specification.supportFunctionCalling && inferenceRequest.model.getTools().length > 0) {
+      config.tools = [
+        {
+          functionDeclarations: inferenceRequest.model.getTools().map((tool) => {
+            return {
+              name: tool.name,
+              description: tool.description,
+              parametersJsonSchema: tool.parameters
+            };
+          })
+        }
+      ];
+    }
+    if (specification.supportReasoningEffort) {
+      const effort = inferenceRequest.model.getReasoningEffort();
+      const thinkingLevel = effort === "none" ? "minimal" : effort;
+      config.thinkingConfig = { thinkingLevel, includeThoughts: true };
+    }
+    return { model: specification.name, contents, config };
+  }
+  extractTokenUsage(response) {
+    var _a, _b, _c, _d, _e;
+    const usage = response.usageMetadata;
+    if (!usage) {
+      return void 0;
+    }
+    return new TokenUsage(
+      (_a = usage.promptTokenCount) != null ? _a : 0,
+      (_b = usage.candidatesTokenCount) != null ? _b : 0,
+      (_c = usage.totalTokenCount) != null ? _c : 0,
+      new InputTokenDetails((_d = usage.cachedContentTokenCount) != null ? _d : 0),
+      new OutputTokenDetails((_e = usage.thoughtsTokenCount) != null ? _e : 0)
+    );
+  }
+  mapContextToRequest(context) {
+    var _a;
+    const contents = [];
+    const system = [];
+    const callNames = /* @__PURE__ */ new Map();
+    for (const item of context.getItems()) {
+      if (item instanceof DeveloperMessageItem || item instanceof SystemMessageItem) {
+        system.push(item.content.text);
+        continue;
+      }
+      if (item instanceof UserMessageItem) {
+        this.addPart(contents, "user", { text: item.content.text });
+        continue;
+      }
+      if (item instanceof ModelMessageItem) {
+        this.addPart(contents, "model", { text: item.content.text });
+        continue;
+      }
+      if (item instanceof FunctionCallItem) {
+        callNames.set(item.callId, item.name);
+        let args;
+        try {
+          args = JSON.parse(item.args);
+        } catch (e) {
+          args = {};
+        }
+        this.addPart(contents, "model", { functionCall: { id: item.callId, name: item.name, args } });
+        continue;
+      }
+      if (item instanceof FunctionCallOutputItem) {
+        this.addPart(contents, "user", {
+          functionResponse: {
+            id: item.callId,
+            name: (_a = callNames.get(item.callId)) != null ? _a : "",
+            response: this.parseResponse(item.output.text)
+          }
+        });
+      }
+    }
+    return {
+      contents,
+      systemInstruction: system.length > 0 ? system.join("\n\n") : void 0
+    };
+  }
+  extractContextItems(response) {
+    var _a, _b, _c, _d, _e, _f;
+    const items = [];
+    const parts = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) != null ? _d : [];
+    for (const part of parts) {
+      if (part.thought && part.text) {
+        items.push(
+          ReasoningItem.rehydrate({
+            content: InputText.rehydrate({ text: part.text }),
+            encryptedContent: void 0,
+            summary: []
+          })
+        );
+        continue;
+      }
+      if (part.text) {
+        items.push(ModelMessageItem.rehydrate({ text: part.text }));
+        continue;
+      }
+      if (part.functionCall) {
+        items.push(
+          FunctionCallItem.rehydrate({
+            callId: (_e = part.functionCall.id) != null ? _e : "",
+            name: part.functionCall.name,
+            args: JSON.stringify((_f = part.functionCall.args) != null ? _f : {})
+          })
+        );
+      }
+    }
+    return items;
+  }
+  parseResponse(output) {
+    try {
+      const parsed = JSON.parse(output);
+      return parsed && typeof parsed === "object" ? parsed : { output };
+    } catch (e) {
+      return { output };
+    }
+  }
+  addPart(contents, role, part) {
+    const last = contents[contents.length - 1];
+    if ((last == null ? void 0 : last.role) === role) {
+      last.parts.push(part);
+      return;
+    }
+    contents.push({ role, parts: [part] });
+  }
+};
+
+// src/infrastructure/providers/gemini/reasoning-effort.ts
+var GeminiReasoningEffort = 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/gemini/models/gemini-3-5-flash.ts
+var Gemini35Flash = class {
+  constructor() {
+    this.specification = {
+      name: "gemini-3.5-flash",
+      supportReasoningEffort: true,
+      defaultReasoningEffort: "medium",
+      supportStreaming: true,
+      contextWindowSize: 1048576,
+      maxOutputTokens: 64e3,
+      supportFunctionCalling: true
+    };
+    this.tools = [];
+    this.streaming = false;
+    this.effort = new GeminiReasoningEffort(
+      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/infrastructure/providers/gemini/models/gemini-3-1-pro.ts
+var Gemini31Pro = class {
+  constructor() {
+    this.specification = {
+      name: "gemini-3.1-pro-preview",
+      supportReasoningEffort: true,
+      defaultReasoningEffort: "high",
+      supportStreaming: true,
+      contextWindowSize: 1048576,
+      maxOutputTokens: 64e3,
+      supportFunctionCalling: true
+    };
+    this.tools = [];
+    this.streaming = false;
+    this.effort = new GeminiReasoningEffort(
+      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();
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Agent,
   AgenticEnvironment,
+  AnthropicMessages,
   BaseAgent,
   BaseHuman,
   BaseObserver,
+  ClaudeHaiku45,
+  ClaudeOpus47,
+  ClaudeOpus48,
+  ClaudeSonnet46,
   ContextItem,
+  DeepSeekV4Flash,
+  DeepSeekV4Pro,
   DefaultFunctionCallRunner,
+  DefaultInferenceRunner,
   DeveloperMessageItem,
   FunctionCallItem,
   FunctionCallOutputItem,
+  Gemini31Pro,
+  Gemini35Flash,
+  GeminiGenerateContent,
   Gpt54,
   Gpt54Mini,
   Gpt54Nano,
   Gpt55,
   Human,
   InMemoryModelContextRepository,
+  InferenceRequest,
+  InferenceResponse,
   InputTokenDetails,
   ModelContext,
   ModelMessageItem,
   Observer,
-  OpenAIInferenceRunner,
+  OpenAICompatibleChatCompletions,
+  OpenAIResponses,
   OutputTokenDetails,
   Participant,
   ReasoningItem,