@agent-native/core 0.175.3 → 0.175.4-nightly-20260826190205

package/corpus/templates/content/shared/nfm.ts

@@ -25,7 +25,9 @@
  *     lines (Notion strips them). Intentional blank blocks are `<empty-block/>`.
  *   - Block attributes as a trailing `{toggle="true" color="red"}` list.
  *   - Tables, toggles, callouts, columns, synced blocks, media, mentions use the
- *     HTML-ish tags from the spec. Tables are `<table>` HTML, never pipe tables.
+ *     HTML-ish tags from the spec. Canonical output uses `<table>` HTML; input
+ *     may also use an unaligned GFM pipe table, which is promoted to that typed
+ *     table grammar instead of flattening each row into a paragraph.
  *   - Inline text backslash-escapes the spec's special characters outside code.
  *
  * Registry blocks (the dev-doc / OpenAPI library shared with plan) are encoded
@@ -61,6 +63,20 @@ export interface PMDoc {
   content: PMNode[];
 }
 
+export type NfmFidelityStatus =
+  | "preserved"
+  | "transformed"
+  | "unresolved"
+  | "failed";
+
+export interface NfmFidelityReport {
+  status: NfmFidelityStatus;
+  normalizedChanged: boolean;
+  conversions: Array<{ kind: string; count: number }>;
+  unresolved: Array<{ kind: string; count: number }>;
+  error?: string;
+}
+
 // ── Colors (from the NFM spec) ──────────────────────────────────────
 const BASE_COLORS = [
   "gray",
@@ -1315,6 +1331,13 @@ function parseBlockSequence(
     const dedent = raw.slice(ind);
     const rel = ind - baseIndent;
 
+    const pipeTable = parseGfmPipeTable(lines, i, ind, rel);
+    if (pipeTable) {
+      out.push(pipeTable.nodes[0]);
+      i = pipeTable.end;
+      continue;
+    }
+
     // Lists group consecutive items.
     const listKind = listKindOf(dedent);
     if (listKind) {
@@ -1332,6 +1355,146 @@ function parseBlockSequence(
   return { nodes: out, end: i };
 }
 
+function endsWithUnescapedPipe(value: string): boolean {
+  if (!value.endsWith("|")) return false;
+  let backslashes = 0;
+  for (let i = value.length - 2; i >= 0 && value[i] === "\\"; i--) {
+    backslashes++;
+  }
+  return backslashes % 2 === 0;
+}
+
+function splitGfmPipeRow(line: string): string[] | null {
+  const value = line.trim();
+  if (!value) return null;
+
+  const cells: string[] = [];
+  let cell = "";
+  let codeFenceLength = 0;
+  let sawSeparator = false;
+
+  for (let i = 0; i < value.length; i++) {
+    const char = value[i];
+    if (char === "\\" && i + 1 < value.length) {
+      cell += char + value[++i];
+      continue;
+    }
+    if (char === "`") {
+      let runLength = 1;
+      while (value[i + runLength] === "`") runLength++;
+      if (codeFenceLength === 0) codeFenceLength = runLength;
+      else if (codeFenceLength === runLength) codeFenceLength = 0;
+      cell += "`".repeat(runLength);
+      i += runLength - 1;
+      continue;
+    }
+    if (char === "|" && codeFenceLength === 0) {
+      cells.push(cell.trim());
+      cell = "";
+      sawSeparator = true;
+      continue;
+    }
+    cell += char;
+  }
+  cells.push(cell.trim());
+
+  if (!sawSeparator) return null;
+  if (value.startsWith("|")) cells.shift();
+  if (endsWithUnescapedPipe(value)) cells.pop();
+  return cells;
+}
+
+function isGfmDelimiterCell(value: string): boolean {
+  return /^-{3,}$/.test(value.trim());
+}
+
+function isAlignedGfmDelimiterCell(value: string): boolean {
+  return /^:?-{3,}:?$/.test(value.trim()) && value.includes(":");
+}
+
+function parseGfmPipeTable(
+  lines: string[],
+  start: number,
+  indent: number,
+  rel: number,
+): ParseResult | null {
+  if (start + 1 >= lines.length) return null;
+  if (leadingTabs(lines[start + 1]) !== indent) return null;
+
+  const header = splitGfmPipeRow(lines[start].slice(indent));
+  const delimiter = splitGfmPipeRow(lines[start + 1].slice(indent));
+  if (
+    !header ||
+    !delimiter ||
+    header.length === 0 ||
+    header.length !== delimiter.length ||
+    !delimiter.every(
+      (cell) => isGfmDelimiterCell(cell) || isAlignedGfmDelimiterCell(cell),
+    )
+  ) {
+    return null;
+  }
+
+  const rows = [header];
+  let end = start + 2;
+  let ragged = false;
+  while (end < lines.length) {
+    if (lines[end].trim() === "" || leadingTabs(lines[end]) !== indent) break;
+    const row = splitGfmPipeRow(lines[end].slice(indent));
+    if (!row) break;
+    if (row.length !== header.length) ragged = true;
+    rows.push(row);
+    end++;
+  }
+
+  const hasAlignment = delimiter.some(isAlignedGfmDelimiterCell);
+  if (hasAlignment || ragged) {
+    // Content's table grammar cannot represent column alignment or a ragged
+    // row without losing meaning. Keep the entire source construct together
+    // as one inspectable raw atom rather than escaping or partially promoting
+    // its lines into plausible-looking paragraphs.
+    return {
+      nodes: [
+        {
+          type: "notionBlockAtom",
+          attrs: {
+            tagName: "unknown",
+            attrsJson: JSON.stringify({ sourceFormat: "gfm-table" }),
+            label: "Unresolved GFM table",
+            __raw: lines
+              .slice(start, end)
+              .map((line) => line.slice(indent))
+              .join("\n"),
+            ...(rel > 0 ? { indent: rel } : {}),
+          },
+        },
+      ],
+      end,
+    };
+  }
+
+  const tableRows = rows.map((row, rowIndex) => ({
+    type: "tableRow",
+    attrs: { color: null },
+    content: row.map((cell) => ({
+      type: rowIndex === 0 ? "tableHeader" : "tableCell",
+      attrs: { color: null },
+      content: [{ type: "paragraph", content: parseInline(cell) }],
+    })),
+  }));
+  const attrs: Record<string, unknown> = {
+    headerRow: true,
+    headerColumn: false,
+    fitPageWidth: false,
+    colMeta: null,
+  };
+  if (rel > 0) attrs.indent = rel;
+  return {
+    nodes: [{ type: "table", attrs, content: tableRows }],
+    end,
+  };
+}
+
 type ListKind = "bullet" | "ordered" | "task";
 function listKindOf(dedent: string): ListKind | null {
   if (/^- \[[ xX]\]\s/.test(dedent)) return "task";
@@ -2263,6 +2426,189 @@ export function canonicalizeNfm(nfm: string | null | undefined): string {
   }
 }
 
+function countLocalMdxNodes(
+  node: PMNode,
+  predicate: (node: PMNode) => boolean,
+): number {
+  let count = node.type === "localMdxComponent" && predicate(node) ? 1 : 0;
+  for (const child of node.content ?? []) {
+    count += countLocalMdxNodes(child, predicate);
+  }
+  return count;
+}
+
+function countGfmPipeTables(
+  source: string,
+  delimiterPredicate: (cells: string[]) => boolean,
+): number {
+  const lines = source.replace(/\r\n?/g, "\n").split("\n");
+  const fencedCodeLines = fencedCodeLineMask(lines);
+  let count = 0;
+  for (let i = 0; i + 1 < lines.length; i++) {
+    if (fencedCodeLines[i] || fencedCodeLines[i + 1]) continue;
+    const indent = leadingTabs(lines[i]);
+    if (leadingTabs(lines[i + 1]) !== indent) continue;
+    const header = splitGfmPipeRow(lines[i].slice(indent));
+    const delimiter = splitGfmPipeRow(lines[i + 1].slice(indent));
+    if (
+      header &&
+      delimiter &&
+      header.length > 0 &&
+      header.length === delimiter.length &&
+      delimiterPredicate(delimiter)
+    ) {
+      count++;
+      i++;
+    }
+  }
+  return count;
+}
+
+function countRaggedGfmPipeTables(source: string): number {
+  const lines = source.replace(/\r\n?/g, "\n").split("\n");
+  const fencedCodeLines = fencedCodeLineMask(lines);
+  let count = 0;
+  for (let i = 0; i + 2 < lines.length; i++) {
+    if (fencedCodeLines[i] || fencedCodeLines[i + 1]) continue;
+    const indent = leadingTabs(lines[i]);
+    if (leadingTabs(lines[i + 1]) !== indent) continue;
+    const header = splitGfmPipeRow(lines[i].slice(indent));
+    const delimiter = splitGfmPipeRow(lines[i + 1].slice(indent));
+    if (
+      !header ||
+      !delimiter ||
+      header.length === 0 ||
+      header.length !== delimiter.length ||
+      !delimiter.every(isGfmDelimiterCell)
+    ) {
+      continue;
+    }
+    for (let rowIndex = i + 2; rowIndex < lines.length; rowIndex++) {
+      if (fencedCodeLines[rowIndex]) break;
+      if (
+        lines[rowIndex].trim() === "" ||
+        leadingTabs(lines[rowIndex]) !== indent
+      ) {
+        break;
+      }
+      const row = splitGfmPipeRow(lines[rowIndex].slice(indent));
+      if (!row) break;
+      if (row.length !== header.length) {
+        count++;
+        break;
+      }
+    }
+    i++;
+  }
+  return count;
+}
+
+function fencedCodeLineMask(lines: string[]): boolean[] {
+  const mask = lines.map(() => false);
+  let fence: { indent: number; length: number } | undefined;
+  for (let index = 0; index < lines.length; index++) {
+    const indent = leadingTabs(lines[index]);
+    const dedented = lines[index].slice(indent);
+    if (fence) {
+      mask[index] = true;
+      const close = dedented.match(/^(`{3,})\s*$/);
+      if (indent >= fence.indent && close && close[1].length >= fence.length) {
+        fence = undefined;
+      }
+      continue;
+    }
+    const open = dedented.match(/^(`{3,})(.*)$/);
+    if (open) {
+      mask[index] = true;
+      fence = { indent, length: open[1].length };
+    }
+  }
+  return mask;
+}
+
+/**
+ * Describe what the shared codec did without making callers infer fidelity
+ * from a clean-looking string. The document body remains the source of truth;
+ * this report is intentionally compact enough for import and agent receipts.
+ */
+export function inspectNfmFidelity(
+  nfm: string | null | undefined,
+): NfmFidelityReport {
+  const source = nfm ?? "";
+  try {
+    const document = nfmToDoc(source);
+    const normalized = canonicalizeNfm(source);
+    const raggedPipeTableCount = countRaggedGfmPipeTables(source);
+    const pipeTableCount = Math.max(
+      0,
+      countGfmPipeTables(source, (cells) => cells.every(isGfmDelimiterCell)) -
+        raggedPipeTableCount,
+    );
+    const alignedPipeTableCount = countGfmPipeTables(
+      source,
+      (cells) =>
+        cells.every(
+          (cell) => isGfmDelimiterCell(cell) || isAlignedGfmDelimiterCell(cell),
+        ) && cells.some(isAlignedGfmDelimiterCell),
+    );
+    const unsupportedMdxCount = countLocalMdxNodes(
+      document,
+      (node) => node.attrs?.unsupportedProps === true,
+    );
+
+    const conversions: NfmFidelityReport["conversions"] = [];
+    if (pipeTableCount > 0) {
+      conversions.push({
+        kind: "gfm-pipe-table-to-content-table",
+        count: pipeTableCount,
+      });
+    }
+    if (normalized !== source && conversions.length === 0) {
+      conversions.push({ kind: "canonicalized-nfm", count: 1 });
+    }
+
+    const unresolved: NfmFidelityReport["unresolved"] = [];
+    if (alignedPipeTableCount > 0) {
+      unresolved.push({
+        kind: "gfm-table-alignment-not-representable",
+        count: alignedPipeTableCount,
+      });
+    }
+    if (raggedPipeTableCount > 0) {
+      unresolved.push({
+        kind: "gfm-table-ragged-rows-preserved-as-raw-source",
+        count: raggedPipeTableCount,
+      });
+    }
+    if (unsupportedMdxCount > 0) {
+      unresolved.push({
+        kind: "mdx-component-props-preserved-as-raw-source",
+        count: unsupportedMdxCount,
+      });
+    }
+
+    return {
+      status:
+        unresolved.length > 0
+          ? "unresolved"
+          : conversions.length > 0 || normalized !== source
+            ? "transformed"
+            : "preserved",
+      normalizedChanged: normalized !== source,
+      conversions,
+      unresolved,
+    };
+  } catch (error) {
+    return {
+      status: "failed",
+      normalizedChanged: false,
+      conversions: [],
+      unresolved: [],
+      error: error instanceof Error ? error.message : "Unreadable content",
+    };
+  }
+}
+
 export function collapseExactRepeatedNfm(
   nfm: string,
   options: { requiredText: string },

package/corpus/templates/slides/server/plugins/agent-chat.ts

@@ -66,6 +66,8 @@ export default createAgentChatPlugin({
   prepareRequest: prepareSlidesChatAttachments,
   systemPrompt: `You are an AI deck assistant. You create, edit, import, export, style, share, and navigate decks through actions and shared application state. For a newly created presentation, use create-deck with slides: [] only when you are creating the deck yourself, then add-slide sequentially with full rendered HTML. The legacy generate-slides-ai action returns Markdown drafts and is not part of the persisted presentation workflow. When speaker notes are requested, keep presenter-only text in each slide's notes field rather than the slide HTML, and preserve notes during source-preserving edits.
 
+When a request includes a public URL as source material, fetch it with web-request before authoring. Inspect the returned page content, links, and agent-readable metadata, then follow any context, transcript, visual/frame, or asset URLs it exposes. Image responses are visual evidence for the deck and should be inspected when available; do not claim to have reviewed visuals that could not be fetched.
+
 When the user asks to improve, beautify, restyle, or make an uploaded/existing deck on-brand, treat it as an in-place source-preserving edit unless the user explicitly asks to rewrite the story or change slide count. First call view-screen when the active deck is unclear, then get-deck with compact=true for deck orientation. If you need slide markup, call get-deck with compact=false explicitly and only when the edit requires the full HTML. If get-deck.sourceImport exists, preserve its slide count, order, IDs, factual copy, notes, images, charts, tables, diagrams, freeform objects, and source aspect ratio. For a deck-wide restyle, use one patch-deck call with requireAllSourceSlides=true and one patch-slide operation with fields.content for every source slide ID; the action rejects partial coverage. Do not split a full-deck restyle into arbitrary batches or use one-by-one update-slide calls - reserve update-slide for targeted one-slide edits. After the patch succeeds, verify with get-deck using compact=true so the verification does not retransmit every slide's HTML. Do not claim a partial or initial pass. Do not use add-slide, delete, reorder, or replace source imagery with generic cards for this workflow. If sourceImport.fidelity is partial or imagesSkipped is nonzero, stop and report the exact fidelity warning instead of claiming a reliable improvement.
 For a targeted one-slide edit, prefer get-deck with the stable slideId from view-screen or compact get-deck. It returns only that slide's full HTML by default, so do not load the full deck when one slide is enough. For code-style edits, request compact=false and format=true, then call update-slide with that slide's contentHash as baseContentHash and an ordered edits list. Use exact replace, insert-before/after, replace-between, or regex-replace edits; include expectedMatches for ambiguous markers. The action applies the whole list atomically under the deck lock, so a failed required match writes nothing. Set format=true on update-slide when readable line breaks should be persisted. Use fullContent only for an intentional full rewrite. Pass compact=true when you only need a lightweight check of that slide.
 

package/dist/agent/engine/ai-sdk-engine.js

@@ -18,6 +18,7 @@ import { LLM_MISSING_CREDENTIALS_ERROR_CODE, LLM_MISSING_CREDENTIALS_MESSAGE, }
 import { classifyProviderError, describeErrorWithCauses, } from "./error-detail.js";
 import { createFirstEventAbortController } from "./first-event-timeout.js";
 import { clampThinkingBudgetTokens, resolveMaxOutputTokensForEngine, } from "./output-tokens.js";
+import { createProviderToolNameMap } from "./tool-name.js";
 import { engineToolsToAISDK, engineMessagesToAISDK, aiSdkPartToEngineEvents, aiSdkStepToAssistantContent, } from "./translate-ai-sdk.js";
 import { createStreamedToolInputState, finalizeStreamedToolInputs, observeStreamedToolInput, } from "./translate-anthropic.js";
 // ---------------------------------------------------------------------------
@@ -235,14 +236,16 @@ class AISDKEngine {
             };
             return;
         }
+        const toolNameMap = createProviderToolNameMap(opts.tools, opts.messages);
         const aiSdkTools = opts.tools.length > 0
-            ? engineToolsToAISDK(opts.tools, jsonSchema)
+            ? engineToolsToAISDK(opts.tools, jsonSchema, toolNameMap)
             : undefined;
         const messages = engineMessagesToAISDK(opts.messages, {
             // Vision-capable provider translators (anthropic/openai/google/
             // openrouter) map image parts to native blocks; the rest stringify
             // tool-result content arrays, so images degrade to their text notes.
             toolResultImages: this.capabilities.vision,
+            toolNameMap,
         });
         // Resolved once so both `maxOutputTokens` (below, in the streamText call)
         // and the thinking-budget headroom clamp agree on the same ceiling.
@@ -381,7 +384,7 @@ class AISDKEngine {
                     : {}),
                 abortSignal: firstEventAbort.signal,
                 onStepFinish: (step) => {
-                    assistantContent = aiSdkStepToAssistantContent(step);
+                    assistantContent = aiSdkStepToAssistantContent(step, toolNameMap);
                 },
                 ...(Object.keys(providerOpts).length > 0
                     ? { providerOptions: providerOpts }
@@ -402,7 +405,7 @@ class AISDKEngine {
                     sawFirstEvent = true;
                     firstEventAbort.markFirstEvent();
                 }
-                for (const event of aiSdkPartToEngineEvents(part)) {
+                for (const event of aiSdkPartToEngineEvents(part, toolNameMap)) {
                     observeStreamedToolInput(toolInputs, event);
                     if (event.type === "stop" &&
                         event.reason === "error" &&
@@ -453,7 +456,14 @@ class AISDKEngine {
                 yield recovered;
             }
             yield { type: "assistant-content", parts: assistantContent };
-            if (!credentialFailureRecorded) {
+            // Clearing the marker asserts "this credential demonstrably works", so
+            // only a turn that actually completed may do it. A turn that ended in
+            // error proves nothing about the credential, and this ran on every one:
+            // a single unrelated 500 re-admitted a credential a 401 had just pinned,
+            // so the next person's first prompt spent itself rediscovering the same
+            // rejection. `credentialFailureRecorded` only covers the 401 path.
+            const stoppedWithError = bufferedStop?.type === "stop" && bufferedStop.reason === "error";
+            if (!credentialFailureRecorded && !stoppedWithError) {
                 await clearProviderCredentialAuthFailure({
                     key: PROVIDER_ENV_VARS[this.provider][0],
                     value: this.apiKey,

package/dist/agent/engine/anthropic-engine.js

@@ -15,6 +15,7 @@ import { describeErrorWithCauses } from "./error-detail.js";
 import { createFirstEventAbortController } from "./first-event-timeout.js";
 import { clampThinkingBudgetTokens, resolveMaxOutputTokensForEngine, } from "./output-tokens.js";
 import { splitSystemPromptForCache, stablePrefixCacheControl, } from "./prompt-cache.js";
+import { createProviderToolNameMap } from "./tool-name.js";
 import { engineToolsToAnthropic, engineMessagesToAnthropic, anthropicContentToEngine, anthropicChunkToEngineEvents, createAnthropicChunkStreamState, createStreamedToolInputState, finalizeStreamedToolInputs, observeStreamedToolInput, } from "./translate-anthropic.js";
 export const ANTHROPIC_CAPABILITIES = {
     thinking: true,
@@ -41,8 +42,9 @@ class AnthropicEngine {
         // MAX_RETRIES times with backoff. Leaving the SDK on its default (2)
         // multiplies the two layers into ~12 HTTP requests per failed run.
         const client = new Anthropic({ apiKey: this.apiKey, maxRetries: 1 });
-        const tools = engineToolsToAnthropic(opts.tools);
-        const messages = engineMessagesToAnthropic(opts.messages);
+        const toolNameMap = createProviderToolNameMap(opts.tools, opts.messages);
+        const tools = engineToolsToAnthropic(opts.tools, toolNameMap);
+        const messages = engineMessagesToAnthropic(opts.messages, toolNameMap);
         const anthropicOpts = opts.providerOptions?.anthropic;
         // Resolved once so both max_tokens and the thinking-budget headroom
         // clamp below agree on the same ceiling.
@@ -170,14 +172,14 @@ class AnthropicEngine {
                 // The SDK's SSE parsing already drops `ping` keepalives before they
                 // reach this loop, so any chunk here is real provider progress.
                 firstEventAbort.markFirstEvent();
-                const events = anthropicChunkToEngineEvents(chunk, chunkState);
+                const events = anthropicChunkToEngineEvents(chunk, chunkState, toolNameMap);
                 for (const event of events) {
                     observeStreamedToolInput(toolInputs, event);
                     yield event;
                 }
             }
             const finalMessage = await apiStream.finalMessage();
-            const assistantContent = anthropicContentToEngine(finalMessage.content);
+            const assistantContent = anthropicContentToEngine(finalMessage.content, toolNameMap);
             // The final content can carry the same tool call with an empty input
             // even though the stream already delivered complete argument deltas.
             // Reconcile that copy before marking its id delivered.

package/dist/agent/engine/builder-engine.js

@@ -29,6 +29,7 @@ import { classifyTerminalErrorCode, describeErrorWithCauses, isBuilderGatewayInt
 import { FIRST_STREAM_EVENT_TIMEOUT_MS } from "./first-event-timeout.js";
 import { resolveMaxOutputTokensForEngine } from "./output-tokens.js";
 import { splitSystemPromptForCache, stablePrefixCacheControl, } from "./prompt-cache.js";
+import { createProviderToolNameMap, toEngineToolName, } from "./tool-name.js";
 import { createStreamedToolInputState, engineMessagesToBuilderGatewayAnthropic, engineToolsToAnthropic, finalizeStreamedToolInputs, observeStreamedToolInput, } from "./translate-anthropic.js";
 export const BUILDER_CAPABILITIES = {
     thinking: true,
@@ -173,8 +174,9 @@ class BuilderEngine {
         const model = requestedModel.length === 0 || requestedModel === "auto"
             ? BUILDER_DEFAULT_MODEL
             : requestedModel;
-        const messages = engineMessagesToBuilderGatewayAnthropic(opts.messages);
-        const tools = engineToolsToAnthropic(opts.tools);
+        const toolNameMap = createProviderToolNameMap(opts.tools, opts.messages);
+        const messages = engineMessagesToBuilderGatewayAnthropic(opts.messages, toolNameMap);
+        const tools = engineToolsToAnthropic(opts.tools, toolNameMap);
         const thinkingBudget = opts.providerOptions?.anthropic?.thinking?.budgetTokens;
         const reasoningEffort = normalizeReasoningEffortForModel(model, opts.reasoningEffort ??
             (typeof thinkingBudget === "number"
@@ -383,6 +385,7 @@ class BuilderEngine {
                 return;
             }
             yield* parseJsonlStream(reader, model, {
+                toolNameMap,
                 creditsLane,
                 abortSignal: gatewayAbort.signal,
                 didGatewayTimeout: gatewayAbort.didTimeout,
@@ -675,7 +678,9 @@ async function* parseJsonlStream(reader, model, captureContext = {}) {
                     const delta = {
                         type: "tool-input-delta",
                         id: event.id,
-                        name: event.name,
+                        name: typeof event.name === "string"
+                            ? toEngineToolName(event.name, captureContext.toolNameMap)
+                            : event.name,
                         text: typeof event.argsTextDelta === "string"
                             ? event.argsTextDelta
                             : typeof event.delta === "string"
@@ -694,7 +699,9 @@ async function* parseJsonlStream(reader, model, captureContext = {}) {
                     const call = {
                         type: "tool-call",
                         id: event.id,
-                        name: event.name,
+                        name: typeof event.name === "string"
+                            ? toEngineToolName(event.name, captureContext.toolNameMap)
+                            : event.name,
                         input: event.input,
                     };
                     parts.push(call);

package/dist/agent/engine/tool-name.d.ts

@@ -0,0 +1,9 @@
+import type { EngineMessage, EngineTool } from "./types.js";
+export declare const PROVIDER_TOOL_NAME_MAX_LENGTH = 64;
+export interface ProviderToolNameMap {
+    toEngine: ReadonlyMap<string, string>;
+    toProvider: ReadonlyMap<string, string>;
+}
+export declare function createProviderToolNameMap(tools: readonly EngineTool[], messages?: readonly EngineMessage[]): ProviderToolNameMap;
+export declare function toProviderToolName(name: string, map?: ProviderToolNameMap): string;
+export declare function toEngineToolName(name: string, map?: ProviderToolNameMap): string;

package/dist/agent/engine/tool-name.js

@@ -0,0 +1,56 @@
+export const PROVIDER_TOOL_NAME_MAX_LENGTH = 64;
+function hashToolName(value, seed) {
+    let hash = seed;
+    for (let index = 0; index < value.length; index += 1) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(36);
+}
+function providerToolAlias(name) {
+    return `tool_${hashToolName(name, 2166136261)}_${hashToolName(name, 16777619)}`;
+}
+function toolNamesFromMessages(messages) {
+    return messages.flatMap((message) => message.content.flatMap((part) => {
+        if (part.type === "tool-call")
+            return [part.name];
+        if (part.type === "tool-result")
+            return [part.toolName];
+        return [];
+    }));
+}
+export function createProviderToolNameMap(tools, messages = []) {
+    const names = new Set([
+        ...tools.map((tool) => tool.name),
+        ...toolNamesFromMessages(messages),
+    ]);
+    const usedProviderNames = new Set([...names].filter((name) => name.length <= PROVIDER_TOOL_NAME_MAX_LENGTH));
+    const toProvider = new Map();
+    const toEngine = new Map();
+    for (const name of names) {
+        if (name.length <= PROVIDER_TOOL_NAME_MAX_LENGTH) {
+            toProvider.set(name, name);
+            toEngine.set(name, name);
+            continue;
+        }
+        const base = providerToolAlias(name);
+        let alias = base;
+        let suffix = 1;
+        while (usedProviderNames.has(alias)) {
+            alias = `${base}_${suffix}`;
+            suffix += 1;
+        }
+        usedProviderNames.add(alias);
+        toProvider.set(name, alias);
+        toEngine.set(alias, name);
+    }
+    return { toEngine, toProvider };
+}
+export function toProviderToolName(name, map) {
+    if (name.length <= PROVIDER_TOOL_NAME_MAX_LENGTH)
+        return name;
+    return map?.toProvider.get(name) ?? providerToolAlias(name);
+}
+export function toEngineToolName(name, map) {
+    return map?.toEngine.get(name) ?? name;
+}

package/dist/agent/engine/translate-ai-sdk.d.ts

@@ -6,6 +6,7 @@
  * These helpers convert in both directions against the v6 `TextStreamPart` and
  * `ModelMessage` shapes.
  */
+import { type ProviderToolNameMap } from "./tool-name.js";
 import type { EngineTool, EngineMessage, EngineContentPart, EngineEvent } from "./types.js";
 /**
  * Convert EngineTool[] into the record shape that AI SDK's `streamText` expects
@@ -15,7 +16,7 @@ import type { EngineTool, EngineMessage, EngineContentPart, EngineEvent } from "
  * schema is wrapped in the SDK's runtime validator; fall back to the raw JSON
  * Schema object otherwise (mostly for unit tests that don't import `ai`).
  */
-export declare function engineToolsToAISDK(tools: EngineTool[], jsonSchema?: (schema: Record<string, unknown>) => unknown): Record<string, any>;
+export declare function engineToolsToAISDK(tools: EngineTool[], jsonSchema?: (schema: Record<string, unknown>) => unknown, toolNameMap?: ProviderToolNameMap): Record<string, any>;
 /**
  * Convert a single EngineMessage into **one or more** AI SDK ModelMessages.
  *
@@ -36,6 +37,7 @@ export interface EngineToAISDKOptions {
      * string keep the model informed of what it cannot see.
      */
     toolResultImages?: boolean;
+    toolNameMap?: ProviderToolNameMap;
 }
 export declare function engineMessageToAISDK(msg: EngineMessage, opts?: EngineToAISDKOptions): any[];
 export declare function engineMessagesToAISDK(messages: EngineMessage[], opts?: EngineToAISDKOptions): any[];
@@ -48,9 +50,9 @@ export declare function engineMessagesToAISDK(messages: EngineMessage[], opts?:
  * We absorb text/reasoning boundaries, forward text/reasoning/tool-input
  * deltas, and keep the terminal `tool-call`, `finish-step`, and `finish` parts.
  */
-export declare function aiSdkPartToEngineEvents(part: any): EngineEvent[];
+export declare function aiSdkPartToEngineEvents(part: any, toolNameMap?: ProviderToolNameMap): EngineEvent[];
 /**
  * Reconstruct the assistant message content from an AI SDK v6 `StepResult`.
  * `step.content` is the canonical structured form — iterate it.
  */
-export declare function aiSdkStepToAssistantContent(step: any): EngineContentPart[];
+export declare function aiSdkStepToAssistantContent(step: any, toolNameMap?: ProviderToolNameMap): EngineContentPart[];