@yourgpt/llm-sdk 2.1.8 → 2.1.10-alpha.0

package/dist/providers/togetherai/index.mjs

@@ -21,7 +21,12 @@ function togetherai(modelId, options = {}) {
       supportsThinking: false,
       supportsPDF: false,
       maxTokens: 131072,
-      supportedImageTypes: ["image/png", "image/jpeg", "image/gif", "image/webp"]
+      supportedImageTypes: [
+        "image/png",
+        "image/jpeg",
+        "image/gif",
+        "image/webp"
+      ]
     },
     async doGenerate(params) {
       const client2 = await getClient();
@@ -197,6 +202,1028 @@ function formatMessages(messages) {
   });
 }
 
-export { togetherai as createTogetherAI, togetherai };
+// src/core/utils.ts
+function generateId(prefix = "id") {
+  return `${prefix}_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+function generateMessageId() {
+  return generateId("msg");
+}
+function generateToolCallId() {
+  return generateId("call");
+}
+
+// src/adapters/base.ts
+function stringifyForDebug(value) {
+  return JSON.stringify(
+    value,
+    (_key, currentValue) => {
+      if (typeof currentValue === "bigint") {
+        return currentValue.toString();
+      }
+      if (currentValue instanceof Error) {
+        return {
+          name: currentValue.name,
+          message: currentValue.message,
+          stack: currentValue.stack
+        };
+      }
+      return currentValue;
+    },
+    2
+  );
+}
+function logProviderPayload(provider, label, payload, enabled) {
+  if (!enabled) {
+    return;
+  }
+  if (label.toLowerCase().includes("stream ")) {
+    return;
+  }
+  try {
+    console.log(
+      `[llm-sdk:${provider}] ${label}
+${stringifyForDebug(payload)}`
+    );
+  } catch (error) {
+    console.log(
+      `[llm-sdk:${provider}] ${label} (failed to stringify payload)`,
+      error
+    );
+  }
+}
+function parameterToJsonSchema(param) {
+  const schema = {
+    type: param.type
+  };
+  if (param.description) {
+    schema.description = param.description;
+  }
+  if (param.enum) {
+    schema.enum = param.enum;
+  }
+  if (param.type === "array" && param.items) {
+    schema.items = parameterToJsonSchema(
+      param.items
+    );
+  }
+  if (param.type === "object" && param.properties) {
+    schema.properties = Object.fromEntries(
+      Object.entries(param.properties).map(([key, prop]) => [
+        key,
+        parameterToJsonSchema(
+          prop
+        )
+      ])
+    );
+    schema.additionalProperties = false;
+  }
+  return schema;
+}
+function normalizeObjectJsonSchema(schema) {
+  if (!schema || typeof schema !== "object") {
+    return {
+      type: "object",
+      properties: {},
+      required: [],
+      additionalProperties: false
+    };
+  }
+  const normalized = { ...schema };
+  const type = normalized.type;
+  if (type === "object") {
+    const properties = normalized.properties && typeof normalized.properties === "object" && !Array.isArray(normalized.properties) ? normalized.properties : {};
+    normalized.properties = Object.fromEntries(
+      Object.entries(properties).map(([key, value]) => [
+        key,
+        normalizeObjectJsonSchema(value)
+      ])
+    );
+    const propertyKeys = Object.keys(properties);
+    const required = Array.isArray(normalized.required) ? normalized.required.filter(
+      (value) => typeof value === "string"
+    ) : [];
+    normalized.required = Array.from(/* @__PURE__ */ new Set([...required, ...propertyKeys]));
+    if (normalized.additionalProperties === void 0) {
+      normalized.additionalProperties = false;
+    }
+  } else if (type === "array" && normalized.items && typeof normalized.items === "object") {
+    normalized.items = normalizeObjectJsonSchema(
+      normalized.items
+    );
+  }
+  return normalized;
+}
+function formatTools(actions) {
+  return actions.map((action) => ({
+    type: "function",
+    function: {
+      name: action.name,
+      description: action.description,
+      parameters: {
+        type: "object",
+        properties: action.parameters ? Object.fromEntries(
+          Object.entries(action.parameters).map(([key, param]) => [
+            key,
+            parameterToJsonSchema(param)
+          ])
+        ) : {},
+        required: action.parameters ? Object.entries(action.parameters).filter(([, param]) => param.required).map(([key]) => key) : [],
+        additionalProperties: false
+      }
+    }
+  }));
+}
+function hasImageAttachments(message) {
+  const attachments = message.metadata?.attachments;
+  return attachments?.some((a) => a.type === "image") ?? false;
+}
+function attachmentToOpenAIImage(attachment) {
+  if (attachment.type !== "image") return null;
+  let imageUrl;
+  if (attachment.url) {
+    imageUrl = attachment.url;
+  } else if (attachment.data) {
+    imageUrl = attachment.data.startsWith("data:") ? attachment.data : `data:${attachment.mimeType || "image/png"};base64,${attachment.data}`;
+  } else {
+    return null;
+  }
+  return {
+    type: "image_url",
+    image_url: {
+      url: imageUrl,
+      detail: "auto"
+    }
+  };
+}
+function messageToOpenAIContent(message) {
+  const attachments = message.metadata?.attachments;
+  const content = message.content ?? "";
+  if (!hasImageAttachments(message)) {
+    return content;
+  }
+  const blocks = [];
+  if (content) {
+    blocks.push({ type: "text", text: content });
+  }
+  if (attachments) {
+    for (const attachment of attachments) {
+      const imageBlock = attachmentToOpenAIImage(attachment);
+      if (imageBlock) {
+        blocks.push(imageBlock);
+      }
+    }
+  }
+  return blocks;
+}
+function formatMessagesForOpenAI(messages, systemPrompt) {
+  const formatted = [];
+  if (systemPrompt) {
+    formatted.push({ role: "system", content: systemPrompt });
+  }
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      formatted.push({ role: "system", content: msg.content ?? "" });
+    } else if (msg.role === "user") {
+      formatted.push({
+        role: "user",
+        content: messageToOpenAIContent(msg)
+      });
+    } else if (msg.role === "assistant") {
+      const hasToolCalls = msg.tool_calls && msg.tool_calls.length > 0;
+      const assistantMsg = {
+        role: "assistant",
+        // Gemini/xAI (OpenAI-compatible) reject content: "" on assistant messages with tool_calls
+        content: hasToolCalls ? msg.content || null : msg.content
+      };
+      if (hasToolCalls) {
+        assistantMsg.tool_calls = msg.tool_calls;
+      }
+      formatted.push(assistantMsg);
+    } else if (msg.role === "tool" && msg.tool_call_id) {
+      formatted.push({
+        role: "tool",
+        content: msg.content ?? "",
+        tool_call_id: msg.tool_call_id
+      });
+    }
+  }
+  return formatted;
+}
+
+// src/adapters/openai.ts
+var OpenAIAdapter = class _OpenAIAdapter {
+  constructor(config) {
+    this.config = config;
+    this.model = config.model || "gpt-4o";
+    this.provider = _OpenAIAdapter.resolveProviderName(config.baseUrl);
+  }
+  static resolveProviderName(baseUrl) {
+    if (!baseUrl) return "openai";
+    if (baseUrl.includes("generativelanguage.googleapis.com")) return "google";
+    if (baseUrl.includes("x.ai")) return "xai";
+    if (baseUrl.includes("azure")) return "azure";
+    if (baseUrl.includes("openrouter.ai")) return "openrouter";
+    return "openai";
+  }
+  async getClient() {
+    if (!this.client) {
+      const { default: OpenAI } = await import('openai');
+      this.client = new OpenAI({
+        apiKey: this.config.apiKey,
+        baseURL: this.config.baseUrl
+      });
+    }
+    return this.client;
+  }
+  shouldUseResponsesApi(request) {
+    return request.providerToolOptions?.openai?.nativeToolSearch?.enabled === true && request.providerToolOptions.openai.nativeToolSearch.useResponsesApi !== false && Array.isArray(request.toolDefinitions) && request.toolDefinitions.length > 0;
+  }
+  buildResponsesInput(request) {
+    const sourceMessages = request.rawMessages && request.rawMessages.length > 0 ? request.rawMessages : formatMessagesForOpenAI(request.messages, void 0);
+    const input = [];
+    for (const message of sourceMessages) {
+      if (message.role === "system") {
+        continue;
+      }
+      if (message.role === "assistant") {
+        const content = typeof message.content === "string" ? message.content : Array.isArray(message.content) ? message.content : message.content ? JSON.stringify(message.content) : "";
+        if (content) {
+          input.push({
+            type: "message",
+            role: "assistant",
+            content
+          });
+        }
+        const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+        for (const toolCall of toolCalls) {
+          input.push({
+            type: "function_call",
+            call_id: toolCall.id,
+            name: toolCall.function?.name,
+            arguments: toolCall.function?.arguments ?? "{}"
+          });
+        }
+        continue;
+      }
+      if (message.role === "tool") {
+        input.push({
+          type: "function_call_output",
+          call_id: message.tool_call_id,
+          output: typeof message.content === "string" ? message.content : JSON.stringify(message.content ?? null)
+        });
+        continue;
+      }
+      input.push({
+        type: "message",
+        role: message.role === "developer" ? "developer" : "user",
+        content: typeof message.content === "string" ? message.content : Array.isArray(message.content) ? message.content : JSON.stringify(message.content ?? "")
+      });
+    }
+    return input;
+  }
+  buildResponsesTools(tools) {
+    const nativeTools = tools.filter((tool) => tool.available !== false).map((tool) => ({
+      type: "function",
+      name: tool.name,
+      description: tool.description,
+      parameters: normalizeObjectJsonSchema(
+        tool.inputSchema ?? {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      ),
+      strict: true,
+      defer_loading: tool.deferLoading === true
+    }));
+    return [{ type: "tool_search" }, ...nativeTools];
+  }
+  parseResponsesResult(response) {
+    const content = typeof response?.output_text === "string" ? response.output_text : "";
+    const toolCalls = Array.isArray(response?.output) ? response.output.filter((item) => item?.type === "function_call").map((item) => ({
+      id: item.call_id ?? item.id ?? generateToolCallId(),
+      name: item.name,
+      args: (() => {
+        try {
+          return JSON.parse(item.arguments ?? "{}");
+        } catch {
+          return {};
+        }
+      })()
+    })) : [];
+    return {
+      content,
+      toolCalls,
+      usage: response?.usage ? {
+        promptTokens: response.usage.input_tokens ?? 0,
+        completionTokens: response.usage.output_tokens ?? 0,
+        totalTokens: response.usage.total_tokens ?? (response.usage.input_tokens ?? 0) + (response.usage.output_tokens ?? 0)
+      } : void 0,
+      rawResponse: response
+    };
+  }
+  /**
+   * OpenAI reasoning models on OpenRouter (o1/o3/o4/gpt-5 family) hide their
+   * reasoning content on the chat-completions endpoint. To surface reasoning
+   * SUMMARIES (not raw CoT, which OpenAI never exposes) we have to use the
+   * Responses API, which streams `response.reasoning_summary_text.delta` events.
+   *
+   * Match by prefix on the OpenRouter model id. Excludes openai/gpt-4o,
+   * openai/gpt-4.1, openai/chatgpt-* — those continue on chat-completions.
+   */
+  isOpenAIReasoningModelOnOpenRouter(activeModel) {
+    if (this.provider !== "openrouter") return false;
+    return activeModel.startsWith("openai/o1") || activeModel.startsWith("openai/o3") || activeModel.startsWith("openai/o4") || activeModel.startsWith("openai/gpt-5");
+  }
+  /**
+   * Convert ActionDefinition[] (the chat-completions tool shape used by the
+   * adapter) to the Responses API tool shape.
+   */
+  buildResponsesToolsFromActions(actions) {
+    if (!actions || actions.length === 0) return void 0;
+    const formatted = formatTools(actions);
+    return formatted.map((t) => ({
+      type: "function",
+      name: t.function.name,
+      description: t.function.description,
+      parameters: t.function.parameters
+    }));
+  }
+  /**
+   * Streaming Responses API path for OpenAI reasoning models on OpenRouter.
+   *
+   * Maps Responses API SSE events back to the same StreamEvent shapes the
+   * chat-completions path emits, so downstream consumers (processChunk.ts,
+   * frontend tool handlers, plan approval, specialist delegations) see
+   * identical events regardless of which path produced them.
+   *
+   *   response.reasoning_summary_text.delta  → thinking:start (once) + thinking:delta
+   *   response.output_text.delta             → message:delta
+   *   response.output_item.added (function_call) → action:start (queued buffer)
+   *   response.function_call_arguments.delta → action:args (progressive)
+   *   response.output_item.done (function_call) → final action:args + action:end
+   *   response.completed                     → message:end + done(usage)
+   *   response.error                         → error
+   */
+  async *streamWithResponsesAPI(request, activeModel, messageId) {
+    const client = await this.getClient();
+    const maxTokensValue = request.config?.maxTokens ?? this.config.maxTokens;
+    const payload = {
+      model: activeModel,
+      input: this.buildResponsesInput(request),
+      stream: true,
+      reasoning: {
+        effort: request.config?.reasoningEffort ?? "medium",
+        summary: "auto"
+      }
+    };
+    if (request.systemPrompt) payload.instructions = request.systemPrompt;
+    if (typeof maxTokensValue === "number")
+      payload.max_output_tokens = maxTokensValue;
+    const tools = this.buildResponsesToolsFromActions(request.actions);
+    if (tools && tools.length > 0) payload.tools = tools;
+    logProviderPayload(
+      "openai",
+      "responses-api request payload",
+      payload,
+      request.debug
+    );
+    let stream;
+    try {
+      stream = await client.responses.create(payload);
+    } catch (error) {
+      yield {
+        type: "error",
+        message: error instanceof Error ? error.message : "Unknown error",
+        code: "OPENAI_RESPONSES_ERROR"
+      };
+      return;
+    }
+    const toolBuffers = /* @__PURE__ */ new Map();
+    const itemIdToCallId = /* @__PURE__ */ new Map();
+    let usage;
+    let reasoningStarted = false;
+    let textStarted = false;
+    let finishEmitted = false;
+    const resolveCallId = (evt) => {
+      if (evt?.call_id) return evt.call_id;
+      if (evt?.item_id) return itemIdToCallId.get(evt.item_id) ?? evt.item_id;
+      if (evt?.item?.call_id) return evt.item.call_id;
+      if (evt?.item?.id) return evt.item.id;
+      return "";
+    };
+    try {
+      for await (const evt of stream) {
+        logProviderPayload(
+          "openai",
+          "responses-api stream chunk",
+          evt,
+          request.debug
+        );
+        if (request.signal?.aborted) break;
+        const t = evt?.type ?? "";
+        if (t === "response.reasoning_summary_text.delta") {
+          const delta = evt.delta ?? "";
+          if (!delta) continue;
+          if (!reasoningStarted) {
+            yield { type: "thinking:start" };
+            reasoningStarted = true;
+          }
+          yield { type: "thinking:delta", content: delta };
+          continue;
+        }
+        if (t === "response.reasoning_summary_text.done" || t === "response.reasoning.done") {
+          continue;
+        }
+        if (t === "response.output_text.delta") {
+          const text = evt.delta ?? "";
+          if (!text) continue;
+          if (reasoningStarted && !textStarted) {
+            yield { type: "thinking:end" };
+            textStarted = true;
+          }
+          yield { type: "message:delta", content: text };
+          continue;
+        }
+        if (t === "response.output_item.added") {
+          const item = evt.item;
+          if (item?.type === "function_call") {
+            const callId = item.call_id ?? item.id ?? "";
+            const itemId = item.id ?? callId;
+            if (callId) {
+              if (itemId && itemId !== callId) {
+                itemIdToCallId.set(itemId, callId);
+              }
+              if (!toolBuffers.has(callId)) {
+                toolBuffers.set(callId, {
+                  id: callId,
+                  name: item.name ?? "",
+                  arguments: item.arguments ?? "",
+                  emittedStart: false
+                });
+              }
+              const buf = toolBuffers.get(callId);
+              if (buf.name && !buf.emittedStart) {
+                yield { type: "action:start", id: buf.id, name: buf.name };
+                buf.emittedStart = true;
+              }
+            }
+          }
+          continue;
+        }
+        if (t === "response.function_call_arguments.delta") {
+          const callId = resolveCallId(evt);
+          const delta = evt.delta ?? "";
+          if (!callId || !delta) continue;
+          let buf = toolBuffers.get(callId);
+          if (!buf) {
+            buf = { id: callId, name: "", arguments: "", emittedStart: false };
+            toolBuffers.set(callId, buf);
+          }
+          buf.arguments += delta;
+          if (buf.emittedStart) {
+            yield {
+              type: "action:args",
+              id: buf.id,
+              args: buf.arguments
+            };
+          }
+          continue;
+        }
+        if (t === "response.output_item.done") {
+          const item = evt.item;
+          if (item?.type === "function_call") {
+            const callId = item.call_id ?? item.id ?? "";
+            const buf = toolBuffers.get(callId);
+            const name = buf?.name || item.name || "";
+            const argsStr = buf?.arguments || item.arguments || "{}";
+            if (callId && name) {
+              if (!buf?.emittedStart) {
+                yield { type: "action:start", id: callId, name };
+              }
+              yield {
+                type: "action:args",
+                id: callId,
+                args: argsStr
+              };
+              yield {
+                type: "action:end",
+                id: callId,
+                name
+              };
+            }
+            toolBuffers.delete(callId);
+          }
+          continue;
+        }
+        if (t === "response.completed") {
+          const u = evt.response?.usage;
+          if (u) {
+            usage = {
+              prompt_tokens: u.input_tokens ?? 0,
+              completion_tokens: u.output_tokens ?? 0,
+              total_tokens: u.total_tokens ?? (u.input_tokens ?? 0) + (u.output_tokens ?? 0)
+            };
+          }
+          for (const buf of toolBuffers.values()) {
+            if (!buf.id || !buf.name) continue;
+            if (!buf.emittedStart) {
+              yield { type: "action:start", id: buf.id, name: buf.name };
+            }
+            yield {
+              type: "action:args",
+              id: buf.id,
+              args: buf.arguments || "{}"
+            };
+            yield { type: "action:end", id: buf.id, name: buf.name };
+          }
+          toolBuffers.clear();
+          if (reasoningStarted && !textStarted) {
+            yield { type: "thinking:end" };
+          }
+          yield { type: "message:end" };
+          yield { type: "done", usage };
+          finishEmitted = true;
+          continue;
+        }
+        if (t === "response.error" || t === "error") {
+          const msg = evt.error?.message || evt.message || "Responses API error";
+          yield {
+            type: "error",
+            message: msg,
+            code: "OPENAI_RESPONSES_ERROR"
+          };
+          return;
+        }
+      }
+    } catch (error) {
+      yield {
+        type: "error",
+        message: error instanceof Error ? error.message : "Unknown error",
+        code: "OPENAI_RESPONSES_ERROR"
+      };
+      return;
+    }
+    if (!finishEmitted) {
+      if (reasoningStarted && !textStarted) {
+        yield { type: "thinking:end" };
+      }
+      yield { type: "message:end" };
+      yield { type: "done", usage };
+    }
+  }
+  async completeWithResponses(request) {
+    const client = await this.getClient();
+    const openaiToolOptions = request.providerToolOptions?.openai;
+    const payload = {
+      model: request.config?.model || this.model,
+      instructions: request.systemPrompt,
+      input: this.buildResponsesInput(request),
+      tools: this.buildResponsesTools(request.toolDefinitions ?? []),
+      tool_choice: openaiToolOptions?.toolChoice === "required" ? "required" : openaiToolOptions?.toolChoice === "auto" ? "auto" : void 0,
+      parallel_tool_calls: openaiToolOptions?.parallelToolCalls,
+      temperature: request.config?.temperature ?? this.config.temperature,
+      max_output_tokens: request.config?.maxTokens ?? this.config.maxTokens,
+      stream: false
+    };
+    logProviderPayload("openai", "request payload", payload, request.debug);
+    const response = await client.responses.create(payload);
+    logProviderPayload("openai", "response payload", response, request.debug);
+    return this.parseResponsesResult(response);
+  }
+  async *stream(request) {
+    if (this.shouldUseResponsesApi(request)) {
+      const messageId2 = generateMessageId();
+      yield { type: "message:start", id: messageId2 };
+      try {
+        const result = await this.completeWithResponses(request);
+        if (result.content) {
+          yield { type: "message:delta", content: result.content };
+        }
+        for (const toolCall of result.toolCalls) {
+          yield {
+            type: "action:start",
+            id: toolCall.id,
+            name: toolCall.name
+          };
+          yield {
+            type: "action:args",
+            id: toolCall.id,
+            args: JSON.stringify(toolCall.args)
+          };
+        }
+        yield { type: "message:end" };
+        yield {
+          type: "done",
+          usage: result.usage ? {
+            prompt_tokens: result.usage.promptTokens,
+            completion_tokens: result.usage.completionTokens,
+            total_tokens: result.usage.totalTokens
+          } : void 0
+        };
+        return;
+      } catch (error) {
+        yield {
+          type: "error",
+          message: error instanceof Error ? error.message : "Unknown error",
+          code: "OPENAI_RESPONSES_ERROR"
+        };
+        return;
+      }
+    }
+    const client = await this.getClient();
+    let messages;
+    if (request.rawMessages && request.rawMessages.length > 0) {
+      const processedMessages = request.rawMessages.map((msg) => {
+        if (msg.role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0 && msg.content === "") {
+          return { ...msg, content: null };
+        }
+        const hasAttachments = msg.attachments && Array.isArray(msg.attachments) && msg.attachments.length > 0;
+        if (hasAttachments) {
+          const content = [];
+          if (msg.content) {
+            content.push({ type: "text", text: msg.content });
+          }
+          for (const attachment of msg.attachments) {
+            if (attachment.type === "image") {
+              let imageUrl;
+              if (attachment.url) {
+                imageUrl = attachment.url;
+              } else if (attachment.data) {
+                imageUrl = attachment.data.startsWith("data:") ? attachment.data : `data:${attachment.mimeType || "image/png"};base64,${attachment.data}`;
+              } else {
+                continue;
+              }
+              content.push({
+                type: "image_url",
+                image_url: { url: imageUrl, detail: "auto" }
+              });
+            }
+          }
+          return { ...msg, content, attachments: void 0 };
+        }
+        return msg;
+      });
+      if (request.systemPrompt) {
+        const hasSystem = processedMessages.some((m) => m.role === "system");
+        if (!hasSystem) {
+          messages = [
+            { role: "system", content: request.systemPrompt },
+            ...processedMessages
+          ];
+        } else {
+          messages = processedMessages;
+        }
+      } else {
+        messages = processedMessages;
+      }
+    } else {
+      messages = formatMessagesForOpenAI(
+        request.messages,
+        request.systemPrompt
+      );
+    }
+    const tools = request.actions?.length ? formatTools(request.actions) : [];
+    const webSearchConfig = request.webSearch ?? this.config.webSearch;
+    if (webSearchConfig) {
+      const webSearchTool = {
+        type: "web_search_preview"
+      };
+      const wsConfig = typeof webSearchConfig === "object" ? webSearchConfig : {};
+      if (wsConfig.userLocation) {
+        webSearchTool.search_context_size = "medium";
+      }
+      tools.push(webSearchTool);
+    }
+    const messageId = generateMessageId();
+    yield { type: "message:start", id: messageId };
+    try {
+      const openaiToolOptions = request.providerToolOptions?.openai;
+      const toolChoice = openaiToolOptions?.toolChoice && typeof openaiToolOptions.toolChoice === "object" ? {
+        type: "function",
+        function: {
+          name: openaiToolOptions.toolChoice.name
+        }
+      } : openaiToolOptions?.toolChoice;
+      const isOpenRouter = this.provider === "openrouter";
+      const activeModel = request.config?.model || this.model;
+      const modelSlug = activeModel.replace("openai/", "");
+      const isOSeries = /^o[1-9]/.test(modelSlug);
+      const isOpenAIOnOpenRouter = isOpenRouter && activeModel.startsWith("openai/");
+      if (!this.config.disableThinking && this.isOpenAIReasoningModelOnOpenRouter(activeModel)) {
+        yield* this.streamWithResponsesAPI(request, activeModel, messageId);
+        return;
+      }
+      const maxTokensValue = request.config?.maxTokens ?? this.config.maxTokens;
+      const payload = {
+        model: activeModel,
+        messages,
+        tools: tools.length > 0 ? tools : void 0,
+        tool_choice: tools.length > 0 ? toolChoice : void 0,
+        parallel_tool_calls: tools.length > 0 ? openaiToolOptions?.parallelToolCalls : void 0,
+        stream: true,
+        stream_options: { include_usage: true },
+        // o-series: use max_completion_tokens + reasoning_effort, no temperature
+        // regular models: use max_tokens + temperature
+        ...isOSeries ? {
+          max_completion_tokens: maxTokensValue,
+          reasoning_effort: request.config?.reasoningEffort ?? "medium"
+        } : {
+          temperature: request.config?.temperature ?? this.config.temperature,
+          max_tokens: maxTokensValue
+        },
+        // Non-OpenAI OpenRouter models support OR's reasoning/include_reasoning params.
+        // When disableThinking=true we must explicitly send include_reasoning:false because
+        // models like Qwen3 and DeepSeek-R1 reason by default even without the reasoning param.
+        ...isOpenRouter && !isOpenAIOnOpenRouter ? this.config.disableThinking ? { include_reasoning: false } : { reasoning: { max_tokens: 8e3 }, include_reasoning: true } : {}
+      };
+      logProviderPayload("openai", "request payload", payload, request.debug);
+      const stream = await client.chat.completions.create(payload);
+      let currentToolCall = null;
+      const collectedCitations = [];
+      let citationIndex = 0;
+      let usage;
+      let adapterReasoningStarted = false;
+      for await (const chunk of stream) {
+        logProviderPayload("openai", "stream chunk", chunk, request.debug);
+        if (request.signal?.aborted) {
+          break;
+        }
+        const delta = chunk.choices[0]?.delta;
+        const choice = chunk.choices[0];
+        if (delta?.content) {
+          yield { type: "message:delta", content: delta.content };
+        }
+        if (isOpenRouter) {
+          const rc = delta?.reasoning_content ?? delta?.reasoning ?? null;
+          if (rc) {
+            const rcText = typeof rc === "string" ? rc : Array.isArray(rc) && rc[0]?.text ? rc[0].text : "";
+            if (rcText) {
+              if (!adapterReasoningStarted) {
+                yield { type: "thinking:start" };
+                adapterReasoningStarted = true;
+              }
+              yield { type: "thinking:delta", content: rcText };
+            }
+          } else if (adapterReasoningStarted && (delta?.content || choice?.finish_reason)) {
+            yield { type: "thinking:end" };
+            adapterReasoningStarted = false;
+          }
+        }
+        const annotations = delta?.annotations;
+        if (annotations && annotations.length > 0) {
+          for (const annotation of annotations) {
+            if (annotation.type === "url_citation" && annotation.url_citation?.url) {
+              citationIndex++;
+              const url = annotation.url_citation.url;
+              const domain = extractDomain(url);
+              collectedCitations.push({
+                index: citationIndex,
+                url,
+                title: annotation.url_citation.title || domain,
+                domain,
+                favicon: domain ? `https://www.google.com/s2/favicons?domain=${domain}&sz=32` : void 0
+              });
+            }
+          }
+        }
+        if (delta?.tool_calls) {
+          for (const toolCall of delta.tool_calls) {
+            if (toolCall.id) {
+              if (currentToolCall) {
+                yield {
+                  type: "action:args",
+                  id: currentToolCall.id,
+                  args: currentToolCall.arguments
+                };
+                yield {
+                  type: "action:end",
+                  id: currentToolCall.id,
+                  name: currentToolCall.name
+                };
+              }
+              const tcExtraContent = toolCall.extra_content;
+              currentToolCall = {
+                id: toolCall.id,
+                name: toolCall.function?.name || "",
+                arguments: toolCall.function?.arguments || "",
+                ...tcExtraContent ? { extra_content: tcExtraContent } : {}
+              };
+              yield {
+                type: "action:start",
+                id: currentToolCall.id,
+                name: currentToolCall.name,
+                ...currentToolCall.extra_content ? { extra_content: currentToolCall.extra_content } : {}
+              };
+            } else if (currentToolCall && toolCall.function?.arguments) {
+              currentToolCall.arguments += toolCall.function.arguments;
+              yield {
+                type: "action:args",
+                id: currentToolCall.id,
+                args: currentToolCall.arguments
+              };
+            }
+          }
+        }
+        if (chunk.usage) {
+          usage = {
+            prompt_tokens: chunk.usage.prompt_tokens,
+            completion_tokens: chunk.usage.completion_tokens,
+            total_tokens: chunk.usage.total_tokens
+          };
+        }
+        if (choice?.finish_reason) {
+          if (currentToolCall) {
+            yield {
+              type: "action:args",
+              id: currentToolCall.id,
+              args: currentToolCall.arguments
+            };
+            yield {
+              type: "action:end",
+              id: currentToolCall.id,
+              name: currentToolCall.name
+            };
+            currentToolCall = null;
+          }
+        }
+      }
+      if (collectedCitations.length > 0) {
+        const uniqueCitations = deduplicateCitations(collectedCitations);
+        yield { type: "citation", citations: uniqueCitations };
+      }
+      yield { type: "message:end" };
+      yield { type: "done", usage };
+    } catch (error) {
+      yield {
+        type: "error",
+        message: error instanceof Error ? error.message : "Unknown error",
+        code: `${this.provider.toUpperCase()}_ERROR`
+      };
+    }
+  }
+  async complete(request) {
+    if (this.shouldUseResponsesApi(request)) {
+      return this.completeWithResponses(request);
+    }
+    const client = await this.getClient();
+    let messages;
+    if (request.rawMessages && request.rawMessages.length > 0) {
+      const sanitized = request.rawMessages.map((msg) => {
+        if (msg.role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0 && msg.content === "") {
+          return { ...msg, content: null };
+        }
+        return msg;
+      });
+      if (request.systemPrompt && !sanitized.some((message2) => message2.role === "system")) {
+        messages = [
+          { role: "system", content: request.systemPrompt },
+          ...sanitized
+        ];
+      } else {
+        messages = sanitized;
+      }
+    } else {
+      messages = formatMessagesForOpenAI(
+        request.messages,
+        request.systemPrompt
+      );
+    }
+    const tools = request.actions?.length ? formatTools(request.actions) : [];
+    const openaiToolOptions = request.providerToolOptions?.openai;
+    const toolChoice = openaiToolOptions?.toolChoice && typeof openaiToolOptions.toolChoice === "object" ? {
+      type: "function",
+      function: {
+        name: openaiToolOptions.toolChoice.name
+      }
+    } : openaiToolOptions?.toolChoice;
+    const activeModel2 = request.config?.model || this.model;
+    const modelSlug2 = activeModel2.replace("openai/", "");
+    const isOSeries2 = /^o[1-9]/.test(modelSlug2);
+    const maxTokensValue2 = request.config?.maxTokens ?? this.config.maxTokens;
+    const payload = {
+      model: activeModel2,
+      messages,
+      tools: tools.length > 0 ? tools : void 0,
+      tool_choice: tools.length > 0 ? toolChoice : void 0,
+      parallel_tool_calls: tools.length > 0 ? openaiToolOptions?.parallelToolCalls : void 0,
+      stream: false,
+      ...isOSeries2 ? {
+        max_completion_tokens: maxTokensValue2,
+        reasoning_effort: request.config?.reasoningEffort ?? "medium"
+      } : {
+        temperature: request.config?.temperature ?? this.config.temperature,
+        max_tokens: maxTokensValue2
+      }
+    };
+    logProviderPayload("openai", "request payload", payload, request.debug);
+    const response = await client.chat.completions.create(payload);
+    logProviderPayload("openai", "response payload", response, request.debug);
+    const choice = response.choices?.[0];
+    const message = choice?.message;
+    return {
+      content: message?.content ?? "",
+      toolCalls: message?.tool_calls?.map((toolCall) => ({
+        id: toolCall.id ?? generateToolCallId(),
+        name: toolCall.function?.name ?? "",
+        args: (() => {
+          try {
+            return JSON.parse(toolCall.function?.arguments ?? "{}");
+          } catch {
+            return {};
+          }
+        })(),
+        ...toolCall.extra_content ? { extra_content: toolCall.extra_content } : {}
+      })) ?? [],
+      usage: response.usage ? {
+        promptTokens: response.usage.prompt_tokens,
+        completionTokens: response.usage.completion_tokens,
+        totalTokens: response.usage.total_tokens
+      } : void 0,
+      rawResponse: response
+    };
+  }
+};
+function extractDomain(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.hostname;
+  } catch {
+    return "";
+  }
+}
+function deduplicateCitations(citations) {
+  const seen = /* @__PURE__ */ new Map();
+  let index = 0;
+  for (const citation of citations) {
+    if (!seen.has(citation.url)) {
+      index++;
+      seen.set(citation.url, { ...citation, index });
+    }
+  }
+  return Array.from(seen.values());
+}
+function createOpenAIAdapter(config) {
+  return new OpenAIAdapter(config);
+}
+
+// src/providers/types.ts
+function createCallableProvider(providerFn, properties) {
+  Object.defineProperty(providerFn, "name", {
+    value: properties.name,
+    writable: false,
+    configurable: true
+  });
+  Object.assign(providerFn, {
+    supportedModels: properties.supportedModels,
+    languageModel: providerFn,
+    getCapabilities: properties.getCapabilities,
+    embeddingModel: properties.embeddingModel
+  });
+  return providerFn;
+}
+
+// src/providers/togetherai/index.ts
+var DEFAULT_CAPABILITIES = {
+  vision: true,
+  tools: true,
+  jsonMode: true,
+  maxTokens: 131072
+};
+function createTogetherAI(config = {}) {
+  const apiKey = config.apiKey ?? process.env.TOGETHER_API_KEY ?? "";
+  const baseUrl = config.baseUrl ?? "https://api.together.xyz/v1";
+  const providerFn = (modelId) => {
+    return createOpenAIAdapter({
+      apiKey,
+      model: modelId,
+      baseUrl
+    });
+  };
+  const getCapabilities = (_modelId) => {
+    return {
+      supportsVision: DEFAULT_CAPABILITIES.vision,
+      supportsTools: DEFAULT_CAPABILITIES.tools,
+      supportsThinking: false,
+      supportsStreaming: true,
+      supportsPDF: false,
+      supportsAudio: false,
+      supportsVideo: false,
+      maxTokens: DEFAULT_CAPABILITIES.maxTokens,
+      supportedImageTypes: ["image/png", "image/jpeg", "image/gif", "image/webp"] ,
+      supportsJsonMode: DEFAULT_CAPABILITIES.jsonMode,
+      supportsSystemMessages: true
+    };
+  };
+  return createCallableProvider(providerFn, {
+    name: "togetherai",
+    supportedModels: [],
+    getCapabilities
+  });
+}
+var createTogetherAIProvider = createTogetherAI;
+
+export { createTogetherAI, createTogetherAIProvider, togetherai };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map