n9router 0.4.49 → 0.4.51

package/app/open-sse/translator/concerns/kiroConversation.js

@@ -0,0 +1,435 @@
+import {
+  KIRO_TOOL_DESCRIPTION_MAX_LENGTH,
+  KIRO_TOOL_ID_MAX_LENGTH,
+  KIRO_TOOL_NAME_MAX_LENGTH,
+} from "../../config/kiroConstants.js";
+
+const TOOL_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+const TOOL_NAME_PATTERN = /[^a-zA-Z0-9_-]/g;
+
+function clone(value) {
+  return value == null ? value : JSON.parse(JSON.stringify(value));
+}
+
+function text(value) {
+  if (typeof value === "string") return value;
+  if (value == null) return "";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+function appendText(target, extra) {
+  if (!extra) return;
+  target.content = target.content ? `${target.content}\n\n${extra}` : extra;
+}
+
+function trimCodePoints(value, limit) {
+  return [...String(value || "")].slice(0, limit).join("");
+}
+
+function uniqueName(rawName, index, usedNames) {
+  const cleaned = String(rawName || "")
+    .trim()
+    .replace(TOOL_NAME_PATTERN, "_")
+    .replace(/_+/g, "_")
+    .replace(/^_+|_+$/g, "");
+  const base = trimCodePoints(cleaned || `tool_${index + 1}`, KIRO_TOOL_NAME_MAX_LENGTH);
+  let candidate = base;
+  let suffix = 2;
+  while (usedNames.has(candidate)) {
+    const tail = `_${suffix++}`;
+    candidate = `${base.slice(0, KIRO_TOOL_NAME_MAX_LENGTH - tail.length)}${tail}`;
+  }
+  usedNames.add(candidate);
+  return candidate;
+}
+
+function cleanSchemaValue(value) {
+  if (Array.isArray(value)) return value.map(cleanSchemaValue);
+  if (!value || typeof value !== "object") return value;
+
+  const cleaned = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (key === "additionalProperties") continue;
+    if (key === "required" && Array.isArray(child) && child.length === 0) continue;
+    cleaned[key] = cleanSchemaValue(child);
+  }
+  return cleaned;
+}
+
+function normalizeRootSchema(schema) {
+  const cleaned = cleanSchemaValue(schema && typeof schema === "object" ? clone(schema) : {});
+  cleaned.type = "object";
+  if (!cleaned.properties || typeof cleaned.properties !== "object" || Array.isArray(cleaned.properties)) {
+    cleaned.properties = {};
+  }
+  if (Array.isArray(cleaned.required)) {
+    cleaned.required = [...new Set(cleaned.required.filter(
+      (name) => typeof name === "string" && Object.hasOwn(cleaned.properties, name)
+    ))];
+    if (cleaned.required.length === 0) delete cleaned.required;
+  }
+  return cleaned;
+}
+
+/** Normalize OpenAI- or Claude-shaped tool definitions into Kiro tool specs. */
+export function normalizeKiroToolSpecs(tools) {
+  const specs = [];
+  const nameMap = new Map();
+  const usedNames = new Set();
+
+  for (const [index, tool] of (Array.isArray(tools) ? tools : []).entries()) {
+    if (!tool || typeof tool !== "object") continue;
+    const rawName = tool.function?.name ?? tool.name;
+    if (typeof rawName !== "string" || !rawName.trim()) continue;
+
+    // A repeated definition with the same source name describes the same tool.
+    if (nameMap.has(rawName)) continue;
+    const name = uniqueName(rawName, index, usedNames);
+    nameMap.set(rawName, name);
+
+    const rawDescription = tool.function?.description ?? tool.description ?? `Tool: ${rawName}`;
+    const description = trimCodePoints(
+      String(rawDescription || `Tool: ${rawName}`),
+      KIRO_TOOL_DESCRIPTION_MAX_LENGTH
+    );
+    const schema = tool.function?.parameters ?? tool.parameters ?? tool.input_schema ?? {};
+    specs.push({
+      toolSpecification: {
+        name,
+        description,
+        inputSchema: { json: normalizeRootSchema(schema) },
+      },
+    });
+  }
+
+  return { specs, nameMap };
+}
+
+function toolCallText(toolUse) {
+  return `[Tool call: ${toolUse?.name || "unknown"}(${text(toolUse?.input || {})})]`;
+}
+
+function toolResultText(toolResult) {
+  const content = Array.isArray(toolResult?.content)
+    ? toolResult.content.map((part) => text(part?.text ?? part)).filter(Boolean).join("\n")
+    : text(toolResult?.content);
+  return `[Tool result${toolResult?.status === "error" ? " (error)" : ""}: ${content}]`;
+}
+
+function mergeUser(target, source) {
+  appendText(target, source.content);
+  if (Array.isArray(source.images) && source.images.length > 0) {
+    target.images = [...(target.images || []), ...source.images];
+  }
+  const results = source.userInputMessageContext?.toolResults;
+  if (Array.isArray(results) && results.length > 0) {
+    target.userInputMessageContext ||= {};
+    target.userInputMessageContext.toolResults = [
+      ...(target.userInputMessageContext.toolResults || []),
+      ...results,
+    ];
+  }
+}
+
+function mergeAssistant(target, source) {
+  appendText(target, source.content);
+  if (Array.isArray(source.toolUses) && source.toolUses.length > 0) {
+    target.toolUses = [...(target.toolUses || []), ...source.toolUses];
+  }
+}
+
+function normalizeTurns(history, currentMessage, modelId) {
+  const rawTurns = [...(Array.isArray(history) ? history : [])];
+  if (currentMessage) rawTurns.push(currentMessage);
+  const turns = [];
+
+  for (const raw of rawTurns) {
+    const isUser = !!raw?.userInputMessage;
+    const isAssistant = !!raw?.assistantResponseMessage;
+    if (isUser === isAssistant) continue;
+
+    const turn = isUser
+      ? { userInputMessage: clone(raw.userInputMessage) }
+      : { assistantResponseMessage: clone(raw.assistantResponseMessage) };
+    const previous = turns[turns.length - 1];
+    if (turn.userInputMessage && previous?.userInputMessage) {
+      mergeUser(previous.userInputMessage, turn.userInputMessage);
+    } else if (turn.assistantResponseMessage && previous?.assistantResponseMessage) {
+      mergeAssistant(previous.assistantResponseMessage, turn.assistantResponseMessage);
+    } else {
+      turns.push(turn);
+    }
+  }
+
+  if (turns[0]?.assistantResponseMessage) {
+    turns.unshift({ userInputMessage: { content: "continue", modelId } });
+  }
+  if (turns.length === 0 || turns[turns.length - 1]?.assistantResponseMessage) {
+    turns.push({ userInputMessage: { content: "continue", modelId } });
+  }
+
+  for (const turn of turns) {
+    if (turn.userInputMessage) {
+      turn.userInputMessage.content = text(turn.userInputMessage.content).trim() || "continue";
+      turn.userInputMessage.modelId ||= modelId;
+      if (turn.userInputMessage.userInputMessageContext?.tools) {
+        delete turn.userInputMessage.userInputMessageContext.tools;
+      }
+    } else {
+      turn.assistantResponseMessage.content =
+        text(turn.assistantResponseMessage.content).trim() || "...";
+    }
+  }
+  return turns;
+}
+
+function rawId(value) {
+  return typeof value === "string" ? value : "";
+}
+
+function reserveToolId(value, turnIndex, callIndex, name, usedIds) {
+  const sanitized = rawId(value).replace(/[^a-zA-Z0-9_-]/g, "");
+  const generated = `call_msg${turnIndex}_tc${callIndex}_${name || "tool"}`;
+  const base = trimCodePoints(
+    TOOL_ID_PATTERN.test(sanitized) && sanitized ? sanitized : generated,
+    KIRO_TOOL_ID_MAX_LENGTH
+  );
+  let candidate = base;
+  let suffix = 2;
+  while (usedIds.has(candidate)) {
+    const tail = `_${suffix++}`;
+    candidate = `${base.slice(0, KIRO_TOOL_ID_MAX_LENGTH - tail.length)}${tail}`;
+  }
+  usedIds.add(candidate);
+  return candidate;
+}
+
+function normalizeToolInput(input) {
+  if (input && typeof input === "object" && !Array.isArray(input)) return clone(input);
+  if (typeof input === "string") {
+    try {
+      const parsed = JSON.parse(input);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+    } catch {
+      return null;
+    }
+  }
+  return input == null ? {} : null;
+}
+
+function normalizeToolResult(result) {
+  const content = Array.isArray(result?.content)
+    ? result.content.map((part) => ({ text: text(part?.text ?? part) }))
+    : [{ text: text(result?.content) }];
+  return {
+    toolUseId: rawId(result?.toolUseId),
+    status: result?.status === "error" ? "error" : "success",
+    content: content.length > 0 ? content : [{ text: "" }],
+  };
+}
+
+function flattenResults(userMessage, results) {
+  for (const result of results) appendText(userMessage, toolResultText(result));
+}
+
+function cleanUserContext(userMessage) {
+  const context = userMessage.userInputMessageContext;
+  if (!context) return;
+  if (!context.toolResults?.length) delete context.toolResults;
+  if (!context.tools?.length) delete context.tools;
+  if (Object.keys(context).length === 0) delete userMessage.userInputMessageContext;
+}
+
+function reconcileToolPair(assistant, user, turnIndex, nameMap, specNames, usedIds, repairs) {
+  const calls = Array.isArray(assistant.toolUses) ? assistant.toolUses : [];
+  const results = Array.isArray(user.userInputMessageContext?.toolResults)
+    ? user.userInputMessageContext.toolResults.map(normalizeToolResult)
+    : [];
+  if (calls.length === 0) {
+    if (results.length > 0) {
+      flattenResults(user, results);
+      repairs.orphanResults += results.length;
+    }
+    if (user.userInputMessageContext) delete user.userInputMessageContext.toolResults;
+    cleanUserContext(user);
+    return;
+  }
+
+  const callQueues = new Map();
+  const callRecords = calls.map((call, callIndex) => {
+    const key = rawId(call?.toolUseId);
+    const mappedName = nameMap.get(call?.name) || call?.name;
+    const input = normalizeToolInput(call?.input);
+    const record = { call, callIndex, key, mappedName, input, result: null };
+    const queue = callQueues.get(key) || [];
+    queue.push(record);
+    callQueues.set(key, queue);
+    return record;
+  });
+
+  const orphanResults = [];
+  for (const result of results) {
+    const queue = callQueues.get(rawId(result.toolUseId));
+    const record = queue?.find((candidate) => !candidate.result);
+    if (record) record.result = result;
+    else orphanResults.push(result);
+  }
+
+  const keptCalls = [];
+  const keptResults = [];
+  for (const record of callRecords) {
+    const hasSpec = typeof record.mappedName === "string" && specNames.has(record.mappedName);
+    const valid = !!record.result && hasSpec && record.input !== null;
+    if (!valid) {
+      appendText(assistant, toolCallText({ name: record.mappedName, input: record.call?.input }));
+      repairs.missingResults += record.result ? 0 : 1;
+      repairs.invalidToolUses += hasSpec && record.input !== null ? 0 : 1;
+      if (record.result) {
+        flattenResults(user, [record.result]);
+        repairs.orphanResults++;
+      }
+      continue;
+    }
+
+    const toolUseId = reserveToolId(
+      record.key,
+      turnIndex,
+      record.callIndex,
+      record.mappedName,
+      usedIds
+    );
+    keptCalls.push({
+      toolUseId,
+      name: record.mappedName,
+      input: record.input,
+    });
+    keptResults.push({ ...record.result, toolUseId });
+  }
+
+  if (orphanResults.length > 0) {
+    flattenResults(user, orphanResults);
+    repairs.orphanResults += orphanResults.length;
+  }
+
+  if (keptCalls.length > 0) assistant.toolUses = keptCalls;
+  else delete assistant.toolUses;
+  user.userInputMessageContext ||= {};
+  if (keptResults.length > 0) user.userInputMessageContext.toolResults = keptResults;
+  else delete user.userInputMessageContext.toolResults;
+  cleanUserContext(user);
+}
+
+/** Validate the final Kiro wire conversation without mutating it. */
+export function validateKiroConversation(history, currentMessage, toolSpecs = []) {
+  const errors = [];
+  const turns = [...(history || []), currentMessage].filter(Boolean);
+  const specNames = new Set(toolSpecs.map((spec) => spec?.toolSpecification?.name).filter(Boolean));
+  const usedIds = new Set();
+
+  for (let index = 0; index < turns.length; index++) {
+    const expectedUser = index % 2 === 0;
+    const isUser = !!turns[index]?.userInputMessage;
+    if (isUser !== expectedUser) errors.push(`role:${index}`);
+    if (!isUser) {
+      const calls = turns[index].assistantResponseMessage?.toolUses || [];
+      const results = turns[index + 1]?.userInputMessage?.userInputMessageContext?.toolResults || [];
+      const callIds = calls.map((call) => call.toolUseId);
+      const resultIds = results.map((result) => result.toolUseId);
+      if (calls.length !== results.length || callIds.some((id) => !resultIds.includes(id))) {
+        errors.push(`pair:${index}`);
+      }
+      for (const call of calls) {
+        if (!call.toolUseId || usedIds.has(call.toolUseId)) errors.push(`id:${index}`);
+        usedIds.add(call.toolUseId);
+        if (!specNames.has(call.name)) errors.push(`spec:${index}`);
+      }
+    } else if (index === 0) {
+      const results = turns[index].userInputMessage?.userInputMessageContext?.toolResults;
+      if (results?.length) errors.push("orphan:0");
+    }
+  }
+  if (!currentMessage?.userInputMessage?.content) errors.push("current");
+  return { valid: errors.length === 0, errors };
+}
+
+function flattenAllStructuredTools(turns, repairs) {
+  for (const turn of turns) {
+    if (turn.assistantResponseMessage?.toolUses?.length) {
+      for (const call of turn.assistantResponseMessage.toolUses) {
+        appendText(turn.assistantResponseMessage, toolCallText(call));
+      }
+      repairs.invalidToolUses += turn.assistantResponseMessage.toolUses.length;
+      delete turn.assistantResponseMessage.toolUses;
+    }
+    const user = turn.userInputMessage;
+    const results = user?.userInputMessageContext?.toolResults;
+    if (results?.length) {
+      flattenResults(user, results);
+      repairs.orphanResults += results.length;
+      delete user.userInputMessageContext.toolResults;
+      cleanUserContext(user);
+    }
+  }
+}
+
+/**
+ * Produce a strict Kiro conversation: alternating turns, current user message,
+ * adjacent one-to-one tool use/result pairs, and tool specs only on currentMessage.
+ */
+export function canonicalizeKiroConversation({
+  history,
+  currentMessage,
+  modelId,
+  toolSpecs = [],
+  nameMap = new Map(),
+} = {}) {
+  const turns = normalizeTurns(history, currentMessage, modelId);
+  const repairs = { missingResults: 0, orphanResults: 0, invalidToolUses: 0 };
+  const specNames = new Set(toolSpecs.map((spec) => spec?.toolSpecification?.name).filter(Boolean));
+  const usedIds = new Set();
+
+  for (let index = 0; index < turns.length; index += 2) {
+    const user = turns[index].userInputMessage;
+    if (index === 0) {
+      const leadingResults = user.userInputMessageContext?.toolResults || [];
+      if (leadingResults.length > 0) {
+        flattenResults(user, leadingResults);
+        repairs.orphanResults += leadingResults.length;
+        delete user.userInputMessageContext.toolResults;
+        cleanUserContext(user);
+      }
+    }
+    const assistant = turns[index + 1]?.assistantResponseMessage;
+    const nextUser = turns[index + 2]?.userInputMessage;
+    if (assistant && nextUser) {
+      reconcileToolPair(assistant, nextUser, index + 1, nameMap, specNames, usedIds, repairs);
+    }
+  }
+
+  const finalCurrent = turns[turns.length - 1];
+  finalCurrent.userInputMessage.userInputMessageContext ||= {};
+  if (toolSpecs.length > 0) {
+    finalCurrent.userInputMessage.userInputMessageContext.tools = clone(toolSpecs);
+  }
+  cleanUserContext(finalCurrent.userInputMessage);
+
+  let finalHistory = turns.slice(0, -1);
+  let validation = validateKiroConversation(finalHistory, finalCurrent, toolSpecs);
+  if (!validation.valid) {
+    flattenAllStructuredTools(turns, repairs);
+    finalHistory = turns.slice(0, -1);
+    validation = validateKiroConversation(finalHistory, finalCurrent, toolSpecs);
+  }
+
+  return {
+    history: finalHistory,
+    currentMessage: finalCurrent,
+    repairs,
+    valid: validation.valid,
+    errors: validation.errors,
+  };
+}

