maka-agent 0.2.1-dev.91.20261018 → 0.2.2-dev.97.20261024

package/dist/runtime-host-setup-command.js

@@ -17,24 +17,27 @@
  * under the License.
  */
 import { randomUUID } from 'node:crypto';
+import { lstat, readFile, realpath } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
 import { isDeepStrictEqual } from 'node:util';
+import { zstdCompressSync, zstdDecompressSync } from 'node:zlib';
 import { truncateUtf8 } from '@maka/core/diagnostic-log';
 import { generalizedErrorMessage } from '@maka/core/redaction';
 import { activateRuntimeHostManagedDeployment, connectRemoteRuntimeHost, ensureRuntimeHostPeerIdentity, RuntimeHostOperationError, } from '@maka/runtime-host/client';
-import { RuntimeHostManagedDeploymentError as RuntimeHostDeploymentAuthorityError, encodeRuntimeHostSetupFrame, isSha512PackageIntegrity, resolveRuntimeHostManagedDeployment, resolveRuntimeHostManagedDeploymentAuthority, runtimeHostManagedOperatorCommand, RUNTIME_HOST_SETUP_ERROR_CODE_MAX_BYTES, RUNTIME_HOST_SETUP_ERROR_MESSAGE_MAX_BYTES, } from '@maka/runtime-host/operator';
+import { RuntimeHostManagedDeploymentError as RuntimeHostDeploymentAuthorityError, encodeRuntimeHostSetupFrame, isSha512PackageIntegrity, resolveRuntimeHostManagedDeployment, resolveRuntimeHostManagedDeploymentAuthority, runtimeHostManagedOperatorCommand, runtimeHostManagedOperatorModulePath, RUNTIME_HOST_SETUP_ERROR_CODE_MAX_BYTES, RUNTIME_HOST_SETUP_ERROR_MESSAGE_MAX_BYTES, } from '@maka/runtime-host/operator';
 import { INTERACTIVE_RUNTIME_HOST_COMPOSITION_ID, RUNTIME_HOST_PROTOCOL_VERSION, } from '@maka/runtime-host/protocol';
 import { prepareRuntimeHostAccessCredential, replaceRuntimeHostAccessCredential, revokeRuntimeHostAccessCredential, RuntimeHostAccessUnavailableError, } from './runtime-host-access-command.js';
 import { convergeRuntimeHostManagedOperator, verifyRuntimeHostManagedOperator, isRuntimeHostDevelopmentPackageVersion, openRuntimeHostManagedPackageDeployment, prepareRuntimeHostManagedPackageDeployment, pruneRuntimeHostManagedPackages, removeRuntimeHostManagedDeployment, resolveRuntimeHostManagedPackageCliPath, resolveRuntimeHostManagedControlRoot, resolveRuntimeHostManagedDeploymentRoot, restoreRuntimeHostLegacyManagedOperator, RuntimeHostManagedDeploymentError, } from './runtime-host-managed-deployment.js';
 import { RuntimeHostUpdatePackageError, withRuntimeHostRegistryUpdatePackage, } from './runtime-host-update-package.js';
 import { readRuntimeHostManagedUpdatePolicy, writeRuntimeHostManagedUpdatePolicy, } from './runtime-host-update-policy-store.js';
 import { resolveRuntimeHostRegistryUpdateCandidate, RuntimeHostUpdateDiscoveryError, } from './runtime-host-update-discovery.js';
-import { repairStorageRootAfterRemount, resolveStorageRoot } from '@maka/storage/root-authority';
+import { repairStorageRootAfterRemount, resolveStorageRoot, tryAcquireStateRootOwner, } from '@maka/storage/root-authority';
 import { createPlatformRuntimeHostServiceBackend, discoverRuntimeHostLifecycleProvider, resolveRuntimeHostLifecycleProvider, } from './runtime-host-service-management-command.js';
 import { allocateRuntimeHostLoopbackPort, allocateRuntimeHostPeerPort, effectiveRuntimeHostProjectDirectoryRoots, manageRuntimeHostService, readRuntimeHostManagedServiceConfig, removeRuntimeHostServiceFile, resolveRuntimeHostManagedServiceConfigPath, resolveRuntimeHostManagedServiceId, resolveRuntimeHostManagedProjectDirectoryRoots, RuntimeHostServiceManagerError, withRuntimeHostManagedServiceDeploymentLock, withRuntimeHostManagedServiceLifecycleLock, } from './runtime-host-service-manager.js';
 import { expandWildcardListenAddresses } from './runtime-host-peer-management-command.js';
