@link-assistant/agent 0.27.0 → 0.27.1

package/src/project/project.ts

@@ -45,7 +45,12 @@ export namespace Project {
     }
     let worktree = path.dirname(git);
     const timer = log.time('git.rev-parse');
-    let id = await Bun.file(path.join(git, 'opencode'))
+    // In a git worktree or submodule `.git` is a file, so the id cache lives in
+    // the common git directory instead (as upstream does). Writing to
+    // `.git/opencode` there used to reject with ENOTDIR; the rejection was not
+    // handled and the CLI exited with an UnhandledRejection (issue #335).
+    const cacheDir = await gitCacheDir(git, worktree);
+    let id = await Bun.file(path.join(cacheDir, 'opencode'))
       .text()
       .then((x) => x.trim())
       .catch(() => {});
@@ -63,7 +68,16 @@ export namespace Project {
             .toSorted()
         );
       id = roots[0];
-      if (id) Bun.file(path.join(git, 'opencode')).write(id);
+      // The cache is best effort: a read-only or unusual `.git` must not fail
+      // project detection.
+      if (id)
+        await Bun.write(path.join(cacheDir, 'opencode'), id).catch((error) =>
+          log.info(() => ({
+            message: 'project id cache not written',
+            path: path.join(cacheDir, 'opencode'),
+            error: String(error),
+          }))
+        );
     }
     timer.stop();
     if (!id) {
@@ -95,6 +109,25 @@ export namespace Project {
     return project;
   }
 
+  /**
+   * Directory that holds the project id cache: `.git` itself when it is a
+   * directory, otherwise the common git directory reported by git (worktrees
+   * and submodules have a `.git` file pointing elsewhere).
+   */
+  async function gitCacheDir(git: string, worktree: string): Promise<string> {
+    const stat = await fs.stat(git).catch(() => undefined);
+    if (stat?.isDirectory()) return git;
+    const common =
+      await $`git rev-parse --path-format=absolute --git-common-dir`
+        .quiet()
+        .nothrow()
+        .cwd(worktree)
+        .text()
+        .then((x) => x.trim())
+        .catch(() => '');
+    return common || git;
+  }
+
   export async function setInitialized(projectID: string) {
     await Storage.update<Info>(['project', projectID], (draft) => {
       draft.time.initialized = Date.now();

package/src/provider/free-tier-error.ts

@@ -13,4 +13,4 @@ export function isFreeTierError(
 }
 
 export const FREE_TIER_ERROR_MESSAGE =
-  "OpenCode Zen's free tier is limited to OpenCode clients. Use kilo/nemotron-3-super-free (authenticate with agent auth login or KILO_API_KEY), or select a paid model.";
+  "OpenCode Zen's free tier is limited to OpenCode clients. Use kilo/nemotron-3-ultra-free (authenticate with agent auth login or KILO_API_KEY), or select a paid model.";

package/src/provider/kilo-deprecation.ts

@@ -0,0 +1,30 @@
+import { Log } from '../util/log';
+import { Kilo } from './kilo';
+
+const log = Log.create({ service: 'kilo' });
+
+// Aliases already warned about. A stored session or config that names an
+// alias reaches getModel()/parseModel() many times in one process, so warn
+// once per alias; the set is bounded by `Kilo.DEPRECATED_ALIASES`.
+const warned = new Set<string>();
+
+/**
+ * Map a deprecated Kilo alias (`Kilo.DEPRECATED_ALIASES`) to its replacement
+ * and warn about it (once per alias and process); any other model ID is
+ * returned unchanged (#335).
+ *
+ * Kept out of `kilo.ts` so that module has no runtime dependencies.
+ */
+export function resolveKiloDeprecatedAlias(modelID: string): string {
+  const replacement = Kilo.deprecatedAliasTarget(modelID);
+  if (!replacement) return modelID;
+  if (warned.has(modelID)) return replacement;
+  warned.add(modelID);
+  log.warn(() => ({
+    message: `kilo/${modelID} is deprecated and no longer served by Kilo; using kilo/${replacement} instead`,
+    deprecatedModel: `kilo/${modelID}`,
+    replacement: `kilo/${replacement}`,
+    hint: `Pass --model kilo/${replacement} to silence this warning`,
+  }));
+  return replacement;
+}

package/src/provider/kilo.ts

@@ -25,14 +25,7 @@ export namespace Kilo {
     };
   }
 
-  // Super's output cap is deliberately conservative for existing integrations.
   export const FREE_MODELS: Record<string, ModelsDev.Model> = {
-    'nemotron-3-super-free': freeModel(
-      'nvidia/nemotron-3-super-120b-a12b:free',
-      'Nemotron 3 Super (Free)',
-      262144,
-      32768
-    ),
     'nemotron-3-ultra-free': freeModel(
       'nvidia/nemotron-3-ultra-550b-a55b:free',
       'Nemotron 3 Ultra (Free)',
@@ -47,6 +40,31 @@ export namespace Kilo {
     ),
   };
 
+  /**
+   * Withdrawn built-in aliases that keep working temporarily. Each one maps to
+   * the served alias in `FREE_MODELS` that replaces it, and every resolution
+   * logs a warning naming the replacement. These are not catalog entries, so
+   * the drift check (`scripts/check-model-drift.mjs`) does not look them up.
+   *
+   * Kilo stopped serving `nvidia/nemotron-3-super-120b-a12b:free`; only the
+   * paid Super model remains on the gateway (#335).
+   */
+  export const DEPRECATED_ALIASES: Readonly<Record<string, string>> = {
+    'nemotron-3-super-free': 'nemotron-3-ultra-free',
+  };
+
+  /**
+   * Replacement for a deprecated alias, or `undefined`. Logs nothing; use
+   * `resolveKiloDeprecatedAlias` from `./kilo-deprecation` to also warn.
+   * This module stays free of runtime dependencies because
+   * `scripts/check-default-models.mjs` imports it without installed packages.
+   */
+  export function deprecatedAliasTarget(modelID: string): string | undefined {
+    return Object.hasOwn(DEPRECATED_ALIASES, modelID)
+      ? DEPRECATED_ALIASES[modelID]
+      : undefined;
+  }
+
   /**
    * Text models models.dev lists for Kilo. Their IDs are the same on the
    * OpenRouter-compatible route this provider uses, so the curated aliases

package/src/provider/provider.ts

@@ -20,8 +20,10 @@ import { createEchoModel } from './echo';
 import { createCacheModel } from './cache';
 import { RetryFetch } from './retry-fetch';
 import { SSEUsageExtractor } from '../util/sse-usage-extractor';
+import { sanitizeUrl } from '../util/verbose-fetch';
 import { OpenCodeZen } from './opencode-zen';
 import { Kilo } from './kilo';
+import { resolveKiloDeprecatedAlias } from './kilo-deprecation';
 import { EnvTemplate } from './env-template';
 import { ExtraProviders } from './extra-providers';
 import { ModelDiscovery } from './model-discovery';
@@ -1199,19 +1201,23 @@ export namespace Provider {
               const [sdkStream, usageStream] = response.body.tee();
               const sseReqId = SSEUsageExtractor.nextRequestId();
               (async () => {
+                const reader = usageStream.getReader();
                 try {
-                  const reader = usageStream.getReader();
+                  // Read the whole branch: a tee branch that stops being read
+                  // keeps buffering the rest of the response (issue #335).
                   const decoder = new TextDecoder();
-                  let body = '';
+                  const tracker = SSEUsageExtractor.createTracker();
                   while (true) {
                     const { done, value } = await reader.read();
                     if (done) break;
-                    body += decoder.decode(value, { stream: true });
-                    if (body.length > 50000) break;
+                    tracker.push(decoder.decode(value, { stream: true }));
                   }
-                  SSEUsageExtractor.processStreamForUsage(sseReqId, body);
+                  tracker.push(decoder.decode());
+                  const usage = tracker.finish();
+                  if (usage) SSEUsageExtractor.storeUsage(sseReqId, usage);
                 } catch {
-                  // Never break the SDK stream
+                  // Never break the SDK stream; release the branch instead.
+                  reader.cancel().catch(() => {});
                 }
               })();
               return new Response(sdkStream, {
@@ -1237,12 +1243,14 @@ export namespace Provider {
             });
           }
 
-          const url =
+          // Logged only; query-string credentials are masked (issue #335).
+          const url = sanitizeUrl(
             typeof input === 'string'
               ? input
               : input instanceof URL
                 ? input.toString()
-                : input.url;
+                : input.url
+          );
           const method = init?.method ?? 'GET';
 
           // Wrap all verbose logging in try/catch so it never breaks the actual HTTP request.
@@ -1369,13 +1377,15 @@ export namespace Provider {
                   try {
                     const reader = logStream.getReader();
                     const decoder = new TextDecoder();
+                    const tracker = SSEUsageExtractor.createTracker();
                     let bodyPreview = '';
                     let truncated = false;
                     while (true) {
                       const { done, value } = await reader.read();
                       if (done) break;
+                      const chunk = decoder.decode(value, { stream: true });
+                      tracker.push(chunk);
                       if (!truncated) {
-                        const chunk = decoder.decode(value, { stream: true });
                         bodyPreview += chunk;
                         if (bodyPreview.length > responseBodyMaxChars) {
                           bodyPreview = bodyPreview.slice(
@@ -1386,11 +1396,12 @@ export namespace Provider {
                         }
                       }
                     }
-                    // Extract usage from raw SSE stream as AI SDK fallback
-                    SSEUsageExtractor.processStreamForUsage(
-                      sseRequestId,
-                      bodyPreview
-                    );
+                    // Extract usage from the whole raw SSE stream (not just
+                    // the logged preview) as AI SDK fallback.
+                    tracker.push(decoder.decode());
+                    const usage = tracker.finish();
+                    if (usage)
+                      SSEUsageExtractor.storeUsage(sseRequestId, usage);
                     // Use direct (non-lazy) logging for stream body
                     // See: https://github.com/link-assistant/agent/issues/211
                     log.info('HTTP response body (stream)', {
@@ -1554,6 +1565,12 @@ export namespace Provider {
     const provider = s.providers[ExtraProviders.canonicalID(providerID)];
     if (!provider) return false;
     if (provider.info.models[modelID]) return true;
+    // Deprecated Kilo aliases still resolve to their replacement (#335).
+    const replacement =
+      provider.info.id === 'kilo'
+        ? Kilo.deprecatedAliasTarget(modelID)
+        : undefined;
+    if (replacement && provider.info.models[replacement]) return true;
     return ExtraProviders.allowsUnknownModels(provider.info.id);
   }
 
@@ -1642,6 +1659,8 @@ export namespace Provider {
 
   export async function getModel(providerID: string, modelID: string) {
     providerID = ExtraProviders.canonicalID(providerID);
+    // Sessions and configs may still name a withdrawn Kilo alias (#335).
+    if (providerID === 'kilo') modelID = resolveKiloDeprecatedAlias(modelID);
     const key = `${providerID}/${modelID}`;
     const s = await state();
     if (s.models.has(key)) return s.models.get(key)!;
@@ -1910,7 +1929,6 @@ export namespace Provider {
     'gpt-5-nano',
     'nemotron-3.5-lightning-free',
     'nemotron-3-ultra-free',
-    'nemotron-3-super-free',
     'gpt-5',
     'claude-sonnet-4',
     'gemini-3-pro',
@@ -1984,10 +2002,14 @@ export namespace Provider {
   }
 
   export function parseModel(model: string) {
-    const [providerID, ...rest] = model.split('/');
+    const [rawProviderID, ...rest] = model.split('/');
+    const providerID = ExtraProviders.canonicalID(rawProviderID);
+    const modelID = rest.join('/');
     return {
-      providerID: ExtraProviders.canonicalID(providerID),
-      modelID: rest.join('/'),
+      providerID,
+      // Withdrawn Kilo aliases keep working with a warning (#335).
+      modelID:
+        providerID === 'kilo' ? resolveKiloDeprecatedAlias(modelID) : modelID,
     };
   }
 
@@ -2007,6 +2029,14 @@ export namespace Provider {
   ): Promise<{ providerID: string; modelID: string } | undefined> {
     const s = await state();
 
+    // A withdrawn built-in alias resolves to its Kilo replacement (#335).
+    if (Kilo.deprecatedAliasTarget(modelID)) {
+      const replacement = resolveKiloDeprecatedAlias(modelID);
+      if (s.providers.kilo?.info.models[replacement]) {
+        return { providerID: 'kilo', modelID: replacement };
+      }
+    }
+
     if (Object.hasOwn(Kilo.FREE_MODELS, modelID)) {
       const kiloProvider = s.providers.kilo;
       if (kiloProvider?.info.models[modelID]) {
@@ -2080,8 +2110,9 @@ export namespace Provider {
    * or a clear error explaining why it's not available.
    *
    * Examples:
-   * - "kilo/nemotron-3-super-free" -> { providerID: "kilo", modelID: "nemotron-3-super-free" }
-   * - "nemotron-3-super-free" -> { providerID: "kilo", modelID: "nemotron-3-super-free" } (resolved)
+   * - "kilo/nemotron-3-ultra-free" -> { providerID: "kilo", modelID: "nemotron-3-ultra-free" }
+   * - "nemotron-3-ultra-free" -> { providerID: "kilo", modelID: "nemotron-3-ultra-free" } (resolved)
+   * - "nemotron-3-super-free" -> { providerID: "kilo", modelID: "nemotron-3-ultra-free" } (deprecated alias, warns)
    * - "big-pickle" -> { providerID: "opencode", modelID: "big-pickle" } (resolved)
    * - "nonexistent-model" -> throws ModelNotFoundError
    *
@@ -2142,7 +2173,7 @@ export namespace Provider {
    * When one provider hits rate limits, the system can try an alternative.
    *
    * Note: This is only used for models without explicit provider specification.
-   * If user specifies "kilo/nemotron-3-super-free", no fallback will occur.
+   * If user specifies "kilo/nemotron-3-ultra-free", no fallback will occur.
    */
   const SHARED_FREE_MODELS: Record<string, string[]> = {
     'nemotron-3.5-lightning-free': ['kilo', 'opencode'],
@@ -2153,7 +2184,7 @@ export namespace Provider {
    * This function returns a list of alternative providers that offer the same model.
    *
    * Note: This only returns alternatives for models without explicit provider specification.
-   * If the original request had an explicit provider (like "kilo/nemotron-3-super-free"), this returns empty array.
+   * If the original request had an explicit provider (like "kilo/nemotron-3-ultra-free"), this returns empty array.
    *
    * @param modelID - The model ID to find alternatives for
    * @param failedProviderID - The provider that failed

package/src/provider/retry-fetch.ts

@@ -461,6 +461,9 @@ export namespace RetryFetch {
           }));
 
           await sleep(delay, init?.signal ?? undefined);
+          // The failed response is dropped: release its body and connection
+          // now instead of waiting for GC (issue #335). Not awaited.
+          response.body?.cancel().catch(() => {});
           continue;
         }
 
@@ -554,6 +557,8 @@ export namespace RetryFetch {
 
         try {
           await sleep(delay, isolatedSignal);
+          // Retrying: release the dropped 429 body (issue #335).
+          response.body?.cancel().catch(() => {});
         } catch (sleepError) {
           // Check if the original request was aborted (user cancellation)
           // In that case, we should stop retrying

package/src/provider/transform.ts

@@ -1,8 +1,97 @@
-import type { ModelMessage } from 'ai';
-import { unique } from 'remeda';
+import type { ModelMessage, ToolResultPart } from 'ai';
+import { mergeDeep, unique } from 'remeda';
 import type { JSONSchema } from 'zod/v4/core';
 
 export namespace ProviderTransform {
+  /**
+   * Replace lone UTF-16 surrogates, which strict JSON parsers reject with a
+   * 400 on every later turn (upstream #25934).
+   */
+  export function sanitizeSurrogates(content: string) {
+    return content.replace(
+      /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g,
+      '�'
+    );
+  }
+
+  function sanitizeToolResult(part: ToolResultPart) {
+    const output = part.output;
+    if (output.type === 'text' || output.type === 'error-text') {
+      return {
+        ...part,
+        output: { ...output, value: sanitizeSurrogates(output.value) },
+      };
+    }
+    if (output.type === 'content') {
+      return {
+        ...part,
+        output: {
+          ...output,
+          value: output.value.map((item) =>
+            item.type === 'text'
+              ? { ...item, text: sanitizeSurrogates(item.text) }
+              : item
+          ),
+        },
+      };
+    }
+    return part;
+  }
+
+  function sanitizeMessages(msgs: ModelMessage[]): ModelMessage[] {
+    return msgs.map((msg) => {
+      if (typeof msg.content === 'string') {
+        return {
+          ...msg,
+          content: sanitizeSurrogates(msg.content),
+        } as typeof msg;
+      }
+      if (!Array.isArray(msg.content)) return msg;
+      return {
+        ...msg,
+        content: msg.content.map((part: any) => {
+          if (part.type === 'text' || part.type === 'reasoning') {
+            return { ...part, text: sanitizeSurrogates(part.text) };
+          }
+          if (part.type === 'tool-result') return sanitizeToolResult(part);
+          return part;
+        }),
+      } as typeof msg;
+    });
+  }
+
+  /**
+   * Anthropic and Bedrock reject empty text blocks; keep reasoning that is
+   * signed or redacted (upstream #14586, #26276).
+   */
+  function dropEmptyParts(msgs: ModelMessage[], npm?: string) {
+    if (npm !== '@ai-sdk/anthropic' && npm !== '@ai-sdk/amazon-bedrock') {
+      return msgs;
+    }
+    const ns = npm === '@ai-sdk/anthropic' ? 'anthropic' : 'bedrock';
+    return msgs
+      .map((msg) => {
+        if (typeof msg.content === 'string') {
+          return msg.content === '' ? undefined : msg;
+        }
+        if (!Array.isArray(msg.content)) return msg;
+        const filtered = (msg.content as any[]).filter((part) => {
+          if (part.type === 'text') return part.text !== '';
+          if (part.type === 'reasoning') {
+            return (
+              part.text.trim().length > 0 ||
+              part.providerOptions?.[ns]?.signature != null ||
+              part.providerOptions?.[ns]?.redactedData != null
+            );
+          }
+          return true;
+        });
+        if (filtered.length === 0) return undefined;
+        return { ...msg, content: filtered } as typeof msg;
+      })
+      .filter((msg): msg is ModelMessage => msg !== undefined);
+  }
+
   function normalizeMessages(
     msgs: ModelMessage[],
     providerID: string,
@@ -84,7 +173,8 @@ export namespace ProviderTransform {
 
   function applyCaching(
     msgs: ModelMessage[],
-    providerID: string
+    providerID: string,
+    npm?: string
   ): ModelMessage[] {
     const system = msgs.filter((msg) => msg.role === 'system').slice(0, 2);
     const final = msgs.filter((msg) => msg.role !== 'system').slice(-2);
@@ -96,35 +186,43 @@ export namespace ProviderTransform {
       openrouter: {
         cache_control: { type: 'ephemeral' },
       },
+      // Bedrock only accepts the 'default' cache point (upstream #11664).
       bedrock: {
-        cachePoint: { type: 'ephemeral' },
+        cachePoint: { type: 'default' },
       },
       openaiCompatible: {
         cache_control: { type: 'ephemeral' },
       },
     };
 
+    // Bedrock reads the cache point from the message (upstream #18959).
+    const useMessageLevelOptions =
+      providerID === 'anthropic' ||
+      providerID.includes('bedrock') ||
+      npm === '@ai-sdk/amazon-bedrock';
+
     for (const msg of unique([...system, ...final])) {
       const shouldUseContentOptions =
-        providerID !== 'anthropic' &&
+        !useMessageLevelOptions &&
         Array.isArray(msg.content) &&
         msg.content.length > 0;
 
+      // Deep-merge so signatures already in providerOptions survive (upstream #10323).
       if (shouldUseContentOptions) {
         const lastContent = msg.content[msg.content.length - 1];
         if (lastContent && typeof lastContent === 'object') {
-          lastContent.providerOptions = {
-            ...lastContent.providerOptions,
-            ...providerOptions,
-          };
+          lastContent.providerOptions = mergeDeep(
+            lastContent.providerOptions ?? {},
+            providerOptions
+          ) as typeof lastContent.providerOptions;
           continue;
         }
       }
 
-      msg.providerOptions = {
-        ...msg.providerOptions,
-        ...providerOptions,
-      };
+      msg.providerOptions = mergeDeep(
+        msg.providerOptions ?? {},
+        providerOptions
+      ) as typeof msg.providerOptions;
     }
 
     return msgs;
@@ -133,15 +231,18 @@ export namespace ProviderTransform {
   export function message(
     msgs: ModelMessage[],
     providerID: string,
-    modelID: string
+    modelID: string,
+    npm?: string
   ) {
+    msgs = sanitizeMessages(msgs);
+    msgs = dropEmptyParts(msgs, npm);
     msgs = normalizeMessages(msgs, providerID, modelID);
     if (
       providerID === 'anthropic' ||
       modelID.includes('anthropic') ||
       modelID.includes('claude')
     ) {
-      msgs = applyCaching(msgs, providerID);
+      msgs = applyCaching(msgs, providerID, npm);
     }
 
     return msgs;
@@ -280,11 +381,32 @@ export namespace ProviderTransform {
     return standardLimit;
   }
 
+  /**
+   * Moonshot expands $ref before validating and rejects sibling keywords, and
+   * it does not accept tuple-style `items` arrays (upstream #24730).
+   */
+  function sanitizeMoonshot(node: unknown): unknown {
+    if (node === null || typeof node !== 'object') return node;
+    if (Array.isArray(node)) return node.map(sanitizeMoonshot);
+    if ('$ref' in node && typeof node.$ref === 'string') {
+      return { $ref: node.$ref };
+    }
+    const result: Record<string, unknown> = Object.fromEntries(
+      Object.entries(node).map(([key, value]) => [key, sanitizeMoonshot(value)])
+    );
+    if (Array.isArray(result.items)) result.items = result.items[0] ?? {};
+    return result;
+  }
+
   export function schema(
-    _providerID: string,
-    _modelID: string,
+    providerID: string,
+    modelID: string,
     schema: JSONSchema.BaseSchema
   ) {
+    if (providerID === 'moonshotai' || modelID.toLowerCase().includes('kimi')) {
+      schema = sanitizeMoonshot(schema) as JSONSchema.BaseSchema;
+    }
+
     /*
     if (["openai", "azure"].includes(providerID)) {
       if (schema.type === "object" && schema.properties) {

package/src/session/compaction.ts

@@ -347,7 +347,8 @@ export namespace SessionCompaction {
         }
 
         return false;
-      })
+      }),
+      { providerID: model.providerID, modelID: model.modelID }
     );
     // Defensive check: ensure modelMessages is iterable (AI SDK 6.0.1 compatibility fix)
     const safeModelMessages = Array.isArray(modelMessages) ? modelMessages : [];
@@ -410,7 +411,8 @@ export namespace SessionCompaction {
                   args.params.prompt = ProviderTransform.message(
                     args.params.prompt,
                     model.providerID,
-                    model.modelID
+                    model.modelID,
+                    model.npm
                   );
                 }
                 return args.params;
@@ -420,6 +422,20 @@ export namespace SessionCompaction {
         }),
       })
     );
+    // The summary request itself overflowed: compacting again would send the
+    // same history, so stop with a clear error (upstream #14707).
+    if (result === 'compact') {
+      processor.message.error = new MessageV2.ContextOverflowError({
+        message:
+          'Conversation history too large to compact - exceeds model context limit',
+      }).toObject();
+      await Session.updateMessage(processor.message);
+      Bus.publish(Session.Event.Error, {
+        sessionID: input.sessionID,
+        error: processor.message.error,
+      });
+      return 'stop';
+    }
     if (result === 'continue') {
       const continueMsg = await Session.updateMessage({
         id: Identifier.ascending('message'),

package/src/session/index.ts

@@ -1,9 +1,10 @@
 import { Decimal } from 'decimal.js';
+import { FileTime } from '../file/time';
 import z from 'zod';
 import { type LanguageModelUsage, type ProviderMetadata } from 'ai';
 import { Bus } from '../bus';
 import { Config } from '../config/file-config';
-import { isVerbose } from '../config/config';
+import { config, isVerbose } from '../config/config';
 import { Identifier } from '../id/id';
 import type { ModelsDev } from '../provider/models';
 import { Storage } from '../storage/storage';
@@ -328,6 +329,7 @@ export namespace Session {
         await Storage.remove(msg);
       }
       await Storage.remove(['session', project.id, sessionID]);
+      FileTime.clear(sessionID);
       Bus.publish(Event.Deleted, {
         info: session,
       });
@@ -757,11 +759,36 @@ export namespace Session {
               )
             )
           : 0;
-      const reasoningTokens = topLevelReasoningTokens || nestedReasoning;
+      // AI SDK 7 reports reasoning under outputTokenDetails.
+      const detailReasoning = safeNum(
+        toNumber(
+          (
+            effectiveUsage as {
+              outputTokenDetails?: { reasoningTokens?: unknown };
+            }
+          ).outputTokenDetails?.reasoningTokens,
+          'outputTokenDetails.reasoningTokens'
+        )
+      );
+      const reasoningTokens =
+        topLevelReasoningTokens || nestedReasoning || detailReasoning;
+
+      // outputTokens already includes reasoning, which is billed separately
+      // below, so take it out to avoid charging it twice (upstream #21047).
+      // Providers that report more reasoning than output count it apart.
+      const rawOutputTokens = safeNum(
+        toNumber(effectiveUsage.outputTokens, 'outputTokens')
+      );
+      // --legacy-token-usage / LINK_ASSISTANT_AGENT_LEGACY_TOKEN_USAGE keeps
+      // the raw figure (reasoning counted in output, as before).
+      const outputTokens =
+        !config.legacyTokenUsage && reasoningTokens <= rawOutputTokens
+          ? rawOutputTokens - reasoningTokens
+          : rawOutputTokens;
 
       const tokens = {
         input: Math.max(0, adjustedInputTokens), // Ensure non-negative
-        output: safeNum(toNumber(effectiveUsage.outputTokens, 'outputTokens')),
+        output: outputTokens,
         reasoning: reasoningTokens,
         cache: {
           write: cacheWriteTokens,