@pensar/apex 2.6.1 → 2.7.0-canary.1572d9a4

package/src/core/ai/ai.ts

@@ -1,8 +1,8 @@
 import { AsyncLocalStorage, AsyncResource } from "node:async_hooks";
 import { setTimeout as delay } from "node:timers/promises";
 import type { AnthropicMessagesModelId } from "@ai-sdk/anthropic/internal";
-import type { OpenAIResponsesProviderOptions } from "@ai-sdk/openai";
 import type { OpenAIChatModelId } from "@ai-sdk/openai/internal";
+import type { LanguageModelV3StreamPart } from "@ai-sdk/provider";
 import {
   generateText,
   type LanguageModel,
@@ -51,6 +51,9 @@ import {
 } from "./compactionTelemetry";
 import {
   estimateMessageTokens,
+  estimateTokens,
+  estimateToolsOverheadTokens,
+  type FitContextResult,
   fitMessagesToContext,
   truncateWithMarker,
 } from "./contextManagement";
@@ -60,7 +63,7 @@ import {
   runWithInferenceRecorder,
 } from "./inference-attempt";
 import {
-  getClaudeCapabilities,
+  type ClaudeThinkingEffort,
   getMaxOutputTokens,
   getModelInfo,
   prefersSequentialToolCalls,
@@ -71,13 +74,20 @@ import {
 } from "./native-rollout-evidence";
 import { CONCENTRATE_GLM_5_3_MODEL_ID } from "./providers/concentrate";
 import { OPENAI_PRO_TIMEOUT_MS } from "./providers/openai-pro-fetch";
+import {
+  buildModelReasoningOptions,
+  getReasoningCapabilities,
+  type ReasoningProviderOptions,
+  type ReasoningSetting,
+  resolveReasoningSetting,
+} from "./reasoning";
 import { STREAM_DEBUG } from "./streamTelemetry";
 import {
   type AIAuthConfig,
+  CompactionRejectedError,
   checkIfContextLengthError,
   createSummarizationStream,
   getProviderModel,
-  isAnthropicProvider,
 } from "./utils";
 
 const log = scopedLogger(() => createLogger("ai"));
@@ -125,6 +135,7 @@ export type AIModel = AnthropicMessagesModelId | OpenAIChatModelId | string; //
 
 export type OpenAIReasoningEffort =
   | "none"
+  | "minimal"
   | "low"
   | "medium"
   | "high"
@@ -136,41 +147,11 @@ export const DEFAULT_OPENAI_REASONING_EFFORT: OpenAIReasoningEffort = "medium";
 
 /**
  * Anthropic adaptive-thinking effort hint. Soft guidance for how much the model
- * reasons (see AWS "adaptive thinking"): `low` minimizes thinking, `max`
- * reasons hardest (`high` is the model default). Only meaningful for models that
- * support adaptive thinking (Claude Opus/Sonnet 4.6+); ignored elsewhere.
+ * reasons (see AWS "adaptive thinking"): `low` minimizes thinking while
+ * `xhigh` and `max` allow progressively deeper work. Only meaningful for
+ * models that support adaptive thinking; ignored elsewhere.
  */
-export type ThinkingEffort = "low" | "medium" | "high" | "xhigh" | "max";
-
-const OPENAI_REASONING_MODEL_IDS = new Set([
-  "gpt-6.1-sol",
-  "gpt-6-luna",
-  "gpt-6-sol",
-  "gpt-6-astra",
-  "gpt-5.5-pro",
-  "gpt-5.5-pro-2026-04-23",
-  "gpt-5.4-nano",
-  "gpt-5.4-nano-2026-03-17",
-  "gpt-5.4-mini",
-  "gpt-5.4-mini-2026-03-17",
-  "gpt-5",
-  "gpt-5-2025-08-07",
-  "gpt-5.1",
-  "gpt-5.1-2025-11-13",
-  "gpt-5.2",
-  "gpt-5.2-2025-12-11",
-  "gpt-5.2-pro",
-  "gpt-5.2-pro-2025-12-11",
-  "gpt-5.4",
-  "gpt-5.4-2026-03-05",
-  "gpt-5.4-pro",
-  "gpt-5.4-pro-2026-03-05",
-  "gpt-5.5",
-  "gpt-5.5-2026-04-23",
-  "gpt-5.6-sol",
-  "gpt-5.6-terra",
-  "gpt-5.6-luna",
-]);
+export type ThinkingEffort = ClaudeThinkingEffort;
 
 /** Per-step billing context attached to a usage report, attributing cost to a specific `(sessionId, stepSeq)`. */
 export interface UsageStepContext {
@@ -606,7 +587,11 @@ async function* withIdleTimeout<T>(
 function isStreamIdleTimeoutError(error: unknown): boolean {
   // AI SDK may rewrap the error, so walk `cause`.
   for (let e: unknown = error, depth = 0; e != null && depth < 6; depth++) {
-    if (e instanceof StreamIdleTimeoutError) return true;
+    if (
+      e instanceof StreamIdleTimeoutError ||
+      (e as { name?: unknown }).name === "StreamIdleTimeoutError"
+    )
+      return true;
     e = (e as { cause?: unknown }).cause;
   }
   return false;
@@ -640,6 +625,7 @@ function createToolExecutionGate(): {
     type: string;
     toolCallId?: string;
     toolName?: string;
+    preliminary?: boolean;
   }) => void;
 } {
   let inFlight = 0;
@@ -648,6 +634,7 @@ function createToolExecutionGate(): {
   return {
     shouldEnforceIdleTimeout: () => inFlight === 0,
     observe: (chunk) => {
+      if (chunk.type === "tool-result" && chunk.preliminary) return;
       if (chunk.type === "tool-call") {
         if (chunk.toolName && NON_GATED_TOOLS.has(chunk.toolName)) return;
         const id = chunk.toolCallId;
@@ -676,6 +663,43 @@ function createToolExecutionGate(): {
   };
 }
 
+class InStreamCompactionRequired extends Error {
+  constructor(readonly fitted: FitContextResult) {
+    super("In-stream compaction required before provider dispatch");
+  }
+}
+
+// Retry once after new tool output, then let fitting handle this turn.
+const MAX_PROACTIVE_SUMMARY_FAILURES = 2;
+
+function shouldSummarizeBeforeFitting(
+  messages: ModelMessage[],
+  contextWindow: number,
+  maxOutputTokens: number,
+  overheadTokens: number,
+  safetyMarginTokens: number,
+  system?: string,
+  toolChoice?: ToolChoice<ToolSet>,
+): boolean {
+  const historyBudget =
+    contextWindow -
+    maxOutputTokens -
+    overheadTokens -
+    safetyMarginTokens -
+    (system ? estimateTokens(system) : 0);
+  const estimatedHistoryTokens = estimateMessageTokens(messages);
+  // Forced-tool replays missed the summary cache; keep their fitted history path.
+  return (
+    historyBudget > 0 &&
+    messages.length > 2 &&
+    toolChoice !== "required" &&
+    typeof toolChoice !== "object" &&
+    estimatedHistoryTokens >=
+      Math.max(100_000, Math.floor(historyBudget * 0.8)) &&
+    estimatedHistoryTokens <= historyBudget
+  );
+}
+
 // Helper function to wrap a stream with error handling for async errors
 function wrapStreamWithErrorHandler(
   originalStream: StreamTextResult<ToolSet, never>,
@@ -686,6 +710,7 @@ function wrapStreamWithErrorHandler(
   rateLimitRetryCount: number = 0,
   idleResumeCount: number = 0,
   generationSpans?: GenerationSpanTracker,
+  drainIdleStream?: (reason: unknown) => Promise<void>,
 ): StreamTextResult<ToolSet, never> {
   // Create a lazy getter for fullStream that wraps it with error handling
   let wrappedStream: AsyncIterable<TextStreamPart<ToolSet>> | null = null;
@@ -786,7 +811,15 @@ function wrapStreamWithErrorHandler(
 
               // Check context length FIRST — these should never be retried
               // as-is; the prompt must be reduced via summarization.
-              const isCtxError = checkIfContextLengthError(error);
+              const isCtxError =
+                error instanceof InStreamCompactionRequired ||
+                error instanceof CompactionRejectedError ||
+                checkIfContextLengthError(error);
+              if (
+                opts.primaryModelOnly &&
+                (!opts.runContextCompaction || !isCtxError)
+              )
+                throw error;
 
               // A latched persistence failure is terminal: retrying would
               // dispatch a turn whose context was never durably committed.
@@ -798,6 +831,9 @@ function wrapStreamWithErrorHandler(
                 throw error;
               }
 
+              if (isStreamIdleTimeoutError(error))
+                await drainIdleStream?.(error);
+
               // Handle stream idle timeout — resume from accumulated messages
               if (
                 !isCtxError &&
@@ -893,42 +929,50 @@ function wrapStreamWithErrorHandler(
               }
 
               if (isCtxError) {
-                let currentMessages: ModelMessage[] = messagesContainer.current;
-                try {
-                  const response = await originalStream.response;
-                  if (response.messages && response.messages.length > 0) {
-                    currentMessages = response.messages as ModelMessage[];
+                let currentMessages: ModelMessage[] =
+                  error instanceof InStreamCompactionRequired
+                    ? error.fitted.messages
+                    : messagesContainer.current;
+                if (!(error instanceof InStreamCompactionRequired)) {
+                  try {
+                    const response = await originalStream.response;
+                    if (response.messages && response.messages.length > 0) {
+                      currentMessages = response.messages as ModelMessage[];
+                    }
+                  } catch {
+                    // Fall back to container messages.
                   }
-                } catch {
-                  // Fall back to container messages.
                 }
 
-                const fitted = fitMessagesToContext(currentMessages, {
-                  contextWindow: getContextWindow(
-                    opts.model,
-                    opts.authConfig?.customProviders,
-                    opts.authConfig?.hoonifyModels,
-                  ),
-                  maxOutputTokens: getMaxOutputTokens(
-                    opts.model,
-                    opts.authConfig?.customProviders,
-                    opts.authConfig?.hoonifyModels,
-                  ),
-                  system: applySequentialToolCallPolicy(
-                    opts.system,
-                    opts.tools,
-                    opts.model,
-                  ),
-                  tools: opts.tools,
-                  sessionPath: opts.sessionPath,
-                  telemetry: {
-                    trigger: "context_overflow",
-                    model: opts.model,
-                    sessionId: opts.sessionId,
-                    restartDepth: opts._restartDepth,
-                    previous: opts._compaction?.last,
-                  },
-                });
+                const fitted =
+                  error instanceof InStreamCompactionRequired
+                    ? error.fitted
+                    : fitMessagesToContext(currentMessages, {
+                        contextWindow: getContextWindow(
+                          opts.model,
+                          opts.authConfig?.customProviders,
+                          opts.authConfig?.hoonifyModels,
+                        ),
+                        maxOutputTokens: getMaxOutputTokens(
+                          opts.model,
+                          opts.authConfig?.customProviders,
+                          opts.authConfig?.hoonifyModels,
+                        ),
+                        system: applySequentialToolCallPolicy(
+                          opts.system,
+                          opts.tools,
+                          opts.model,
+                        ),
+                        tools: opts.tools,
+                        sessionPath: opts.sessionPath,
+                        telemetry: {
+                          trigger: "context_overflow",
+                          model: opts.model,
+                          sessionId: opts.sessionId,
+                          restartDepth: opts._restartDepth,
+                          previous: opts._compaction?.last,
+                        },
+                      });
 
                 if (fitted.compaction && opts._compaction)
                   opts._compaction.last = fitted.compaction;
@@ -944,7 +988,11 @@ function wrapStreamWithErrorHandler(
                 // `MAX_RESTART_DEPTH` finally trips.
                 let postReactiveDepth = opts._restartDepth ?? 0;
 
-                if (fitted.fitsBudget && fitted.modified) {
+                if (
+                  !(error instanceof CompactionRejectedError) &&
+                  fitted.fitsBudget &&
+                  fitted.modified
+                ) {
                   if (!silent) {
                     log.warn(
                       `Context length error — Layer 1+2 reduced to ~${fitted.estimatedInputTokens} tokens, retrying`,
@@ -1017,12 +1065,19 @@ function wrapStreamWithErrorHandler(
                 }
 
                 try {
+                  if (error instanceof CompactionRejectedError) throw error;
                   const summarizationStream = createSummarizationStream(
                     messagesForSummary,
                     {
                       ...opts,
                       _restartDepth: postReactiveDepth,
-                      _compactionTrigger: "context_overflow",
+                      _compactionTrigger:
+                        error instanceof InStreamCompactionRequired
+                          ? "proactive"
+                          : "context_overflow",
+                      _proactiveSummaryMayFit:
+                        error instanceof InStreamCompactionRequired &&
+                        error.fitted.fitsBudget,
                     },
                     model,
                   );
@@ -1030,7 +1085,7 @@ function wrapStreamWithErrorHandler(
                     yield chunk;
                   }
                 } catch (summarizeError) {
-                  // Only fall through to minimal-restart for context-length
+                  // Fall through to minimal restart for context or rejected-summary
                   // errors. For everything else — auth failures, network
                   // errors, abort signals, the typed terminal
                   // `ContextLengthExhaustedError`, or non-`Error` throws —
@@ -1039,11 +1094,15 @@ function wrapStreamWithErrorHandler(
                   // auth failure would burn an extra cycle that fails
                   // identically.
                   if (
+                    opts.primaryModelOnly ||
                     summarizeError instanceof ContextLengthExhaustedError ||
                     (summarizeError instanceof Error &&
                       summarizeError.name === "AbortError") ||
                     opts.abortSignal?.aborted ||
-                    !checkIfContextLengthError(summarizeError)
+                    !(
+                      checkIfContextLengthError(summarizeError) ||
+                      summarizeError instanceof CompactionRejectedError
+                    )
                   ) {
                     throw summarizeError;
                   }
@@ -1137,56 +1196,27 @@ export interface ModelInfo {
 }
 
 export function modelRequiresThinking(modelId: string): boolean {
-  return getClaudeCapabilities(modelId)?.alwaysOnThinking ?? false;
+  return getReasoningCapabilities(modelId).alwaysOn ?? false;
 }
 
-/**
- * Check whether a model supports extended thinking based on its ID.
- *
- * Thinking is available on Claude 3.7 Sonnet and all Claude 4.x+ models
- * (Sonnet, Opus, Haiku 4.5). Works for Anthropic direct, Bedrock, and
- * Pensar provider IDs.
- */
 export function modelSupportsThinking(modelId: string): boolean {
-  if (getClaudeCapabilities(modelId)) return true;
-  // Normalize: strip provider prefixes so we match the base Claude model ID
-  const normalized = modelId
-    .replace(/^pensar:/, "")
-    .replace(/^(us\.|eu\.|global\.|ap\.)?anthropic\./, "");
-
+  const cap = getReasoningCapabilities(modelId);
   return (
-    /^claude-3-7-sonnet/.test(normalized) ||
-    /^claude-sonnet-4/.test(normalized) ||
-    /^claude-opus-4/.test(normalized) ||
-    /^claude-haiku-4-5/.test(normalized)
+    cap.control !== "none" &&
+    (!!cap.thinking || modelId.startsWith("anthropic/claude-"))
   );
 }
 
-/**
- * Whether a model accepts the `adaptive` thinking type — Claude Opus 4.6+ and
- * Sonnet 4.6+. Pre-4.6 models (Opus 4.0–4.5, Sonnet 4.5, Haiku 4.5) support
- * extended thinking but reject `adaptive`, so we don't request thinking for
- * them at all.
- */
 export function modelSupportsAdaptiveThinking(modelId: string): boolean {
-  if (getClaudeCapabilities(modelId)) return true;
-  const normalized = modelId
-    .replace(/^pensar:/, "")
-    .replace(/^(us\.|eu\.|global\.|ap\.)?anthropic\./, "");
-
-  return (
-    /^claude-sonnet-4-[6-9]/.test(normalized) ||
-    /^claude-opus-4-[6-9]/.test(normalized)
-  );
+  return getReasoningCapabilities(modelId).thinking === "adaptive";
 }
 
 export function modelSupportsOpenAIReasoning(modelId: string): boolean {
-  if (modelId === CONCENTRATE_GLM_5_3_MODEL_ID) return true;
-  const { provider } = getModelInfo(modelId);
-  if (!["openai", "openrouter", "concentrate"].includes(provider)) return false;
-  modelId = modelId.replace(/^(openai\/|concentrate:)/, "");
+  const cap = getReasoningCapabilities(modelId);
   return (
-    OPENAI_REASONING_MODEL_IDS.has(modelId) || /^o[134](?:\b|-)/.test(modelId)
+    cap.control === "effort" &&
+    !modelSupportsThinking(modelId) &&
+    cap.transport !== "google"
   );
 }
 
@@ -1197,99 +1227,41 @@ export function modelRequiresReasoning(modelId: string): boolean {
 export function getOpenAIReasoningEfforts(
   modelId: string,
 ): OpenAIReasoningEffort[] {
-  if (!modelSupportsOpenAIReasoning(modelId)) return [];
-  if (modelId === CONCENTRATE_GLM_5_3_MODEL_ID) {
-    return ["low", "high", "max"];
-  }
-  if (/^concentrate:gpt-5\.4-(?:mini|nano)$/.test(modelId)) {
-    return ["none", "low", "medium", "high"];
-  }
-  modelId = modelId.replace(/^(openai\/|concentrate:)/, "");
-  if (modelId === "gpt-6-sol" || modelId === "gpt-6-luna") {
-    return ["none", "low", "medium", "high", "xhigh", "max"];
-  }
-  if (/^gpt-6[.-]/.test(modelId)) {
-    return ["low", "medium", "high", "xhigh", "max"];
-  }
-  if (/^gpt-5\.5-pro(?:-|$)/.test(modelId)) {
-    return ["medium", "high", "xhigh"];
-  }
-  if (/^gpt-5\.4-(?:mini|nano)(?:-|$)/.test(modelId)) {
-    return ["none", "low", "medium", "high", "xhigh"];
-  }
-  if (/^gpt-5\.6(?:\b|-)/.test(modelId)) {
-    return ["low", "medium", "high", "xhigh", "max", "ultra"];
-  }
-  if (/^gpt-5\.5(?:\b|-)/.test(modelId)) {
-    return ["none", "low", "medium", "high", "xhigh"];
-  }
-  return ["low", "medium", "high"];
+  return modelSupportsOpenAIReasoning(modelId)
+    ? ([
+        ...getReasoningCapabilities(modelId).efforts,
+      ] as OpenAIReasoningEffort[])
+    : [];
 }
 
 export function normalizeOpenAIReasoningEffort(
   modelId: string,
   effort?: OpenAIReasoningEffort | null,
 ): OpenAIReasoningEffort | undefined {
-  if (modelId === CONCENTRATE_GLM_5_3_MODEL_ID) {
-    switch (effort) {
-      case "none":
-      case "low":
-        return "low";
-      case "medium":
-      case "high":
-        return "high";
-      case "xhigh":
-      case "max":
-      case "ultra":
-        return "max";
-      default:
-        return "high";
+  if (!modelSupportsOpenAIReasoning(modelId)) return undefined;
+  const setting = resolveReasoningSetting(modelId, {
+    openAIReasoningEffort: effort,
+  });
+  return setting === "default"
+    ? undefined
+    : (setting as OpenAIReasoningEffort | undefined);
+}
+
+export type { ReasoningProviderOptions } from "./reasoning";
+
+export function mergeProviderOptions(
+  ...options: Array<ReasoningProviderOptions | undefined>
+): ReasoningProviderOptions | undefined {
+  if (options.every((value) => value === undefined)) return undefined;
+  const merged: ReasoningProviderOptions = {};
+  for (const option of options) {
+    for (const [provider, value] of Object.entries(option ?? {})) {
+      merged[provider] = { ...merged[provider], ...value };
     }
   }
-  const efforts = getOpenAIReasoningEfforts(modelId);
-  if (efforts.length === 0) return undefined;
-  if (effort && efforts.includes(effort)) {
-    // ponytail: OpenAI has no distinct ultra level; keep the UI choice as a max alias.
-    return effort === "ultra" ? "max" : effort;
-  }
-  return DEFAULT_OPENAI_REASONING_EFFORT;
+  return merged;
 }
 
-/**
- * Provider-specific options passed to `streamText` to request reasoning /
- * extended thinking. Each provider reads only its own namespace:
- *   - `anthropic.thinking` — direct Anthropic provider AND the Pensar gateway
- *     (the gateway formatter maps it to the Bedrock `thinking` field).
- *   - `bedrock.reasoningConfig` — the AWS Bedrock provider; it ignores the
- *     `anthropic` namespace entirely, so Anthropic-on-Bedrock thinking is only
- *     requested when this key is present. `display: 'summarized'` makes the
- *     model actually return reasoning text (adaptive can otherwise omit it).
- *   - `openai.reasoningEffort` — OpenAI/o-series reasoning models.
- */
-export type ReasoningProviderOptions = {
-  openrouter?: {
-    reasoning: { effort: OpenAIReasoningEffort; enabled?: boolean };
-  };
-  anthropic?: {
-    thinking:
-      | { type: "adaptive"; display?: "summarized" }
-      | { type: "disabled" };
-    // Soft effort hint for adaptive thinking; omitted when no level requested
-    // (model defaults to "high"). Sibling of `thinking` per the AI SDK.
-    effort?: ThinkingEffort;
-  };
-  bedrock?: {
-    reasoningConfig: {
-      type: "adaptive";
-      display: "summarized";
-      // Bedrock's channel for the adaptive effort hint (maps to Claude's
-      // output_config.effort). Omitted when no level requested.
-      maxReasoningEffort?: ThinkingEffort;
-    };
-  };
-  openai?: OpenAIResponsesProviderOptions;
-};
-
 export type OpenRouterProviderOptions = {
   openrouter?: {
     provider:
@@ -1344,99 +1316,21 @@ export function buildOpenRouterStructuredProviderOptions(
   };
 }
 
-/**
- * Build the `providerOptions` for a request based on the model and reasoning
- * settings. Returns `undefined` when no reasoning/thinking is requested.
- *
- * When thinking is enabled for an Anthropic-family model we set BOTH the
- * `anthropic` and `bedrock` keys: the resolved provider (direct Anthropic,
- * Pensar gateway, or Bedrock) reads only its own namespace and ignores the
- * other, so this is safe across all three and avoids brittle provider
- * branching here.
- */
 export function buildReasoningProviderOptions(
   model: AIModel,
   opts: {
+    reasoning?: ReasoningSetting;
     enableThinking?: boolean;
-    /**
-     * Adaptive-thinking effort hint for Anthropic models that support it
-     * (Opus/Sonnet 4.6+). Ignored on models without adaptive support. When
-     * omitted the model uses its own default (`high`).
-     */
     thinkingEffort?: ThinkingEffort | null;
     openAIReasoningEffort?: OpenAIReasoningEffort | null;
+    customProviders?: import("../config/customProviders").CustomProviders;
+    maxOutputTokens?: number;
   },
 ): ReasoningProviderOptions | undefined {
-  const claude = getClaudeCapabilities(model);
-  if (claude) {
-    const provider = getModelInfo(model).provider;
-    const thinking = !!opts.enableThinking || claude.alwaysOnThinking;
-    if (provider === "openrouter") {
-      return {
-        openrouter: {
-          reasoning: {
-            effort: thinking ? (opts.thinkingEffort ?? "high") : "none",
-            enabled: thinking,
-          },
-        },
-      };
-    }
-    if (provider === "concentrate") {
-      return {
-        openai: {
-          forceReasoning: true,
-          reasoningEffort: thinking ? (opts.thinkingEffort ?? "high") : "none",
-          reasoningSummary: "auto",
-        },
-      };
-    }
-    return {
-      anthropic: {
-        thinking:
-          opts.enableThinking || claude.alwaysOnThinking
-            ? { type: "adaptive", display: "summarized" }
-            : { type: "disabled" },
-        ...(opts.thinkingEffort ? { effort: opts.thinkingEffort } : {}),
-      },
-    };
-  }
-  const useThinking =
-    !!opts.enableThinking &&
-    isAnthropicProvider(model) &&
-    modelSupportsAdaptiveThinking(model);
-  const normalizedOpenAIEffort = normalizeOpenAIReasoningEffort(
-    model,
-    opts.openAIReasoningEffort,
-  );
-  // The effort hint only rides along when adaptive thinking is actually used.
-  const effort = useThinking ? (opts.thinkingEffort ?? undefined) : undefined;
-
-  if (!useThinking && !normalizedOpenAIEffort) return undefined;
-
-  if (getModelInfo(model).provider === "openrouter" && normalizedOpenAIEffort) {
-    return { openrouter: { reasoning: { effort: normalizedOpenAIEffort } } };
-  }
-
-  return {
-    ...(useThinking
-      ? {
-          anthropic: {
-            thinking: { type: "adaptive" as const },
-            ...(effort ? { effort } : {}),
-          },
-          bedrock: {
-            reasoningConfig: {
-              type: "adaptive" as const,
-              display: "summarized" as const,
-              ...(effort ? { maxReasoningEffort: effort } : {}),
-            },
-          },
-        }
-      : {}),
-    ...(normalizedOpenAIEffort
-      ? { openai: { reasoningEffort: normalizedOpenAIEffort } }
-      : {}),
-  };
+  const setting = resolveReasoningSetting(model, opts);
+  return setting === undefined
+    ? undefined
+    : buildModelReasoningOptions(model, setting, opts);
 }
 
 /** Cache token metrics extracted from Anthropic providerMetadata */
@@ -1446,6 +1340,12 @@ export interface CacheMetrics {
 }
 
 export interface StreamResponseOpts {
+  /** Disables model repair and general recovery; compaction requires explicit admission. */
+  primaryModelOnly?: boolean;
+  runContextCompaction?: <T>(work: () => Promise<T>) => Promise<T>;
+  /** Session-local working state restored after compaction. */
+  getContinuationContext?: () => string;
+  onInvalidToolCall?: (name: string) => void;
   prompt: string;
   system?: string;
   model: AIModel;
@@ -1474,6 +1374,11 @@ export interface StreamResponseOpts {
    * new messages (not the full pre-summarization history).
    */
   onSummarized?: (summary: string) => void;
+  /** The fitted context and prior generated-message count for transcript writers. */
+  onContextPrepared?: (context: {
+    messages: ModelMessage[];
+    responseMessageOffset: number;
+  }) => void;
   /**
    * Deprecated host shim: fires only when a cache counter is `> 0`.
    * Apex internals read cache from {@link normalizeStepUsage} on the step.
@@ -1488,6 +1393,7 @@ export interface StreamResponseOpts {
   thinkingEffort?: ThinkingEffort | null;
   /** OpenAI reasoning effort for GPT/o-series reasoning models. */
   openAIReasoningEffort?: OpenAIReasoningEffort | null;
+  reasoning?: ReasoningSetting;
   /** Session root path — used by context management layers to persist truncated tool results */
   sessionPath?: string;
   /** Session id (`ses_…`) of the agent making this call; stamped onto AI-span telemetry so traces are filterable by session. */
@@ -1506,12 +1412,15 @@ export interface StreamResponseOpts {
   /** Shared only by continuations of this stream, never across agents. */
   _compaction?: { last?: CompactionLink };
   _compactionTrigger?: CompactionTrigger;
+  _proactiveSummaryMayFit?: boolean;
+  _proactiveSummaryFailures?: number;
+  _initialPrompt?: string;
 }
 
 const NATIVE_STREAM_RECOVERY = Symbol("native-stream-recovery");
 
 interface NativeStreamRecovery {
-  model: LanguageModel;
+  model: ReturnType<typeof getProviderModel>;
   run<T>(fn: () => T): T;
 }
 
@@ -1545,6 +1454,7 @@ function streamResponseWithinOperation(
   // map. Re-entry is identity (`activeTools` already consumed).
   opts = {
     ...opts,
+    _initialPrompt: opts._initialPrompt ?? opts.prompt,
     _compaction: compactionState,
     // `activeTools` is authoritative for advertisement and execution: a tool
     // (including `response`) is exposed only when the caller lists it, so the
@@ -1580,14 +1490,21 @@ function streamResponseWithinOperation(
     enableThinking,
     thinkingEffort,
     openAIReasoningEffort,
+    reasoning,
     sessionId,
+    sessionPath,
     contextRecorder,
+    onContextPrepared,
   } = opts;
 
-  // Recorded-run base, captured once at the first prepareStep of this
-  // streamText call; only used to reconstruct cumulative prefixes in
-  // onStepFinish (response.messages excludes the input base).
+  // response.messages accumulates generated steps after prepareStep rewrites
+  // provider context. The offset prevents transcript writers from appending
+  // older, pre-fit messages again.
   let recorderBase: ModelMessage[] | undefined;
+  let responseMessageLength = 0;
+  const estimatedOverheadTokens = estimateToolsOverheadTokens(tools) + 1_000;
+  let preparedInputEstimateTokens = 0;
+  let inputSafetyMarginTokens = 10_000;
 
   // Wrap onStepFinish to fire cache metrics and the usage callback for every
   // step. Must be async so that callers returning a Promise (persistence,
@@ -1596,6 +1513,18 @@ function streamResponseWithinOperation(
   // provider metadata is never parsed twice.
   const onStepFinish: typeof userOnStepFinish = async (step) => {
     const stepUsage = normalizeStepUsage(step);
+    if (
+      preparedInputEstimateTokens > 0 &&
+      stepUsage.inputTokens > 0 &&
+      step.response?.id !== "summarization" &&
+      step.response?.id !== "tool-repair"
+    ) {
+      // Fixed system and tool overhead is already reserved by the fitter; calibrate only the remaining tokenization gap.
+      inputSafetyMarginTokens = Math.max(
+        inputSafetyMarginTokens,
+        stepUsage.inputTokens - preparedInputEstimateTokens + 10_000,
+      );
+    }
     // Canonical commit precedes every downstream use; the recorder latches
     // rejections (SDK notify() swallows them) until the next turn gate or
     // agent-side flush turns the latch into a stream failure.
@@ -1611,10 +1540,20 @@ function streamResponseWithinOperation(
         throw new Error("context recorder active without a committed base");
       }
       await contextRecorder.checkpoint({
-        messages: [...recorderBase, ...step.response.messages],
+        messages: [
+          ...recorderBase,
+          ...step.response.messages.slice(responseMessageLength),
+        ],
         system: effectiveSystem ?? null,
       });
     }
+    if (
+      step.response?.id !== "summarization" &&
+      step.response?.id !== "tool-repair" &&
+      step.response?.messages
+    ) {
+      responseMessageLength = step.response.messages.length;
+    }
     if (
       onCacheMetrics &&
       (stepUsage.cacheReadTokens > 0 || stepUsage.cacheWriteTokens > 0)
@@ -1661,22 +1600,55 @@ function streamResponseWithinOperation(
     model,
   );
 
+  const contextWindow = getContextWindow(
+    model,
+    authConfig?.customProviders,
+    authConfig?.hoonifyModels,
+  );
+  const maxOutputTokens = getMaxOutputTokens(
+    model,
+    authConfig?.customProviders,
+    authConfig?.hoonifyModels,
+  );
+  if (
+    messages &&
+    (!opts.primaryModelOnly || opts.runContextCompaction) &&
+    !opts._proactiveSummaryFailures &&
+    shouldSummarizeBeforeFitting(
+      messages,
+      contextWindow,
+      maxOutputTokens,
+      estimatedOverheadTokens,
+      inputSafetyMarginTokens,
+      systemWithToolPolicy,
+      toolChoice,
+    )
+  ) {
+    return wrapStreamWithErrorHandler(
+      createSummarizationStream(
+        messages,
+        {
+          ...opts,
+          _compactionTrigger: "proactive",
+          _proactiveSummaryMayFit: true,
+        },
+        providerModel,
+      ),
+      { current: messages },
+      opts,
+      providerModel,
+      silent,
+    );
+  }
+
   // Proactive context fit: compact before the call. Reactive recovery
   // below is a safety net for tokenizer drift the estimate doesn't catch.
   let fittedMessages = messages;
   let proactiveFitFailed = false;
   if (messages && messages.length > 0) {
     const fitted = fitMessagesToContext(messages, {
-      contextWindow: getContextWindow(
-        model,
-        authConfig?.customProviders,
-        authConfig?.hoonifyModels,
-      ),
-      maxOutputTokens: getMaxOutputTokens(
-        model,
-        authConfig?.customProviders,
-        authConfig?.hoonifyModels,
-      ),
+      contextWindow,
+      maxOutputTokens,
       system: systemWithToolPolicy,
       tools,
       sessionPath: opts.sessionPath,
@@ -1707,6 +1679,8 @@ function streamResponseWithinOperation(
   // an overflow inside the summarization call itself escapes uncaught while
   // the equivalent post-streamText path (line ~880) recovers.
   if (proactiveFitFailed && fittedMessages) {
+    if (opts.primaryModelOnly && !opts.runContextCompaction)
+      throw new Error("Lance context budget exhausted");
     if (!silent) {
       log.warn(
         `Proactive context fit returned fitsBudget=false on ${fittedMessages.length} messages — escalating to summarization before send`,
@@ -1723,7 +1697,11 @@ function streamResponseWithinOperation(
     return wrapStreamWithErrorHandler(
       createSummarizationStream(
         fittedMessages,
-        { ...opts, _compactionTrigger: "proactive" },
+        {
+          ...opts,
+          _compactionTrigger: "proactive",
+          _proactiveSummaryMayFit: false,
+        },
         providerModel,
       ),
       messagesContainer,
@@ -1760,12 +1738,15 @@ function streamResponseWithinOperation(
     enableThinking,
     thinkingEffort,
     openAIReasoningEffort,
+    reasoning,
+    customProviders: authConfig?.customProviders,
+    maxOutputTokens,
   });
   const openRouterProviderOptions = buildOpenRouterProviderOptions(model);
-  const providerOptions =
-    reasoningProviderOptions || openRouterProviderOptions
-      ? { ...reasoningProviderOptions, ...openRouterProviderOptions }
-      : undefined;
+  const providerOptions = mergeProviderOptions(
+    reasoningProviderOptions,
+    openRouterProviderOptions,
+  );
 
   let rateLimitRetryCount = 0;
 
@@ -1781,8 +1762,81 @@ function streamResponseWithinOperation(
     // Create the appropriate provider instance. The span tracker captures
     // the SDK's root generation span for error marking (see below).
     const generationSpans = createGenerationSpanTracker();
-    const responseOptions: Parameters<typeof streamText>[0] = {
+    const attemptAbort = new AbortController();
+    const attemptSignal = abortSignal
+      ? AbortSignal.any([abortSignal, attemptAbort.signal])
+      : attemptAbort.signal;
+    let cancelModelStream: ((reason: unknown) => Promise<void>) | undefined;
+    // Cancelling the SDK fullStream only detaches its subscriber.
+    const attemptModel = wrapLanguageModel({
       model: providerModel,
+      middleware: {
+        specificationVersion: "v3",
+        wrapStream: async ({ doStream }) => {
+          const pending = doStream();
+          let reader:
+            | ReadableStreamDefaultReader<LanguageModelV3StreamPart>
+            | undefined;
+          cancelModelStream = async (reason) => {
+            try {
+              const source = await pending;
+              await (reader
+                ? reader.cancel(reason)
+                : source.stream.cancel(reason));
+            } catch (error) {
+              if (
+                !(error instanceof Error) ||
+                (error.name !== "AbortError" &&
+                  !isStreamIdleTimeoutError(error))
+              ) {
+                throw error;
+              }
+            }
+          };
+          const source = await pending;
+          reader = source.stream.getReader();
+          const ownedReader = reader;
+          return {
+            ...source,
+            stream: new ReadableStream({
+              async pull(controller) {
+                const next = await ownedReader.read();
+                if (next.done) controller.close();
+                else controller.enqueue(next.value);
+              },
+              cancel: (reason) => ownedReader.cancel(reason),
+            }),
+          };
+        },
+      },
+    });
+    const drainIdleStream = async (reason: unknown) => {
+      attemptAbort.abort(reason);
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      try {
+        await Promise.race([
+          cancelModelStream?.(reason),
+          new Promise<never>((_, reject) => {
+            timer = setTimeout(
+              () =>
+                reject(
+                  Object.assign(
+                    new Error(
+                      "Stalled model stream did not drain within 30 seconds",
+                    ),
+                    { name: "ModelStreamDrainTimeoutError" },
+                  ),
+                ),
+              30_000,
+            );
+          }),
+        ]);
+      } finally {
+        clearTimeout(timer);
+      }
+    };
+    const responseOptions: Parameters<typeof streamText>[0] = {
+      model: attemptModel,
       system: effectiveSystem,
       ...(effectiveMessages ? { messages: effectiveMessages } : { prompt }),
       stopWhen,
@@ -1802,6 +1856,10 @@ function streamResponseWithinOperation(
           operation: "apex.agent.stream",
           sessionId,
           compaction: opts._compaction?.last,
+          reasoning: {
+            requested: reasoning ?? "legacy-default",
+            parameters: JSON.stringify(reasoningProviderOptions ?? {}),
+          },
         }),
         tracer: generationSpans.tracer,
       },
@@ -1818,30 +1876,86 @@ function streamResponseWithinOperation(
       // Awaiting inside prepareStep keeps streamResponse synchronous; the
       // SDK awaits it before provider dispatch, so every turn and every
       // recovery re-entry commits before use.
-      prepareStep: async (opts) => {
-        if (contextRecorder) {
-          if (recorderBase === undefined) {
-            recorderBase = structuredClone(opts.messages);
+      prepareStep: async (step) => {
+        let stepMessages = step.messages;
+        if (step.stepNumber > 0) {
+          if (
+            (!opts.primaryModelOnly || opts.runContextCompaction) &&
+            (opts._proactiveSummaryFailures ?? 0) <
+              MAX_PROACTIVE_SUMMARY_FAILURES &&
+            shouldSummarizeBeforeFitting(
+              stepMessages,
+              contextWindow,
+              maxOutputTokens,
+              estimatedOverheadTokens,
+              inputSafetyMarginTokens,
+              effectiveSystem,
+              toolChoice,
+            )
+          ) {
+            messagesContainer.current = stepMessages;
+            throw new InStreamCompactionRequired({
+              messages: stepMessages,
+              estimatedInputTokens: estimateMessageTokens(stepMessages),
+              modified: false,
+              fitsBudget: true,
+            });
           }
+          const fitted = fitMessagesToContext(stepMessages, {
+            contextWindow,
+            maxOutputTokens,
+            system: effectiveSystem,
+            tools,
+            overheadTokens: estimatedOverheadTokens,
+            sessionPath,
+            safetyMarginTokens: inputSafetyMarginTokens,
+            telemetry: {
+              trigger: "proactive",
+              model,
+              sessionId,
+              restartDepth,
+              previous: compactionState.last,
+            },
+          });
+          if (fitted.compaction) compactionState.last = fitted.compaction;
+          stepMessages = fitted.messages;
+          if (!fitted.fitsBudget) {
+            messagesContainer.current = stepMessages;
+            throw new InStreamCompactionRequired(fitted);
+          }
+        }
+        if (contextRecorder) {
+          recorderBase = structuredClone(stepMessages);
           // Full logical context each turn — accepted step outputs must
           // survive into every later commit, and system is explicit (when
           // cached into messages, effectiveSystem is undefined → null).
           await contextRecorder.checkpoint({
-            messages: opts.messages,
+            messages: stepMessages,
             system: effectiveSystem ?? null,
           });
         }
         // Update the container with the latest messages
-        messagesContainer.current = opts.messages;
+        messagesContainer.current = stepMessages;
+        preparedInputEstimateTokens =
+          estimateMessageTokens(stepMessages) +
+          estimatedOverheadTokens +
+          (effectiveSystem ? estimateTokens(effectiveSystem) : 0);
+        onContextPrepared?.({
+          messages: stepMessages,
+          responseMessageOffset: responseMessageLength,
+        });
         // Mark the last message so the growing conversation caches incrementally
         if (cacheBreakpoint) {
           return {
-            messages: withCachedLastMessage(opts.messages, cacheBreakpoint),
+            messages: withCachedLastMessage(stepMessages, cacheBreakpoint),
           };
         }
-        return undefined;
+        return stepMessages === step.messages
+          ? undefined
+          : { messages: stepMessages };
       },
       onError: async ({ error }: { error: unknown }) => {
+        if (opts.primaryModelOnly) return;
         // Never throw here: the SDK calls this inside its stream pipeline,
         // and a thrown callback kills the pipeline's terminal lifecycle —
         // the root generation span never ends and nothing exports. Return
@@ -1868,7 +1982,7 @@ function streamResponseWithinOperation(
         }
       },
       onStepFinish,
-      abortSignal,
+      abortSignal: attemptSignal,
       activeTools: allowedTools,
       experimental_repairToolCall: async ({
         toolCall,
@@ -1876,6 +1990,8 @@ function streamResponseWithinOperation(
         tools,
         error,
       }) => {
+        opts.onInvalidToolCall?.(toolCall.toolName);
+        if (opts.primaryModelOnly) return null;
         // [response-debug] Log when repair fires for `response` (streamed args failed Zod validation), bypassing `silent`.
         if (RESPONSE_DEBUG && toolCall.toolName === RESPONSE_TOOL_NAME) {
           const raw = toolCall.input;
@@ -1953,8 +2069,9 @@ function streamResponseWithinOperation(
             () =>
               generateText({
                 model: providerModel,
+                maxOutputTokens,
                 providerOptions: {
-                  ...openRouterProviderOptions,
+                  ...providerOptions,
                   // Durable runtime: tool-call repair fires only when a
                   // replayed tool call fails validation — nondeterministically
                   // vs the first run — so it must stay off the checkpoint
@@ -1982,6 +2099,10 @@ function streamResponseWithinOperation(
                 experimental_telemetry: createAiTelemetrySettings({
                   operation: "apex.tool.repair",
                   sessionId,
+                  reasoning: {
+                    requested: reasoning ?? "legacy-default",
+                    parameters: JSON.stringify(reasoningProviderOptions ?? {}),
+                  },
                 }),
               }),
           );
@@ -2081,10 +2202,16 @@ function streamResponseWithinOperation(
       0,
       0,
       generationSpans,
+      drainIdleStream,
     );
   } catch (error) {
     // Check if the error is related to context length
     const isContextLengthError = checkIfContextLengthError(error);
+    if (
+      opts.primaryModelOnly &&
+      (!opts.runContextCompaction || !isContextLengthError)
+    )
+      throw error;
     const outerErrorMessage =
       error instanceof Error ? error.message : String(error);
 
@@ -2136,6 +2263,7 @@ export interface GenerateObjectOpts<T extends z.ZodType> {
   maxTokens?: number;
   temperature?: number;
   openAIReasoningEffort?: OpenAIReasoningEffort | null;
+  reasoning?: ReasoningSetting;
   authConfig?: AIAuthConfig;
   abortSignal?: AbortSignal;
   onTokenUsage?: (inputTokens: number, outputTokens: number) => void;
@@ -2173,6 +2301,7 @@ async function generateObjectResponseWithinRecorder<T extends z.ZodType>(
     maxTokens,
     temperature,
     openAIReasoningEffort,
+    reasoning,
     authConfig,
     abortSignal,
     onTokenUsage,
@@ -2197,6 +2326,9 @@ async function generateObjectResponseWithinRecorder<T extends z.ZodType>(
     : baseProviderModel;
   const reasoningProviderOptions = buildReasoningProviderOptions(model, {
     openAIReasoningEffort,
+    reasoning,
+    customProviders: authConfig?.customProviders,
+    maxOutputTokens: maxTokens,
   });
   const openRouterProviderOptions =
     buildOpenRouterStructuredProviderOptions(model);
@@ -2224,25 +2356,19 @@ async function generateObjectResponseWithinRecorder<T extends z.ZodType>(
             system,
             maxOutputTokens: maxTokens,
             temperature,
-            providerOptions:
-              reasoningProviderOptions || openRouterProviderOptions
-                ? {
-                    ...reasoningProviderOptions,
-                    ...(openRouterProviderOptions
-                      ? {
-                          openrouter: {
-                            ...reasoningProviderOptions?.openrouter,
-                            ...openRouterProviderOptions.openrouter,
-                          },
-                        }
-                      : {}),
-                  }
-                : undefined,
+            providerOptions: mergeProviderOptions(
+              reasoningProviderOptions,
+              openRouterProviderOptions,
+            ),
             maxRetries: 0,
             abortSignal,
             experimental_telemetry: createAiTelemetrySettings({
               operation: opts.operation ?? "apex.structured.generate",
               sessionId,
+              reasoning: {
+                requested: reasoning ?? "legacy-default",
+                parameters: JSON.stringify(reasoningProviderOptions ?? {}),
+              },
             }),
           });