package/app/open-sse/translator/concerns/thinkingUnified.js

@@ -3,6 +3,7 @@
 // never hardcoded per-model here. See .docs/thinking/plan.md MATRIX VI-A.
 
 import { getCapabilitiesForModel } from "../../providers/capabilities.js";
+import { getThinkingLevels } from "../../providers/thinkingLevels.js";
 import { PROVIDERS } from "../../providers/index.js";
 import { LEVEL_TO_BUDGET, budgetToLevel, effortToBudget, effortToThinkingLevel } from "./thinking.js";
 
@@ -37,6 +38,7 @@ export function parseSuffix(model) {
   const raw = m[2].trim().toLowerCase();
   if (raw === "none" || raw === "off") return { cleanModel, override: { mode: "none" } };
   if (raw === "auto") return { cleanModel, override: { mode: "auto" } };
+  if (raw === "ultra") return { cleanModel, override: { mode: "level", level: raw } };
   if (/^\d+$/.test(raw)) return { cleanModel, override: { mode: "budget", budget: Number(raw) } };
   if (LEVEL_TO_BUDGET[raw] !== undefined) return { cleanModel, override: { mode: "level", level: raw } };
   return { cleanModel, override: null };
@@ -134,6 +136,13 @@ function toLevel(cfg) {
   return null;
 }
 
+function normalizeOpenAILevel(level, supportedLevels) {
+  if (level !== "max" && level !== "ultra") return level;
+  if (supportedLevels?.includes(level)) return level;
+  if (level === "ultra" && supportedLevels?.includes("max")) return "max";
+  return "xhigh";
+}
+
 function toGeminiThinkingLevel(cfg) {
   const raw = cfg.mode === "auto" ? "high" : (toLevel(cfg) || "high");
   return effortToThinkingLevel(raw);
@@ -213,7 +222,7 @@ function stripAll(body) {
 }
 
 // Apply unified thinking config to body in the resolved provider-native format.
-function applyFormat(fmt, body, cfg, caps) {
+function applyFormat(fmt, body, cfg, caps, supportedLevels) {
   const none = cfg.mode === "none";
   const canDisable = caps.thinkingCanDisable !== false;
   // Model cannot disable thinking → clamp "none" to minimal effort instead.
@@ -223,8 +232,7 @@ function applyFormat(fmt, body, cfg, caps) {
     case "openai": {
       if (none && canDisable) { body.reasoning_effort = "none"; break; }
       const level = toLevel(eff);
-      // OpenAI reasoning_effort enum caps at "xhigh" (no "max"); clamp Claude Code's "max".
-      if (level) body.reasoning_effort = level === "max" ? "xhigh" : level;
+      if (level) body.reasoning_effort = normalizeOpenAILevel(level, supportedLevels);
       break;
     }
     case "claude-adaptive": {
@@ -296,6 +304,15 @@ function applyFormat(fmt, body, cfg, caps) {
       if (level) body.reasoning_effort = level === "xhigh" || level === "max" ? "high" : level;
       break;
     }
+    case "tokenrouter": {
+      // TokenRouter's reasoning_effort enum is low/medium/high/xhigh/max — it rejects
+      // "none"/"auto" with a 400 and supports "max" natively (no clamp like openai).
+      // "none" → omit the field so the upstream default applies; pass levels through.
+      if (none || eff.mode === "auto") break;
+      const level = toLevel(eff);
+      if (level) body.reasoning_effort = level;
+      break;
+    }
     case "kiro":
       // Kiro thinking handled via system-tag injection in openai-to-kiro.js; no body field here.
       break;
@@ -323,7 +340,8 @@ export function applyThinking(targetFormat, model, body, provider = null, intent
   if (!cfg) return body;
 
   const fmt = resolveFormat(targetFormat, cleanModel, provider);
+  const supportedLevels = getThinkingLevels(provider, cleanModel);
   stripAll(body);
-  applyFormat(fmt, body, cfg, caps);
+  applyFormat(fmt, body, cfg, caps, supportedLevels);
   return body;
 }

package/app/open-sse/translator/formats/claude.js

@@ -16,7 +16,9 @@ export function hasValidContent(msg) {
     return msg.content.some(block =>
       (block.type === CLAUDE_BLOCK.TEXT && block.text?.trim()) ||
       block.type === CLAUDE_BLOCK.TOOL_USE ||
-      block.type === CLAUDE_BLOCK.TOOL_RESULT
+      block.type === CLAUDE_BLOCK.TOOL_RESULT ||
+      block.type === CLAUDE_BLOCK.IMAGE ||
+      block.type === CLAUDE_BLOCK.DOCUMENT
     );
   }
   return false;

package/app/open-sse/translator/formats/gemini.js

@@ -7,7 +7,13 @@ import { OPENAI_BLOCK } from "../schema/index.js";
 export const UNSUPPORTED_SCHEMA_CONSTRAINTS = [
   // Basic constraints (not supported by Gemini API)
   "minLength", "maxLength", "exclusiveMinimum", "exclusiveMaximum",
-  "minItems", "maxItems", "format",
+  "minItems", "maxItems", "format", "multipleOf",
+  // Array keywords the Gemini schema proto has no field for. Agent tool
+  // schemas set these routinely, and one occurrence rejects the whole request
+  // with "Unknown name ...: Cannot find field".
+  "uniqueItems", "contains",
+  // 2020-12 keywords with no Gemini equivalent
+  "unevaluatedProperties", "unevaluatedItems", "contentSchema",
   // Claude rejects these in VALIDATED mode
   "default", "examples",
   // JSON Schema meta keywords
@@ -353,6 +359,19 @@ export function cleanJSONSchemaForAntigravity(schema) {
   function addPlaceholders(obj) {
     if (!obj || typeof obj !== "object") return;
 
+    // Empty schema {} (no type, no properties) after $ref removal — treat as object with placeholder
+    if (Object.keys(obj).length === 0) {
+      obj.type = "object";
+      obj.properties = {
+        reason: {
+          type: "string",
+          description: "Brief explanation of why you are calling this tool"
+        }
+      };
+      obj.required = ["reason"];
+      return;
+    }
+
     if (obj.type === "object") {
       if (!obj.properties || Object.keys(obj.properties).length === 0) {
         obj.properties = {

package/app/open-sse/translator/index.js

@@ -62,8 +62,13 @@ export function translateRequest(sourceFormat, targetFormat, model, body, stream
   // Always ensure tool_calls have id (some providers require it)
   ensureToolCallIds(result);
   
-  // Fix missing tool responses (insert empty tool_result if needed)
-  fixMissingToolResponses(result);
+  // Kiro performs stricter source-aware reconciliation after session replay.
+  // The generic helper inserts OpenAI `role: tool` messages, which a direct
+  // Claude→Kiro translator cannot consume and which cannot repair partial
+  // parallel tool results.
+  if (targetFormat !== FORMATS.KIRO) {
+    fixMissingToolResponses(result);
+  }
 
   // Capture thinking intent from the original (pre-translation) body, before any
   // format conversion strips/renames the fields. Applied after translation.
@@ -103,8 +108,16 @@ export function translateRequest(sourceFormat, targetFormat, model, body, stream
     }
   }
 
-  // Normalize thinking to the target provider-native format (config-driven, capability-aware)
-  applyThinking(targetFormat, model, result, provider, thinkingIntent);
+  // Normalize thinking to the target provider-native format (config-driven, capability-aware).
+  // Kiro's GenerateAssistantResponse request does not accept the generic top-level
+  // `thinking` field; its translators map thinking intent to KAS-compatible
+  // systemPrompt/additionalModelRequestFields instead.
+  const kiroThinkingMappedByTranslator =
+    targetFormat === FORMATS.KIRO &&
+    (sourceFormat === FORMATS.OPENAI || sourceFormat === FORMATS.CLAUDE);
+  if (!kiroThinkingMappedByTranslator) {
+    applyThinking(targetFormat, model, result, provider, thinkingIntent);
+  }
 
   // Always normalize to clean OpenAI format when target is OpenAI
   // This handles hybrid requests (e.g., OpenAI messages + Claude tools)
@@ -245,8 +258,10 @@ export function initState(sourceFormat) {
       funcArgsBuf: {},
       funcNames: {},
       funcCallIds: {},
+      funcItemAdded: {},
       funcArgsDone: {},
       funcItemDone: {},
+      customToolNames: new Set(),
       completedSent: false
     };
   }