@yourgpt/llm-sdk 2.1.5 → 2.1.6

package/dist/providers/xai/index.js

@@ -241,6 +241,9 @@ function generateId(prefix = "id") {
 function generateMessageId() {
   return generateId("msg");
 }
+function generateToolCallId() {
+  return generateId("call");
+}
 
 // src/adapters/base.ts
 function stringifyForDebug(value) {
@@ -309,6 +312,40 @@ function parameterToJsonSchema(param) {
   }
   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",
@@ -385,11 +422,13 @@ function formatMessagesForOpenAI(messages, systemPrompt) {
         content: messageToOpenAIContent(msg)
       });
     } else if (msg.role === "assistant") {
+      const hasToolCalls = msg.tool_calls && msg.tool_calls.length > 0;
       const assistantMsg = {
         role: "assistant",
-        content: msg.content
+        // Gemini/xAI (OpenAI-compatible) reject content: "" on assistant messages with tool_calls
+        content: hasToolCalls ? msg.content || null : msg.content
       };
-      if (msg.tool_calls && msg.tool_calls.length > 0) {
+      if (hasToolCalls) {
         assistantMsg.tool_calls = msg.tool_calls;
       }
       formatted.push(assistantMsg);
@@ -404,29 +443,183 @@ function formatMessagesForOpenAI(messages, systemPrompt) {
   return formatted;
 }
 
-// src/adapters/xai.ts
-var XAI_BASE_URL = "https://api.x.ai/v1";
-var XAIAdapter = class {
+// src/adapters/openai.ts
+var OpenAIAdapter = class _OpenAIAdapter {
   constructor(config) {
-    this.provider = "xai";
     this.config = config;
-    this.model = config.model || "grok-2";
+    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";
+    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 || XAI_BASE_URL
+        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
+    };
+  }
+  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 = [];
@@ -435,9 +628,13 @@ var XAIAdapter = class {
           }
           for (const attachment of msg.attachments) {
             if (attachment.type === "image") {
-              let imageUrl = attachment.data;
-              if (!imageUrl.startsWith("data:")) {
-                imageUrl = `data:${attachment.mimeType || "image/png"};base64,${attachment.data}`;
+              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",
@@ -468,30 +665,72 @@ var XAIAdapter = class {
         request.systemPrompt
       );
     }
-    const tools = request.actions?.length ? formatTools(request.actions) : void 0;
+    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 payload = {
         model: request.config?.model || this.model,
         messages,
-        tools,
+        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,
         temperature: request.config?.temperature ?? this.config.temperature,
         max_tokens: request.config?.maxTokens ?? this.config.maxTokens,
-        stream: true
+        stream: true,
+        stream_options: { include_usage: true }
       };
-      logProviderPayload("xai", "request payload", payload, request.debug);
+      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;
       for await (const chunk of stream) {
-        logProviderPayload("xai", "stream chunk", chunk, request.debug);
+        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 };
         }
+        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) {
@@ -502,22 +741,32 @@ var XAIAdapter = class {
                   args: currentToolCall.arguments
                 };
               }
+              const tcExtraContent = toolCall.extra_content;
               currentToolCall = {
                 id: toolCall.id,
                 name: toolCall.function?.name || "",
-                arguments: toolCall.function?.arguments || ""
+                arguments: toolCall.function?.arguments || "",
+                ...tcExtraContent ? { extra_content: tcExtraContent } : {}
               };
               yield {
                 type: "action:start",
                 id: currentToolCall.id,
-                name: currentToolCall.name
+                name: currentToolCall.name,
+                ...currentToolCall.extra_content ? { extra_content: currentToolCall.extra_content } : {}
               };
             } else if (currentToolCall && toolCall.function?.arguments) {
               currentToolCall.arguments += toolCall.function.arguments;
             }
           }
         }
-        if (chunk.choices[0]?.finish_reason) {
+        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",
@@ -527,32 +776,40 @@ var XAIAdapter = class {
           }
         }
       }
+      if (collectedCitations.length > 0) {
+        const uniqueCitations = deduplicateCitations(collectedCitations);
+        yield { type: "citation", citations: uniqueCitations };
+      }
       yield { type: "message:end" };
-      yield { type: "done" };
+      yield { type: "done", usage };
     } catch (error) {
       yield {
         type: "error",
         message: error instanceof Error ? error.message : "Unknown error",
-        code: "XAI_ERROR"
+        code: `${this.provider.toUpperCase()}_ERROR`
       };
     }
   }
-  /**
-   * Non-streaming completion (optional, for debugging)
-   */
   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) {
-      messages = request.rawMessages;
-      if (request.systemPrompt) {
-        const hasSystem = messages.some((m) => m.role === "system");
-        if (!hasSystem) {
-          messages = [
-            { role: "system", content: request.systemPrompt },
-            ...messages
-          ];
+      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(
@@ -560,33 +817,85 @@ var XAIAdapter = class {
         request.systemPrompt
       );
     }
-    const tools = request.actions?.length ? formatTools(request.actions) : void 0;
+    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 payload = {
       model: request.config?.model || this.model,
       messages,
-      tools,
+      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,
       temperature: request.config?.temperature ?? this.config.temperature,
-      max_tokens: request.config?.maxTokens ?? this.config.maxTokens
+      max_tokens: request.config?.maxTokens ?? this.config.maxTokens,
+      stream: false
     };
-    logProviderPayload("xai", "request payload", payload, request.debug);
+    logProviderPayload("openai", "request payload", payload, request.debug);
     const response = await client.chat.completions.create(payload);
-    logProviderPayload("xai", "response payload", response, request.debug);
-    const choice = response.choices[0];
+    logProviderPayload("openai", "response payload", response, request.debug);
+    const choice = response.choices?.[0];
     const message = choice?.message;
-    const toolCalls = (message?.tool_calls || []).map((tc) => ({
-      id: tc.id,
-      name: tc.function.name,
-      args: JSON.parse(tc.function.arguments || "{}")
-    }));
     return {
-      content: message?.content || "",
-      toolCalls,
+      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/adapters/xai.ts
+var XAI_BASE_URL = "https://api.x.ai/v1";
 function createXAIAdapter(config) {
-  return new XAIAdapter(config);
+  return createOpenAIAdapter({
+    apiKey: config.apiKey,
+    model: config.model || "grok-3",
+    baseUrl: config.baseUrl || XAI_BASE_URL,
+    temperature: config.temperature,
+    maxTokens: config.maxTokens
+  });
 }
 
 // src/providers/types.ts