opencode-anthropic-multi-account 0.2.16 → 0.2.18

package/dist/index.js

@@ -1658,6 +1658,9 @@ function hasMeaningfulContent(content) {
     if (!isRecord(block)) {
       return false;
     }
+    if (block.type === "tool_use") {
+      return true;
+    }
     if (typeof block.text === "string" && block.text.trim().length > 0) {
       return true;
     }
@@ -1727,6 +1730,27 @@ function extractFirstUserMessage(messages) {
 function hasCompleteToolSchemas(tools) {
   return tools.length > 0 && tools.every((tool2) => typeof tool2 === "object" && tool2 !== null && "input_schema" in tool2);
 }
+function enrichIncomingToolsWithTemplateSchemas(incomingTools, templateTools) {
+  if (!hasCompleteToolSchemas(templateTools) || incomingTools.length !== templateTools.length) {
+    return incomingTools;
+  }
+  return incomingTools.map((tool2, index) => {
+    if ("input_schema" in tool2) {
+      return tool2;
+    }
+    const templateTool = templateTools[index];
+    return templateTool && "input_schema" in templateTool ? { ...tool2, input_schema: templateTool.input_schema } : tool2;
+  });
+}
+function buildOutboundTools(incomingTools, templateTools) {
+  if (incomingTools.length > 0) {
+    return enrichIncomingToolsWithTemplateSchemas(incomingTools, templateTools);
+  }
+  if (!hasCompleteToolSchemas(templateTools)) {
+    return incomingTools;
+  }
+  return templateTools.map((tool2) => ({ ...tool2 }));
+}
 function getCcVersion(template) {
   return template.cc_version ?? DEFAULT_CC_VERSION;
 }
@@ -1860,7 +1884,7 @@ function buildUpstreamRequest(inputBody, identity, template, options) {
   const activeSessionId = options?.sessionId ?? getActiveSessionId();
   body.messages = messages;
   const incomingTools = Array.isArray(body.tools) ? body.tools : [];
-  body.tools = hasCompleteToolSchemas(template.tools) ? template.tools.map((tool2) => ({ ...tool2 })) : incomingTools;
+  body.tools = buildOutboundTools(incomingTools, template.tools);
   body.system = [
     {
       type: "text",
@@ -1962,6 +1986,149 @@ function createStreamingReverseMapper(response, reverseLookup) {
   });
 }
 
+// src/tool-flow.ts
+import { createHash as createHash3 } from "crypto";
+var TOOL_MASK_PREFIX = "tool_";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function shouldMaskToolName(name, claudeToolNames) {
+  if (!name) {
+    return false;
+  }
+  return !claudeToolNames.has(name) && !name.startsWith("mcp__") && !name.startsWith(TOOL_MASK_PREFIX);
+}
+function extractFirstUserText(parsed) {
+  if (!Array.isArray(parsed.messages)) {
+    return "";
+  }
+  const firstUser = parsed.messages.find((message) => message.role === "user");
+  if (!isRecord2(firstUser)) {
+    return "";
+  }
+  const content = firstUser.content;
+  if (typeof content === "string") {
+    return content.trim();
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.filter((block) => isRecord2(block) && block.type === "text" && typeof block.text === "string").map((block) => String(block.text)).join("\n\n").trim();
+}
+function buildMaskedToolName(seed, toolName, length = 8) {
+  const digest = createHash3("sha256").update(`tool-mask:${seed}:${toolName}`).digest("hex").slice(0, length);
+  return `${TOOL_MASK_PREFIX}${digest}`;
+}
+function collectToolNames(parsed) {
+  const names = /* @__PURE__ */ new Set();
+  if (Array.isArray(parsed.tools)) {
+    for (const tool2 of parsed.tools) {
+      if (isRecord2(tool2) && typeof tool2.name === "string") {
+        names.add(tool2.name);
+      }
+    }
+  }
+  if (Array.isArray(parsed.messages)) {
+    for (const message of parsed.messages) {
+      if (!isRecord2(message) || !Array.isArray(message.content)) {
+        continue;
+      }
+      for (const block of message.content) {
+        if (isRecord2(block) && block.type === "tool_use" && typeof block.name === "string") {
+          names.add(block.name);
+        }
+      }
+    }
+  }
+  if (isRecord2(parsed.tool_choice) && parsed.tool_choice.type === "tool" && typeof parsed.tool_choice.name === "string") {
+    names.add(parsed.tool_choice.name);
+  }
+  return [...names];
+}
+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();
+  const seed = extractFirstUserText(parsed);
+  const claudeToolSet = buildClaudeToolNameSet(claudeToolNames);
+  for (const originalName of collectToolNames(parsed)) {
+    if (!shouldMaskToolName(originalName, claudeToolSet)) {
+      lookup.set(originalName, originalName);
+      usedOutgoing.add(originalName);
+      continue;
+    }
+    let length = 8;
+    let masked = buildMaskedToolName(seed, originalName, length);
+    while (usedOutgoing.has(masked)) {
+      length += 2;
+      masked = buildMaskedToolName(seed, originalName, length);
+    }
+    lookup.set(masked, originalName);
+    usedOutgoing.add(masked);
+  }
+  return lookup;
+}
+function getOutgoingName(name, reverseLookup) {
+  if (!name) {
+    return name;
+  }
+  for (const [outgoing, original] of reverseLookup) {
+    if (original === name) {
+      return outgoing;
+    }
+  }
+  return name;
+}
+function rewriteToolUseNames(value, reverseLookup) {
+  if (Array.isArray(value)) {
+    return value.map((item) => rewriteToolUseNames(item, reverseLookup));
+  }
+  if (!isRecord2(value)) {
+    return value;
+  }
+  const cloned = {};
+  for (const [key, nested] of Object.entries(value)) {
+    cloned[key] = rewriteToolUseNames(nested, reverseLookup);
+  }
+  if (cloned.type === "tool_use" && typeof cloned.name === "string") {
+    cloned.name = getOutgoingName(cloned.name, reverseLookup);
+  }
+  return cloned;
+}
+function applyOutboundToolFlow(parsed, claudeToolNames) {
+  const reverseLookup = buildRequestScopedToolLookup(parsed, claudeToolNames);
+  const next = { ...parsed };
+  if (Array.isArray(parsed.tools)) {
+    next.tools = parsed.tools.map((tool2) => ({
+      ...tool2,
+      name: getOutgoingName(tool2.name, reverseLookup)
+    }));
+  }
+  if (Array.isArray(parsed.messages)) {
+    next.messages = parsed.messages.map((message) => {
+      if (!isRecord2(message) || !Array.isArray(message.content)) {
+        return message;
+      }
+      return {
+        ...message,
+        content: rewriteToolUseNames(message.content, reverseLookup)
+      };
+    });
+  }
+  if (isRecord2(parsed.tool_choice) && parsed.tool_choice.type === "tool") {
+    next.tool_choice = {
+      ...parsed.tool_choice,
+      name: getOutgoingName(parsed.tool_choice.name, reverseLookup)
+    };
+  }
+  return {
+    body: JSON.stringify(next),
+    reverseLookup
+  };
+}
+
 // src/upstream-headers.ts
 import { randomUUID as randomUUID3 } from "crypto";
 var UPSTREAM_TIMEOUT_MS = 3e5;
@@ -2048,6 +2215,9 @@ function filterBillableBetas(betas) {
 }
 
 // src/request-transform.ts
+function applyRequestToolMasking(parsed, claudeToolNames) {
+  return applyOutboundToolFlow(parsed, claudeToolNames);
+}
 function extractModelIdFromBody(body) {
   if (typeof body !== "string") {
     return "unknown";
@@ -2258,18 +2428,38 @@ function transformBodyToUpstream(body, identity, sessionId2) {
   try {
     const parsed = JSON.parse(body);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      return body;
-    }
-    return JSON.stringify(
-      buildUpstreamRequest(
-        parsed,
-        identity,
-        loadTemplate(),
-        { sessionId: sessionId2 }
-      )
+      return { body, reverseLookup: /* @__PURE__ */ new Map() };
+    }
+    const template = loadTemplate();
+    const upstreamRequest = buildUpstreamRequest(
+      parsed,
+      identity,
+      template,
+      { sessionId: sessionId2 }
     );
+    return applyRequestToolMasking(upstreamRequest, template.tool_names);
   } catch {
-    return body;
+    return { body, reverseLookup: /* @__PURE__ */ new Map() };
+  }
+}
+async function applyResponseReverseLookup(response, reverseLookup) {
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("text/event-stream")) {
+    return createStreamingReverseMapper(response, reverseLookup);
+  }
+  if (!contentType.includes("application/json") || reverseLookup.size === 0) {
+    return response;
+  }
+  try {
+    const payload = await response.clone().json();
+    const remapped = reverseMapResponse(payload, reverseLookup);
+    return new Response(JSON.stringify(remapped), {
+      status: response.status,
+      statusText: response.statusText,
+      headers: new Headers(response.headers)
+    });
+  } catch {
+    return response;
   }
 }
 async function enrichRateLimitResponse(response) {
@@ -2393,7 +2583,7 @@ var AccountRuntimeFactory = class {
       void recordObservedToolNames(extractToolNamesFromRequestBody(init.body)).catch(() => {
       });
     }
-    const transformedBody = typeof init?.body === "string" ? transformBodyToUpstream(init.body, this.identity, sessionId2) : init?.body;
+    const transformedRequest = typeof init?.body === "string" ? transformBodyToUpstream(init.body, this.identity, sessionId2) : { body: init?.body, reverseLookup: /* @__PURE__ */ new Map() };
     const pacingCfg = resolvePacingConfig();
     const getNow = this.pacingTestOverrides.now ?? Date.now;
     const sleepFn = this.pacingTestOverrides.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
@@ -2420,7 +2610,7 @@ var AccountRuntimeFactory = class {
         const response2 = await fetch(transformedInput, {
           ...init,
           headers: requestHeaders,
-          body: transformedBody
+          body: transformedRequest.body
         });
         return await enrichRateLimitResponse(response2);
       } catch (error) {
@@ -2453,7 +2643,7 @@ var AccountRuntimeFactory = class {
       );
       response = await performFetch(retryHeaders);
     }
-    return createStreamingReverseMapper(response);
+    return applyResponseReverseLookup(response, transformedRequest.reverseLookup);
   }
   async createRuntime(uuid) {
     const fetchWithAccount = async (input, init) => {
@@ -2463,9 +2653,8 @@ var AccountRuntimeFactory = class {
         throw new Error(`No credentials found for account ${uuid}`);
       }
       let accessToken = storedAccount.accessToken;
-      let expiresAt = storedAccount.expiresAt;
-      if (!accessToken || !expiresAt || isTokenExpired({ accessToken, expiresAt })) {
-        ({ accessToken, expiresAt } = await this.ensureFreshToken(storedAccount, uuid));
+      if (!accessToken || !storedAccount.expiresAt || isTokenExpired({ accessToken, expiresAt: storedAccount.expiresAt })) {
+        ({ accessToken } = await this.ensureFreshToken(storedAccount, uuid));
       }
       if (!accessToken) {
         throw new Error(`No access token available for account ${uuid}`);
@@ -2626,7 +2815,7 @@ var EMPTY_OAUTH_CREDENTIALS = {
   access: "",
   expires: 0
 };
-function extractFirstUserText(input) {
+function extractFirstUserText2(input) {
   try {
     const raw = input;
     const messages = raw.messages ?? raw.request?.messages;
@@ -2819,7 +3008,7 @@ var ClaudeMultiAuthPlugin = async (ctx) => {
   });
   return {
     "experimental.chat.system.transform": (input, output) => {
-      const billingHeader = composeBillingSystemEntry(extractFirstUserText(input), claudeCodeVersion);
+      const billingHeader = composeBillingSystemEntry(extractFirstUserText2(input), claudeCodeVersion);
       prependMissingSystemEntries(output, [
         billingHeader,
         upstreamAgentIdentity,