@cognipeer/agent-sdk 0.6.6 → 0.7.1

package/dist/index.cjs

@@ -52,7 +52,7 @@ function getTokenCounter() {
 function countApproxTokens(text) {
   return activeTokenCounter(text || "");
 }
-function extractMessageText(m) {
+function extractMessageText2(m) {
   if (!m) return "";
   const parts = [];
   parts.push(m.role || "");
@@ -102,7 +102,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;
@@ -1272,6 +1272,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),
@@ -1743,6 +1744,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,
@@ -2193,16 +2195,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,
@@ -2210,13 +2295,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: {
@@ -2233,14 +2318,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],
@@ -2269,54 +2354,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) {
@@ -2406,53 +2491,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") {
@@ -2567,6 +2605,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.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 || {
@@ -2675,6 +2804,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;
@@ -2695,21 +2825,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" };
@@ -2796,6 +2922,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" };
       }
@@ -2820,6 +2965,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" };
         }
@@ -2940,28 +3117,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}`,
@@ -2969,8 +3124,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",
@@ -2989,6 +3156,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}`,
@@ -2996,27 +3164,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 };
@@ -3093,29 +3254,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) {
@@ -3187,15 +3345,40 @@ function countToolCallsInLastTurn(state) {
 function stripReflectionAskMessages(messages) {
   return messages.filter((m) => !(m?.role === "user" && m?.name === REFLECTION_ASK_NAME));
 }
+function lastTwoToolTurns(state) {
+  const groups = [];
+  let cur = [];
+  let sawTool = false;
+  for (let i = state.messages.length - 1; i >= 0; i--) {
+    const m = state.messages[i];
+    if (m?.role === "tool") {
+      if (m.name) cur.push(m.name);
+      sawTool = true;
+    } else if (m?.role === "assistant") {
+      if (sawTool) {
+        groups.push(cur);
+        cur = [];
+        sawTool = false;
+        if (groups.length >= 2) break;
+      }
+    }
+  }
+  if (sawTool && cur.length) groups.push(cur);
+  return { current: groups[0] ?? [], previous: groups[1] ?? [] };
+}
 function shouldRunReflection(cadence, state, ranToolsThisTurn) {
   if (cadence === "off") return false;
   if (cadence === "every_turn") return true;
   if (cadence === "after_tool") return ranToolsThisTurn;
+  if (cadence === "initial_then_after_tool") return ranToolsThisTurn;
   if (cadence === "on_branch") {
-    const reflections = state.reflections || [];
-    const lastReflectionTurn = reflections[reflections.length - 1]?.turn ?? -1;
-    const currentTurnId = state.toolCallCount ?? 0;
-    return currentTurnId - lastReflectionTurn >= 2;
+    const { current, previous } = lastTwoToolTurns(state);
+    if (previous.length === 0) return true;
+    const a = new Set(current);
+    const b = new Set(previous);
+    for (const n of a) if (!b.has(n)) return true;
+    for (const n of b) if (!a.has(n)) return true;
+    return false;
   }
   return false;
 }
@@ -3212,7 +3395,10 @@ function createReflectionNode(opts, resolved) {
     const onEvent = state.ctx?.__onEvent;
     const traceSession = state.ctx?.__traceSession;
     const maxChars = resolved.maxChars;
-    const promptBody = (resolved.promptTemplate || DEFAULT_REFLECT_PROMPT).replace(/\$\{maxChars\}/g, String(maxChars));
+    const turnNow = state.toolCallCount ?? 0;
+    const hookCtx = { state, turn: turnNow, trigger, ranToolsThisTurn: true };
+    const defaultPrompt = (resolved.promptTemplate || DEFAULT_REFLECT_PROMPT).replace(/\$\{maxChars\}/g, String(maxChars));
+    const promptBody = resolved.buildPrompt ? String(resolved.buildPrompt({ ...hookCtx, defaultPrompt, maxChars }) ?? defaultPrompt) : defaultPrompt;
     const baseMessages = stripReflectionAskMessages([...state.messages]);
     const askMessage = {
       role: "user",
@@ -3246,6 +3432,8 @@ function createReflectionNode(opts, resolved) {
     const rawText = extractText(response);
     const text = trimToChars(String(rawText ?? "").trim(), maxChars);
     if (!text) return {};
+    const prevText = (state.reflections?.[state.reflections.length - 1]?.text || "").trim();
+    if (prevText && isNearDuplicate(prevText, text)) return {};
     const rawUsage = response?.usage_metadata || response?.response_metadata?.usage || response?.usage || response?.additional_kwargs?.usage;
     const usage = normalizeUsage(rawUsage);
     const { ids, names } = countToolCallsInLastTurn(state);
@@ -3294,6 +3482,12 @@ function createReflectionNode(opts, resolved) {
       } catch (e) {
       }
     }
+    if (resolved.onReflection) {
+      try {
+        resolved.onReflection(record, hookCtx);
+      } catch {
+      }
+    }
     const nextMessages = stripReflectionAskMessages([...state.messages]);
     const reflections = [...state.reflections || [], record];
     const kept = reflections.slice(-Math.max(1, resolved.keepLast));
@@ -3310,7 +3504,20 @@ ${r.text}
         metadata: { reflectionId: r.id, reflectionTurn: r.turn, reflectionTrigger: r.trigger }
       });
     }
-    return { messages: prunedMessages, reflections };
+    const patch = { messages: prunedMessages, reflections };
+    if (resolved.feedTo === "memory") {
+      const fact = {
+        key: `reflection_turn_${turn}`,
+        value: text,
+        sourceTurn: turn,
+        confidence: 0.3,
+        tags: ["reflection"]
+      };
+      patch.memoryFacts = [...state.memoryFacts || [], fact];
+    } else if (resolved.feedTo === "plan" && state.plan) {
+      patch.plan = { ...state.plan, lastReflection: text };
+    }
+    return patch;
   };
 }
 function extractText(chunk) {
@@ -3339,24 +3546,75 @@ function safeRandomId() {
     return `r_${Math.random().toString(36).slice(2, 10)}_${Date.now().toString(36)}`;
   }
 }