-import { canDiscardRuntimeHostLifecycleDesiredArtifacts, replaceRuntimeHostLifecycle, resolveRecoverableRuntimeHostManagedDeployment, RUNTIME_HOST_READY_TIMEOUT_MS, RuntimeHostLifecycleTransactionError, } from './runtime-host-lifecycle-transaction.js';
+import { applyRuntimeHostLifecycleTransition, canDiscardRuntimeHostLifecycleDesiredArtifacts, recoverRuntimeHostLifecycleTransition, replaceRuntimeHostLifecycle, resolveRecoverableRuntimeHostManagedDeployment, RUNTIME_HOST_READY_TIMEOUT_MS, RuntimeHostLifecycleTransactionError, } from './runtime-host-lifecycle-transaction.js';
 import { resolveRuntimeHostManagedPeerKeyPath, resolveRuntimeHostNativePath, } from './runtime-host-peer-artifact.js';
 import { activateRuntimeHostManagedDeploymentWithReconciliation } from './runtime-host-activation-command.js';
 const SETUP_LOCK_TIMEOUT_MS = 5 * 60_000;
@@ -73,6 +76,8 @@ async function resolveRuntimeHostSetupPackage(options, deps) {
 }
 export async function runRuntimeHostSetupCli(options, overrides = {}) {
     const deps = {
+        isWsl: async () => process.platform === 'linux' &&
+            /microsoft/i.test(await readFile('/proc/sys/kernel/osrelease', 'utf8')),
         manageService: manageRuntimeHostService,
         createBackend: createPlatformRuntimeHostServiceBackend,
         discoverLifecycleProvider: discoverRuntimeHostLifecycleProvider,
@@ -105,6 +110,9 @@ export async function runRuntimeHostSetupCli(options, overrides = {}) {
     };
     const emit = createEmitter(options.json, deps);
     try {
+        if (options.expectedExisting && !(await deps.isWsl())) {
+            throw new RuntimeHostSetupError('invalid_setup', 'Missing Node recovery is available only in WSL');
+        }
         const rootId = await resolveRuntimeHostSetupRootId(options);
         const controlRoot = resolveRuntimeHostManagedControlRoot(rootId);
         await withRuntimeHostManagedServiceDeploymentLock(options.clientDataRoot, () => withRuntimeHostManagedServiceLifecycleLock(options.clientDataRoot, () => withRuntimeHostManagedServiceDeploymentLock(controlRoot, () => withRuntimeHostManagedServiceLifecycleLock(controlRoot, () => runRuntimeHostSetupLocked(options, deps, emit, rootId), SETUP_LOCK_TIMEOUT_MS), SETUP_LOCK_TIMEOUT_MS), SETUP_LOCK_TIMEOUT_MS), SETUP_LOCK_TIMEOUT_MS);
@@ -117,6 +125,17 @@ export async function runRuntimeHostSetupCli(options, overrides = {}) {
     }
 }
 async function resolveRuntimeHostSetupRootId(options) {
+    if (options.expectedExisting) {
+        if (!options.reuseExistingEnvironment) {
+            throw new RuntimeHostSetupError('invalid_setup', 'Node recovery requires an existing Root and POSIX Node operator');
+        }
+        if (!(await resolveRuntimeHostManagedDeploymentAuthority(options.expectedExisting.rootId, {
+            ...(options.repairRootAfterRemount ? { repairRootAfterRemount: true } : {}),
+        }))) {
+            throw new RuntimeHostSetupError('not_installed', 'The requested WSL deployment is not installed');
+        }
+        return options.expectedExisting.rootId;
+    }
     const legacyRootPath = (await readOptionalLegacyServiceConfig(options.clientDataRoot))?.rootPath;
     const path = resolve(options.rootPath ??
         legacyRootPath ??
@@ -145,11 +164,16 @@ async function runRuntimeHostSetupLocked(options, deps, emit, rootId) {
         }
         const existing = await resolveRuntimeHostManagedDeploymentAuthority(rootId);
         if (existing) {
-            const { config, capability } = await resolveRuntimeHostManagedDeployment(rootId);
+            const { capability } = existing;
             assertCanonicalSetupTarget(options.expectedTarget, rootId, capability.canonicalPath);
-            assertExpectedDeploymentGeneration(options.expectedTarget, config);
-            // The binding comes from canonical authority. The installed operator validates
-            // its own projection when connected; discovery must not rewrite an older launcher.
+            assertExpectedDeploymentGeneration(options.expectedTarget, existing.record.state === 'active'
+                ? existing.record
+                : (existing.record.from ?? existing.record.to ?? undefined));
+            const config = options.expectedExisting
+                ? await repairMissingWslNode(rootId, options.expectedExisting.operator, deps)
+                : (await resolveRuntimeHostManagedDeployment(rootId)).config;
+            // Ordinary discovery retains an older launcher; only explicit missing-Node
+            // recovery rewrites it, without replacing the installed package.
             emit({
                 kind: 'existing_environment',
                 version: config.launch.package.version,
@@ -161,6 +185,9 @@ async function runRuntimeHostSetupLocked(options, deps, emit, rootId) {
             });
             return;
         }
+        if (options.expectedExisting) {
+            throw new RuntimeHostSetupError('not_installed', 'The requested WSL deployment is not installed');
+        }
     }
     if (options.lifecycle === 'on_demand') {
         await runRuntimeHostOnDemandSetupLocked(options, deps, emit);
@@ -169,6 +196,86 @@ async function runRuntimeHostSetupLocked(options, deps, emit, rootId) {
     const target = await runRuntimeHostSupervisedSetupLocked(options, deps, emit);
     await pairAndVerifyRuntimeHostSetup(options, target, deps, emit);
 }
+/** Called only after Desktop has proved its saved Node is missing. */
+async function repairMissingWslNode(rootId, expected, deps) {
+    const [major, minor] = process.versions.node.split('.').map(Number);
+    if (!(major >= 24 || (major === 22 && minor >= 19)) ||
+        typeof DatabaseSync !== 'function' ||
+        typeof zstdCompressSync !== 'function' ||
+        typeof zstdDecompressSync !== 'function') {
+        throw new RuntimeHostSetupError('activation_failed', 'The Node found by the WSL login shell cannot run this Runtime Host');
+    }
+    const nodePath = await realpath(process.execPath);
+    const resolved = await resolveRuntimeHostManagedDeploymentAuthority(rootId);
+    if (!resolved)
+        throw new RuntimeHostSetupError('activation_failed', 'WSL deployment is absent or requires transaction recovery');
+    const { record } = resolved;
+    const current = record.state === 'active' ? record : record.from;
+    // Only this operation's Node-only plan may be recovered without retiring a Host.
+    if (record.state !== 'active' &&
+        (record.operation !== 'configure' ||
+            record.recovery !== 'restore_from' ||
+            !record.from ||
+            !record.to ||
+            record.from.launch.nodePath !== expected.nodePath ||
+            !isDeepStrictEqual(record.to, {
+                ...record.from,
+                configRevision: record.from.configRevision + 1,
+                launch: { ...record.from.launch, nodePath: record.to.launch.nodePath },
+            })))
+        throw new RuntimeHostSetupError('activation_failed', 'WSL deployment is absent or requires transaction recovery');
+    if (!current ||
+        current.lifecycle.mode !== 'on_demand' ||
+        runtimeHostManagedOperatorModulePath(current.deploymentRoot, 'posix') !== expected.modulePath) {
+        throw new RuntimeHostSetupError('activation_failed', 'WSL Node recovery does not match the on-demand deployment');
+    }
+    // A stale Desktop binding may be retried after another repair committed.
+    if (current.launch.nodePath !== expected.nodePath) {
+        if (await missingNode(current.launch.nodePath))
+            throw new RuntimeHostSetupError('activation_failed', 'WSL deployment Node binding changed; reconnect its current profile');
+        return current;
+    }
+    const owner = await tryAcquireStateRootOwner(resolved.capability);
+    if (!owner)
+        throw new RuntimeHostSetupError('activation_failed', 'The WSL Host is still running; Node recovery will not interrupt it');
+    const lifecycle = {
+        convergeOperator: deps.convergeOperator,
+        verifyOperator: deps.verifyOperator,
+        resolveProvider: deps.resolveLifecycleProvider,
+    };
+    try {
+        if (!(await missingNode(current.launch.nodePath)))
+            throw new RuntimeHostSetupError('activation_failed', 'The saved WSL Node still exists; refusing to replace it');
+        if (record.state !== 'active')
+            await recoverRuntimeHostLifecycleTransition(owner, record, lifecycle);
+        const configured = await applyRuntimeHostLifecycleTransition(owner, {
+            operation: 'configure',
+            current,
+            desired: {
+                ...current,
+                configRevision: current.configRevision + 1,
+                launch: { ...current.launch, nodePath },
+            },
+        }, lifecycle);
+        if (!configured)
+            throw new RuntimeHostSetupError('activation_failed', 'WSL Node recovery did not retain the deployment');
+        return configured;
+    }
+    finally {
+        await owner.close();
+    }
+}
+async function missingNode(path) {
+    try {
+        await lstat(path);
+        return false;
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT')
+            return true;
+        throw error;
+    }
+}
 async function runRuntimeHostSupervisedSetupLocked(options, deps, emit) {
     emit({ kind: 'progress', phase: 'checking_environment' });
     const legacyServiceId = resolveRuntimeHostManagedServiceId(options.clientDataRoot);

package/dist/tui-copy-catalog.js

@@ -482,7 +482,31 @@ const TUI_COPY_RESOURCES_TODO_EN = {
     loading: 'Loading Todo…',
     hint: '↑↓/PgUp/PgDn scroll · Home/End · Esc close',
 };
+const TUI_COPY_RESOURCES_GOAL_EN = {
+    cancelWaitBusy: 'Wait for the current action to finish, then cancel the wait.',
+    noCancellableWait: 'No cancellable event wait.',
+    waitCancelled: 'Wait cancelled. Goal paused; the background task keeps running.',
+    waitChanged: 'The wait changed or its continuation was admitted. Use /goal to inspect the current state.',
+    usage: 'Usage: /goal [pause|resume|clear|cancel-wait]',
+};
 export const TUI_COPY_RESOURCES = {
+    goal: resolveUiMessageCatalog(defineShippedUiMessageCatalog()({
+        en: TUI_COPY_RESOURCES_GOAL_EN,
+        'zh-CN': {
+            cancelWaitBusy: '请等待当前操作完成，再取消等待。',
+            noCancellableWait: '没有可取消的事件等待。',
+            waitCancelled: '等待已取消，目标已暂停；后台任务继续运行。',
+            waitChanged: '等待状态已变化，或后续执行已获准启动。请使用 /goal 查看当前状态。',
+            usage: '用法：/goal [pause|resume|clear|cancel-wait]',
+        },
+        'zh-TW': {
+            cancelWaitBusy: '請等待目前操作完成，再取消等待。',
+            noCancellableWait: '沒有可取消的事件等待。',
+            waitCancelled: '等待已取消，目標已暫停；背景任務繼續執行。',
+            waitChanged: '等待狀態已變更，或後續執行已獲准啟動。請使用 /goal 檢視目前狀態。',
+            usage: '用法：/goal [pause|resume|clear|cancel-wait]',
+        },
+    })),
     todo: resolveUiMessageCatalog(defineShippedUiMessageCatalog()({
         en: TUI_COPY_RESOURCES_TODO_EN,
         'zh-CN': {

package/node_modules/@ai-sdk/provider-utils/node_modules/undici/docs/docs/api/Client.md

@@ -27,6 +27,8 @@ Returns: `Client`
 * **webSocket** `WebSocketOptions` (optional) - WebSocket-specific configuration options.
   * **maxFragments** `number` (optional) - Default: `131072` - Maximum number of fragments in a message. Set to 0 to disable the limit.
   * **maxPayloadSize** `number` (optional) - Default: `134217728` (128 MB) - Maximum allowed payload size in bytes for WebSocket messages. Applied to uncompressed messages, compressed frame payloads, and decompressed (permessage-deflate) messages. Set to 0 to disable the limit.
+* **eventSource** `EventSourceOptions` (optional) - EventSource-specific configuration options.
+  * **maxEventSize** `number` (optional) - The maximum total bytes of data and metadata field values retained for a pending EventSource event. Each unfinished line is separately limited to this value plus seven syntax bytes. The number of `data:` lines per event and input chunks buffered for an unfinished line are each limited to `min(131072, max(1024, floor(maxEventSize / 128)))` to bound object overhead. Set to `0` to disable these limits. Default: `buffer.kStringMaxLength`.
 * **pipelining** `number | null` (optional) - Default: `1` - The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Carefully consider your workload and environment before enabling concurrent requests as pipelining may reduce performance if used incorrectly. Pipelining is sensitive to network stack settings as well as head of line blocking caused by e.g. long running requests. Set to `0` to disable keep-alive connections.
 * **connect** `ConnectOptions | Function | null` (optional) - Default: `null`.
 * **strictContentLength** `Boolean` (optional) - Default: `true` - Whether to treat request content length mismatches as errors. If true, an error is thrown when the request content-length header doesn't match the length of the request body. **Security Warning:** Disabling this option can expose your application to HTTP Request Smuggling attacks, where mismatched content-length headers cause servers and proxies to interpret request boundaries differently. This can lead to cache poisoning, credential hijacking, and bypassing security controls. Only disable this in controlled environments where you fully trust the request source.

package/node_modules/@ai-sdk/provider-utils/node_modules/undici/lib/core/connect.js

@@ -41,16 +41,22 @@ const SessionCache = class WeakSessionCache {
     if (this._sessionCache.has(sessionKey)) {
       this._sessionCache.delete(sessionKey)
     } else if (this._sessionCache.size >= this._maxCachedSessions) {
+      // Make room for the new session: prefer an entry whose session has
+      // already been collected, otherwise evict the oldest one.
+      let evicted = false
       for (const [key, ref] of this._sessionCache) {
         if (ref.deref() === undefined) {
           this._sessionCache.delete(key)
-          return
+          evicted = true
+          break
         }
       }
 
-      const oldest = this._sessionCache.keys().next()
-      if (!oldest.done) {
-        this._sessionCache.delete(oldest.value)
+      if (!evicted) {
+        const oldest = this._sessionCache.keys().next()
+        if (!oldest.done) {
+          this._sessionCache.delete(oldest.value)
+        }
       }
     }
 

package/node_modules/@ai-sdk/provider-utils/node_modules/undici/lib/core/symbols.js

@@ -5,6 +5,7 @@ module.exports = {
   kDestroy: Symbol('destroy'),
   kDispatch: Symbol('dispatch'),
   kUrl: Symbol('url'),
+  kRedirectCacheControl: Symbol('redirect cache control'),
   kWriting: Symbol('writing'),
   kResuming: Symbol('resuming'),
   kQueue: Symbol('queue'),

package/node_modules/@ai-sdk/provider-utils/node_modules/undici/lib/dispatcher/agent.js

@@ -22,7 +22,7 @@ function defaultFactory (origin, opts) {
 }
 
 class Agent extends DispatcherBase {
-  constructor ({ factory = defaultFactory, maxOrigins = Infinity, connect, ...options } = {}) {
+  constructor ({ factory = defaultFactory, maxOrigins = Infinity, connect, tls, ...options } = {}) {
     if (typeof factory !== 'function') {
       throw new InvalidArgumentError('factory must be a function.')
     }
@@ -41,7 +41,11 @@ class Agent extends DispatcherBase {
       connect = { ...connect }
     }
 
-    this[kOptions] = { ...util.deepClone(options), maxOrigins, connect }
+    if (tls && typeof tls !== 'function') {
+      tls = { ...tls }
+    }
+
+    this[kOptions] = { ...util.deepClone(options), maxOrigins, connect, tls }
     this[kFactory] = factory
     this[kClients] = new Map()
     this[kOrigins] = new Set()

package/node_modules/@ai-sdk/provider-utils/node_modules/undici/lib/dispatcher/client-h1.js

@@ -928,8 +928,6 @@ function connectH1 (client, socket) {
 }
 
 function onHttpSocketError (err) {
-  assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
-
   const parser = this[kParser]
 
   // On Mac OS, we get an ECONNRESET even if there is a full body to be forwarded

package/node_modules/@ai-sdk/provider-utils/node_modules/undici/lib/dispatcher/client-h2.js

@@ -293,8 +293,6 @@ function onHttp2SendPing (session) {
 }
 
 function onHttp2SessionError (err) {
-  assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
-
   this[kSocket][kError] = err
   this[kClient][kOnError](err)
 }
@@ -436,8 +434,6 @@ function onHttp2SocketClose () {
 }
 
 function onHttp2SocketError (err) {
-  assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
-
   this[kError] = err
 
   this[kClient][kOnError](err)

package/node_modules/@ai-sdk/provider-utils/node_modules/undici/lib/dispatcher/client.js

@@ -115,7 +115,8 @@ class Client extends DispatcherBase {
     initialWindowSize,
     connectionWindowSize,
     pingInterval,
-    webSocket
+    webSocket,
+    eventSource
   } = {}) {
     if (keepAlive !== undefined) {
       throw new InvalidArgumentError('unsupported keepAlive, use pipelining=0 instead')
@@ -223,7 +224,7 @@ class Client extends DispatcherBase {
       throw new InvalidArgumentError('pingInterval must be a positive integer, greater or equal to 0')
     }
 
-    super({ webSocket })
+    super({ webSocket, eventSource })
 
     if (typeof connect !== 'function') {
       connect = buildConnector({

package/node_modules/@ai-sdk/provider-utils/node_modules/undici/lib/dispatcher/dispatcher-base.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const buffer = require('node:buffer')
 const Dispatcher = require('./dispatcher')
 const UnwrapHandler = require('../handler/unwrap-handler')
 const {
@@ -12,6 +13,7 @@ const { kDestroy, kClose, kClosed, kDestroyed, kDispatch } = require('../core/sy
 const kOnDestroyed = Symbol('onDestroyed')
 const kOnClosed = Symbol('onClosed')
 const kWebSocketOptions = Symbol('webSocketOptions')
+const kEventSourceOptions = Symbol('eventSourceOptions')
 
 class DispatcherBase extends Dispatcher {
   /** @type {boolean} */
@@ -32,6 +34,7 @@ class DispatcherBase extends Dispatcher {
   constructor (opts) {
     super()
     this[kWebSocketOptions] = opts?.webSocket ?? {}
+    this[kEventSourceOptions] = opts?.eventSource ?? {}
   }
 
   /**
@@ -44,6 +47,15 @@ class DispatcherBase extends Dispatcher {
     }
   }
 
+  /**
+   * @returns {import('../../types/client').Client.EventSourceOptions}
+   */
+  get eventSourceOptions () {
+    return {
+      maxEventSize: this[kEventSourceOptions].maxEventSize ?? buffer.kStringMaxLength
+    }
+  }
+
   /** @returns {boolean} */
   get destroyed () {
     return this[kDestroyed]

package/node_modules/@ai-sdk/provider-utils/node_modules/undici/lib/handler/cache-handler.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const util = require('../core/util')
+const { kRedirectCacheControl } = require('../core/symbols')
 const {
   parseCacheControlHeader,
   hasInvalidCacheControlDirective,
@@ -13,6 +14,19 @@ const { parseHttpDate } = require('../util/date.js')
 
 function noop () {}
 
+/**
+ * @param {string | URL} a
+ * @param {string | URL} b
+ * @returns {boolean}
+ */
+function sameOrigin (a, b) {
+  try {
+    return new URL(String(a)).origin === new URL(String(b)).origin
+  } catch {
+    return String(a) === String(b)
+  }
+}
+
 // Status codes that we can use some heuristics on to cache
 const HEURISTICALLY_CACHEABLE_STATUS_CODES = [
   200, 203, 204, 206, 300, 301, 308, 404, 405, 410, 414, 501
@@ -151,6 +165,14 @@ class CacheHandler {
    */
   #writeStream
 
+  /**
+   * The URLs visited while following redirects, shared by reference from the
+   * redirect handler through the request context. Carries the suppressed hops'
+   * cache-control under {@link kRedirectCacheControl}.
+   * @type {URL[] | undefined}
+   */
+  #history
+
   /**
    * @param {import('../../types/cache-interceptor.d.ts').default.CacheHandlerOptions} opts
    * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} cacheKey
@@ -167,6 +189,9 @@ class CacheHandler {
   onRequestStart (controller, context) {
     this.#writeStream?.destroy()
     this.#writeStream = undefined
+    // The redirect handler mutates this shared history as redirects are
+    // followed, allowing the cache to identify the response's actual origin.
+    this.#history = context?.history
     this.#handler.onRequestStart?.(controller, context)
   }
 
@@ -206,6 +231,29 @@ class CacheHandler {
       return downstreamOnHeaders()
     }
 
+    // Never store a response produced by a different origin under the original
+    // request's cache key.
+    if (this.#history && this.#history.length > 0) {
+      const finalUrl = this.#history[this.#history.length - 1]
+      if (!sameOrigin(finalUrl.origin, this.#cacheKey.origin)) {
+        return downstreamOnHeaders()
+      }
+    }
+
+    // Preserve restrictive cache policy from suppressed redirect responses.
+    const redirectCacheControl = this.#history?.[kRedirectCacheControl]
+    if (redirectCacheControl) {
+      for (const hopCacheControl of redirectCacheControl) {
+        const hopDirectives = hopCacheControl ? parseCacheControlHeader(hopCacheControl) : {}
+        if (
+          hopDirectives['no-store'] === true ||
+          (this.#cacheType === 'shared' && hopDirectives.private === true)
+        ) {
+          return downstreamOnHeaders()
+        }
+      }
+    }
+
     const cacheControlHeader = resHeaders['cache-control']
     const cacheControlDirectives = cacheControlHeader ? parseCacheControlHeader(cacheControlHeader) : {}
 

package/node_modules/@ai-sdk/provider-utils/node_modules/undici/lib/handler/deduplication-handler.js

@@ -16,6 +16,7 @@ const DEFAULT_MAX_BUFFER_SIZE = 5 * 1024 * 1024
  * @property {number} bufferedBytes
  * @property {object | null} pendingTrailers
  * @property {boolean} done
+ * @property {boolean} [pendingStart] onRequestStart deferred until the primary request's context is known
  */
 
 /**
@@ -30,6 +31,20 @@ class DeduplicationHandler {
    */
   #primaryHandler
 
+  /**
+   * Whether the primary request has started (onRequestStart received). Until
+   * then the request context is unknown and cannot be given to waiting handlers.
+   * @type {boolean}
+   */
+  #requestStarted = false
+
+  /**
+   * The primary request context, replayed to waiting handlers so they observe
+   * the same redirect history as the primary.
+   * @type {any}
+   */
+  #context = null
+
   /**
    * @type {WaitingHandler[]}
    */
@@ -112,20 +127,30 @@ class DeduplicationHandler {
     const waitingController = waitingHandler.controller
 
     try {
-      handler.onRequestStart?.(waitingController, null)
+      if (this.#requestStarted) {
+        // The primary request has started, so its context (including the
+        // redirect history) is known and can be delivered immediately.
+        handler.onRequestStart?.(waitingController, this.#context)
 
-      if (waitingController.aborted) {
-        waitingHandler.done = true
-        return true
-      }
+        if (waitingController.aborted) {
+          waitingHandler.done = true
+          return true
+        }
 
-      if (this.#responseStarted) {
-        handler.onResponseStart?.(
-          waitingController,
-          this.#statusCode,
-          this.#headers,
-          this.#statusMessage
-        )
+        if (this.#responseStarted) {
+          handler.onResponseStart?.(
+            waitingController,
+            this.#statusCode,
+            this.#headers,
+            this.#statusMessage
+          )
+        }
+      } else {
+        // The primary request has not started yet. Defer onRequestStart until
+        // its context is known, so the waiting handler observes the same
+        // redirect history as the primary (a cache handler relies on it to
+        // reject cross-origin redirect responses).
+        waitingHandler.pendingStart = true
       }
     } catch {
       // Ignore errors from waiting handlers
@@ -146,6 +171,24 @@ class DeduplicationHandler {
    */
   onRequestStart (controller, context) {
     this.#controller = controller
+    if (!this.#requestStarted) {
+      this.#requestStarted = true
+      this.#context = context
+      // Deliver the now-known context to handlers that joined before the
+      // primary request started.
+      for (const waitingHandler of this.#waitingHandlers) {
+        if (waitingHandler.pendingStart && !waitingHandler.done && !waitingHandler.controller.aborted) {
+          waitingHandler.pendingStart = false
+          try {
+            waitingHandler.handler.onRequestStart?.(waitingHandler.controller, context)
+          } catch {
+            // Ignore errors from waiting handlers
+            waitingHandler.done = true
+          }
+        }
+      }
+      this.#pruneDoneWaitingHandlers()
+    }
     this.#primaryHandler.onRequestStart?.(controller, context)
   }
 
@@ -319,7 +362,8 @@ class DeduplicationHandler {
       bufferedChunks: [],
       bufferedBytes: 0,
       pendingTrailers: null,
-      done: false
+      done: false,
+      pendingStart: false
     }
 
     const state = {

package/node_modules/@ai-sdk/provider-utils/node_modules/undici/lib/handler/redirect-handler.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const util = require('../core/util')
-const { kBodyUsed } = require('../core/symbols')
+const { kBodyUsed, kRedirectCacheControl } = require('../core/symbols')
 const assert = require('node:assert')
 const { InvalidArgumentError } = require('../core/errors')
 const EE = require('node:events')
@@ -47,6 +47,11 @@ class RedirectHandler {
     this.maxRedirections = maxRedirections
     this.handler = handler
     this.history = []
+    // Retain cache-control from suppressed redirect hops for an outer cache.
+    Object.defineProperty(this.history, kRedirectCacheControl, {
+      value: [],
+      enumerable: false
+    })
 
     if (util.isStream(this.opts.body)) {
       // TODO (fix): Provide some way for the user to cache the file to e.g. /tmp
@@ -130,6 +135,8 @@ class RedirectHandler {
       return
     }
 
+    this.history[kRedirectCacheControl].push(headers['cache-control'])
+
     const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)))
     const path = search ? `${pathname}${search}` : pathname
 

package/node_modules/@ai-sdk/provider-utils/node_modules/undici/lib/interceptor/decompress.js

@@ -220,9 +220,14 @@ class DecompressHandler extends DecoratorHandler {
             this.#decompressedSize = decompressedSize
           }
 
-          const result = super.onResponseData(this.#controller, chunk)
-          if (result === false && !this.#controller.paused) {
-            this.#controller.pause()
+          try {
+            const result = super.onResponseData(this.#controller, chunk)
+            if (result === false && !this.#controller.paused) {
+              this.#controller.pause()
+            }
+          } catch (err) {
+            this.#fail(err)
+            return
           }
         }
       } while (this.#drainRequested && !this.#terminated && !this.#controller.paused)
@@ -239,9 +244,14 @@ class DecompressHandler extends DecoratorHandler {
       return
     }
 
-    this.#terminated = true
     this.#cleanupDecompressors()
-    super.onResponseEnd(this.#controller, this.#trailers)
+    try {
+      super.onResponseEnd(this.#controller, this.#trailers)
+    } catch (err) {
+      this.#fail(err)
+      return
+    }
+    this.#terminated = true
   }
 
   #onDecompressionEnd () {

package/node_modules/@ai-sdk/provider-utils/node_modules/undici/lib/web/cookies/index.js

@@ -32,8 +32,10 @@ function getCookies (headers) {
 
   const cookie = headers.get('cookie')
 
+  // A null prototype keeps a cookie named `__proto__` from hitting the
+  // Object.prototype setter, which would silently drop it.
   /** @type {Record<string, string>} */
-  const out = {}
+  const out = { __proto__: null }
 
   if (!cookie) {
     return out