@xmem-ai/memcode 4.0.2

package/dist/utils/ansiToSvg.js

@@ -0,0 +1,210 @@
+import { escapeXml } from "./xml.js";
+const ANSI_COLORS = {
+  30: { r: 0, g: 0, b: 0 },
+  // black
+  31: { r: 205, g: 49, b: 49 },
+  // red
+  32: { r: 13, g: 188, b: 121 },
+  // green
+  33: { r: 229, g: 229, b: 16 },
+  // yellow
+  34: { r: 36, g: 114, b: 200 },
+  // blue
+  35: { r: 188, g: 63, b: 188 },
+  // magenta
+  36: { r: 17, g: 168, b: 205 },
+  // cyan
+  37: { r: 229, g: 229, b: 229 },
+  // white
+  // Bright colors
+  90: { r: 102, g: 102, b: 102 },
+  // bright black (gray)
+  91: { r: 241, g: 76, b: 76 },
+  // bright red
+  92: { r: 35, g: 209, b: 139 },
+  // bright green
+  93: { r: 245, g: 245, b: 67 },
+  // bright yellow
+  94: { r: 59, g: 142, b: 234 },
+  // bright blue
+  95: { r: 214, g: 112, b: 214 },
+  // bright magenta
+  96: { r: 41, g: 184, b: 219 },
+  // bright cyan
+  97: { r: 255, g: 255, b: 255 }
+  // bright white
+};
+const DEFAULT_FG = { r: 229, g: 229, b: 229 };
+const DEFAULT_BG = { r: 30, g: 30, b: 30 };
+function parseAnsi(text) {
+  const lines = [];
+  const rawLines = text.split("\n");
+  for (const line of rawLines) {
+    const spans = [];
+    let currentColor = DEFAULT_FG;
+    let bold = false;
+    let i = 0;
+    while (i < line.length) {
+      if (line[i] === "\x1B" && line[i + 1] === "[") {
+        let j = i + 2;
+        while (j < line.length && !/[A-Za-z]/.test(line[j])) {
+          j++;
+        }
+        if (line[j] === "m") {
+          const codes = line.slice(i + 2, j).split(";").map(Number);
+          let k = 0;
+          while (k < codes.length) {
+            const code = codes[k];
+            if (code === 0) {
+              currentColor = DEFAULT_FG;
+              bold = false;
+            } else if (code === 1) {
+              bold = true;
+            } else if (code >= 30 && code <= 37) {
+              currentColor = ANSI_COLORS[code] || DEFAULT_FG;
+            } else if (code >= 90 && code <= 97) {
+              currentColor = ANSI_COLORS[code] || DEFAULT_FG;
+            } else if (code === 39) {
+              currentColor = DEFAULT_FG;
+            } else if (code === 38) {
+              if (codes[k + 1] === 5 && codes[k + 2] !== void 0) {
+                const colorIndex = codes[k + 2];
+                currentColor = get256Color(colorIndex);
+                k += 2;
+              } else if (codes[k + 1] === 2 && codes[k + 2] !== void 0 && codes[k + 3] !== void 0 && codes[k + 4] !== void 0) {
+                currentColor = {
+                  r: codes[k + 2],
+                  g: codes[k + 3],
+                  b: codes[k + 4]
+                };
+                k += 4;
+              }
+            }
+            k++;
+          }
+        }
+        i = j + 1;
+        continue;
+      }
+      const textStart = i;
+      while (i < line.length && line[i] !== "\x1B") {
+        i++;
+      }
+      const spanText = line.slice(textStart, i);
+      if (spanText) {
+        spans.push({ text: spanText, color: currentColor, bold });
+      }
+    }
+    if (spans.length === 0) {
+      spans.push({ text: "", color: DEFAULT_FG, bold: false });
+    }
+    lines.push(spans);
+  }
+  return lines;
+}
+function get256Color(index) {
+  if (index < 16) {
+    const standardColors = [
+      { r: 0, g: 0, b: 0 },
+      // 0 black
+      { r: 128, g: 0, b: 0 },
+      // 1 red
+      { r: 0, g: 128, b: 0 },
+      // 2 green
+      { r: 128, g: 128, b: 0 },
+      // 3 yellow
+      { r: 0, g: 0, b: 128 },
+      // 4 blue
+      { r: 128, g: 0, b: 128 },
+      // 5 magenta
+      { r: 0, g: 128, b: 128 },
+      // 6 cyan
+      { r: 192, g: 192, b: 192 },
+      // 7 white
+      { r: 128, g: 128, b: 128 },
+      // 8 bright black
+      { r: 255, g: 0, b: 0 },
+      // 9 bright red
+      { r: 0, g: 255, b: 0 },
+      // 10 bright green
+      { r: 255, g: 255, b: 0 },
+      // 11 bright yellow
+      { r: 0, g: 0, b: 255 },
+      // 12 bright blue
+      { r: 255, g: 0, b: 255 },
+      // 13 bright magenta
+      { r: 0, g: 255, b: 255 },
+      // 14 bright cyan
+      { r: 255, g: 255, b: 255 }
+      // 15 bright white
+    ];
+    return standardColors[index] || DEFAULT_FG;
+  }
+  if (index < 232) {
+    const i = index - 16;
+    const r = Math.floor(i / 36);
+    const g = Math.floor(i % 36 / 6);
+    const b = i % 6;
+    return {
+      r: r === 0 ? 0 : 55 + r * 40,
+      g: g === 0 ? 0 : 55 + g * 40,
+      b: b === 0 ? 0 : 55 + b * 40
+    };
+  }
+  const gray = (index - 232) * 10 + 8;
+  return { r: gray, g: gray, b: gray };
+}
+function ansiToSvg(ansiText, options = {}) {
+  const {
+    fontFamily = "Menlo, Monaco, monospace",
+    fontSize = 14,
+    lineHeight = 22,
+    paddingX = 24,
+    paddingY = 24,
+    backgroundColor = `rgb(${DEFAULT_BG.r}, ${DEFAULT_BG.g}, ${DEFAULT_BG.b})`,
+    borderRadius = 8
+  } = options;
+  const lines = parseAnsi(ansiText);
+  while (lines.length > 0 && lines[lines.length - 1].every((span) => span.text.trim() === "")) {
+    lines.pop();
+  }
+  const charWidthEstimate = fontSize * 0.6;
+  const maxLineLength = Math.max(
+    ...lines.map((spans) => spans.reduce((acc, s) => acc + s.text.length, 0))
+  );
+  const width = Math.ceil(maxLineLength * charWidthEstimate + paddingX * 2);
+  const height = lines.length * lineHeight + paddingY * 2;
+  let svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">
+`;
+  svg += `  <rect width="100%" height="100%" fill="${backgroundColor}" rx="${borderRadius}" ry="${borderRadius}"/>
+`;
+  svg += `  <style>
+`;
+  svg += `    text { font-family: ${fontFamily}; font-size: ${fontSize}px; white-space: pre; }
+`;
+  svg += `    .b { font-weight: bold; }
+`;
+  svg += `  </style>
+`;
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+    const spans = lines[lineIndex];
+    const y = paddingY + (lineIndex + 1) * lineHeight - (lineHeight - fontSize) / 2;
+    svg += `  <text x="${paddingX}" y="${y}" xml:space="preserve">`;
+    for (const span of spans) {
+      if (!span.text) continue;
+      const colorStr = `rgb(${span.color.r}, ${span.color.g}, ${span.color.b})`;
+      const boldClass = span.bold ? ' class="b"' : "";
+      svg += `<tspan fill="${colorStr}"${boldClass}>${escapeXml(span.text)}</tspan>`;
+    }
+    svg += `</text>
+`;
+  }
+  svg += `</svg>`;
+  return svg;
+}
+export {
+  DEFAULT_BG,
+  DEFAULT_FG,
+  ansiToSvg,
+  parseAnsi
+};

package/dist/utils/api.js

@@ -0,0 +1,478 @@
+import { createHash } from "crypto";
+import { SYSTEM_PROMPT_DYNAMIC_BOUNDARY } from "src/constants/prompts.js";
+import { getSystemContext, getUserContext } from "src/context.js";
+import { isAnalyticsDisabled } from "src/services/analytics/config.js";
+import {
+  checkStatsigFeatureGate_CACHED_MAY_BE_STALE,
+  getFeatureValue_CACHED_MAY_BE_STALE
+} from "src/services/analytics/growthbook.js";
+import {
+  logEvent
+} from "src/services/analytics/index.js";
+import { prefetchAllMcpResources } from "src/services/mcp/client.js";
+import { BashTool } from "src/tools/BashTool/BashTool.js";
+import { FileEditTool } from "src/tools/FileEditTool/FileEditTool.js";
+import {
+  normalizeFileEditInput,
+  stripTrailingWhitespace
+} from "src/tools/FileEditTool/utils.js";
+import { FileWriteTool } from "src/tools/FileWriteTool/FileWriteTool.js";
+import { getTools } from "src/tools.js";
+import { CLI_SYSPROMPT_PREFIXES } from "../constants/system.js";
+import { roughTokenCountEstimation } from "../services/tokenEstimation.js";
+import { AGENT_TOOL_NAME } from "../tools/AgentTool/constants.js";
+import { EXIT_PLAN_MODE_V2_TOOL_NAME } from "../tools/ExitPlanModeTool/constants.js";
+import { TASK_OUTPUT_TOOL_NAME } from "../tools/TaskOutputTool/constants.js";
+import { isAgentSwarmsEnabled } from "./agentSwarmsEnabled.js";
+import {
+  modelSupportsStructuredOutputs,
+  shouldUseGlobalCacheScope
+} from "./betas.js";
+import { getCwd } from "./cwd.js";
+import { logForDebugging } from "./debug.js";
+import { isEnvTruthy } from "./envUtils.js";
+import { createUserMessage } from "./messages.js";
+import {
+  getAPIProvider,
+  isFirstPartyAnthropicBaseUrl
+} from "./model/providers.js";
+import {
+  getFileReadIgnorePatterns,
+  normalizePatternsToPath
+} from "./permissions/filesystem.js";
+import {
+  getPlan,
+  getPlanFilePath,
+  persistFileSnapshotIfRemote
+} from "./plans.js";
+import { getPlatform } from "./platform.js";
+import { countFilesRoundedRg } from "./ripgrep.js";
+import { jsonStringify } from "./slowOperations.js";
+import { getToolSchemaCache } from "./toolSchemaCache.js";
+import { windowsPathToPosixPath } from "./windowsPaths.js";
+import { zodToJsonSchema } from "./zodToJsonSchema.js";
+async function getToolSchemaCacheKey(tool, options) {
+  const baseKey = "inputJSONSchema" in tool && tool.inputJSONSchema ? `${tool.name}:${jsonStringify(tool.inputJSONSchema)}` : tool.name;
+  if (tool.name !== AGENT_TOOL_NAME) {
+    return baseKey;
+  }
+  const permissionContext = await options.getToolPermissionContext();
+  const mcpServers = Array.from(
+    new Set(
+      options.tools.map((t) => t.mcpInfo?.serverName ?? t.name?.split("__")[1]).filter((server) => Boolean(server))
+    )
+  ).sort();
+  const agentPromptInputs = options.agents.map((agent) => ({
+    agentType: agent.agentType,
+    whenToUse: agent.whenToUse,
+    tools: agent.tools,
+    disallowedTools: agent.disallowedTools,
+    mcpServers: agent.mcpServers,
+    requiredMcpServers: agent.requiredMcpServers
+  })).sort((a, b) => a.agentType.localeCompare(b.agentType));
+  const dynamicKey = createHash("sha256").update(
+    jsonStringify({
+      agents: agentPromptInputs,
+      allowedAgentTypes: options.allowedAgentTypes?.slice().sort(),
+      mcpServers,
+      denyRules: permissionContext.alwaysDenyRules
+    })
+  ).digest("hex").slice(0, 16);
+  return `${baseKey}:dynamic:${dynamicKey}`;
+}
+const SWARM_FIELDS_BY_TOOL = {
+  [EXIT_PLAN_MODE_V2_TOOL_NAME]: ["launchSwarm", "teammateCount"],
+  [AGENT_TOOL_NAME]: ["name", "team_name", "mode"]
+};
+function filterSwarmFieldsFromSchema(toolName, schema) {
+  const fieldsToRemove = SWARM_FIELDS_BY_TOOL[toolName];
+  if (!fieldsToRemove || fieldsToRemove.length === 0) {
+    return schema;
+  }
+  const filtered = { ...schema };
+  const props = filtered.properties;
+  if (props && typeof props === "object") {
+    const filteredProps = { ...props };
+    for (const field of fieldsToRemove) {
+      delete filteredProps[field];
+    }
+    filtered.properties = filteredProps;
+  }
+  return filtered;
+}
+async function toolToAPISchema(tool, options) {
+  const cacheKey = await getToolSchemaCacheKey(tool, options);
+  const cache = getToolSchemaCache();
+  let base = cache.get(cacheKey);
+  if (!base) {
+    const strictToolsEnabled = checkStatsigFeatureGate_CACHED_MAY_BE_STALE("tengu_tool_pear");
+    let input_schema = "inputJSONSchema" in tool && tool.inputJSONSchema ? tool.inputJSONSchema : zodToJsonSchema(tool.inputSchema);
+    if (!isAgentSwarmsEnabled()) {
+      input_schema = filterSwarmFieldsFromSchema(tool.name, input_schema);
+    }
+    base = {
+      name: tool.name,
+      description: await tool.prompt({
+        getToolPermissionContext: options.getToolPermissionContext,
+        tools: options.tools,
+        agents: options.agents,
+        allowedAgentTypes: options.allowedAgentTypes
+      }),
+      input_schema
+    };
+    if (strictToolsEnabled && tool.strict === true && options.model && modelSupportsStructuredOutputs(options.model)) {
+      base.strict = true;
+    }
+    if (getAPIProvider() === "firstParty" && isFirstPartyAnthropicBaseUrl() && (getFeatureValue_CACHED_MAY_BE_STALE("tengu_fgts", false) || isEnvTruthy(process.env.XCODE_ENABLE_FINE_GRAINED_TOOL_STREAMING))) {
+      base.eager_input_streaming = true;
+    }
+    cache.set(cacheKey, base);
+  }
+  const schema = {
+    name: base.name,
+    description: base.description,
+    input_schema: base.input_schema,
+    ...base.strict && { strict: true },
+    ...base.eager_input_streaming && { eager_input_streaming: true }
+  };
+  if (options.deferLoading) {
+    schema.defer_loading = true;
+  }
+  if (options.cacheControl) {
+    schema.cache_control = options.cacheControl;
+  }
+  if (isEnvTruthy(process.env.XCODE_DISABLE_EXPERIMENTAL_BETAS)) {
+    const allowed = /* @__PURE__ */ new Set([
+      "name",
+      "description",
+      "input_schema",
+      "cache_control"
+    ]);
+    const stripped = Object.keys(schema).filter((k) => !allowed.has(k));
+    if (stripped.length > 0) {
+      logStripOnce(stripped);
+      return {
+        name: schema.name,
+        description: schema.description,
+        input_schema: schema.input_schema,
+        ...schema.cache_control && { cache_control: schema.cache_control }
+      };
+    }
+  }
+  return schema;
+}
+let loggedStrip = false;
+function logStripOnce(stripped) {
+  if (loggedStrip) return;
+  loggedStrip = true;
+  logForDebugging(
+    `[betas] Stripped from tool schemas: [${stripped.join(", ")}] (XCODE_DISABLE_EXPERIMENTAL_BETAS=1)`
+  );
+}
+function logAPIPrefix(systemPrompt) {
+  const [firstSyspromptBlock] = splitSysPromptPrefix(systemPrompt);
+  const firstSystemPrompt = firstSyspromptBlock?.text;
+  logEvent("tengu_sysprompt_block", {
+    snippet: firstSystemPrompt?.slice(
+      0,
+      20
+    ),
+    length: firstSystemPrompt?.length ?? 0,
+    hash: firstSystemPrompt ? createHash("sha256").update(firstSystemPrompt).digest("hex") : ""
+  });
+}
+function splitSysPromptPrefix(systemPrompt, options) {
+  const useGlobalCacheFeature = shouldUseGlobalCacheScope();
+  if (useGlobalCacheFeature && options?.skipGlobalCacheForSystemPrompt) {
+    logEvent("tengu_sysprompt_using_tool_based_cache", {
+      promptBlockCount: systemPrompt.length
+    });
+    let attributionHeader2;
+    let systemPromptPrefix2;
+    const rest2 = [];
+    for (const prompt of systemPrompt) {
+      if (!prompt) continue;
+      if (prompt === SYSTEM_PROMPT_DYNAMIC_BOUNDARY) continue;
+      if (prompt.startsWith("x-anthropic-billing-header")) {
+        attributionHeader2 = prompt;
+      } else if (CLI_SYSPROMPT_PREFIXES.has(prompt)) {
+        systemPromptPrefix2 = prompt;
+      } else {
+        rest2.push(prompt);
+      }
+    }
+    const result2 = [];
+    if (attributionHeader2) {
+      result2.push({ text: attributionHeader2, cacheScope: null });
+    }
+    if (systemPromptPrefix2) {
+      result2.push({ text: systemPromptPrefix2, cacheScope: "org" });
+    }
+    const restJoined2 = rest2.join("\n\n");
+    if (restJoined2) {
+      result2.push({ text: restJoined2, cacheScope: "org" });
+    }
+    return result2;
+  }
+  if (useGlobalCacheFeature) {
+    const boundaryIndex = systemPrompt.findIndex(
+      (s) => s === SYSTEM_PROMPT_DYNAMIC_BOUNDARY
+    );
+    if (boundaryIndex !== -1) {
+      let attributionHeader2;
+      let systemPromptPrefix2;
+      const staticBlocks = [];
+      const dynamicBlocks = [];
+      for (let i = 0; i < systemPrompt.length; i++) {
+        const block = systemPrompt[i];
+        if (!block || block === SYSTEM_PROMPT_DYNAMIC_BOUNDARY) continue;
+        if (block.startsWith("x-anthropic-billing-header")) {
+          attributionHeader2 = block;
+        } else if (CLI_SYSPROMPT_PREFIXES.has(block)) {
+          systemPromptPrefix2 = block;
+        } else if (i < boundaryIndex) {
+          staticBlocks.push(block);
+        } else {
+          dynamicBlocks.push(block);
+        }
+      }
+      const result2 = [];
+      if (attributionHeader2)
+        result2.push({ text: attributionHeader2, cacheScope: null });
+      if (systemPromptPrefix2)
+        result2.push({ text: systemPromptPrefix2, cacheScope: null });
+      const staticJoined = staticBlocks.join("\n\n");
+      if (staticJoined)
+        result2.push({ text: staticJoined, cacheScope: "global" });
+      const dynamicJoined = dynamicBlocks.join("\n\n");
+      if (dynamicJoined) result2.push({ text: dynamicJoined, cacheScope: null });
+      logEvent("tengu_sysprompt_boundary_found", {
+        blockCount: result2.length,
+        staticBlockLength: staticJoined.length,
+        dynamicBlockLength: dynamicJoined.length
+      });
+      return result2;
+    } else {
+      logEvent("tengu_sysprompt_missing_boundary_marker", {
+        promptBlockCount: systemPrompt.length
+      });
+    }
+  }
+  let attributionHeader;
+  let systemPromptPrefix;
+  const rest = [];
+  for (const block of systemPrompt) {
+    if (!block) continue;
+    if (block.startsWith("x-anthropic-billing-header")) {
+      attributionHeader = block;
+    } else if (CLI_SYSPROMPT_PREFIXES.has(block)) {
+      systemPromptPrefix = block;
+    } else {
+      rest.push(block);
+    }
+  }
+  const result = [];
+  if (attributionHeader)
+    result.push({ text: attributionHeader, cacheScope: null });
+  if (systemPromptPrefix)
+    result.push({ text: systemPromptPrefix, cacheScope: "org" });
+  const restJoined = rest.join("\n\n");
+  if (restJoined) result.push({ text: restJoined, cacheScope: "org" });
+  return result;
+}
+function appendSystemContext(systemPrompt, context) {
+  return [
+    ...systemPrompt,
+    Object.entries(context).map(([key, value]) => `${key}: ${value}`).join("\n")
+  ].filter(Boolean);
+}
+function prependUserContext(messages, context) {
+  if (process.env.NODE_ENV === "test") {
+    return messages;
+  }
+  if (Object.entries(context).length === 0) {
+    return messages;
+  }
+  return [
+    createUserMessage({
+      content: `<system-reminder>
+As you answer the user's questions, you can use the following context:
+${Object.entries(
+        context
+      ).map(([key, value]) => `# ${key}
+${value}`).join("\n")}
+
+      IMPORTANT: this context may or may not be relevant to your tasks. You should not respond to this context unless it is highly relevant to your task.
+</system-reminder>
+`,
+      isMeta: true
+    }),
+    ...messages
+  ];
+}
+async function logContextMetrics(mcpConfigs, toolPermissionContext) {
+  if (isAnalyticsDisabled()) {
+    return;
+  }
+  const [{ tools: mcpTools }, tools, userContext, systemContext] = await Promise.all([
+    prefetchAllMcpResources(mcpConfigs),
+    getTools(toolPermissionContext),
+    getUserContext(),
+    getSystemContext()
+  ]);
+  const gitStatusSize = systemContext.gitStatus?.length ?? 0;
+  const claudeMdSize = userContext.claudeMd?.length ?? 0;
+  const totalContextSize = gitStatusSize + claudeMdSize;
+  const currentDir = getCwd();
+  const ignorePatternsByRoot = getFileReadIgnorePatterns(toolPermissionContext);
+  const normalizedIgnorePatterns = normalizePatternsToPath(
+    ignorePatternsByRoot,
+    currentDir
+  );
+  const fileCount = await countFilesRoundedRg(
+    currentDir,
+    AbortSignal.timeout(1e3),
+    normalizedIgnorePatterns
+  );
+  let mcpToolsCount = 0;
+  let mcpServersCount = 0;
+  let mcpToolsTokens = 0;
+  let nonMcpToolsCount = 0;
+  let nonMcpToolsTokens = 0;
+  const nonMcpTools = tools.filter((tool) => !tool.isMcp);
+  mcpToolsCount = mcpTools.length;
+  nonMcpToolsCount = nonMcpTools.length;
+  const serverNames = /* @__PURE__ */ new Set();
+  for (const tool of mcpTools) {
+    const parts = tool.name.split("__");
+    if (parts.length >= 3 && parts[1]) {
+      serverNames.add(parts[1]);
+    }
+  }
+  mcpServersCount = serverNames.size;
+  for (const tool of mcpTools) {
+    const schema = "inputJSONSchema" in tool && tool.inputJSONSchema ? tool.inputJSONSchema : zodToJsonSchema(tool.inputSchema);
+    mcpToolsTokens += roughTokenCountEstimation(jsonStringify(schema));
+  }
+  for (const tool of nonMcpTools) {
+    const schema = "inputJSONSchema" in tool && tool.inputJSONSchema ? tool.inputJSONSchema : zodToJsonSchema(tool.inputSchema);
+    nonMcpToolsTokens += roughTokenCountEstimation(jsonStringify(schema));
+  }
+  logEvent("tengu_context_size", {
+    git_status_size: gitStatusSize,
+    memcode_md_size: claudeMdSize,
+    total_context_size: totalContextSize,
+    project_file_count_rounded: fileCount,
+    mcp_tools_count: mcpToolsCount,
+    mcp_servers_count: mcpServersCount,
+    mcp_tools_tokens: mcpToolsTokens,
+    non_mcp_tools_count: nonMcpToolsCount,
+    non_mcp_tools_tokens: nonMcpToolsTokens
+  });
+}
+function normalizeToolInput(tool, input, agentId) {
+  switch (tool.name) {
+    case EXIT_PLAN_MODE_V2_TOOL_NAME: {
+      const plan = getPlan(agentId);
+      const planFilePath = getPlanFilePath(agentId);
+      void persistFileSnapshotIfRemote();
+      return plan !== null ? { ...input, plan, planFilePath } : input;
+    }
+    case BashTool.name: {
+      const parsed = BashTool.inputSchema.parse(input);
+      const { command, timeout, description } = parsed;
+      const cwd = getCwd();
+      let normalizedCommand = command.replace(`cd ${cwd} && `, "");
+      if (getPlatform() === "windows") {
+        normalizedCommand = normalizedCommand.replace(
+          `cd ${windowsPathToPosixPath(cwd)} && `,
+          ""
+        );
+      }
+      normalizedCommand = normalizedCommand.replace(/\\\\;/g, "\\;");
+      if (/^echo\s+["']?[^|&;><]*["']?$/i.test(normalizedCommand.trim())) {
+        logEvent("tengu_bash_tool_simple_echo", {});
+      }
+      const run_in_background = "run_in_background" in parsed ? parsed.run_in_background : void 0;
+      return {
+        command: normalizedCommand,
+        description,
+        ...timeout !== void 0 && { timeout },
+        ...description !== void 0 && { description },
+        ...run_in_background !== void 0 && { run_in_background },
+        ..."dangerouslyDisableSandbox" in parsed && parsed.dangerouslyDisableSandbox !== void 0 && {
+          dangerouslyDisableSandbox: parsed.dangerouslyDisableSandbox
+        }
+      };
+    }
+    case FileEditTool.name: {
+      const parsedInput = FileEditTool.inputSchema.parse(input);
+      const { file_path, edits } = normalizeFileEditInput({
+        file_path: parsedInput.file_path,
+        edits: [
+          {
+            old_string: parsedInput.old_string,
+            new_string: parsedInput.new_string,
+            replace_all: parsedInput.replace_all
+          }
+        ]
+      });
+      return {
+        replace_all: edits[0].replace_all,
+        file_path,
+        old_string: edits[0].old_string,
+        new_string: edits[0].new_string
+      };
+    }
+    case FileWriteTool.name: {
+      const parsedInput = FileWriteTool.inputSchema.parse(input);
+      const isMarkdown = /\.(md|mdx)$/i.test(parsedInput.file_path);
+      return {
+        file_path: parsedInput.file_path,
+        content: isMarkdown ? parsedInput.content : stripTrailingWhitespace(parsedInput.content)
+      };
+    }
+    case TASK_OUTPUT_TOOL_NAME: {
+      const legacyInput = input;
+      const taskId = legacyInput.task_id ?? legacyInput.agentId ?? legacyInput.bash_id;
+      const timeout = legacyInput.timeout ?? (typeof legacyInput.wait_up_to === "number" ? legacyInput.wait_up_to * 1e3 : void 0);
+      return {
+        task_id: taskId ?? "",
+        block: legacyInput.block ?? true,
+        timeout: timeout ?? 3e4
+      };
+    }
+    default:
+      return input;
+  }
+}
+function normalizeToolInputForAPI(tool, input) {
+  switch (tool.name) {
+    case EXIT_PLAN_MODE_V2_TOOL_NAME: {
+      if (input && typeof input === "object" && ("plan" in input || "planFilePath" in input)) {
+        const { plan, planFilePath, ...rest } = input;
+        return rest;
+      }
+      return input;
+    }
+    case FileEditTool.name: {
+      if (input && typeof input === "object" && "edits" in input) {
+        const { old_string, new_string, replace_all, ...rest } = input;
+        return rest;
+      }
+      return input;
+    }
+    default:
+      return input;
+  }
+}
+export {
+  appendSystemContext,
+  logAPIPrefix,
+  logContextMetrics,
+  normalizeToolInput,
+  normalizeToolInputForAPI,
+  prependUserContext,
+  splitSysPromptPrefix,
+  toolToAPISchema
+};

package/dist/utils/apiKeyHelper.js

@@ -0,0 +1,11 @@
+import { XCODE_DEFAULT_API_KEY } from "../constants/memcodeDefaults.js";
+function resolveOpenRouterApiKey() {
+  return process.env.OPENROUTER_API_KEY || process.env.XCODE_API_KEY || (process.env.ANTHROPIC_API_KEY?.startsWith("sk-or-") ? process.env.ANTHROPIC_API_KEY : void 0) || XCODE_DEFAULT_API_KEY || "";
+}
+function hasAnyApiKey() {
+  return resolveOpenRouterApiKey().length > 0;
+}
+export {
+  hasAnyApiKey,
+  resolveOpenRouterApiKey
+};