+function isNearDuplicate(a, b) {
+  const norm = (s) => s.toLowerCase().replace(/\s+/g, " ").trim();
+  const na = norm(a);
+  const nb = norm(b);
+  if (na === nb) return true;
+  const tokensA = new Set(na.split(" ").filter(Boolean));
+  const tokensB = new Set(nb.split(" ").filter(Boolean));
+  if (tokensA.size === 0 || tokensB.size === 0) return false;
+  let inter = 0;
+  for (const t of tokensA) if (tokensB.has(t)) inter++;
+  const union = tokensA.size + tokensB.size - inter;
+  return union > 0 && inter / union >= 0.9;
+}
 
 // src/smart/reasoning.ts
 var LEVEL_DEFAULTS = {
+  minimal: {
+    native: { effort: "minimal" },
+    reflection: { maxTokens: 150, maxChars: 400, cadence: "off" }
+  },
   low: {
     native: { effort: "low" },
     reflection: { maxTokens: 200, maxChars: 600, cadence: "on_branch" }
   },
   medium: {
     native: { effort: "medium" },
-    reflection: { maxTokens: 350, maxChars: 1200, cadence: "after_tool" }
+    reflection: { maxTokens: 350, maxChars: 1200, cadence: "initial_then_after_tool" }
   },
   high: {
     native: { effort: "high" },
-    reflection: { maxTokens: 600, maxChars: 2e3, cadence: "after_tool" }
+    reflection: { maxTokens: 600, maxChars: 2e3, cadence: "initial_then_after_tool" }
   }
 };
+var VALID_LEVELS = ["minimal", "low", "medium", "high"];
+var VALID_CADENCES = ["off", "every_turn", "after_tool", "on_branch", "initial_then_after_tool"];
+var VALID_EFFORTS = ["minimal", "low", "medium", "high"];
+function validateReasoningConfig(input) {
+  if (!input) return;
+  if (input.level !== void 0 && !VALID_LEVELS.includes(input.level)) {
+    throw new Error(`reasoning.level must be one of ${VALID_LEVELS.join(", ")} (got "${input.level}")`);
+  }
+  if (input.native) {
+    const n = input.native;
+    if (n.effort !== void 0 && !VALID_EFFORTS.includes(n.effort)) {
+      throw new Error(`reasoning.native.effort must be one of ${VALID_EFFORTS.join(", ")} (got "${n.effort}")`);
+    }
+    if (n.budgetTokens !== void 0 && (!Number.isFinite(n.budgetTokens) || n.budgetTokens < 0)) {
+      throw new Error(`reasoning.native.budgetTokens must be a non-negative number (got ${n.budgetTokens})`);
+    }
+  }
+  if (input.reflection) {
+    const r = input.reflection;
+    if (r.cadence !== void 0 && !VALID_CADENCES.includes(r.cadence)) {
+      throw new Error(`reasoning.reflection.cadence must be one of ${VALID_CADENCES.join(", ")} (got "${r.cadence}")`);
+    }
+    if (r.maxPerRun !== void 0 && (!Number.isFinite(r.maxPerRun) || r.maxPerRun < 0)) {
+      throw new Error(`reasoning.reflection.maxPerRun must be a non-negative number (got ${r.maxPerRun})`);
+    }
+    if (r.everyNTurns !== void 0 && (!Number.isFinite(r.everyNTurns) || r.everyNTurns < 1)) {
+      throw new Error(`reasoning.reflection.everyNTurns must be >= 1 (got ${r.everyNTurns})`);
+    }
+    if (r.feedTo !== void 0 && !["memory", "plan", "none"].includes(r.feedTo)) {
+      throw new Error(`reasoning.reflection.feedTo must be "memory", "plan", or "none" (got "${r.feedTo}")`);
+    }
+  }
+}
 function resolveReasoning(input) {
   if (!input || input.enabled === false) return void 0;
+  validateReasoningConfig(input);
   const enabled = input.enabled ?? (input.native !== void 0 || input.reflection !== void 0 || input.level !== void 0);
   if (!enabled) return void 0;
   const level = input.level ?? "medium";
@@ -3381,7 +3639,8 @@ function resolveReflection(input, preset) {
       keepLast: 3,
       summarize: false,
       emitEvents: true,
-      everyNTurns: 1
+      everyNTurns: 1,
+      feedTo: "none"
     };
   }
   const cfg = input ?? {};
