@juspay/neurolink 10.10.0 → 10.10.2

package/dist/context/stages/structuredSummarizer.js

@@ -8,6 +8,7 @@ import { randomUUID } from "crypto";
 import { generateSummary } from "../../utils/conversationMemory.js";
 import { estimateTokens } from "../../utils/tokenEstimation.js";
 import { logger } from "../../utils/logger.js";
+import { snapSplitToBatchBoundary } from "../toolPairRepair.js";
 /**
  * Find the split index using token counting — walk backward from the end,
  * accumulating token counts until we've reserved `targetRecentTokens` worth
@@ -38,8 +39,10 @@ function findSplitIndexByTokens(messages, targetRecentTokens, provider) {
         }
         recentTokens += msgTokens;
     }
-    // Ensure at least one message is summarized
-    return Math.max(1, splitIndex);
+    // Ensure at least one message is summarized, then snap off any tool batch
+    // the boundary would otherwise cut in half — a summary that starts the
+    // recent window on an orphaned tool_result is rejected by the provider.
+    return snapSplitToBatchBoundary(messages, Math.max(1, splitIndex));
 }
 export async function summarizeMessages(messages, config) {
     const keepRecentRatio = config?.keepRecentRatio ?? 0.3;
@@ -65,7 +68,16 @@ export async function summarizeMessages(messages, config) {
     }
     // Clamp so at least the last message is always preserved (never summarize everything)
     splitIndex = Math.min(splitIndex, messages.length - 1);
-    if (splitIndex <= 0) {
+    // Re-snap AFTER the clamp: the clamp can pull the boundary back into a tool
+    // batch that findSplitIndexByTokens had already cleared, and it is also the
+    // only guard covering the legacy message-count branch above.
+    splitIndex = snapSplitToBatchBoundary(messages, splitIndex);
+    // A boundary that still cuts a batch means no legal split exists (e.g. the
+    // whole array is one tool batch). Summarizing anyway would hand the provider
+    // an orphaned tool_result, so decline and let a later stage reclaim instead.
+    if (splitIndex <= 0 ||
+        splitIndex >= messages.length ||
+        splitIndex !== snapSplitToBatchBoundary(messages, splitIndex)) {
         return { summarized: false, messages };
     }
     const messagesToSummarize = messages.slice(0, splitIndex);

package/dist/context/summarizationEngine.js

@@ -7,6 +7,7 @@
 import { TokenUtils } from "../constants/tokens.js";
 import { buildContextFromPointer, generateSummary, } from "../utils/conversationMemory.js";
 import { RECENT_MESSAGES_RATIO } from "../config/conversationMemory.js";
+import { snapSplitToBatchBoundary } from "./toolPairRepair.js";
 import { withSpan } from "../telemetry/withSpan.js";
 import { tracers } from "../telemetry/tracers.js";
 import { logger } from "../utils/logger.js";
@@ -143,7 +144,16 @@ export class SummarizationEngine {
             }
             recentTokens += msgTokens;
         }
-        // Ensure at least one message is summarized
-        return Math.max(1, splitIndex);
+        // Ensure at least one message is summarized, then snap off any tool batch
+        // the boundary would otherwise cut in half (which would leave the recent
+        // window opening on an orphaned tool_result).
+        const snapped = snapSplitToBatchBoundary(messages, Math.max(1, splitIndex));
+        // A forward snap can consume the ENTIRE array when the batch starts at
+        // index 0. Summarizing everything would leave no recent window at all and
+        // move the pointer to the last message, so the next read returns a summary
+        // and nothing else. Decline instead — `summarizeSession` skips a round on
+        // an empty slice. `structuredSummarizer` already guards this case; this is
+        // the same guard for the pointer-based path.
+        return snapped >= messages.length ? 0 : snapped;
     }
 }

package/dist/context/toolPairRepair.d.ts

@@ -1,14 +1,43 @@
 /**
  * Tool Use/Result Pair Repair
  *
- * After compaction, validates that every tool_use (tool_call) has a
- * corresponding tool_result and vice versa. Inserts synthetic
- * placeholders for orphaned entries.
+ * After compaction (or a pointer-based history slice) the message array can
+ * contain a `tool_call` whose `tool_result` was dropped, or a `tool_result`
+ * whose `tool_call` was dropped. Providers reject both, so orphans are filled
+ * with synthetic placeholders.
+ *
+ * Pairing is BATCH- and ID-aware, not adjacency-based. A single agent step
+ * with parallel tool calls is persisted as every `tool_call` followed by every
+ * `tool_result` (see flushPendingToolData), so `tool_call` is routinely
+ * followed by another `tool_call` in perfectly healthy history. Matching on
+ * adjacency treats that as an orphan and injects a bogus "result unavailable"
+ * over a result that is present a few entries later.
+ *
+ * Two modes, chosen per batch:
+ *   - ID mode      — `toolCallId` present: pair by id, order-independent.
+ *   - legacy mode  — sessions written before `toolCallId` existed: pair
+ *                    positionally WITHIN the batch (call[i] ↔ result[i]).
  */
 import type { ChatMessage, RepairResult } from "../types/index.js";
 /**
- * Repair orphaned tool_use/tool_result pairs in a message array.
+ * Move a summarize/keep split so it never falls INSIDE a tool batch.
+ *
+ * `splitIndex` means "messages[0..splitIndex) get summarized" — so the summary
+ * pointer lands on messages[splitIndex - 1]. Landing mid-batch leaves the
+ * recent window starting on an orphaned `tool_result`, which providers reject.
+ *
+ * Preferred direction is BACKWARD (summarize less, keep the whole batch in the
+ * recent window) since that never loses detail. When the batch starts at index
+ * 0 there is nothing left to summarize, so the split moves forward past the
+ * batch instead — the caller's "at least one message summarized" invariant
+ * wins over keeping the batch recent.
+ */
+export declare function snapSplitToBatchBoundary(messages: ChatMessage[], splitIndex: number): number;
+/**
+ * Repair orphaned tool_call/tool_result pairs in a message array.
  *
- * Ensures every tool_call has a following tool_result and vice versa.
+ * Guarantees on return: every `tool_call` is followed (within its batch) by
+ * exactly one `tool_result`, and no `tool_result` precedes its `tool_call`.
+ * A healthy batch — including a parallel one — is returned untouched.
  */
 export declare function repairToolPairs(messages: ChatMessage[]): RepairResult;

