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

package/dist/adapters/index.js

@@ -103,6 +103,63 @@ function textToolOutput(value, fallback) {
   return toolOutputForProvider(value, "unsupported").map((part) => part.text).join("\n");
 }
 
+// src/core/anthropic-replay.ts
+function anthropicReplay(content) {
+  if (!Array.isArray(content) || !content.some(
+    (b) => b?.type === "thinking" || b?.type === "redacted_thinking"
+  ))
+    return void 0;
+  const blocks = content.flatMap((block) => {
+    if (block?.type === "thinking" && typeof block.thinking === "string" && typeof block.signature === "string")
+      return [
+        {
+          type: "thinking",
+          thinking: block.thinking,
+          signature: block.signature
+        }
+      ];
+    if (block?.type === "redacted_thinking" && typeof block.data === "string")
+      return [{ type: "redacted_thinking", data: block.data }];
+    if (block?.type === "text" && typeof block.text === "string")
+      return [{ type: "text", text: block.text }];
+    if (block?.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string")
+      return [
+        {
+          type: "tool_use",
+          id: block.id,
+          name: block.name,
+          input: block.input
+        }
+      ];
+    return [];
+  });
+  return { anthropic: { content: blocks } };
+}
+function anthropicReplayContent(metadata) {
+  const state = metadata?.anthropic;
+  return anthropicReplay(state?.content)?.anthropic?.content;
+}
+function collectAnthropicContent(blocks, event) {
+  if (event.type === "content_block_start")
+    blocks[event.index] = { ...event.content_block };
+  const block = blocks[event.index];
+  if (event.type !== "content_block_delta" || !block) return;
+  const delta = event.delta;
+  if (delta.type === "thinking_delta")
+    block.thinking = (block.thinking ?? "") + delta.thinking;
+  else if (delta.type === "signature_delta")
+    block.signature = (block.signature ?? "") + delta.signature;
+  else if (delta.type === "text_delta")
+    block.text = (block.text ?? "") + delta.text;
+  else if (delta.type === "input_json_delta") {
+    block.partialInput = (block.partialInput ?? "") + delta.partial_json;
+    try {
+      block.input = JSON.parse(block.partialInput);
+    } catch {
+    }
+  }
+}
+
 // src/core/openai-parameters.ts
 function capabilities(model) {
   const gpt = /^gpt-(\d+)(?:\.(\d+))?(?:-(.+))?$/i.exec(model);
@@ -113,6 +170,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);
@@ -284,7 +354,22 @@ function stripSchemaKeys(schema, keysToDrop, options = {}) {
   )) {
     if (keysToDrop.has(key)) continue;
     const renamed = options.renameKeys?.[key] ?? key;
-    out[renamed] = stripSchemaKeys(value, keysToDrop, options);
+    if ([
+      "properties",
+      "$defs",
+      "definitions",
+      "patternProperties",
+      "dependentSchemas"
+    ].includes(key) && value && typeof value === "object" && !Array.isArray(value)) {
+      out[renamed] = Object.fromEntries(
+        Object.entries(value).map(([name, child]) => [
+          name,
+          stripSchemaKeys(child, keysToDrop, options)
+        ])
+      );
+    } else if (["enum", "const", "default", "examples"].includes(key)) {
+      out[renamed] = value;
+    } else out[renamed] = stripSchemaKeys(value, keysToDrop, options);
   }
   if (options.forceAdditionalPropertiesFalse && out.type === "object") {
     out.additionalProperties = false;
@@ -305,6 +390,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",
@@ -544,6 +630,14 @@ function formatMessagesForAnthropic(messages, systemPrompt) {
     const msg = messages[i];
     if (msg.role === "system") continue;
     if (msg.role === "assistant") {
+      const replay = anthropicReplayContent(msg.providerMetadata);
+      if (replay) {
+        formatted.push({
+          role: "assistant",
+          content: replay
+        });
+        continue;
+      }
       const content = [];
       if (msg.content) {
         content.push({ type: "text", text: msg.content });
@@ -634,6 +728,63 @@ function formatMessagesForOpenAI(messages, systemPrompt, preserveProviderMetadat
   return formatted;
 }
 
+// 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 {
@@ -740,35 +891,6 @@ function getResponseReplay(metadata) {
   return responseReplayMetadata(metadata)?.openai?.response?.output;
 }
 
-// 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/utils.ts
 function generateId(prefix = "id") {
   return `${prefix}_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
@@ -802,6 +924,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
       });
     }
@@ -1083,6 +1207,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,
@@ -1106,14 +1240,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
     };
@@ -1484,15 +1611,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",
@@ -1576,20 +1708,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,
@@ -1622,6 +1754,52 @@ function createOpenAIAdapter(config) {
   return new OpenAIAdapter(config);
 }
 
+// src/core/anthropic-parameters.ts
+function anthropicMaxTokens(maxTokens, thinking) {
+  return maxTokens ?? Math.max(4096, Number(thinking?.budget_tokens ?? 0) + 1);
+}
+function anthropicModelRules(model) {
+  const match = /^claude-(opus|sonnet|haiku)-(\d+)(?:-(\d{1,2})(?=-|$))?(?:-|$)/i.exec(
+    model
+  );
+  const family = match?.[1]?.toLowerCase();
+  const major = Number(match?.[2] ?? 0);
+  const minor = Number(match?.[3] ?? 0);
+  const adaptive = major >= 5 || major === 4 && minor >= 6;
+  return {
+    structured: major >= 5 || major === 4 && minor >= 5,
+    thinking: major >= 4 || /^claude-3-7-/.test(model),
+    adaptive,
+    rejectsSampling: major >= 5 || family === "opus" && major === 4 && minor >= 7
+  };
+}
+function anthropicInputTokens(usage) {
+  return (usage?.input_tokens ?? 0) + (usage?.cache_creation_input_tokens ?? 0) + (usage?.cache_read_input_tokens ?? 0);
+}
+function anthropicThinking(model, thinking) {
+  if (!thinking) return void 0;
+  if (thinking.type === "enabled") {
+    if (anthropicModelRules(model).adaptive) {
+      console.warn(
+        `[llm-sdk] ${model}: using adaptive thinking instead of a legacy token budget.`
+      );
+      return { type: "adaptive" };
+    }
+    return { type: "enabled", budget_tokens: thinking.budgetTokens ?? 1e4 };
+  }
+  return { ...thinking };
+}
+function anthropicTemperature(model, temperature, thinking = false) {
+  if (temperature === void 0) return {};
+  if (thinking || anthropicModelRules(model).rejectsSampling) {
+    console.warn(
+      `[llm-sdk] ${model}: omitted temperature because this model or thinking mode does not support it.`
+    );
+    return {};
+  }
+  return { temperature };
+}
+
 // src/adapters/anthropic.ts
 var AnthropicAdapter = class {
   constructor(config) {
@@ -1633,7 +1811,10 @@ var AnthropicAdapter = class {
     if (!this.client) {
       const { default: Anthropic } = await import('@anthropic-ai/sdk');
       this.client = new Anthropic({
-        apiKey: this.config.apiKey
+        apiKey: this.config.apiKey,
+        baseURL: this.config.baseUrl,
+        timeout: this.config.timeout,
+        defaultHeaders: this.config.headers
       });
     }
     return this.client;
@@ -1670,6 +1851,15 @@ var AnthropicAdapter = class {
           lastToolCallIds = [];
           toolResultIndex = 0;
         }
+        const replay = anthropicReplayContent(
+          msg.providerMetadata
+        );
+        if (replay) {
+          messages.push({ role: "assistant", content: replay });
+          lastToolCallIds = replay.filter((b) => b.type === "tool_use").map((b) => b.id);
+          toolResultIndex = 0;
+          continue;
+        }
         const content = [];
         if (msg.content && typeof msg.content === "string" && msg.content.trim()) {
           content.push({ type: "text", text: msg.content });
@@ -1845,7 +2035,7 @@ var AnthropicAdapter = class {
    */
   buildRequestOptions(request) {
     const responseFormat = request.config?.responseFormat;
-    const jsonObjectSuffix = responseFormat?.type === "json_object" ? "\n\nRespond with a single JSON object and no other text." : "";
+    const jsonObjectSuffix = responseFormat?.type === "json_object" ? "\n\nRespond with a single JSON object and no other text. Do not include Markdown code fences." : "";
     let systemMessage;
     let messages;
     if (request.rawMessages && request.rawMessages.length > 0) {
@@ -1867,7 +2057,17 @@ var AnthropicAdapter = class {
     const tools = anthropicNativeSearch?.enabled ? this.buildNativeSearchTools(
       request.toolDefinitions ?? [],
       anthropicNativeSearch.variant
-    ) : request.actions?.map((action) => ({
+    ) : request.toolDefinitions?.length ? request.toolDefinitions.filter((tool) => tool.available !== false).map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      // Keep the original schema. Legacy ActionParameter conversion
+      // cannot represent unions, null, or nested required constraints.
+      input_schema: tool.inputSchema ?? {
+        type: "object",
+        properties: {},
+        required: []
+      }
+    })) : request.actions?.map((action) => ({
       name: action.name,
       description: action.description,
       input_schema: {
@@ -1909,12 +2109,25 @@ var AnthropicAdapter = class {
         };
       }
     }
+    const thinking = anthropicThinking(
+      request.config?.model || this.model,
+      this.config.thinking
+    );
     const options = {
       model: request.config?.model || this.model,
-      max_tokens: request.config?.maxTokens || this.config.maxTokens || 4096,
+      max_tokens: anthropicMaxTokens(
+        request.config?.maxTokens ?? this.config.maxTokens,
+        thinking
+      ),
       system: systemMessage,
       messages,
-      tools: tools.length ? tools : void 0
+      tools: tools.length ? tools : void 0,
+      ...this.config.cacheControl ? { cache_control: { type: "ephemeral" } } : {},
+      ...anthropicTemperature(
+        request.config?.model || this.model,
+        request.config?.temperature ?? this.config.temperature,
+        !!this.config.thinking && this.config.thinking.type !== "disabled"
+      )
     };
     const anthropicToolOptions = request.providerToolOptions?.anthropic;
     if (tools.length > 0 && anthropicToolOptions) {
@@ -1933,15 +2146,13 @@ var AnthropicAdapter = class {
       options.server_tool_configuration = serverToolConfiguration;
     }
     const outputConfig = toAnthropicOutputConfig(responseFormat);
-    if (outputConfig) {
-      options.output_config = outputConfig;
-    }
-    if (this.config.thinking?.type === "enabled") {
-      options.thinking = {
-        type: "enabled",
-        budget_tokens: this.config.thinking.budgetTokens || 1e4
+    if (outputConfig || this.config.effort) {
+      options.output_config = {
+        ...outputConfig,
+        ...this.config.effort ? { effort: this.config.effort } : {}
       };
     }
+    if (thinking) options.thinking = thinking;
     return { options, messages };
   }
   /**
@@ -1961,7 +2172,9 @@ var AnthropicAdapter = class {
         nonStreamingOptions,
         request.debug
       );
-      const response = await client.messages.create(nonStreamingOptions);
+      const response = await client.messages.create(nonStreamingOptions, {
+        signal: request.signal
+      });
       logProviderPayload(
         "anthropic",
         "response payload",
@@ -1984,14 +2197,20 @@ var AnthropicAdapter = class {
           });
         }
       }
+      validateToolCalls(toolCalls);
+      if (toolCalls.length && response.stop_reason !== "tool_use")
+        throw invalidProviderResponse(
+          "Anthropic response ended with incomplete tool calls"
+        );
       return {
         content,
+        providerMetadata: anthropicReplay(response.content),
         toolCalls,
         thinking: thinking || void 0,
         usage: response.usage ? {
-          promptTokens: response.usage.input_tokens ?? 0,
+          promptTokens: anthropicInputTokens(response.usage),
           completionTokens: response.usage.output_tokens ?? 0,
-          totalTokens: (response.usage.input_tokens ?? 0) + (response.usage.output_tokens ?? 0)
+          totalTokens: anthropicInputTokens(response.usage) + (response.usage.output_tokens ?? 0)
         } : void 0,
         rawResponse: response
       };
@@ -2011,28 +2230,33 @@ var AnthropicAdapter = class {
         options,
         request.debug
       );
-      const stream = await client.messages.stream(options);
+      const stream = await client.messages.stream(options, {
+        signal: request.signal
+      });
       let currentToolUse = null;
       let isInThinkingBlock = false;
+      const content = [];
+      const toolCalls = [];
+      let stopReason;
       const collectedCitations = [];
       let citationIndex = 0;
       let usage;
       for await (const event of stream) {
+        collectAnthropicContent(content, event);
         logProviderPayload("anthropic", "stream event", event, request.debug);
-        if (request.signal?.aborted) {
-          break;
-        }
+        throwIfAborted(request.signal);
         switch (event.type) {
           case "message_start":
             if (event.message?.usage) {
               usage = {
-                prompt_tokens: event.message.usage.input_tokens,
+                prompt_tokens: anthropicInputTokens(event.message.usage),
                 completion_tokens: 0,
-                total_tokens: event.message.usage.input_tokens
+                total_tokens: anthropicInputTokens(event.message.usage)
               };
             }
             break;
           case "message_delta":
+            if (event.delta?.stop_reason) stopReason = event.delta.stop_reason;
             if (event.usage && usage) {
               usage.completion_tokens = event.usage.output_tokens;
               usage.total_tokens = usage.prompt_tokens + event.usage.output_tokens;
@@ -2045,13 +2269,6 @@ var AnthropicAdapter = class {
                 name: event.content_block.name,
                 input: ""
               };
-              if (currentToolUse.name !== "web_search") {
-                yield {
-                  type: "action:start",
-                  id: currentToolUse.id,
-                  name: currentToolUse.name
-                };
-              }
             } else if (event.content_block.type === "web_search_tool_result") {
               const webSearchResult = event.content_block;
               if (webSearchResult.content && Array.isArray(webSearchResult.content)) {
@@ -2100,16 +2317,11 @@ var AnthropicAdapter = class {
           case "content_block_stop":
             if (currentToolUse) {
               if (currentToolUse.name !== "web_search") {
-                yield {
-                  type: "action:args",
-                  id: currentToolUse.id,
-                  args: currentToolUse.input
-                };
-                yield {
-                  type: "action:end",
+                toolCalls.push({
                   id: currentToolUse.id,
-                  name: currentToolUse.name
-                };
+                  name: currentToolUse.name,
+                  args: parseToolArguments(currentToolUse.input)
+                });
               }
               currentToolUse = null;
             }
@@ -2122,18 +2334,33 @@ var AnthropicAdapter = class {
             break;
         }
       }
+      throwIfAborted(request.signal);
+      if (!stopReason || currentToolUse)
+        throw invalidProviderResponse(
+          "Anthropic stream ended before its turn completed"
+        );
+      validateToolCalls(toolCalls);
+      if (toolCalls.length && stopReason !== "tool_use")
+        throw invalidProviderResponse(
+          "Anthropic stream ended with incomplete tool calls"
+        );
+      for (const call of toolCalls) {
+        yield { type: "action:start", id: call.id, name: call.name };
+        yield {
+          type: "action:args",
+          id: call.id,
+          args: JSON.stringify(call.args)
+        };
+        yield { type: "action:end", id: call.id, name: call.name };
+      }
       if (collectedCitations.length > 0) {
         const uniqueCitations = deduplicateCitations2(collectedCitations);
         yield { type: "citation", citations: uniqueCitations };
       }
       yield { type: "message:end" };
-      yield { type: "done", usage };
+      yield { type: "done", usage, providerMetadata: anthropicReplay(content) };
     } catch (error) {
-      yield {
-        type: "error",
-        message: error instanceof Error ? error.message : "Unknown error",
-        code: "ANTHROPIC_ERROR"
-      };
+      yield providerErrorEvent(error, "ANTHROPIC_ERROR");
     }
   }
 };