@@ -3398,7 +3657,11 @@ function resolveReflection(input, preset) {
     promptTemplate: cfg.promptTemplate,
     emitEvents: cfg.emitEvents ?? true,
     maxPerRun: typeof cfg.maxPerRun === "number" && cfg.maxPerRun >= 0 ? cfg.maxPerRun : void 0,
-    everyNTurns: Math.max(1, Math.trunc(cfg.everyNTurns ?? 1))
+    everyNTurns: Math.max(1, Math.trunc(cfg.everyNTurns ?? 1)),
+    feedTo: cfg.feedTo ?? "none",
+    shouldReflect: cfg.shouldReflect,
+    buildPrompt: cfg.buildPrompt,
+    onReflection: cfg.onReflection
   };
 }
 function ensureArray(value) {
@@ -4124,12 +4387,14 @@ function createAgent(opts) {
     if (summarizationThreshold === void 0) {
       state = clearNeedsSummarization(state);
     }
-    if (resolvedReasoning?.native) {
+    if (resolvedReasoning) {
       const ctx = { ...state.ctx || {} };
-      if (!ctx.__reasoning) {
+      if (resolvedReasoning.native) {
         ctx.__reasoning = resolvedReasoning.native;
-        state = { ...state, ctx };
+      } else {
+        delete ctx.__reasoning;
       }
+      state = { ...state, ctx: Object.keys(ctx).length > 0 ? ctx : void 0 };
     }
     const mergedLimits = {
       ...opts.limits || {},
@@ -4177,6 +4442,7 @@ function createAgent(opts) {
       return { breached: false };
     };
     let iterations = 0;
+    let reflectionsThisRun = 0;
     const onStateChange = config?.onStateChange;
     const checkpointReason = config?.checkpointReason;
     let pausedStage = null;
@@ -4222,6 +4488,16 @@ function createAgent(opts) {
       pausedStage = stage;
       return true;
     };
+    if (reflectNode && resolvedReasoning?.reflection.enabled && resolvedReasoning.reflection.cadence === "initial_then_after_tool" && resumeStage === null && !state.ctx?.__awaitingApproval && !state.ctx?.__awaitingUserQuestion && !state.messages.some((m) => m?.role === "assistant")) {
+      try {
+        const patch = await reflectNode(state, "initial_then_after_tool");
+        if (patch && Object.keys(patch).length > 0) {
+          state = { ...state, ...patch };
+          reflectionsThisRun++;
+        }
+      } catch {
+      }
+    }
     while (iterations < iterationLimit) {
       iterations++;
       const budget = checkBudgetBreached();
@@ -4366,7 +4642,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) {
@@ -4398,16 +4674,18 @@ function createAgent(opts) {
       if (reflectNode && resolvedReasoning?.reflection.enabled) {
         const cadence = resolvedReasoning.reflection.cadence;
         const refl = resolvedReasoning.reflection;
-        const reflectionsSoFar = state.reflections?.length ?? 0;
         const lastTurn = state.reflections?.at(-1)?.turn ?? -Infinity;
         const currentTurn = state.toolCallCount || 0;
-        const budgetExceeded = typeof refl.maxPerRun === "number" && reflectionsSoFar >= refl.maxPerRun;
-        const cadenceGap = currentTurn - (Number.isFinite(lastTurn) ? lastTurn : -refl.everyNTurns) < refl.everyNTurns;
-        if (!budgetExceeded && !cadenceGap && shouldRunReflection(cadence, state, true)) {
+        const budgetExceeded = typeof refl.maxPerRun === "number" && reflectionsThisRun >= refl.maxPerRun;
+        const sinceLast = currentTurn - (Number.isFinite(lastTurn) ? lastTurn : -refl.everyNTurns);
+        const cadenceGap = sinceLast < refl.everyNTurns;
+        const cadenceWantsIt = refl.shouldReflect ? !!refl.shouldReflect({ state, turn: currentTurn, trigger: cadence, ranToolsThisTurn: true }) : shouldRunReflection(cadence, state, true);
+        if (!budgetExceeded && !cadenceGap && cadenceWantsIt) {
           try {
             const patch = await reflectNode(state, cadence);
             if (patch && Object.keys(patch).length > 0) {
               state = { ...state, ...patch };
+              reflectionsThisRun++;
             }
           } catch {
           }
@@ -4417,7 +4695,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) {
@@ -4570,7 +4848,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) {
@@ -4878,7 +5156,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;
@@ -5981,7 +6259,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 || []);
@@ -6670,6 +6948,20 @@ function parseSSEBlock(block) {
 }
 
 // src/providers/utils/reasoning.ts
+var ANTHROPIC_EFFORT_BUDGET = {
+  minimal: 1024,
+  low: 2048,
+  medium: 8192,
+  high: 16384
+};
+var GEMINI_EFFORT_BUDGET = {
+  minimal: 512,
+  low: 1024,
+  medium: 4096,
+  high: 12e3
+};
+var THINKING_OUTPUT_RESERVE = 1024;
+var THINKING_MIN_MAX_TOKENS = 4096;
 function applyOpenAIReasoning(body, reasoning, mode = "legacy_effort") {
   if (!reasoning) return;
   const effort = normalizeEffort(reasoning.effort);
@@ -6686,21 +6978,56 @@ function applyOpenAIReasoning(body, reasoning, mode = "legacy_effort") {
 }
 function applyAnthropicReasoning(body, reasoning) {
   if (!reasoning) return;
-  const budget = resolveBudget(reasoning, { low: 2048, medium: 8192, high: 16384, minimal: 1024 });
+  let budget = resolveBudget(reasoning, ANTHROPIC_EFFORT_BUDGET);
   if (!budget) return;
+  const currentMax = typeof body.max_tokens === "number" ? body.max_tokens : 0;
+  const requiredMax = Math.max(THINKING_MIN_MAX_TOKENS, budget + THINKING_OUTPUT_RESERVE);
+  if (currentMax < requiredMax) {
+    body.max_tokens = requiredMax;
+  }
+  budget = clampBudget(budget, body.max_tokens);
   const thinking = { type: "enabled", budget_tokens: budget };
   if (reasoning.providerExtras) Object.assign(thinking, reasoning.providerExtras);
   body.thinking = thinking;
+  stripSamplingParams(body, ["temperature", "top_p", "top_k"]);
+}
+function applyBedrockReasoning(body, reasoning) {
+  if (!reasoning) return;
+  let budget = resolveBudget(reasoning, ANTHROPIC_EFFORT_BUDGET);
+  if (!budget) return;
+  const inference = body.inferenceConfig ?? (body.inferenceConfig = {});
+  const currentMax = typeof inference.maxTokens === "number" ? inference.maxTokens : 0;
+  const requiredMax = Math.max(THINKING_MIN_MAX_TOKENS, budget + THINKING_OUTPUT_RESERVE);
+  if (currentMax < requiredMax) {
+    inference.maxTokens = requiredMax;
+  }
+  budget = clampBudget(budget, inference.maxTokens);
+  const extra = body.additionalModelRequestFields ?? (body.additionalModelRequestFields = {});
+  const thinking = { type: "enabled", budget_tokens: budget };
+  if (reasoning.providerExtras) Object.assign(thinking, reasoning.providerExtras);
+  extra.thinking = thinking;
+  stripSamplingParams(inference, ["temperature", "topP"]);
 }
 function applyGeminiReasoning(generationConfig, reasoning) {
   if (!reasoning) return;
-  const budget = resolveBudget(reasoning, { low: 1024, medium: 4096, high: 12e3, minimal: 512 });
+  const budget = resolveBudget(reasoning, GEMINI_EFFORT_BUDGET);
   if (budget == null) return;
   const thinkingConfig = { thinkingBudget: budget };
   if (reasoning.includeThoughts) thinkingConfig.includeThoughts = true;
   if (reasoning.providerExtras) Object.assign(thinkingConfig, reasoning.providerExtras);
   generationConfig.thinkingConfig = thinkingConfig;
 }
+function stripSamplingParams(target, keys) {
+  for (const k of keys) {
+    if (k in target) delete target[k];
+  }
+}
+function clampBudget(budget, maxTokens) {
+  if (typeof maxTokens !== "number" || maxTokens <= 0) return budget;
+  const ceiling = maxTokens - THINKING_OUTPUT_RESERVE;
+  if (ceiling < 1024) return Math.max(1024, Math.floor(maxTokens / 2));
+  return Math.min(budget, ceiling);
+}
 function normalizeEffort(effort) {
   if (!effort) return void 0;
   const allowed = ["minimal", "low", "medium", "high"];
@@ -6729,13 +7056,38 @@ var OpenAIProvider = class extends BaseProvider {
     };
     if (config.retry) this.retryPolicy = { ...this.retryPolicy, ...config.retry };
   }
+  /** True when the request targets a reasoning model (o-series / gpt-5) so we
+   * should route through the Responses API, which exposes `reasoning.effort`
+   * and reasoning summaries. Chat Completions silently drops these. */
+  useResponsesApi(request) {
+    if (!request.reasoning) return false;
+    return isReasoningModel(request.model || this.defaultModel);
+  }
   async complete(request) {
+    if (this.useResponsesApi(request)) {
+      return this.completeResponses(request);
+    }
     const body = this.buildRequestBody(request, false);
     const res = await this.doFetch(body);
     const json = await res.json();
     return this.parseResponse(json);
   }
   async *completeStream(request) {
+    if (this.useResponsesApi(request)) {
+      const response = await this.completeResponses(request);
+      yield {
+        id: response.id,
+        model: response.model,
+        delta: {
+          content: response.content ?? void 0,
+          toolCalls: response.toolCalls.length > 0 ? response.toolCalls : void 0,
+          reasoning: response.reasoning
+        },
+        usage: response.usage,
+        finishReason: response.finishReason
+      };
+      return;
+    }
     const body = this.buildRequestBody(request, true);
     const res = await this.doFetch(body);
     if (!res.body) throw new ProviderError("No response body for stream", this.providerName);
@@ -6834,6 +7186,156 @@ var OpenAIProvider = class extends BaseProvider {
     applyOpenAIReasoning(body, request.reasoning, "legacy_effort");
     return body;
   }
+  // ─── Responses API (reasoning models) ──────────────────────────────────────
+  async completeResponses(request) {
+    const body = this.buildResponsesBody(request);
+    const res = await this.responsesFetch(body);
+    const json = await res.json();
+    return this.parseResponsesResponse(json, request.model || this.defaultModel);
+  }
+  buildResponsesBody(request) {
+    const body = {
+      model: request.model || this.defaultModel,
+      input: request.messages.map((m) => this.toResponsesInput(m))
+    };
+    if (request.maxTokens != null) body.max_output_tokens = request.maxTokens;
+    if (request.topP != null) body.top_p = request.topP;
+    if (request.tools?.length) {
+      body.tools = request.tools.map((t) => ({
+        type: "function",
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters,
+        ...t.strict ? { strict: true } : {}
+      }));
+    }
+    if (request.toolChoice != null && request.tools?.length) {
+      if (typeof request.toolChoice === "string") {
+        body.tool_choice = request.toolChoice;
+      } else {
+        body.tool_choice = { type: "function", name: request.toolChoice.name };
+      }
+    }
+    if (request.responseFormat) {
+      if (request.responseFormat.type === "json_schema") {
+        body.text = {
+          format: {
+            type: "json_schema",
+            name: request.responseFormat.name ?? "response",
+            schema: request.responseFormat.schema,
+            strict: true
+          }
+        };
+      } else if (request.responseFormat.type === "json_object") {
+        body.text = { format: { type: "json_object" } };
+      }
+    }
+    if (request.extra) Object.assign(body, request.extra);
+    applyOpenAIReasoning(body, request.reasoning, "responses");
+    return body;
+  }
+  /** Maps a unified message to a Responses API `input` item. */
+  toResponsesInput(m) {
+    if (m.role === "tool" && m.toolCallId) {
+      const output = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+      return { type: "function_call_output", call_id: m.toolCallId, output };
+    }
+    if (m.role === "assistant" && m.toolCalls?.length) {
+      return {
+        __assistantWithCalls: true,
+        text: typeof m.content === "string" ? m.content : "",
+        calls: m.toolCalls.map((tc) => ({
+          type: "function_call",
+          call_id: tc.id,
+          name: tc.name,
+          arguments: tc.arguments
+        }))
+      };
+    }
+    const role = m.role === "system" ? "system" : m.role === "assistant" ? "assistant" : "user";
+    const textType = role === "assistant" ? "output_text" : "input_text";
+    if (typeof m.content === "string") {
+      return { role, content: [{ type: textType, text: m.content }] };
+    }
+    const content = m.content.map((part) => {
+      if (part.type === "text") return { type: textType, text: part.text };
+      if (part.type === "image") {
+        const src = part.source;
+        const url = src.type === "url" ? src.url : `data:${src.mediaType};base64,${src.data}`;
+        return { type: "input_image", image_url: url };
+      }
+      return { type: textType, text: "" };
+    });
+    return { role, content };
+  }
+  async responsesFetch(body) {
+    body.input = expandResponsesInput(body.input);
+    const url = `${this.baseURL}/responses`;
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`,
+      ...this.defaultHeaders
+    };
+    const payload = JSON.stringify(body);
+    const res = await this.doFetchWithRetry(() => fetch(url, { method: "POST", headers, body: payload }));
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new ProviderError(
+        `OpenAI Responses API error ${res.status}: ${text}`,
+        this.providerName,
+        res.status,
+        text
+      );
+    }
+    return res;
+  }
+  parseResponsesResponse(json, modelId) {
+    const textParts = [];
+    const toolCalls = [];
+    const summaryParts = [];
+    for (const item of json.output ?? []) {
+      if (item.type === "message") {
+        for (const c of item.content ?? []) {
+          if (c.type === "output_text" && typeof c.text === "string") textParts.push(c.text);
+        }
+      } else if (item.type === "function_call") {
+        toolCalls.push({
+          id: item.call_id ?? item.id ?? "",
+          name: item.name ?? "",
+          arguments: typeof item.arguments === "string" ? item.arguments : JSON.stringify(item.arguments ?? {})
+        });
+      } else if (item.type === "reasoning") {
+        for (const s of item.summary ?? []) {
+          if (typeof s.text === "string") summaryParts.push(s.text);
+        }
+      }
+    }
+    if (textParts.length === 0 && typeof json.output_text === "string") {
+      textParts.push(json.output_text);
+    }
+    const usage = json.usage ?? {};
+    const reasoningTokens = usage.output_tokens_details?.reasoning_tokens ?? 0;
+    const tokenUsage = {
+      inputTokens: usage.input_tokens ?? 0,
+      outputTokens: usage.output_tokens ?? 0,
+      totalTokens: usage.total_tokens ?? (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0),
+      cachedInputTokens: usage.input_tokens_details?.cached_tokens ?? 0,
+      cachedWriteTokens: 0,
+      cachedOutputTokens: 0,
+      reasoningTokens
+    };
+    const finishReason = toolCalls.length > 0 ? "tool_calls" : json.status === "incomplete" ? "length" : "stop";
+    return {
+      id: json.id ?? "",
+      model: json.model ?? modelId,
+      content: textParts.join("") || null,
+      toolCalls,
+      usage: tokenUsage,
+      finishReason,
+      reasoning: summaryParts.length > 0 ? { summary: summaryParts.join("\n").trim() || void 0 } : void 0,
+      raw: json
+    };
+  }
   toOpenAIMessage(m) {
     const msg = { role: m.role };
     if (typeof m.content === "string") {
@@ -6926,6 +7428,25 @@ var OpenAIProvider = class extends BaseProvider {
     };
   }
 };
+function isReasoningModel(model) {
+  if (!model) return false;
+  const m = model.toLowerCase();
+  return /(^|[/_-])o[0-9]/.test(m) || m.startsWith("o1") || m.startsWith("o3") || m.startsWith("o4") || m.includes("gpt-5") || m.includes("gpt5");
+}
+function expandResponsesInput(input) {
+  const out = [];
+  for (const item of input) {
+    if (item && item.__assistantWithCalls) {
+      if (item.text) {
+        out.push({ role: "assistant", content: [{ type: "output_text", text: item.text }] });
+      }
+      for (const call of item.calls) out.push(call);
+    } else {
+      out.push(item);
+    }
+  }
+  return out;
+}
 function mapFinishReason(reason) {
   switch (reason) {
     case "stop":
@@ -6971,6 +7492,7 @@ var AnthropicProvider = class extends BaseProvider {
     let cacheReadInputTokens = 0;
     let cacheCreationInputTokens = 0;
     const currentToolCalls = /* @__PURE__ */ new Map();
+    const reasoningBlocks = /* @__PURE__ */ new Map();
     for await (const event of parseSSEStream(res.body)) {
       let data;
       try {
@@ -7000,6 +7522,10 @@ var AnthropicProvider = class extends BaseProvider {
               name: block.name ?? "",
               arguments: ""
             });
+          } else if (block?.type === "thinking") {
+            reasoningBlocks.set(idx, { type: "thinking", text: block.thinking ?? "", signature: block.signature });
+          } else if (block?.type === "redacted_thinking") {
+            reasoningBlocks.set(idx, { type: "redacted_thinking", data: block.data });
           }
           break;
         }
@@ -7012,6 +7538,19 @@ var AnthropicProvider = class extends BaseProvider {
               model,
               delta: { content: delta.text }
             };
+          } else if (delta?.type === "thinking_delta" && delta.thinking) {
+            const blk = reasoningBlocks.get(idx) ?? { type: "thinking", text: "" };
+            blk.text = (blk.text ?? "") + delta.thinking;
+            reasoningBlocks.set(idx, blk);
+            yield {
+              id,
+              model,
+              delta: { reasoning: { summary: delta.thinking } }
+            };
+          } else if (delta?.type === "signature_delta" && delta.signature) {
+            const blk = reasoningBlocks.get(idx) ?? { type: "thinking", text: "" };
+            blk.signature = (blk.signature ?? "") + delta.signature;
+            reasoningBlocks.set(idx, blk);
           } else if (delta?.type === "input_json_delta" && delta.partial_json) {
             const tc = currentToolCalls.get(idx);
             if (tc) {
@@ -7044,10 +7583,13 @@ var AnthropicProvider = class extends BaseProvider {
             cachedOutputTokens: 0,
             reasoningTokens: 0
           };
+          const blocks = [...reasoningBlocks.values()].filter(
+            (b) => b.type === "thinking" && b.signature || b.type === "redacted_thinking" && b.data
+          );
           yield {
             id,
             model,
-            delta: {},
+            delta: blocks.length > 0 ? { reasoning: { blocks } } : {},
             finishReason,
             usage
           };
@@ -7139,6 +7681,7 @@ var AnthropicProvider = class extends BaseProvider {
     }
     if (m.role === "assistant" && m.toolCalls?.length) {
       const content = [];
+      appendReasoningBlocks(content, m.reasoning?.blocks);
       if (typeof m.content === "string" && m.content) {
         content.push({ type: "text", text: m.content });
       }
@@ -7152,6 +7695,13 @@ var AnthropicProvider = class extends BaseProvider {
       }
       return { role: "assistant", content };
     }
+    if (m.role === "assistant" && m.reasoning?.blocks?.length) {
+      const content = [];
+      appendReasoningBlocks(content, m.reasoning.blocks);
+      const text = typeof m.content === "string" ? m.content : "";
+      if (text) content.push({ type: "text", text });
+      return { role: "assistant", content };
+    }
     const msg = { role: m.role };
     if (typeof m.content === "string") {
       msg.content = m.content;
@@ -7207,9 +7757,20 @@ var AnthropicProvider = class extends BaseProvider {
   parseResponse(json) {
     const textParts = [];
     const toolCalls = [];
+    const reasoningBlocks = [];
+    const summaryParts = [];
     for (const block of json.content ?? []) {
       if (block.type === "text") {
         textParts.push(block.text);
+      } else if (block.type === "thinking") {
+        reasoningBlocks.push({
+          type: "thinking",
+          text: block.thinking ?? "",
+          signature: block.signature
+        });
+        if (block.thinking) summaryParts.push(block.thinking);
+      } else if (block.type === "redacted_thinking") {
+        reasoningBlocks.push({ type: "redacted_thinking", data: block.data });
       } else if (block.type === "tool_use") {
         toolCalls.push({
           id: block.id,
@@ -7226,6 +7787,9 @@ var AnthropicProvider = class extends BaseProvider {
       cachedInputTokens: usage.cache_read_input_tokens ?? 0,
       cachedWriteTokens: usage.cache_creation_input_tokens ?? 0,
       cachedOutputTokens: 0,
+      // Anthropic bills thinking tokens inside `output_tokens` and does not
+      // expose a separate count, so reasoningTokens stays 0 here (cost is still
+      // captured via outputTokens). See docs for the limitation.
       reasoningTokens: 0
     };
     return {
@@ -7235,6 +7799,7 @@ var AnthropicProvider = class extends BaseProvider {
       toolCalls,
       usage: tokenUsage,
       finishReason: mapAnthropicStopReason(json.stop_reason),
+      reasoning: reasoningBlocks.length > 0 ? { blocks: reasoningBlocks, summary: summaryParts.join("\n").trim() || void 0 } : void 0,
       raw: json
     };
   }
@@ -7259,6 +7824,18 @@ function safeJsonParse(str) {
     return {};
   }
 }
+function appendReasoningBlocks(content, blocks) {
+  if (!blocks?.length) return;
+  for (const b of blocks) {
+    if (b.type === "redacted_thinking") {
+      if (b.data) content.push({ type: "redacted_thinking", data: b.data });
+    } else if (b.type === "thinking") {
+      if (b.signature) {
+        content.push({ type: "thinking", thinking: b.text ?? "", signature: b.signature });
+      }
+    }
+  }
+}
 
 // src/providers/azure.ts
 var AzureProvider = class extends OpenAIProvider {
@@ -7302,7 +7879,52 @@ var AzureProvider = class extends OpenAIProvider {
     }
     return res;
   }
+  /** Azure exposes the Responses API at /openai/responses with api-key auth.
+   * Reasoning summaries require a preview api-version; callers can override via
+   * the `apiVersion` config. */
+  async responsesFetch(body) {
+    body.input = expandAzureResponsesInput(body.input);
+    const deployment = this.deploymentName ?? body.model;
+    if (!deployment) {
+      throw new ProviderError("Azure requires a deploymentName or model", this.providerName);
+    }
+    const url = `${this.endpoint}/openai/responses?api-version=${this.apiVersion}`;
+    const payload = JSON.stringify({ ...body, model: deployment });
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "api-key": this.azureApiKey,
+        ...this.defaultHeaders
+      },
+      body: payload
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new ProviderError(
+        `Azure OpenAI Responses API error ${res.status}: ${text}`,
+        this.providerName,
+        res.status,
+        text
+      );
+    }
+    return res;
+  }
 };
+function expandAzureResponsesInput(input) {
+  const out = [];
+  for (const item of input) {
+    if (item && item.__assistantWithCalls) {
+      if (item.text) {
+        out.push({ role: "assistant", content: [{ type: "output_text", text: item.text }] });
+      }
+      for (const call of item.calls) out.push(call);
+    } else {
+      out.push(item);
+    }
+  }
+  return out;
+}
 
 // src/providers/openaiCompatible.ts
 var OpenAICompatibleProvider = class extends OpenAIProvider {
@@ -7475,6 +8097,7 @@ var BedrockProvider = class extends BaseProvider {
     if (request.extra) {
       Object.assign(body, request.extra);
     }
+    applyBedrockReasoning(body, request.reasoning);
     return body;
   }
   splitSystemMessages(messages) {
@@ -7508,6 +8131,7 @@ var BedrockProvider = class extends BaseProvider {
     }
     if (m.role === "assistant" && m.toolCalls?.length) {
       const content2 = [];
+      appendBedrockReasoning(content2, m.reasoning?.blocks);
       if (typeof m.content === "string" && m.content) {
         content2.push({ text: m.content });
       }
@@ -7588,9 +8212,23 @@ var BedrockProvider = class extends BaseProvider {
     const output = json.output?.message;
     const textParts = [];
     const toolCalls = [];
+    const reasoningBlocks = [];
+    const summaryParts = [];
     for (const block of output?.content ?? []) {
       if (block.text) {
         textParts.push(block.text);
+      } else if (block.reasoningContent) {
+        const rc = block.reasoningContent;
+        if (rc.reasoningText) {
+          reasoningBlocks.push({
+            type: "thinking",
+            text: rc.reasoningText.text ?? "",
+            signature: rc.reasoningText.signature
+          });
+          if (rc.reasoningText.text) summaryParts.push(rc.reasoningText.text);
+        } else if (rc.redactedContent) {
+          reasoningBlocks.push({ type: "redacted_thinking", data: rc.redactedContent });
+        }
       } else if (block.toolUse) {
         toolCalls.push({
           id: block.toolUse.toolUseId,
@@ -7607,6 +8245,7 @@ var BedrockProvider = class extends BaseProvider {
       cachedInputTokens: usage.cacheReadInputTokenCount ?? 0,
       cachedWriteTokens: usage.cacheWriteInputTokenCount ?? 0,
       cachedOutputTokens: 0,
+      // Bedrock bills thinking tokens inside outputTokens; no separate count.
       reasoningTokens: 0
     };
     return {
@@ -7616,10 +8255,25 @@ var BedrockProvider = class extends BaseProvider {
       toolCalls,
       usage: tokenUsage,
       finishReason: mapBedrockStopReason(json.stopReason),
+      reasoning: reasoningBlocks.length > 0 ? { blocks: reasoningBlocks, summary: summaryParts.join("\n").trim() || void 0 } : void 0,
       raw: json
     };
   }
 };
+function appendBedrockReasoning(content, blocks) {
+  if (!blocks?.length) return;
+  for (const b of blocks) {
+    if (b.type === "redacted_thinking") {
+      if (b.data) content.push({ reasoningContent: { redactedContent: b.data } });
+    } else if (b.type === "thinking") {
+      if (b.signature) {
+        content.push({
+          reasoningContent: { reasoningText: { text: b.text ?? "", signature: b.signature } }
+        });
+      }
+    }
+  }
+}
 function mapBedrockStopReason(reason) {
   switch (reason) {
     case "end_turn":
@@ -7942,10 +8596,15 @@ var VertexProvider = class extends BaseProvider {
     const parts = candidate?.content?.parts ?? [];
     const textParts = [];
     const toolCalls = [];
+    const thoughtParts = [];
     let toolCallIdx = 0;
     for (const part of parts) {
       if (part.text) {
-        textParts.push(part.text);
+        if (part.thought === true) {
+          thoughtParts.push(part.text);
+        } else {
+          textParts.push(part.text);
+        }
       } else if (part.functionCall) {
         toolCalls.push({
           id: `call_${toolCallIdx++}`,
@@ -7971,6 +8630,7 @@ var VertexProvider = class extends BaseProvider {
       toolCalls,
       usage: tokenUsage,
       finishReason: mapGeminiFinishReason(candidate?.finishReason),
+      reasoning: thoughtParts.length > 0 ? { summary: thoughtParts.join("\n").trim() || void 0 } : void 0,
       raw: json
     };
   }
@@ -7980,7 +8640,11 @@ var VertexProvider = class extends BaseProvider {
     const delta = {};
     for (const part of parts) {
       if (part.text) {
-        delta.content = (delta.content ?? "") + part.text;
+        if (part.thought === true) {
+          delta.reasoning = { summary: (delta.reasoning?.summary ?? "") + part.text };
+        } else {
+          delta.content = (delta.content ?? "") + part.text;
+        }
       } else if (part.functionCall) {
         if (!delta.toolCalls) delta.toolCalls = [];
         delta.toolCalls.push({
@@ -8054,12 +8718,16 @@ function fromNativeProvider(provider, options) {
       let fullContent = "";
       let allToolCalls = [];
       let lastUsage;
+      let reasoningBlocks;
       const toolCallBuffers = /* @__PURE__ */ new Map();
       for await (const chunk of provider.completeStream(request)) {
         if (chunk.delta.content) {
           fullContent += chunk.delta.content;
           yield chunk.delta.content;
         }
+        if (chunk.delta.reasoning?.blocks?.length) {
+          reasoningBlocks = chunk.delta.reasoning.blocks;
+        }
         if (chunk.delta.toolCalls) {
           for (const tc of chunk.delta.toolCalls) {
             if (tc.id) {
@@ -8080,6 +8748,9 @@ function fromNativeProvider(provider, options) {
       }
       allToolCalls = [...toolCallBuffers.values()];
       const finalMessage = assembleMessage(fullContent, allToolCalls, lastUsage);
+      if (reasoningBlocks?.length) {
+        finalMessage.reasoning = { blocks: reasoningBlocks };
+      }
       yield finalMessage;
     },
     bindTools: (tools, _bindOptions) => {
@@ -8142,6 +8813,10 @@ function toUnifiedMessage(msg) {
       arguments: tc.function?.arguments ?? tc.arguments ?? "{}"
     }));
   }
+  const reasoning = msg.reasoning;
+  if (reasoning && (reasoning.blocks?.length || reasoning.summary)) {
+    unified.reasoning = reasoning;
+  }
   return unified;
 }
 function convertContent(content) {
@@ -8350,6 +9025,9 @@ function toBaseChatMessage(response) {
       function: { name: tc.name, arguments: tc.arguments }
     }));
   }
+  if (response.reasoning && (response.reasoning.blocks?.length || response.reasoning.summary)) {
+    msg.reasoning = response.reasoning;
+  }
   return msg;
 }
 function assembleMessage(content, toolCalls, usage) {
@@ -8509,6 +9187,7 @@ exports.otlpSink = otlpSink;
 exports.readMemoryFacts = readMemoryFacts;
 exports.regexRule = regexRule;
 exports.resolveMemoryStore = resolveMemoryStore;
+exports.resolveReasoning = resolveReasoning;
 exports.resolveStrategy = resolveStrategy;
 exports.resolveToolApprovalState = resolveToolApprovalState;
 exports.resolveUserQuestionState = resolveUserQuestionState;
@@ -8517,6 +9196,7 @@ exports.runSmartAgentEvalHarness = runSmartAgentEvalHarness;
 exports.setTokenCounter = setTokenCounter;
 exports.startStreamingSession = startStreamingSession;
 exports.traceSessionToOtlp = traceSessionToOtlp;
+exports.validateReasoningConfig = validateReasoningConfig;
 exports.withTools = withTools;
 exports.writeSummaryFactsToMemory = writeSummaryFactsToMemory;
 //# sourceMappingURL=index.cjs.map