package/dist/context/toolPairRepair.js

@@ -1,62 +1,237 @@
 /**
  * Tool Use/Result Pair Repair
  *
- * After compaction, validates that every tool_use (tool_call) has a
- * corresponding tool_result and vice versa. Inserts synthetic
- * placeholders for orphaned entries.
+ * After compaction (or a pointer-based history slice) the message array can
+ * contain a `tool_call` whose `tool_result` was dropped, or a `tool_result`
+ * whose `tool_call` was dropped. Providers reject both, so orphans are filled
+ * with synthetic placeholders.
+ *
+ * Pairing is BATCH- and ID-aware, not adjacency-based. A single agent step
+ * with parallel tool calls is persisted as every `tool_call` followed by every
+ * `tool_result` (see flushPendingToolData), so `tool_call` is routinely
+ * followed by another `tool_call` in perfectly healthy history. Matching on
+ * adjacency treats that as an orphan and injects a bogus "result unavailable"
+ * over a result that is present a few entries later.
+ *
+ * Two modes, chosen per batch:
+ *   - ID mode      — `toolCallId` present: pair by id, order-independent.
+ *   - legacy mode  — sessions written before `toolCallId` existed: pair
+ *                    positionally WITHIN the batch (call[i] ↔ result[i]).
  */
 import { randomUUID } from "crypto";
+const MISSING_RESULT_CONTENT = "[Tool result unavailable - conversation was compacted]";
 /**
- * Repair orphaned tool_use/tool_result pairs in a message array.
- *
- * Ensures every tool_call has a following tool_result and vice versa.
+ * Collect the tool batch starting at `start` (which must index a tool-role
+ * message). Consumes the maximal run of calls followed by the maximal run of
+ * results. A leading run of results with no calls (head-cut orphan) yields a
+ * batch with an empty `calls` array.
  */
