opencode-anthropic-multi-account 0.2.26 → 0.2.28

package/dist/fingerprint-capture.d.ts

@@ -1,7 +1,7 @@
 declare const LIVE_TTL_MS: number;
 declare const SUPPORTED_CC_RANGE: {
     readonly min: "1.0.0";
-    readonly maxTested: "2.1.121";
+    readonly maxTested: "2.1.122";
 };
 type TemplateSource = "bundled" | "cached" | "live";
 type TemplateTool = {

package/dist/fingerprint-capture.js

@@ -12,7 +12,7 @@ import {
   refreshLiveFingerprintAsync,
   resetFingerprintCaptureForTest,
   setFingerprintCaptureTestOverridesForTest
-} from "./chunk-5PQ3VP24.js";
+} from "./chunk-I2QRH74W.js";
 import "./chunk-3CTML5AX.js";
 export {
   LIVE_TTL_MS,

package/dist/index.js

@@ -25,7 +25,7 @@ import {
   showToast,
   sleep,
   updateConfigField
-} from "./chunk-5PQ3VP24.js";
+} from "./chunk-I2QRH74W.js";
 import "./chunk-3CTML5AX.js";
 
 // src/index.ts
@@ -2153,17 +2153,36 @@ var TOOL_MASK_PREFIX = "tool_";
 function isRecord3(value) {
   return typeof value === "object" && value !== null;
 }
