@mozaik-ai/core 3.11.0 → 3.12.0

package/dist/index.js

@@ -38,12 +38,19 @@ __export(index_exports, {
   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,
@@ -56,7 +63,7 @@ __export(index_exports, {
   ModelContext: () => ModelContext,
   ModelMessageItem: () => ModelMessageItem,
   Observer: () => Observer,
-  OpenAIInferenceRunner: () => OpenAIInferenceRunner,
+  OpenAICompatibleChatCompletions: () => OpenAICompatibleChatCompletions,
   OpenAIResponses: () => OpenAIResponses,
   OutputTokenDetails: () => OutputTokenDetails,
   Participant: () => Participant,
@@ -333,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;
@@ -409,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;
@@ -526,6 +533,7 @@ var SystemMessageItem = class _SystemMessageItem extends ContextItem {
 var Participant = class {
   constructor() {
     this.environments = [];
+    this.listens = [];
   }
   join(environment) {
     if (this.isJoinedTo(environment)) {
@@ -547,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);
@@ -577,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);
       }
     }
   }
@@ -764,8 +776,8 @@ var InferenceRequest = class {
   }
 };
 
-// src/application/runners/openai-inference-runner.ts
-var OpenAIInferenceRunner = class {
+// src/application/runners/inference-runner.ts
+var DefaultInferenceRunner = class {
   constructor(runtime) {
     this.runtime = runtime;
   }
@@ -970,6 +982,142 @@ var OpenAIResponses = class {
   }
 };
 
+// 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 {
@@ -977,6 +1125,24 @@ var AnthropicMessages = class {
     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 = {
@@ -1007,10 +1173,7 @@ var AnthropicMessages = class {
         };
       }
     }
-    const response = await this.client.messages.create(request);
-    const contextItems = this.extractContextItems(response);
-    const tokenUsage = this.extractTokenUsage(response);
-    return new InferenceResponse(contextItems, tokenUsage);
+    return request;
   }
   extractTokenUsage(response) {
     var _a, _b;
@@ -1130,6 +1293,44 @@ var AnthropicReasoningEffort = class {
   }
 };
 
+// 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() {
@@ -1243,6 +1444,345 @@ var ClaudeHaiku45 = class {
     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,
@@ -1253,12 +1793,19 @@ var ClaudeHaiku45 = class {
   BaseObserver,
   ClaudeHaiku45,
   ClaudeOpus47,
+  ClaudeOpus48,
   ClaudeSonnet46,
   ContextItem,
+  DeepSeekV4Flash,
+  DeepSeekV4Pro,
   DefaultFunctionCallRunner,
+  DefaultInferenceRunner,
   DeveloperMessageItem,
   FunctionCallItem,
   FunctionCallOutputItem,
+  Gemini31Pro,
+  Gemini35Flash,
+  GeminiGenerateContent,
   Gpt54,
   Gpt54Mini,
   Gpt54Nano,
@@ -1271,7 +1818,7 @@ var ClaudeHaiku45 = class {
   ModelContext,
   ModelMessageItem,
   Observer,
-  OpenAIInferenceRunner,
+  OpenAICompatibleChatCompletions,
   OpenAIResponses,
   OutputTokenDetails,
   Participant,