-export function repairToolPairs(messages) {
-    const result = [];
+function collectBatch(messages, start) {
+    let i = start;
+    const calls = [];
+    const results = [];
+    while (i < messages.length && messages[i].role === "tool_call") {
+        calls.push(messages[i]);
+        i++;
+    }
+    while (i < messages.length && messages[i].role === "tool_result") {
+        results.push(messages[i]);
+        i++;
+    }
+    return { calls, results, endIndex: i };
+}
+/** Synthetic `tool_result` standing in for a call whose result was dropped. */
+function syntheticResult(call) {
+    return {
+        id: `repair-result-${randomUUID()}`,
+        role: "tool_result",
+        content: MISSING_RESULT_CONTENT,
+        tool: call.tool,
+        ...(call.toolCallId ? { toolCallId: call.toolCallId } : {}),
+        timestamp: call.timestamp,
+        metadata: { truncated: true },
+    };
+}
+/** Synthetic `tool_call` standing in for a result whose call was dropped. */
+function syntheticCall(result) {
+    return {
+        id: `repair-call-${randomUUID()}`,
+        role: "tool_call",
+        content: `[Tool call for ${result.tool || "unknown"} - conversation was compacted]`,
+        tool: result.tool,
+        ...(result.toolCallId ? { toolCallId: result.toolCallId } : {}),
+        timestamp: result.timestamp,
+        metadata: { truncated: true },
+    };
+}
+/**
+ * Repair one batch, emitting calls then results with every call matched to
+ * exactly one result. Returns the rebuilt run plus how many placeholders of
+ * each kind were needed.
+ */
+function repairBatch(batch) {
+    const { calls, results } = batch;
+    // ID mode requires ids on BOTH sides; a partially-migrated batch (some
+    // entries written before toolCallId existed) falls back to legacy pairing
+    // rather than treating the id-less half as universally orphaned.
+    const useIds = calls.length > 0 &&
+        results.length > 0 &&
+        calls.every((m) => !!m.toolCallId) &&
+        results.every((m) => !!m.toolCallId);
+    const outCalls = [...calls];
+    const outResults = [];
     let orphanedCallsFixed = 0;
     let orphanedResultsFixed = 0;
-    for (let i = 0; i < messages.length; i++) {
-        const msg = messages[i];
-        const nextMsg = i + 1 < messages.length ? messages[i + 1] : undefined;
-        if (msg.role === "tool_call") {
-            result.push(msg);
-            // Check if next message is the corresponding tool_result
-            if (!nextMsg || nextMsg.role !== "tool_result") {
-                // Insert synthetic tool_result
-                result.push({
-                    id: `repair-result-${randomUUID()}`,
-                    role: "tool_result",
-                    content: "[Tool result unavailable - conversation was compacted]",
-                    tool: msg.tool,
-                    timestamp: msg.timestamp,
-                    metadata: { truncated: true },
-                });
-                orphanedCallsFixed++;
+    let changed = false;
+    if (useIds) {
+        // Duplicate ids (a retry that re-emitted a result) keep the FIRST result;
+        // later duplicates are dropped so a call never gains a second result.
+        const resultById = new Map();
+        for (const result of results) {
+            const key = result.toolCallId;
+            if (!resultById.has(key)) {
+                resultById.set(key, result);
+            }
+            else {
+                changed = true;
             }
         }
-        else if (msg.role === "tool_result") {
-            // Check if previous message was the corresponding tool_call
-            const prevMsg = result.length > 0 ? result[result.length - 1] : undefined;
-            if (!prevMsg ||
-                (prevMsg.role !== "tool_call" && prevMsg.role !== "tool_result")) {
-                // Insert synthetic tool_call before this result
-                result.push({
-                    id: `repair-call-${randomUUID()}`,
-                    role: "tool_call",
-                    content: `[Tool call for ${msg.tool || "unknown"} - conversation was compacted]`,
-                    tool: msg.tool,
-                    timestamp: msg.timestamp,
-                    metadata: { truncated: true },
-                });
-                orphanedResultsFixed++;
+        for (const call of calls) {
+            const key = call.toolCallId;
+            const match = resultById.get(key);
+            if (match) {
+                outResults.push(match);
+                resultById.delete(key);
+            }
+            else {
+                outResults.push(syntheticResult(call));
+                orphanedCallsFixed++;
             }
-            result.push(msg);
         }
-        else {
+        // Results with no surviving call — the compactor cut the head of the batch.
+        for (const leftover of resultById.values()) {
+            outCalls.push(syntheticCall(leftover));
+            outResults.push(leftover);
+            orphanedResultsFixed++;
+        }
+    }
+    else {
+        // Legacy positional pairing, scoped to the batch.
+        const paired = Math.min(calls.length, results.length);
+        for (let i = 0; i < paired; i++) {
+            outResults.push(results[i]);
+        }
+        for (let i = paired; i < calls.length; i++) {
+            outResults.push(syntheticResult(calls[i]));
+            orphanedCallsFixed++;
+        }
+        for (let i = paired; i < results.length; i++) {
+            outCalls.push(syntheticCall(results[i]));
+            outResults.push(results[i]);
+            orphanedResultsFixed++;
+        }
+    }
+    return {
+        messages: [...outCalls, ...outResults],
+        orphanedCallsFixed,
+        orphanedResultsFixed,
+        changed,
+    };
+}
+/** True for the two roles that make up a tool batch. */
+function isToolRole(msg) {
+    return msg?.role === "tool_call" || msg?.role === "tool_result";
+}
+/**
+ * True when a split at `index` would cut a single batch in half.
+ *
+ * A batch is calls-then-results, so a `tool_result` FOLLOWED BY a `tool_call`
+ * is the boundary BETWEEN two batches — a legal place to split. Treating every
+ * adjacent pair of tool messages as "inside a batch" would fuse a whole
+ * `call,result,call,result,…` history into one indivisible run, and the walks
+ * below would then skip past all of it.
+ */
+function cutsBatch(messages, index) {
+    const before = messages[index - 1];
+    const after = messages[index];
+    if (!isToolRole(before) || !isToolRole(after)) {
+        return false;
+    }
+    return !(before?.role === "tool_result" && after?.role === "tool_call");
+}
+/**
+ * Move a summarize/keep split so it never falls INSIDE a tool batch.
+ *
+ * `splitIndex` means "messages[0..splitIndex) get summarized" — so the summary
+ * pointer lands on messages[splitIndex - 1]. Landing mid-batch leaves the
+ * recent window starting on an orphaned `tool_result`, which providers reject.
+ *
+ * Preferred direction is BACKWARD (summarize less, keep the whole batch in the
+ * recent window) since that never loses detail. When the batch starts at index
+ * 0 there is nothing left to summarize, so the split moves forward past the
+ * batch instead — the caller's "at least one message summarized" invariant
+ * wins over keeping the batch recent.
+ */
+export function snapSplitToBatchBoundary(messages, splitIndex) {
+    if (splitIndex <= 0 || splitIndex >= messages.length) {
+        return splitIndex;
+    }
+    if (!cutsBatch(messages, splitIndex)) {
+        return splitIndex;
+    }
+    let start = splitIndex;
+    while (start > 0 && cutsBatch(messages, start)) {
+        start--;
+    }
+    if (start > 0) {
+        return start;
+    }
+    let end = splitIndex;
+    while (end < messages.length && cutsBatch(messages, end)) {
+        end++;
+    }
+    return end;
+}
+/**
+ * Repair orphaned tool_call/tool_result pairs in a message array.
+ *
+ * Guarantees on return: every `tool_call` is followed (within its batch) by
+ * exactly one `tool_result`, and no `tool_result` precedes its `tool_call`.
+ * A healthy batch — including a parallel one — is returned untouched.
+ */
+export function repairToolPairs(messages) {
+    // Fast path: nothing tool-shaped to repair. Keeps the read-path cost at one
+    // linear scan for the overwhelmingly common text-only conversation.
+    const hasToolMessage = messages.some((msg) => msg.role === "tool_call" || msg.role === "tool_result");
+    if (!hasToolMessage) {
+        return {
+            repaired: false,
+            messages,
+            orphanedCallsFixed: 0,
+            orphanedResultsFixed: 0,
+        };
+    }
+    const result = [];
+    let orphanedCallsFixed = 0;
+    let orphanedResultsFixed = 0;
+    let changed = false;
+    let i = 0;
+    while (i < messages.length) {
+        const msg = messages[i];
+        if (msg.role !== "tool_call" && msg.role !== "tool_result") {
             result.push(msg);
+            i++;
+            continue;
         }
+        const batch = collectBatch(messages, i);
+        const repaired = repairBatch(batch);
+        result.push(...repaired.messages);
+        orphanedCallsFixed += repaired.orphanedCallsFixed;
+        orphanedResultsFixed += repaired.orphanedResultsFixed;
+        changed = changed || repaired.changed;
+        i = batch.endIndex;
     }
-    const repaired = orphanedCallsFixed > 0 || orphanedResultsFixed > 0;
+    const repaired = orphanedCallsFixed > 0 || orphanedResultsFixed > 0 || changed;
     return {
         repaired,
         messages: repaired ? result : messages,

package/dist/core/modules/GenerationHandler.js

@@ -26,6 +26,7 @@ import { DEFAULT_MAX_STEPS, DEFAULT_WRAPUP_TIME_LEAD_MS, } from "../constants.js
 import { createStepBudgetGuard, estimateFixedOverheadTokens, } from "../../context/stepBudgetGuard.js";
 import { isTemperatureDeprecatedError, isSchemaComplexityError, isToolsSchemaConflictError, isToolsSchemaExclusionInForce, } from "./structuredOutputPolicy.js";
 import { coerceJsonToSchema } from "../../utils/json/coerce.js";
+import { convertZodToJsonSchema } from "../../utils/schemaConversion.js";
 import { NoObjectGeneratedError } from "../../utils/generationErrors.js";
 import { Output, stepCountIs } from "../../utils/tool.js";
 import { generateText } from "../../utils/generation.js";
@@ -105,11 +106,14 @@ export function resolveTurnBudget(options, turnStartMs) {
  * `providerOptions:` spreads in the args literal would silently clobber each
  * other (object spread does not deep-merge).
  */
-function buildProviderOptions(options, isGoogleProvider, callerTimeoutMs) {
+function buildProviderOptions(options, isGoogleProvider, callerTimeoutMs, finalResultSchema) {
     const providerOptions = {};
     if (callerTimeoutMs !== undefined) {
         providerOptions.neurolink = { timeoutMs: callerTimeoutMs };
     }
+    if (finalResultSchema) {
+        providerOptions.anthropic = { finalResultSchema };
+    }
     if (options.thinkingConfig?.enabled && isGoogleProvider) {
         // Gemini 3 uses thinkingLevel; Gemini 2.5 uses thinkingBudget.
         providerOptions.google = {
@@ -236,7 +240,22 @@ export class GenerationHandler {
         const prepareStep = options.prepareStep;
         const { callerTimeoutMs, turnBudgetMs, wrapupLeadMs, turnDeadline } = resolveTurnBudget(options, turnStartMs);
         let wrapupForced = false;
-        const providerOptions = buildProviderOptions(options, isGoogleProvider, callerTimeoutMs);
+        // The native Anthropic Messages surface cannot combine AI-SDK structured
+        // output with tools (see structuredOutputPolicy — experimental_output
+        // replaces the tools array), so `useStructuredOutput` is false above and
+        // the schema would simply be dropped for every agent/MCP turn. Hand the
+        // JSON Schema to the provider instead: it appends an additive
+        // `final_result` tool and returns the answer as that tool's arguments,
+        // keeping the real tools callable. Bedrock is deliberately excluded — it
+        // runs on the third-party @ai-sdk/amazon-bedrock model, which has no such
+        // handling.
+        const finalResultSchema = this.providerName === "anthropic" &&
+            !!options.schema &&
+            shouldUseTools &&
+            Object.keys(tools).length > 0
+            ? convertZodToJsonSchema(options.schema)
+            : undefined;
+        const providerOptions = buildProviderOptions(options, isGoogleProvider, callerTimeoutMs, finalResultSchema);
         // Hoist system-role messages into generateText's top-level `system` option
         // rather than passing them inside `messages` (deprecated by the AI SDK,
         // rejected in v7). See extractSystemMessages for the rationale. (#1024)

package/dist/core/modules/structuredOutputPolicy.d.ts

@@ -23,6 +23,14 @@ export declare function isGeminiProvider(providerName: string, modelName: string
  * experimental_output + tools silently drops tool_use blocks on this surface, so
  * structured output must be disabled when tools are active. Vertex+Claude is NOT
  * matched here (different transport, no conflict).
+ *
+ * Being excluded here no longer means the schema is LOST for provider
+ * "anthropic": GenerationHandler forwards the JSON Schema to the provider via
+ * `providerOptions.anthropic.finalResultSchema`, and the provider appends an
+ * additive `final_result` tool (see providers/anthropic/structuredOutput.ts) —
+ * schema enforcement without giving up tool calling. "bedrock" has no such
+ * handling (it runs on the third-party @ai-sdk/amazon-bedrock model) and still
+ * falls back to text-mode coercion.
  */
 export declare function isNativeAnthropicProvider(providerName: string): boolean;
 /**

package/dist/core/modules/structuredOutputPolicy.js

@@ -33,6 +33,14 @@ export function isGeminiProvider(providerName, modelName) {
  * experimental_output + tools silently drops tool_use blocks on this surface, so
  * structured output must be disabled when tools are active. Vertex+Claude is NOT
  * matched here (different transport, no conflict).
+ *
+ * Being excluded here no longer means the schema is LOST for provider
+ * "anthropic": GenerationHandler forwards the JSON Schema to the provider via
+ * `providerOptions.anthropic.finalResultSchema`, and the provider appends an
+ * additive `final_result` tool (see providers/anthropic/structuredOutput.ts) —
+ * schema enforcement without giving up tool calling. "bedrock" has no such
+ * handling (it runs on the third-party @ai-sdk/amazon-bedrock model) and still
+ * falls back to text-mode coercion.
  */
 export function isNativeAnthropicProvider(providerName) {
     return providerName === "anthropic" || providerName === "bedrock";

package/dist/core/redisConversationMemoryManager.js

@@ -1406,6 +1406,10 @@ User message: "${userMessage}"`;
                     role: "tool_call",
                     content: "", // Can be empty for tool calls
                     tool: toolName,
+                    // Persisted so repairToolPairs can pair by ID rather than adjacency —
+                    // a parallel batch writes all calls before any result, so position
+                    // carries no pairing information.
+                    ...(toolCallId ? { toolCallId } : {}),
                     args: (toolCall.args ||
                         toolCall.arguments ||
                         toolCall.parameters ||
@@ -1493,6 +1497,10 @@ User message: "${userMessage}"`;
                     role: "tool_result",
                     content: serializedResult, // Full output (was "")
                     tool: toolName,
+                    // Only a REAL id is persisted: the "unknown" sentinel above would
+                    // otherwise collide across every unidentifiable result and pair them
+                    // to each other. Absent id falls back to legacy positional pairing.
+                    ...(toolCallId && toolCallId !== "unknown" ? { toolCallId } : {}),
                     result,
                     metadata,
                 };

package/dist/lib/context/stages/structuredSummarizer.js

@@ -8,6 +8,7 @@ import { randomUUID } from "crypto";
 import { generateSummary } from "../../utils/conversationMemory.js";
 import { estimateTokens } from "../../utils/tokenEstimation.js";
 import { logger } from "../../utils/logger.js";
+import { snapSplitToBatchBoundary } from "../toolPairRepair.js";
 /**
  * Find the split index using token counting — walk backward from the end,
  * accumulating token counts until we've reserved `targetRecentTokens` worth
@@ -38,8 +39,10 @@ function findSplitIndexByTokens(messages, targetRecentTokens, provider) {
         }
         recentTokens += msgTokens;
     }
-    // Ensure at least one message is summarized
-    return Math.max(1, splitIndex);
+    // Ensure at least one message is summarized, then snap off any tool batch
+    // the boundary would otherwise cut in half — a summary that starts the
+    // recent window on an orphaned tool_result is rejected by the provider.
+    return snapSplitToBatchBoundary(messages, Math.max(1, splitIndex));
 }
 export async function summarizeMessages(messages, config) {
     const keepRecentRatio = config?.keepRecentRatio ?? 0.3;
@@ -65,7 +68,16 @@ export async function summarizeMessages(messages, config) {
     }
     // Clamp so at least the last message is always preserved (never summarize everything)
     splitIndex = Math.min(splitIndex, messages.length - 1);
-    if (splitIndex <= 0) {
+    // Re-snap AFTER the clamp: the clamp can pull the boundary back into a tool
+    // batch that findSplitIndexByTokens had already cleared, and it is also the
+    // only guard covering the legacy message-count branch above.
+    splitIndex = snapSplitToBatchBoundary(messages, splitIndex);
+    // A boundary that still cuts a batch means no legal split exists (e.g. the
+    // whole array is one tool batch). Summarizing anyway would hand the provider
+    // an orphaned tool_result, so decline and let a later stage reclaim instead.
+    if (splitIndex <= 0 ||
+        splitIndex >= messages.length ||
+        splitIndex !== snapSplitToBatchBoundary(messages, splitIndex)) {
         return { summarized: false, messages };
     }
     const messagesToSummarize = messages.slice(0, splitIndex);

package/dist/lib/context/summarizationEngine.js

@@ -7,6 +7,7 @@
 import { TokenUtils } from "../constants/tokens.js";
 import { buildContextFromPointer, generateSummary, } from "../utils/conversationMemory.js";
 import { RECENT_MESSAGES_RATIO } from "../config/conversationMemory.js";
+import { snapSplitToBatchBoundary } from "./toolPairRepair.js";
 import { withSpan } from "../telemetry/withSpan.js";
 import { tracers } from "../telemetry/tracers.js";
 import { logger } from "../utils/logger.js";
@@ -143,8 +144,17 @@ export class SummarizationEngine {
             }
             recentTokens += msgTokens;
         }
-        // Ensure at least one message is summarized
-        return Math.max(1, splitIndex);
+        // Ensure at least one message is summarized, then snap off any tool batch
+        // the boundary would otherwise cut in half (which would leave the recent
+        // window opening on an orphaned tool_result).
+        const snapped = snapSplitToBatchBoundary(messages, Math.max(1, splitIndex));
+        // A forward snap can consume the ENTIRE array when the batch starts at
+        // index 0. Summarizing everything would leave no recent window at all and
+        // move the pointer to the last message, so the next read returns a summary
+        // and nothing else. Decline instead — `summarizeSession` skips a round on
+        // an empty slice. `structuredSummarizer` already guards this case; this is
+        // the same guard for the pointer-based path.
+        return snapped >= messages.length ? 0 : snapped;
     }
 }
 //# sourceMappingURL=summarizationEngine.js.map

package/dist/lib/context/toolPairRepair.d.ts

@@ -1,14 +1,43 @@
 /**
  * Tool Use/Result Pair Repair
  *
- * After compaction, validates that every tool_use (tool_call) has a
- * corresponding tool_result and vice versa. Inserts synthetic
- * placeholders for orphaned entries.
+ * After compaction (or a pointer-based history slice) the message array can
+ * contain a `tool_call` whose `tool_result` was dropped, or a `tool_result`
+ * whose `tool_call` was dropped. Providers reject both, so orphans are filled
+ * with synthetic placeholders.
+ *
+ * Pairing is BATCH- and ID-aware, not adjacency-based. A single agent step
+ * with parallel tool calls is persisted as every `tool_call` followed by every
+ * `tool_result` (see flushPendingToolData), so `tool_call` is routinely
+ * followed by another `tool_call` in perfectly healthy history. Matching on
+ * adjacency treats that as an orphan and injects a bogus "result unavailable"
+ * over a result that is present a few entries later.
+ *
+ * Two modes, chosen per batch:
+ *   - ID mode      — `toolCallId` present: pair by id, order-independent.
+ *   - legacy mode  — sessions written before `toolCallId` existed: pair
+ *                    positionally WITHIN the batch (call[i] ↔ result[i]).
  */
 import type { ChatMessage, RepairResult } from "../types/index.js";
 /**
- * Repair orphaned tool_use/tool_result pairs in a message array.
+ * Move a summarize/keep split so it never falls INSIDE a tool batch.
+ *
+ * `splitIndex` means "messages[0..splitIndex) get summarized" — so the summary
+ * pointer lands on messages[splitIndex - 1]. Landing mid-batch leaves the
+ * recent window starting on an orphaned `tool_result`, which providers reject.
+ *
+ * Preferred direction is BACKWARD (summarize less, keep the whole batch in the
+ * recent window) since that never loses detail. When the batch starts at index
+ * 0 there is nothing left to summarize, so the split moves forward past the
+ * batch instead — the caller's "at least one message summarized" invariant
+ * wins over keeping the batch recent.
+ */
+export declare function snapSplitToBatchBoundary(messages: ChatMessage[], splitIndex: number): number;
+/**
+ * Repair orphaned tool_call/tool_result pairs in a message array.
  *
- * Ensures every tool_call has a following tool_result and vice versa.
+ * Guarantees on return: every `tool_call` is followed (within its batch) by
+ * exactly one `tool_result`, and no `tool_result` precedes its `tool_call`.
+ * A healthy batch — including a parallel one — is returned untouched.
  */
 export declare function repairToolPairs(messages: ChatMessage[]): RepairResult;