@jambonz/llm 0.6.9 → 0.6.10

package/dist/test-kit/index.cjs

@@ -1291,6 +1291,21 @@ var ANTHROPIC_KNOWN_MODELS = [
       maxContextTokens: 2e5
     }
   },
+  {
+    // Thinks by default (effort `medium`), and the thinking counts toward
+    // max_tokens. For voice, send `providerParams: {output_config: {effort:
+    // 'low'}}`. Rejects non-default sampling parameters, so the adapter
+    // leaves `temperature` out of its requests.
+    id: "claude-haiku-5-5",
+    displayName: "Claude Haiku 5.5",
+    capabilities: {
+      streaming: true,
+      tools: true,
+      vision: true,
+      systemPrompt: true,
+      maxContextTokens: 1e6
+    }
+  },
   {
     id: "claude-haiku-4-5-20251001",
     displayName: "Claude Haiku 4.5",
@@ -1374,6 +1389,7 @@ var ANTHROPIC_METADATA_EXTRACTOR = makeMetadataExtractor([
   { header: "anthropic-ratelimit-input-tokens-remaining", key: "input_tokens_remaining", numeric: true },
   { header: "anthropic-ratelimit-output-tokens-remaining", key: "output_tokens_remaining", numeric: true }
 ]);
+var REJECTS_SAMPLING_PARAMS = /^claude-(opus-4-[7-9]|opus-5|sonnet-5|haiku-5|fable|mythos)/;
 var AnthropicAdapter = class {
   vendor = anthropicManifest.vendor;
   acceptedAuth = ["apiKey"];
@@ -1406,7 +1422,14 @@ var AnthropicAdapter = class {
     };
     if (req.system) body.system = req.system;
     if (tools) body.tools = tools;
-    if (req.temperature !== void 0) body.temperature = req.temperature;
+    if (req.temperature !== void 0 && !REJECTS_SAMPLING_PARAMS.test(req.model)) {
+      body.temperature = req.temperature;
+    }
+    if (req.providerParams) {
+      for (const [key, value] of Object.entries(req.providerParams)) {
+        if (!(key in body)) body[key] = value;
+      }
+    }
     if (req.cacheKey) {
       if (req.system) {
         body.system = [{ type: "text", text: req.system, cache_control: { type: "ephemeral" } }];
@@ -1417,21 +1440,31 @@ var AnthropicAdapter = class {
       }
       markLastMessageForCaching(messages);
     }
-    let stream;
-    let responseHeaders;
-    try {
+    const open = async (b) => {
       const apiPromise = client.messages.create(
-        body,
+        b,
         { signal: req.signal }
       );
       const maybeWithResponse = apiPromise.withResponse;
       if (typeof maybeWithResponse === "function") {
         const result = await maybeWithResponse.call(apiPromise);
-        stream = result.data;
-        responseHeaders = result.response?.headers;
-      } else {
-        stream = await apiPromise;
+        return { stream: result.data, headers: result.response?.headers };
       }
+      return { stream: await apiPromise, headers: void 0 };
+    };
+    let stream;
+    let responseHeaders;
+    try {
+      let opened;
+      try {
+        opened = await open(body);
+      } catch (err) {
+        const stripped = isThinkingBlockRejection(err) ? withoutThinking(messages) : void 0;
+        if (!stripped) throw err;
+        opened = await open({ ...body, messages: stripped });
+      }
+      stream = opened.stream;
+      responseHeaders = opened.headers;
     } catch (err) {
       if (isAbortError2(err)) {
         yield { type: "end", finishReason: "aborted" };
@@ -1440,7 +1473,10 @@ var AnthropicAdapter = class {
       throw err;
     }
     let currentToolUse = null;
+    let currentThinking = null;
+    let currentText = null;
     const completedToolCalls = [];
+    const turnContent = [];
     let stopReason;
     let inputTokens;
     let outputTokens;
@@ -1473,19 +1509,42 @@ var AnthropicAdapter = class {
                   name: currentToolUse.name
                 };
               }
+            } else if (block?.type === "text") {
+              currentText = block.text ?? "";
+            } else if (block?.type === "thinking") {
+              currentThinking = {
+                type: "thinking",
+                thinking: block.thinking ?? "",
+                signature: block.signature ?? ""
+              };
+            } else if (block?.type === "redacted_thinking" && block.data) {
+              turnContent.push({ type: "redacted_thinking", data: block.data });
             }
             break;
           }
           case "content_block_delta": {
             const delta = event.delta;
             if (delta?.type === "text_delta" && delta.text) {
+              if (currentText !== null) currentText += delta.text;
               yield { type: "token", text: delta.text };
             } else if (delta?.type === "input_json_delta" && currentToolUse && delta.partial_json) {
               currentToolUse.argumentsText += delta.partial_json;
+            } else if (delta?.type === "thinking_delta" && currentThinking && delta.thinking) {
+              currentThinking.thinking += delta.thinking;
+            } else if (delta?.type === "signature_delta" && currentThinking && delta.signature) {
+              currentThinking.signature += delta.signature;
             }
             break;
           }
           case "content_block_stop":
+            if (currentThinking) {
+              if (currentThinking.signature) turnContent.push(currentThinking);
+              currentThinking = null;
+            }
+            if (currentText !== null) {
+              if (currentText) turnContent.push({ type: "text", text: currentText });
+              currentText = null;
+            }
             if (currentToolUse && currentToolUse.id && currentToolUse.name) {
               let parsed = {};
               try {
@@ -1498,6 +1557,12 @@ var AnthropicAdapter = class {
                 name: currentToolUse.name,
                 arguments: parsed
               });
+              turnContent.push({
+                type: "tool_use",
+                id: currentToolUse.id,
+                name: currentToolUse.name,
+                input: parsed
+              });
             }
             currentToolUse = null;
             break;
@@ -1526,12 +1591,14 @@ var AnthropicAdapter = class {
       yield { type: "end", finishReason: "aborted" };
       return;
     }
+    const toolCallRaw = { content: turnContent };
     for (const tc of completedToolCalls) {
       yield {
         type: "toolCall",
         id: tc.id,
         name: tc.name,
-        arguments: tc.arguments
+        arguments: tc.arguments,
+        vendorRaw: toolCallRaw
       };
     }
     const finishReason = mapStopReason(stopReason, completedToolCalls.length > 0);
@@ -1562,15 +1629,7 @@ var AnthropicAdapter = class {
     const text = assistantText?.trim() ? assistantText : null;
     const wireMessage = {
       role: "assistant",
-      content: [
-        ...text ? [{ type: "text", text }] : [],
-        ...toolCalls.map((tc) => ({
-          type: "tool_use",
-          id: tc.id,
-          name: tc.name,
-          input: tc.arguments ?? {}
-        }))
-      ]
+      content: assistantTurnContent(toolCalls, text)
     };
     return [
       ...history,
@@ -1662,6 +1721,62 @@ function markLastMessageForCaching(messages) {
     };
   }
 }
+function isThinkingBlockRejection(err) {
+  const e = err;
+  return e?.status === 400 && /`thinking` block/.test(String(e.message ?? ""));
+}
+function withoutThinking(messages) {
+  let removed = false;
+  const out = messages.map((m) => {
+    const content = m.content;
+    if (!Array.isArray(content)) return m;
+    const kept = content.filter((b) => {
+      const thinking = b?.type === "thinking" || b?.type === "redacted_thinking";
+      if (thinking) removed = true;
+      return !thinking;
+    });
+    return kept.length === content.length ? m : { ...m, content: kept };
+  });
+  return removed ? out : void 0;
+}
+function assistantTurnContent(toolCalls, text) {
+  const recorded = recordedTurnOf(toolCalls);
+  if (!recorded) {
+    return [
+      ...text ? [{ type: "text", text }] : [],
+      ...toolCalls.map((tc) => ({
+        type: "tool_use",
+        id: tc.id,
+        name: tc.name,
+        input: tc.arguments ?? {}
+      }))
+    ];
+  }
+  const ids = new Set(toolCalls.map((tc) => tc.id));
+  const content = recorded.filter(
+    (b) => b.type !== "tool_use" || ids.has(b.id)
+  );
+  if (text && !content.some((b) => b.type === "text")) {
+    const at = content.findIndex((b) => b.type === "tool_use");
+    content.splice(at === -1 ? content.length : at, 0, { type: "text", text });
+  }
+  const known = new Set(
+    content.flatMap((b) => b.type === "tool_use" ? [b.id] : [])
+  );
+  for (const tc of toolCalls) {
+    if (!known.has(tc.id)) {
+      content.push({ type: "tool_use", id: tc.id, name: tc.name, input: tc.arguments ?? {} });
+    }
+  }
+  return content;
+}
+function recordedTurnOf(toolCalls) {
+  for (const tc of toolCalls) {
+    const raw = tc.vendorRaw;
+    if (raw && Array.isArray(raw.content)) return raw.content;
+  }
+  return void 0;
+}
 function formatTools2(tools) {
   return tools.map((t) => ({
     name: t.name,
@@ -1679,6 +1794,8 @@ function mapStopReason(r, hadToolCalls) {
       return "tool";
     case "max_tokens":
       return "length";
+    case "refusal":
+      return "filtered";
     default:
       return "stop";
   }