@link-assistant/agent 0.26.15 → 0.27.1

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;
@@ -159,6 +260,27 @@ export namespace ProviderTransform {
     return undefined;
   }
 
+  /**
+   * Catalogue providers whose chat-completions endpoint accepts an unscoped
+   * `prompt_cache_key`, as audited by OpenCode
+   * (packages/core/src/plugin/provider/prompt-cache-key.ts).
+   * @see https://github.com/link-assistant/agent/issues/334
+   */
+  export const PROMPT_CACHE_KEY_PROVIDERS = new Set([
+    'abliteration-ai',
+    'aihubmix',
+    'anyapi',
+    'auriko',
+    'edenai',
+    'jalapeno',
+    'llama',
+    'morph',
+    'snowflake-cortex',
+    'tencent-tokenhub',
+    'upstage',
+    'venice',
+  ]);
+
   export function options(
     providerID: string,
     modelID: string,
@@ -167,6 +289,14 @@ export namespace ProviderTransform {
   ): Record<string, any> | undefined {
     const result: Record<string, any> = {};
 
+    if (
+      npm === '@ai-sdk/openai-compatible' &&
+      PROMPT_CACHE_KEY_PROVIDERS.has(providerID)
+    ) {
+      // Unknown openai-compatible options are sent verbatim in the body.
+      result['prompt_cache_key'] = sessionID;
+    }
+
     if (providerID === 'openai') {
       result['promptCacheKey'] = sessionID;
     }
@@ -251,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,