@yourgpt/llm-sdk 2.6.0-beta.2 → 2.6.0

package/dist/providers/fireworks/index.d.mts

@@ -1,7 +1,7 @@
-import { L as LanguageModel } from '../../types-Dg1Bcg1k.mjs';
-import { A as AIProvider } from '../../types-DHQEMFHA.mjs';
+import { L as LanguageModel } from '../../types-D7lzMMLu.mjs';
+import { A as AIProvider } from '../../types-C7_qVSSd.mjs';
 import 'zod';
-import '../../base-BICaQaRS.mjs';
+import '../../base-DySbTP8C.mjs';
 
 /**
  * Fireworks Provider

package/dist/providers/fireworks/index.d.ts

@@ -1,7 +1,7 @@
-import { L as LanguageModel } from '../../types-Dg1Bcg1k.js';
-import { A as AIProvider } from '../../types-Dikj3En4.js';
+import { L as LanguageModel } from '../../types-D7lzMMLu.js';
+import { A as AIProvider } from '../../types-BXQMtaCX.js';
 import 'zod';
-import '../../base-CpRPB8u8.js';
+import '../../base-6LzczuCg.js';
 
 /**
  * Fireworks Provider

package/dist/providers/fireworks/index.js

@@ -113,6 +113,19 @@ function capabilities(model) {
   const supportsNone = major === 5 && minor >= 1 && !chat || /^gpt-6-(?:sol|luna)(?:-\d{4}-\d{2}-\d{2})?$/i.test(model);
   return { major, minor, reasoning, supportsNone };
 }
+function filterOpenAIResponseInclude(model, include, options = {}) {
+  const c = capabilities(model);
+  let result = include;
+  if (options.parameterPolicy !== "passthrough" && c.reasoning && !(options.reasoningEffort === "none" && c.supportsNone) && include.includes("message.output_text.logprobs")) {
+    result = include.filter(
+      (value) => value !== "message.output_text.logprobs"
+    );
+    (options.onWarning ?? console.warn)(
+      `[llm-sdk] ${model}: omitted message.output_text.logprobs because reasoning is enabled.`
+    );
+  }
+  return result.length ? result : void 0;
+}
 function requiresOpenAIResponses(model, baseUrl, options = {}) {
   if (options.parameterPolicy === "passthrough") return false;
   const c = capabilities(model);
@@ -274,6 +287,7 @@ function toOpenAIResponseFormat(rf) {
   };
 }
 function toOpenAIResponsesTextFormat(rf) {
+  if (rf?.type === "json_object") return { type: "json_object" };
   if (!rf || rf.type !== "json_schema") return void 0;
   return {
     type: "json_schema",
@@ -588,6 +602,63 @@ function formatMessages(messages) {
   });
 }
 
+// src/core/provider-error.ts
+function invalidProviderResponse(message) {
+  return Object.assign(new Error(message), {
+    name: "InvalidProviderResponseError",
+    status: 502,
+    code: "INVALID_PROVIDER_RESPONSE"
+  });
+}
+function providerErrorEvent(error, code) {
+  const details = error ?? {};
+  const event = {
+    type: "error",
+    message: error instanceof Error ? error.message : String(error),
+    code,
+    ...typeof details.status === "number" ? { status: details.status } : {},
+    ...typeof details.code === "string" ? { providerCode: details.code } : {},
+    ...typeof details.param === "string" ? { param: details.param } : {},
+    ...typeof details.request_id === "string" ? { requestId: details.request_id } : {}
+  };
+  Object.defineProperty(event, "cause", { value: error, enumerable: false });
+  return event;
+}
+function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  throw error;
+}
+
+// src/core/tool-validation.ts
+function parseToolArguments(value) {
+  let args = value;
+  if (typeof value === "string") {
+    try {
+      args = JSON.parse(value || "{}");
+    } catch {
+      throw invalidProviderResponse("Tool arguments are not valid JSON");
+    }
+  }
+  if (args === null || typeof args !== "object" || Array.isArray(args))
+    throw invalidProviderResponse("Tool arguments must be a JSON object");
+  return args;
+}
+function validateToolCalls(calls) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const call of calls) {
+    if (!call || typeof call.id !== "string" || !call.id || typeof call.name !== "string" || !call.name || ids.has(call.id))
+      throw invalidProviderResponse(
+        "Tool calls have missing or duplicate identities"
+      );
+    ids.add(call.id);
+    if (typeof call.args === "string")
+      throw invalidProviderResponse("Parsed tool arguments must be an object");
+    parseToolArguments(call.args);
+  }
+}
+
 // src/core/openai-responses.ts
 function resolveOpenAITransport(defaults, overrides) {
   return {
@@ -635,6 +706,54 @@ function responseMetadata(response) {
     }
   };
 }
+function responseReplayMetadata(metadata) {
+  const response = metadata?.openai?.response;
+  if (!response) return metadata;
+  const output = response.output.map((item) => {
+    const fields = ["type", "id", "status"];
+    switch (item.type) {
+      case "reasoning":
+        fields.push("encrypted_content");
+        break;
+      case "message":
+        fields.push("role", "phase");
+        break;
+      case "function_call":
+        fields.push("call_id", "name", "namespace", "arguments");
+        break;
+      case "tool_search_call":
+        fields.push("call_id", "execution", "arguments");
+        break;
+      case "tool_search_output":
+        fields.push("call_id", "tools");
+        break;
+      case "web_search_call":
+        fields.push("action");
+        break;
+      default:
+        return stripItemDiagnostics(item);
+    }
+    const replay = Object.fromEntries(
+      fields.filter((key) => item[key] !== void 0).map((key) => [key, item[key]])
+    );
+    if (item.type === "reasoning") replay.summary = [];
+    if (item.type === "message")
+      replay.content = Array.isArray(item.content) ? item.content.flatMap(
+        (part) => part?.type === "output_text" && typeof part.text === "string" ? [{ type: "output_text", text: part.text, annotations: [] }] : part?.type === "refusal" && typeof part.refusal === "string" ? [{ type: "refusal", refusal: part.refusal }] : []
+      ) : [];
+    return stripItemDiagnostics(replay);
+  });
+  return { openai: { response: { output, refusals: [] } } };
+}
+function stripItemDiagnostics(item) {
+  const {
+    usage: _usage,
+    logprobs: _logprobs,
+    metadata: _metadata,
+    ...state
+  } = item;
+  return state;
+}
 function getResponseReplay(metadata) {
   const response = metadata?.openai?.response;
   if (response === void 0) return void 0;
@@ -643,29 +762,7 @@ function getResponseReplay(metadata) {
       "Invalid OpenAI Responses replay metadata: output must contain typed items"
     );
   }
-  return response.output;
-}
-
-// src/core/provider-error.ts
-function providerErrorEvent(error, code) {
-  const details = error ?? {};
-  const event = {
-    type: "error",
-    message: error instanceof Error ? error.message : String(error),
-    code,
-    ...typeof details.status === "number" ? { status: details.status } : {},
-    ...typeof details.code === "string" ? { providerCode: details.code } : {},
-    ...typeof details.param === "string" ? { param: details.param } : {},
-    ...typeof details.request_id === "string" ? { requestId: details.request_id } : {}
-  };
-  Object.defineProperty(event, "cause", { value: error, enumerable: false });
-  return event;
-}
-function throwIfAborted(signal) {
-  if (!signal?.aborted) return;
-  const error = new Error("The operation was aborted");
-  error.name = "AbortError";
-  throw error;
+  return responseReplayMetadata(metadata)?.openai?.response?.output;
 }
 
 // src/core/utils.ts
@@ -675,9 +772,6 @@ function generateId(prefix = "id") {
 function generateMessageId() {
   return generateId("msg");
 }
-function generateToolCallId() {
-  return generateId("call");
-}
 
 // src/adapters/openai.ts
 var OpenAIAdapter = class _OpenAIAdapter {
@@ -701,6 +795,8 @@ var OpenAIAdapter = class _OpenAIAdapter {
         apiKey: this.config.apiKey,
         baseURL: this.config.baseUrl,
         organization: this.config.organization,
+        project: this.config.project,
+        timeout: this.config.timeout,
         defaultHeaders: this.config.headers
       });
     }
@@ -823,7 +919,7 @@ var OpenAIAdapter = class _OpenAIAdapter {
   formatRawMessages(messages, preserveProviderMetadata = false) {
     return messages.map((message) => {
       const { attachments, providerMetadata, modelOutput, ...rest } = message;
-      let content = message.role === "tool" && !preserveProviderMetadata ? textToolOutput(modelOutput, String(message.content ?? "")) : message.content;
+      let content = message.role === "tool" && !preserveProviderMetadata && modelOutput !== void 0 ? textToolOutput(modelOutput, "") : message.content;
       if (preserveProviderMetadata && modelOutput)
         rest.modelOutput = modelOutput;
       if (message.role === "assistant" && Array.isArray(message.tool_calls) && message.tool_calls.length > 0 && content === "") {
@@ -926,17 +1022,32 @@ var OpenAIAdapter = class _OpenAIAdapter {
     const seenCallIds = /* @__PURE__ */ new Set();
     const toolCalls = Array.isArray(response?.output) ? response.output.filter((item) => item?.type === "function_call").map((item) => {
       if (typeof item.call_id !== "string" || !item.call_id || typeof item.name !== "string" || !item.name || typeof item.arguments !== "string" || item.status && item.status !== "completed") {
-        throw new Error("Responses contains an incomplete function call");
+        throw invalidProviderResponse(
+          "Responses contains an incomplete function call"
+        );
       }
       if (seenCallIds.has(item.call_id))
-        throw new Error("Responses contains duplicate function call IDs");
+        throw invalidProviderResponse(
+          "Responses contains duplicate function call IDs"
+        );
       seenCallIds.add(item.call_id);
-      const args = JSON.parse(item.arguments);
+      let args;
+      try {
+        args = JSON.parse(item.arguments);
+      } catch {
+        throw invalidProviderResponse(
+          "Responses function arguments must be valid JSON"
+        );
+      }
       if (!args || typeof args !== "object" || Array.isArray(args))
-        throw new Error(
+        throw invalidProviderResponse(
           "Responses function arguments must be a JSON object"
         );
-      return { id: item.call_id, name: item.name, args };
+      return {
+        id: item.call_id,
+        name: item.name,
+        args
+      };
     }) : [];
     return {
       content,
@@ -967,6 +1078,16 @@ var OpenAIAdapter = class _OpenAIAdapter {
       request.config?.responseFormat
     );
     const modelIdForPayload = request.config?.model || this.model;
+    const include = filterOpenAIResponseInclude(
+      modelIdForPayload,
+      [
+        .../* @__PURE__ */ new Set([
+          ...options?.include ?? [],
+          ...options?.store === false ? ["reasoning.encrypted_content"] : []
+        ])
+      ],
+      this.parameterOptions(request)
+    );
     const payload = {
       model: modelIdForPayload,
       instructions: request.systemPrompt,
@@ -990,14 +1111,7 @@ var OpenAIAdapter = class _OpenAIAdapter {
       ...options?.promptCacheKey !== void 0 ? { prompt_cache_key: options.promptCacheKey } : {},
       ...options?.promptCacheOptions !== void 0 ? { prompt_cache_options: options.promptCacheOptions } : {},
       ...options?.promptCacheRetention !== void 0 ? { prompt_cache_retention: options.promptCacheRetention } : {},
-      ...options?.store === false || options?.include ? {
-        include: [
-          .../* @__PURE__ */ new Set([
-            ...options?.include ?? [],
-            ...options?.store === false ? ["reasoning.encrypted_content"] : []
-          ])
-        ]
-      } : {},
+      ...include ? { include } : {},
       ...responsesTextFormat ? { text: { format: responsesTextFormat } } : {},
       stream
     };
@@ -1179,7 +1293,9 @@ var OpenAIAdapter = class _OpenAIAdapter {
     const uniqueCalls = /* @__PURE__ */ new Map();
     for (const call of toolCalls.values()) {
       if (!call.id || !call.name)
-        throw new Error("Responses stream contains an incomplete tool call");
+        throw invalidProviderResponse(
+          "Responses stream contains an incomplete tool call"
+        );
       uniqueCalls.set(call.id, call);
     }
     toolCalls.clear();
@@ -1366,15 +1482,20 @@ var OpenAIAdapter = class _OpenAIAdapter {
       }
       throwIfAborted(request.signal);
       if (!finishReason)
-        throw new Error("OpenAI stream ended without a finish reason");
+        throw invalidProviderResponse(
+          "OpenAI stream ended without a finish reason"
+        );
       if (toolCalls.size && !["tool_calls", "function_call"].includes(finishReason)) {
-        throw new Error("OpenAI stream ended with incomplete tool calls");
-      }
-      for (const call of toolCalls.values()) {
-        if (!call.id || !call.name)
-          throw new Error("OpenAI stream contains an incomplete tool call");
-        JSON.parse(call.arguments || "{}");
+        throw invalidProviderResponse(
+          "OpenAI stream ended with incomplete tool calls"
+        );
       }
+      validateToolCalls(
+        [...toolCalls.values()].map((call) => ({
+          ...call,
+          args: parseToolArguments(call.arguments)
+        }))
+      );
       for (const call of toolCalls.values()) {
         yield {
           type: "action:start",
@@ -1458,20 +1579,20 @@ var OpenAIAdapter = class _OpenAIAdapter {
     logProviderPayload("openai", "response payload", response, request.debug);
     const choice = response.choices?.[0];
     const message = choice?.message;
+    const toolCalls = (message?.tool_calls ?? []).map((toolCall) => ({
+      id: toolCall.id,
+      name: toolCall.function?.name,
+      args: parseToolArguments(toolCall.function?.arguments ?? "{}"),
+      ...toolCall.extra_content ? { extra_content: toolCall.extra_content } : {}
+    }));
+    validateToolCalls(toolCalls);
+    if (toolCalls.length && choice?.finish_reason && !["tool_calls", "function_call"].includes(choice.finish_reason))
+      throw invalidProviderResponse(
+        "OpenAI response ended with incomplete tool calls"
+      );
     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 } : {}
-      })) ?? [],
+      toolCalls,
       usage: response.usage ? {
         promptTokens: response.usage.prompt_tokens,
         completionTokens: response.usage.completion_tokens,