-function shouldMaskToolName(name, claudeToolNames) {
+function shouldMaskToolName(name, claudeToolNames, options) {
   if (!name) {
     return false;
   }
-  return !claudeToolNames.has(name) && !name.startsWith("mcp__") && !name.startsWith(TOOL_MASK_PREFIX);
+  return !claudeToolNames.has(name) && !name.startsWith("mcp__") && (!options.preserveToolPrefix || !name.startsWith(TOOL_MASK_PREFIX));
 }
 function buildMaskedToolName(toolName, length = 8) {
   const digest = createHash3("sha256").update(`tool-mask:${toolName}`).digest("hex").slice(0, length);
   return `${TOOL_MASK_PREFIX}${digest}`;
 }
-function collectToolNames(parsed) {
+function isOutgoingNameAvailable(name, registry) {
+  return !registry.usedOutgoing.has(name) && !registry.reservedOriginals.has(name);
+}
+function buildAvailableMaskedToolName(toolName, registry) {
+  for (let length = 8; length <= 64; length += 2) {
+    const masked = buildMaskedToolName(toolName, length);
+    if (isOutgoingNameAvailable(masked, registry)) {
+      return masked;
+    }
+  }
+  const fullDigestName = buildMaskedToolName(toolName, 64);
+  for (let suffix = 1; suffix <= 1024; suffix += 1) {
+    const masked = `${fullDigestName}_${suffix}`;
+    if (isOutgoingNameAvailable(masked, registry)) {
+      return masked;
+    }
+  }
+  return `${fullDigestName}_${registry.usedOutgoing.size + registry.reservedOriginals.size}`;
+}
+function collectCurrentToolNames(parsed) {
   const names = /* @__PURE__ */ new Set();
   if (Array.isArray(parsed.tools)) {
     for (const tool2 of parsed.tools) {
@@ -2172,6 +2191,10 @@ function collectToolNames(parsed) {
       }
     }
   }
+  return [...names];
+}
+function collectReferencedToolNames(parsed) {
+  const names = /* @__PURE__ */ new Set();
   if (Array.isArray(parsed.messages)) {
     for (const message of parsed.messages) {
       if (!isRecord3(message) || !Array.isArray(message.content)) {
@@ -2192,61 +2215,84 @@ function collectToolNames(parsed) {
 function buildClaudeToolNameSet(claudeToolNames) {
   return new Set(claudeToolNames.filter((name) => typeof name === "string" && name.length > 0));
 }
-function buildRequestScopedToolLookup(parsed, claudeToolNames) {
-  const lookup = /* @__PURE__ */ new Map();
-  const usedOutgoing = /* @__PURE__ */ new Set();
+function buildToolFlowLookup(parsed, claudeToolNames) {
+  const originalToOutgoing = /* @__PURE__ */ new Map();
+  const outgoingToOriginal = /* @__PURE__ */ new Map();
+  const registry = {
+    usedOutgoing: /* @__PURE__ */ new Set(),
+    reservedOriginals: new Set(collectCurrentToolNames(parsed))
+  };
   const claudeToolSet = buildClaudeToolNameSet(claudeToolNames);
-  for (const originalName of collectToolNames(parsed)) {
-    if (!shouldMaskToolName(originalName, claudeToolSet)) {
-      lookup.set(originalName, originalName);
-      usedOutgoing.add(originalName);
-      continue;
+  const registerCurrent = (originalName) => {
+    if (originalToOutgoing.has(originalName)) {
+      return;
+    }
+    if (!shouldMaskToolName(originalName, claudeToolSet, { preserveToolPrefix: false })) {
+      originalToOutgoing.set(originalName, originalName);
+      outgoingToOriginal.set(originalName, originalName);
+      registry.usedOutgoing.add(originalName);
+      return;
     }
-    let length = 8;
-    let masked = buildMaskedToolName(originalName, length);
-    while (usedOutgoing.has(masked)) {
-      length += 2;
-      masked = buildMaskedToolName(originalName, length);
+    const masked = buildAvailableMaskedToolName(originalName, registry);
+    originalToOutgoing.set(originalName, masked);
+    outgoingToOriginal.set(masked, originalName);
+    registry.usedOutgoing.add(masked);
+  };
+  const registerReference = (originalName) => {
+    if (originalToOutgoing.has(originalName) || outgoingToOriginal.has(originalName)) {
+      return;
     }
-    lookup.set(masked, originalName);
-    usedOutgoing.add(masked);
+    if (!shouldMaskToolName(originalName, claudeToolSet, { preserveToolPrefix: true })) {
+      originalToOutgoing.set(originalName, originalName);
+      outgoingToOriginal.set(originalName, originalName);
+      registry.usedOutgoing.add(originalName);
+      return;
+    }
+    const masked = buildAvailableMaskedToolName(originalName, registry);
+    originalToOutgoing.set(originalName, masked);
+    outgoingToOriginal.set(masked, originalName);
+    registry.usedOutgoing.add(masked);
+  };
+  for (const originalName of collectCurrentToolNames(parsed)) {
+    registerCurrent(originalName);
+  }
+  for (const originalName of collectReferencedToolNames(parsed)) {
+    registerReference(originalName);
   }
-  return lookup;
+  return { originalToOutgoing, outgoingToOriginal };
 }
-function getOutgoingName(name, reverseLookup) {
+function getOutgoingName(name, lookup) {
   if (!name) {
     return name;
   }
-  for (const [outgoing, original] of reverseLookup) {
-    if (original === name) {
-      return outgoing;
-    }
+  if (lookup.outgoingToOriginal.has(name)) {
+    return name;
   }
-  return name;
+  return lookup.originalToOutgoing.get(name) ?? name;
 }
-function rewriteToolUseNames(value, reverseLookup) {
+function rewriteToolUseNames(value, lookup) {
   if (Array.isArray(value)) {
-    return value.map((item) => rewriteToolUseNames(item, reverseLookup));
+    return value.map((item) => rewriteToolUseNames(item, lookup));
   }
   if (!isRecord3(value)) {
     return value;
   }
   const cloned = {};
   for (const [key, nested] of Object.entries(value)) {
-    cloned[key] = rewriteToolUseNames(nested, reverseLookup);
+    cloned[key] = rewriteToolUseNames(nested, lookup);
   }
   if (cloned.type === "tool_use" && typeof cloned.name === "string") {
-    cloned.name = getOutgoingName(cloned.name, reverseLookup);
+    cloned.name = getOutgoingName(cloned.name, lookup);
   }
   return cloned;
 }
 function applyOutboundToolFlow(parsed, claudeToolNames) {
-  const reverseLookup = buildRequestScopedToolLookup(parsed, claudeToolNames);
+  const lookup = buildToolFlowLookup(parsed, claudeToolNames);
   const next = { ...parsed };
   if (Array.isArray(parsed.tools)) {
     next.tools = parsed.tools.map((tool2) => ({
       ...tool2,
-      name: getOutgoingName(tool2.name, reverseLookup)
+      name: getOutgoingName(tool2.name, lookup)
     }));
   }
   if (Array.isArray(parsed.messages)) {
@@ -2256,19 +2302,19 @@ function applyOutboundToolFlow(parsed, claudeToolNames) {
       }
       return {
         ...message,
-        content: rewriteToolUseNames(message.content, reverseLookup)
+        content: rewriteToolUseNames(message.content, lookup)
       };
     });
   }
   if (isRecord3(parsed.tool_choice) && parsed.tool_choice.type === "tool") {
     next.tool_choice = {
       ...parsed.tool_choice,
-      name: getOutgoingName(parsed.tool_choice.name, reverseLookup)
+      name: getOutgoingName(parsed.tool_choice.name, lookup)
     };
   }
   return {
     body: JSON.stringify(next),
-    reverseLookup
+    reverseLookup: lookup.outgoingToOriginal
   };
 }
 
@@ -2522,6 +2568,7 @@ function resolvePacingConfig(explicit = {}, env = process.env) {
 
 // src/runtime/factory.ts
 var TOKEN_REFRESH_PERMANENT_FAILURE_STATUS = 401;
+var ASSISTANT_PREFILL_UNSUPPORTED_MESSAGE = "This model does not support assistant message prefill";
 function mergeHeaders(target, headers) {
   if (!headers) {
     return;
@@ -2552,6 +2599,41 @@ function extractIncomingHeaders(input, init) {
   mergeHeaders(headers, init?.headers);
   return headers;
 }
+function isRecord4(value) {
+  return typeof value === "object" && value !== null;
+}
+function messageHasToolUse(message) {
+  return Array.isArray(message.content) && message.content.some((block) => isRecord4(block) && block.type === "tool_use");
+}
+function removeTrailingAssistantPrefillBody(body) {
+  if (typeof body !== "string") {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(body);
+    if (!isRecord4(parsed) || !Array.isArray(parsed.messages)) {
+      return null;
+    }
+    const messages = parsed.messages;
+    const originalLength = messages.length;
+    while (messages.length > 0) {
+      const lastMessage = messages[messages.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant" || messageHasToolUse(lastMessage)) {
+        break;
+      }
+      messages.pop();
+    }
+    return messages.length === originalLength ? null : JSON.stringify(parsed);
+  } catch {
+    return null;
+  }
+}
+async function isAssistantPrefillUnsupportedResponse(response) {
+  if (response.status !== 400) {
+    return false;
+  }
+  return (await response.clone().text()).includes(ASSISTANT_PREFILL_UNSUPPORTED_MESSAGE);
+}
 function splitBetaValues(value) {
   if (!value) {
     return [];
@@ -2765,13 +2847,13 @@ var AccountRuntimeFactory = class {
         releaseGate?.();
       }
     };
-    const performFetch = async (requestHeaders) => {
+    const performFetch = async (requestHeaders, requestBody) => {
       await reservePacingSlot();
       try {
         const response2 = await fetch(transformedInput, {
           ...init,
           headers: requestHeaders,
-          body: transformedRequest.body
+          body: requestBody
         });
         return await enrichRateLimitResponse(response2);
       } catch (error) {
@@ -2781,7 +2863,15 @@ var AccountRuntimeFactory = class {
         throw error;
       }
     };
-    let response = await performFetch(headers);
+    let outboundBody = transformedRequest.body;
+    let response = await performFetch(headers, outboundBody);
+    if (await isAssistantPrefillUnsupportedResponse(response)) {
+      const retryBody = removeTrailingAssistantPrefillBody(outboundBody);
+      if (retryBody) {
+        outboundBody = retryBody;
+        response = await performFetch(headers, outboundBody);
+      }
+    }
     for (let attempt = 0; attempt < LONG_CONTEXT_BETAS.length; attempt += 1) {
       if (response.status !== 400 && response.status !== 429) {
         break;
@@ -2812,7 +2902,7 @@ var AccountRuntimeFactory = class {
         modelId,
         getExcludedBetas(modelId)
       );
-      response = await performFetch(retryHeaders);
+      response = await performFetch(retryHeaders, outboundBody);
     }
     return applyResponseReverseLookup(response, transformedRequest.reverseLookup);
   }