@cognipeer/agent-sdk 0.6.6 → 0.7.0

package/dist/index.mjs

@@ -42,7 +42,7 @@ function getTokenCounter() {
 function countApproxTokens(text) {
   return activeTokenCounter(text || "");
 }
-function extractMessageText(m) {
+function extractMessageText2(m) {
   if (!m) return "";
   const parts = [];
   parts.push(m.role || "");
@@ -92,7 +92,7 @@ function extractMessageText(m) {
 }
 function countMessagesTokens(messages) {
   if (!Array.isArray(messages) || messages.length === 0) return 0;
-  const allText = messages.map(extractMessageText).join("\n");
+  const allText = messages.map(extractMessageText2).join("\n");
   return countApproxTokens(allText) + messages.length * 4;
 }
 var activeTokenCounter;
@@ -1262,6 +1262,7 @@ function eventToOtlpSpan(event) {
     stringAttr("cognipeer.actor.role", event.actor?.role),
     stringAttr("cognipeer.model", event.model),
     stringAttr("cognipeer.provider", event.provider),
+    stringAttr("cognipeer.tool.details", event.toolDetails ? JSON.stringify(event.toolDetails) : void 0),
     intAttr("cognipeer.tokens.input", event.inputTokens),
     intAttr("cognipeer.tokens.output", event.outputTokens),
     intAttr("cognipeer.tokens.total", event.totalTokens),
@@ -1733,6 +1734,7 @@ function recordTraceEvent(session, event) {
     responseBytes,
     model: resolvedModel,
     provider: resolvedProvider,
+    toolDetails: session.resolvedConfig.logData ? sanitizeTracePayload(event.toolDetails) : void 0,
     toolExecutionId: event.toolExecutionId,
     retryOf: event.retryOf,
     error: event.error ?? (status === "error" ? { message: "Unknown error" } : void 0) ?? void 0,
@@ -2183,16 +2185,99 @@ function createAgentCoreNode(opts) {
   };
 }
 
+// src/utils/content.ts
+function contentToString(content) {
+  try {
+    if (content == null) return "";
+    if (typeof content === "string") return content;
+    if (Array.isArray(content)) {
+      return content.map((p) => {
+        if (!p || typeof p !== "object") return String(p);
+        if (p.type === "text") return String(p.text ?? "");
+        if (p.type === "image_url") {
+          const img = p.image_url;
+          const url = typeof img === "string" ? img : img?.url;
+          const detail = typeof img === "string" ? void 0 : img?.detail;
+          return `[image:${url || "unknown"}${detail ? ` detail=${detail}` : ""}]`;
+        }
+        return JSON.stringify(p);
+      }).join("\n");
+    }
+    return JSON.stringify(content);
+  } catch {
+    return String(content);
+  }
+}
+function mergeContentsToString(contents) {
+  return contents.map((c) => contentToString(c)).join("\n");
+}
+function safeStringify(value, pretty = false) {
+  if (value == null) return "";
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value, null, pretty ? 2 : void 0) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function extractMessageText(message) {
+  if (!message) return "";
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((part) => typeof part === "string" ? part : part?.text ?? part?.content ?? "").join("");
+  }
+  return "";
+}
+
+// src/utils/traceSections.ts
+function truncate(text, max = 500) {
+  if (!text) return "";
+  return text.length > max ? `${text.slice(0, max)}\u2026` : text;
+}
+function summarizeToolOutput(output) {
+  if (output == null) return "";
+  if (typeof output === "string") return truncate(output.trim());
+  if (Array.isArray(output)) {
+    const preview = output.slice(0, 3).map((item, index) => `${index + 1}. ${truncate(safeStringify(item))}`).join("\n");
+    const suffix = output.length > 3 ? `
+\u2026 (+${output.length - 3} more)` : "";
+    return `${preview}${suffix}`.trim();
+  }
+  if (typeof output === "object") {
+    if (Array.isArray(output.items)) {
+      return summarizeToolOutput(output.items);
+    }
+    return truncate(safeStringify(output));
+  }
+  return truncate(String(output));
+}
+function extractToolItems(output) {
+  const source = Array.isArray(output) ? output : Array.isArray(output?.items) ? output.items : void 0;
+  if (!Array.isArray(source) || source.length === 0) return void 0;
+  return source.slice(0, 5).map((item) => {
+    if (item && typeof item === "object") {
+      const snippetSource = item.content ?? item.snippet ?? item.description ?? item.text ?? item.summary ?? item;
+      return {
+        title: typeof item.title === "string" ? item.title : void 0,
+        url: typeof item.url === "string" ? item.url : void 0,
+        snippet: truncate(safeStringify(snippetSource))
+      };
+    }
+    return { snippet: truncate(safeStringify(item)) };
+  });
+}
+
 // src/smart/runtimeConfig.ts
 var DEFAULT_CRITICAL_TOOLS = ["response", "manage_todo_list", "get_tool_response"];
 var BASE_DEFAULTS = {
-  limits: { maxToolCalls: 8, maxParallelTools: 2, maxContextTokens: 24e3, maxTotalOutputTokens: 0, maxCostUsd: 0, maxWallClockMs: 0 },
+  limits: { maxToolCalls: 20, maxParallelTools: 5, maxContextTokens: 96e3, maxTotalOutputTokens: 0, maxCostUsd: 0, maxWallClockMs: 0 },
   summarization: {
     enable: true,
-    maxTokens: 24e3,
-    summaryTriggerTokens: 17e3,
-    summaryPromptMaxTokens: 7e3,
-    summaryCompressionRatioTarget: 0.35,
+    maxTokens: 96e3,
+    summaryTriggerTokens: 72e3,
+    summaryPromptMaxTokens: 12e3,
+    summaryCompressionRatioTarget: 0.45,
     summaryMode: "incremental",
     promptTemplate: "",
     toolFreeCall: true,
@@ -2200,13 +2285,13 @@ var BASE_DEFAULTS = {
   },
   context: {
     policy: "hybrid",
-    lastTurnsToKeep: 8,
+    lastTurnsToKeep: 16,
     toolResponsePolicy: "summarize_archive",
     budget: {
-      systemReserveTokens: 1200,
-      goalsReserveTokens: 1200,
-      recentTurnsReserveTokens: 5200,
-      toolResponseReserveTokens: 2800
+      systemReserveTokens: 2e3,
+      goalsReserveTokens: 2e3,
+      recentTurnsReserveTokens: 18e3,
+      toolResponseReserveTokens: 9e3
     }
   },
   planning: {
@@ -2223,14 +2308,14 @@ var BASE_DEFAULTS = {
   delegation: {
     mode: "role_based",
     maxDelegationDepth: 2,
-    maxChildCalls: 4,
-    maxParallelChild: 2,
+    maxChildCalls: 6,
+    maxParallelChild: 3,
     childContextPolicy: "scoped",
     requireJsonOutputContract: true
   },
   toolResponses: {
-    maxToolResponseChars: 12e3,
-    maxToolResponseTokens: 3e3,
+    maxToolResponseChars: 32e3,
+    maxToolResponseTokens: 8e3,
     defaultPolicy: "summarize_archive",
     toolResponseRetentionByTool: {},
     criticalTools: [...DEFAULT_CRITICAL_TOOLS],
@@ -2259,54 +2344,54 @@ function buildProfile(overrides) {
 }
 var DEFAULT_PROFILE_CONFIGS = {
   fast: buildProfile({
-    limits: { maxToolCalls: 4, maxParallelTools: 1, maxContextTokens: 12e3 },
+    limits: { maxToolCalls: 8, maxParallelTools: 3, maxContextTokens: 32e3 },
     summarization: {
-      maxTokens: 12e3,
-      summaryTriggerTokens: 9e3,
-      summaryPromptMaxTokens: 5e3,
-      summaryCompressionRatioTarget: 0.4
+      maxTokens: 32e3,
+      summaryTriggerTokens: 24e3,
+      summaryPromptMaxTokens: 6e3,
+      summaryCompressionRatioTarget: 0.5
     },
     context: {
-      lastTurnsToKeep: 6,
+      lastTurnsToKeep: 8,
       toolResponsePolicy: "keep_structured",
-      budget: { systemReserveTokens: 1e3, goalsReserveTokens: 900, recentTurnsReserveTokens: 3200, toolResponseReserveTokens: 1800 }
+      budget: { systemReserveTokens: 1500, goalsReserveTokens: 1200, recentTurnsReserveTokens: 6e3, toolResponseReserveTokens: 3500 }
     },
     memory: { readPolicy: "recent_only" },
     delegation: { mode: "off", maxDelegationDepth: 1, maxChildCalls: 2, maxParallelChild: 1, childContextPolicy: "minimal" },
-    toolResponses: { maxToolResponseChars: 8e3, maxToolResponseTokens: 2e3 }
+    toolResponses: { maxToolResponseChars: 16e3, maxToolResponseTokens: 4e3 }
   }),
   balanced: buildProfile({}),
   deep: buildProfile({
-    limits: { maxToolCalls: 14, maxParallelTools: 3, maxContextTokens: 42e3 },
+    limits: { maxToolCalls: 40, maxParallelTools: 8, maxContextTokens: 2e5 },
     summarization: {
-      maxTokens: 42e3,
-      summaryTriggerTokens: 3e4,
-      summaryPromptMaxTokens: 9e3,
-      summaryCompressionRatioTarget: 0.3
+      maxTokens: 2e5,
+      summaryTriggerTokens: 15e4,
+      summaryPromptMaxTokens: 16e3,
+      summaryCompressionRatioTarget: 0.4
     },
     context: {
-      lastTurnsToKeep: 12,
-      budget: { systemReserveTokens: 1400, goalsReserveTokens: 1600, recentTurnsReserveTokens: 7e3, toolResponseReserveTokens: 3600 }
+      lastTurnsToKeep: 30,
+      budget: { systemReserveTokens: 2500, goalsReserveTokens: 2500, recentTurnsReserveTokens: 36e3, toolResponseReserveTokens: 18e3 }
     },
     memory: { scope: "workspace" },
-    delegation: { maxDelegationDepth: 3, maxChildCalls: 6 },
-    toolResponses: { maxToolResponseChars: 16e3, maxToolResponseTokens: 4e3 }
+    delegation: { maxDelegationDepth: 3, maxChildCalls: 10, maxParallelChild: 4 },
+    toolResponses: { maxToolResponseChars: 64e3, maxToolResponseTokens: 16e3 }
   }),
   research: buildProfile({
-    limits: { maxToolCalls: 20, maxParallelTools: 4, maxContextTokens: 56e3 },
+    limits: { maxToolCalls: 80, maxParallelTools: 10, maxContextTokens: 4e5 },
     summarization: {
-      maxTokens: 56e3,
-      summaryTriggerTokens: 42e3,
-      summaryPromptMaxTokens: 1e4,
-      summaryCompressionRatioTarget: 0.28
+      maxTokens: 4e5,
+      summaryTriggerTokens: 3e5,
+      summaryPromptMaxTokens: 24e3,
+      summaryCompressionRatioTarget: 0.35
     },
     context: {
-      lastTurnsToKeep: 20,
-      budget: { systemReserveTokens: 1600, goalsReserveTokens: 1800, recentTurnsReserveTokens: 9e3, toolResponseReserveTokens: 4800 }
+      lastTurnsToKeep: 60,
+      budget: { systemReserveTokens: 3e3, goalsReserveTokens: 3e3, recentTurnsReserveTokens: 72e3, toolResponseReserveTokens: 32e3 }
     },
     memory: { scope: "workspace" },
-    delegation: { mode: "automatic", maxDelegationDepth: 4, maxChildCalls: 8, maxParallelChild: 3, childContextPolicy: "full" },
-    toolResponses: { maxToolResponseChars: 24e3, maxToolResponseTokens: 6e3 }
+    delegation: { mode: "automatic", maxDelegationDepth: 4, maxChildCalls: 16, maxParallelChild: 6, childContextPolicy: "full" },
+    toolResponses: { maxToolResponseChars: 96e3, maxToolResponseTokens: 24e3 }
   })
 };
 function mergeLimits(base, override) {
@@ -2396,53 +2481,6 @@ function getResolvedSmartConfig(opts, runtime) {
 
 // src/smart/toolResponses.ts
 init_utilTokens();
-
-// src/utils/content.ts
-function contentToString(content) {
-  try {
-    if (content == null) return "";
-    if (typeof content === "string") return content;
-    if (Array.isArray(content)) {
-      return content.map((p) => {
-        if (!p || typeof p !== "object") return String(p);
-        if (p.type === "text") return String(p.text ?? "");
-        if (p.type === "image_url") {
-          const img = p.image_url;
-          const url = typeof img === "string" ? img : img?.url;
-          const detail = typeof img === "string" ? void 0 : img?.detail;
-          return `[image:${url || "unknown"}${detail ? ` detail=${detail}` : ""}]`;
-        }
-        return JSON.stringify(p);
-      }).join("\n");
-    }
-    return JSON.stringify(content);
-  } catch {
-    return String(content);
-  }
-}
-function mergeContentsToString(contents) {
-  return contents.map((c) => contentToString(c)).join("\n");
-}
-function safeStringify(value, pretty = false) {
-  if (value == null) return "";
-  if (typeof value === "string") return value;
-  try {
-    return JSON.stringify(value, null, pretty ? 2 : void 0) ?? String(value);
-  } catch {
-    return String(value);
-  }
-}
-function extractMessageText2(message) {
-  if (!message) return "";
-  const content = message.content;
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content.map((part) => typeof part === "string" ? part : part?.text ?? part?.content ?? "").join("");
-  }
-  return "";
-}
-
-// src/smart/toolResponses.ts
 function summarizeObject(value) {
   if (value == null) return "null";
   if (typeof value === "string") {
@@ -2557,6 +2595,97 @@ function normalizeToolCall(call) {
     args: call.args ?? call.arguments ?? call.input ?? call.function?.arguments ?? call.function_call?.arguments
   };
 }
+function normalizeToolSchema(tool, toolName) {
+  const schema = tool.schema;
+  if (!schema) return void 0;
+  if (typeof schema === "object" && schema._def) {
+    try {
+      return sanitizeTracePayload(zodToJsonSchema(schema, { name: toolName }));
+    } catch {
+    }
+  }
+  if (schema && typeof schema === "object" && typeof schema.toJSON === "function") {
+    try {
+      return sanitizeTracePayload(schema.toJSON());
+    } catch {
+    }
+  }
+  return sanitizeTracePayload(schema);
+}
+function buildToolDetails(tool, toolName) {
+  if (!tool) return void 0;
+  const details = { name: toolName };
+  if (typeof tool.description === "string" && tool.description.trim().length > 0) {
+    details.description = tool.description;
+  }
+  const inputSchema = normalizeToolSchema(tool, toolName);
+  if (inputSchema !== void 0) details.inputSchema = inputSchema;
+  const needsApproval = typeof tool.needsApproval === "boolean" ? tool.needsApproval : void 0;
+  if (needsApproval !== void 0 || tool.approvalPrompt !== void 0 || tool.approvalDefaults !== void 0) {
+    details.approval = {
+      required: needsApproval,
+      prompt: typeof tool.approvalPrompt === "string" ? tool.approvalPrompt : void 0,
+      defaults: tool.approvalDefaults !== void 0 ? sanitizeTracePayload(tool.approvalDefaults) : void 0
+    };
+  }
+  const cache = tool.cache;
+  if (cache !== void 0) {
+    details.cache = {
+      enabled: Boolean(cache),
+      scope: cache && typeof cache === "object" && typeof cache.scope === "string" ? cache.scope : void 0,
+      ttlMs: cache && typeof cache === "object" && typeof cache.ttlMs === "number" ? cache.ttlMs : void 0,
+      hasKeyFn: Boolean(cache && typeof cache === "object" && typeof cache.keyFn === "function")
+    };
+  }
+  const retry = tool.retry;
+  if (retry && typeof retry === "object") {
+    details.retry = {
+      maxRetries: typeof retry.maxRetries === "number" ? retry.maxRetries : void 0,
+      backoffMs: typeof retry.backoffMs === "number" ? retry.backoffMs : void 0,
+      circuitBreakerThreshold: typeof retry.circuitBreakerThreshold === "number" ? retry.circuitBreakerThreshold : void 0,
+      hasShouldRetry: typeof retry.shouldRetry === "function"
+    };
+  }
+  if (tool.maxExecutionsPerRun !== void 0) {
+    details.limits = { maxExecutionsPerRun: tool.maxExecutionsPerRun };
+  }
+  if (typeof tool.__source === "string") {
+    details.source = tool.__source;
+  }
+  return details;
+}
+function buildToolTraceSections(params) {
+  const sanitizedArgs = sanitizeTracePayload(params.args ?? {});
+  const sanitizedOutput = sanitizeTracePayload(params.output);
+  const summary = params.summary ?? summarizeToolOutput(sanitizedOutput);
+  const items = extractToolItems(sanitizedOutput);
+  return [
+    {
+      kind: "tool_call",
+      label: `Tool Call: ${params.toolName}`,
+      tool: params.toolName,
+      arguments: sanitizedArgs,
+      toolDetails: params.toolDetails
+    },
+    {
+      kind: "tool_result",
+      label: `Tool Result: ${params.toolName}`,
+      tool: params.toolName,
+      summary,
+      items,
+      output: sanitizedOutput,
+      toolDetails: params.toolDetails,
+      execution: {
+        id: params.executionId,
+        status: params.status,
+        durationMs: params.durationMs,
+        fromCache: params.fromCache
+      },
+      classification: params.classification,
+      retentionPolicy: params.retentionPolicy
+    }
+  ];
+}
 function createToolsNode(initialTools, opts) {
   return async (state) => {
     const runtime = state.agent || {
@@ -2665,6 +2794,7 @@ function createToolsNode(initialTools, opts) {
         args = validatedArgs.value;
       }
       const toolName = tool.name || tc.name;
+      const toolDetails = buildToolDetails(tool, toolName);
       const toolStateRef = tool._stateRef && typeof tool._stateRef === "object" ? tool._stateRef : null;
       if (toolStateRef) {
         toolStateRef.pendingApprovals = pendingApprovals;
@@ -2685,21 +2815,17 @@ function createToolsNode(initialTools, opts) {
             label: `Tool Skipped - ${toolName}`,
             actor: { scope: "tool", name: toolName, role: "tool" },
             status: "skipped",
+            toolDetails,
             toolExecutionId: tc.id,
-            messageList: [
-              {
-                role: "assistant",
-                name: toolName,
-                content: limitMessage,
-                tool_calls: [
-                  {
-                    id: tc.id,
-                    type: "function",
-                    function: { name: toolName, arguments: sanitizeTracePayload(args) }
-                  }
-                ]
-              }
-            ]
+            sections: buildToolTraceSections({
+              args,
+              executionId: tc.id,
+              output: limitMessage,
+              status: "skipped",
+              summary: limitMessage,
+              toolDetails,
+              toolName
+            })
           });
           toolCount += 1;
           return { status: "error" };
@@ -2786,6 +2912,25 @@ function createToolsNode(initialTools, opts) {
         push({ role: "tool", content: breakerMsg, tool_call_id: toolCallId, name: tc.name });
         markToolFailure(breakerMsg, toolName, toolCallId);
         onEvent?.({ type: "tool_call", phase: "error", name: toolName, id: tc.id, args, error: { message: breakerMsg } });
+        recordTraceEvent(traceSession, {
+          type: "tool_call",
+          label: `Tool Error - ${toolName}`,
+          actor: { scope: "tool", name: toolName, role: "tool" },
+          status: "error",
+          requestBytes: inputBytes,
+          toolDetails,
+          toolExecutionId: toolCallId,
+          error: { message: breakerMsg },
+          sections: buildToolTraceSections({
+            args,
+            executionId: toolCallId,
+            output: { message: breakerMsg },
+            status: "error",
+            summary: breakerMsg,
+            toolDetails,
+            toolName
+          })
+        });
         toolCount += 1;
         return { status: "error" };
       }
@@ -2810,6 +2955,38 @@ function createToolsNode(initialTools, opts) {
           });
           push({ role: "tool", content: responsePolicy2.content, tool_call_id: tc.id || `${tc.name}_${toolCount}`, name: tc.name });
           onEvent?.({ type: "tool_call", phase: "success", name: toolName, id: tc.id, args, result: cachedHit, durationMs: 0 });
+          const sanitizedCachedHit = sanitizeTracePayload(cachedHit);
+          const outputBytes2 = traceSession?.resolvedConfig.logData ? estimatePayloadBytes(sanitizedCachedHit) : void 0;
+          recordTraceEvent(traceSession, {
+            type: "tool_call",
+            label: `Tool Execution - ${toolName}`,
+            actor: { scope: "tool", name: toolName, role: "tool" },
+            durationMs: 0,
+            requestBytes: inputBytes,
+            responseBytes: outputBytes2,
+            toolDetails,
+            toolExecutionId: executionId2,
+            sections: buildToolTraceSections({
+              args,
+              classification: responsePolicy2.classification,
+              durationMs: 0,
+              executionId: executionId2,
+              fromCache: true,
+              output: sanitizedCachedHit,
+              retentionPolicy: "keep_full",
+              status: "cached",
+              summary: responsePolicy2.content,
+              toolDetails,
+              toolName
+            }),
+            debug: {
+              classification: responsePolicy2.classification,
+              retentionPolicy: "keep_full",
+              originalTokenCount: responsePolicy2.tokenCount,
+              truncated: responsePolicy2.truncated,
+              fromCache: true
+            }
+          });
           toolCount += 1;
           return { status: "success" };
         }
@@ -2930,28 +3107,6 @@ function createToolsNode(initialTools, opts) {
         }
         const sanitizedOutput = sanitizeTracePayload(output);
         const outputBytes = traceSession?.resolvedConfig.logData ? estimatePayloadBytes(sanitizedOutput) : void 0;
-        const messageList = [
-          {
-            role: "assistant",
-            name: toolName,
-            content: "",
-            tool_calls: [
-              {
-                id: tc.id || executionId,
-                type: "function",
-                function: {
-                  name: toolName,
-                  arguments: sanitizedArgs
-                }
-              }
-            ]
-          },
-          {
-            role: "tool",
-            name: toolName,
-            content: responsePolicy.content
-          }
-        ];
         recordTraceEvent(traceSession, {
           type: "tool_call",
           label: `Tool Execution - ${toolName}`,
@@ -2959,8 +3114,20 @@ function createToolsNode(initialTools, opts) {
           durationMs,
           requestBytes: inputBytes,
           responseBytes: outputBytes,
+          toolDetails,
           toolExecutionId: executionId,
-          messageList,
+          sections: buildToolTraceSections({
+            args: sanitizedArgs,
+            classification: responsePolicy.classification,
+            durationMs,
+            executionId,
+            output: sanitizedOutput,
+            retentionPolicy: "keep_full",
+            status: "success",
+            summary: responsePolicy.content,
+            toolDetails,
+            toolName
+          }),
           debug: {
             classification: responsePolicy.classification,
             retentionPolicy: "keep_full",
@@ -2979,6 +3146,7 @@ function createToolsNode(initialTools, opts) {
         markToolFailure(message, toolName, toolCallId);
         onEvent?.({ type: "tool_call", phase: "error", name: toolName, id: tc.id, args, error: { message } });
         onProgress?.({ stage: "tools", message: `Tool ${tc.name} failed`, detail: { error: message } });
+        const errorOutput = { message, stack: error?.stack };
         recordTraceEvent(traceSession, {
           type: "tool_call",
           label: `Tool Error - ${toolName}`,
@@ -2986,27 +3154,20 @@ function createToolsNode(initialTools, opts) {
           status: "error",
           durationMs,
           requestBytes: inputBytes,
+          responseBytes: traceSession?.resolvedConfig.logData ? estimatePayloadBytes(errorOutput) : void 0,
+          toolDetails,
           toolExecutionId: executionId,
           error: { message, stack: error?.stack },
-          messageList: [
-            {
-              role: "assistant",
-              name: toolName,
-              content: "",
-              tool_calls: [
-                {
-                  id: tc.id || executionId,
-                  type: "function",
-                  function: { name: toolName, arguments: sanitizedArgs }
-                }
-              ]
-            },
-            {
-              role: "tool",
-              name: toolName,
-              content: `Error executing tool: ${message}`
-            }
-          ]
+          sections: buildToolTraceSections({
+            args: sanitizedArgs,
+            durationMs,
+            executionId,
+            output: errorOutput,
+            status: "error",
+            summary: `Error executing tool: ${message}`,
+            toolDetails,
+            toolName
+          })
         });
         toolCount += 1;
         return { status: "error", approval: approvalEntry };
@@ -3083,29 +3244,26 @@ function createToolsNode(initialTools, opts) {
     }
     for (const tc of skipped) {
       onEvent?.({ type: "tool_call", phase: "skipped", name: tc.name, id: tc.id, args: tc.args });
-      const sanitizedArgs = sanitizeTracePayload(tc.args);
+      const toolDetails = buildToolDetails(toolByName.get(tc.name), tc.name);
+      const skipMessage = `Skipped tool due to tool-call limit: ${tc.name}`;
       recordTraceEvent(traceSession, {
         type: "tool_call",
         label: `Tool Skipped - ${tc.name}`,
         actor: { scope: "tool", name: tc.name, role: "tool" },
         status: "skipped",
+        toolDetails,
         toolExecutionId: tc.id,
-        messageList: [
-          {
-            role: "assistant",
-            name: tc.name,
-            content: `Skipped tool due to tool-call limit: ${tc.name}`,
-            tool_calls: [
-              {
-                id: tc.id,
-                type: "function",
-                function: { name: tc.name, arguments: sanitizedArgs }
-              }
-            ]
-          }
-        ]
+        sections: buildToolTraceSections({
+          args: tc.args,
+          executionId: tc.id,
+          output: skipMessage,
+          status: "skipped",
+          summary: skipMessage,
+          toolDetails,
+          toolName: tc.name
+        })
       });
-      appended.push({ role: "tool", content: `Skipped tool due to tool-call limit: ${tc.name}`, tool_call_id: tc.id || `${tc.name}_${appended.length}`, name: tc.name });
+      appended.push({ role: "tool", content: skipMessage, tool_call_id: tc.id || `${tc.name}_${appended.length}`, name: tc.name });
       toolCount += 1;
     }
     if (!awaitingApproval && state.ctx?.__awaitingApproval) {
@@ -4356,7 +4514,7 @@ function createAgent(opts) {
       if (toolCalls.length === 0) {
         if (soManager && !state.ctx?.__finalizedDueToStructuredOutput && !state.ctx?.__structuredOutputForceFinalize) {
           if (soManager.strategy.kind === "native") {
-            const assistantText = extractMessageText2(lastMsg);
+            const assistantText = extractMessageText(lastMsg);
             if (assistantText) {
               const parsed = soManager.parseFromContent(assistantText);
               if (parsed.success) {
@@ -4407,7 +4565,7 @@ function createAgent(opts) {
     if (soManager && !state.ctx?.__finalizedDueToStructuredOutput) {
       const lastForParse = state.messages[state.messages.length - 1];
       if (lastForParse?.role === "assistant") {
-        const assistantText = extractMessageText2(lastForParse);
+        const assistantText = extractMessageText(lastForParse);
         if (assistantText) {
           const parsed = soManager.parseFromContent(assistantText);
           if (parsed.success) {
@@ -4560,7 +4718,7 @@ function createAgent(opts) {
     const isTransientSummarizationExit = !!res.ctx?.__needsSummarization;
     const finalAssistantMsg = isTransientSummarizationExit ? void 0 : getLastAssistantMessage(res.messages);
     const finalIsSyntheticSummary = !isTransientSummarizationExit && finalAssistantMsg && isSyntheticSummaryMessage(finalAssistantMsg);
-    const content = isTransientSummarizationExit || finalIsSyntheticSummary ? "" : extractMessageText2(finalAssistantMsg);
+    const content = isTransientSummarizationExit || finalIsSyntheticSummary ? "" : extractMessageText(finalAssistantMsg);
     let parsed = void 0;
     let outputError = void 0;
     if (soManager) {
@@ -4868,7 +5026,7 @@ function renderMemoryBlock(facts) {
 function clampToBudget(messages, maxContextTokens) {
   let working = [...messages];
   while (working.length > 2) {
-    const tokenCount = countApproxTokens(working.map(extractMessageText2).join("\n"));
+    const tokenCount = countApproxTokens(working.map(extractMessageText).join("\n"));
     if (tokenCount <= maxContextTokens) return working;
     const firstNonSystem = working.findIndex((message, index) => !(index === 0 && message.role === "system"));
     if (firstNonSystem < 0) break;
@@ -5971,7 +6129,7 @@ function createSmartAgent(opts) {
   ].join("\n");
   function latestUserPrompt(messages) {
     const latest = [...messages].reverse().find((message) => message.role === "user");
-    return latest ? extractMessageText2(latest) : "";
+    return latest ? extractMessageText(latest) : "";
   }
   async function syncMemory(state) {
     const query = latestUserPrompt(state.messages || []);