@remnic/core 9.7.15 → 9.8.0

package/dist/recall-state.d.ts

@@ -1,6 +1,9 @@
+import { HeldFileLockOptions } from './utils/serialize-mutations.js';
 import { SearchDegradation } from './search/port.js';
-import { b as RecallPlanMode, I as IdentityInjectionMode, s as RecallTierExplain } from './types-Cg8q7W7_.js';
+import { R as RecallPlanMode, I as IdentityInjectionMode, g as RecallTierExplain } from './types-D_fG2ix8.js';
 import './message-parts/index.js';
+import './bounded-jsonl-state.js';
+import './types-continuity.js';
 
 interface LastRecallBudgetSummary {
     requestedTopK?: number;
@@ -13,6 +16,10 @@ interface LastRecallBudgetSummary {
     truncated?: boolean;
     includedSections?: string[];
     omittedSections?: string[];
+    includedMemoryIds?: string[];
+    includedMemoryPaths?: string[];
+    includedMemoryNamespaces?: Array<string | undefined>;
+    omittedMemoryIds?: string[];
 }
 interface LastRecallSnapshot {
     sessionKey: string;
@@ -31,6 +38,7 @@ interface LastRecallSnapshot {
     budgetsApplied?: LastRecallBudgetSummary;
     latencyMs?: number;
     resultPaths?: string[];
+    resultNamespaces?: Array<string | undefined>;
     policyVersion?: string;
     identityInjectionMode?: IdentityInjectionMode | "none";
     identityInjectedChars?: number;
@@ -101,14 +109,42 @@ interface TierMigrationStatusSnapshot {
         errors: number;
     };
 }
+/**
+ * Outcome of {@link LastRecallStore.drainPendingImpressions}. Distinguishes a
+ * completed drain (or nothing pending) from a DEFERRED drain that left durable
+ * spills in the offline-sync-EXCLUDED queue, so the caller can tell the
+ * data-safe cases apart from the one where an offline-sync snapshot would
+ * silently omit recorded impressions (#2033).
+ */
+interface DrainPendingImpressionsResult {
+    /** Pending spill rows were folded into the synced active file this call. */
+    folded: boolean;
+    /**
+     * Durable spill rows remain in the offline-sync-EXCLUDED pending queue after
+     * this drain: the rotation lock could not be acquired, a spill could not be
+     * claimed, or the drain-only fold left rows that would only fit by rotating
+     * into a sync-excluded archive. A snapshot taken now would silently omit them
+     * (#2033): the caller MUST treat the active file as INCOMPLETE and retry or
+     * abort the snapshot rather than report success. `false` means the active file
+     * is complete — every pending row was folded or nothing was pending.
+     */
+    pendingDeferred: boolean;
+}
 declare class LastRecallStore {
     private readonly statePath;
     private readonly impressionsPath;
     private readonly writeStateFile;
+    private readonly impressionsRotateBytes;
+    private readonly impressionsRotateKeep;
+    private readonly impressionsLockOptions?;
     private state;
     private stateWriteChain;
+    private impressionsWriteChain;
     constructor(memoryDir: string, options?: {
         writeStateFile?: StateFileWriter;
+        impressionsRotateBytes?: number;
+        impressionsRotateKeep?: number;
+        impressionsLockOptions?: Pick<HeldFileLockOptions, "maxWaitMs" | "pollMs">;
     });
     load(): Promise<void>;
     get(sessionKey: string): LastRecallSnapshot | null;
@@ -132,6 +168,7 @@ declare class LastRecallStore {
         budgetsApplied?: LastRecallBudgetSummary;
         latencyMs?: number;
         resultPaths?: string[];
+        resultNamespaces?: Array<string | undefined>;
         policyVersion?: string;
         appendImpression?: boolean;
         identityInjection?: {
@@ -153,6 +190,130 @@ declare class LastRecallStore {
          */
         backendDegradations?: SearchDegradation[];
     }): Promise<void>;
+    /**
+     * Drain pending spills, rotate (best-effort, sized to the projected payload),
+     * then append one impression line under ONE shared cross-process lock (#1910,
+     * #2033). Both the archive-shift renames AND the append run inside the same
+     * held lock so a peer process holding the lock can never rename the active
+     * inode to `.1` between our open and write — which would land the impression in
+     * a rotated archive that offline-sync excludes, silently dropping it from
+     * active-state/sync consumers.
+     *
+     * On lock-acquisition timeout the impression is NEVER written to the active
+     * file unlocked (#2033): a peer holding the lock is likely mid-rotation, so an
+     * unlocked append can land in the inode it is about to rename to `.1` — the
+     * exact silent-drop this lock prevents. Instead the row is spilled to a
+     * durable node-local per-event file under `<impressions>.pending.d/` and
+     * folded back into the active file by the next append that DOES hold the lock,
+     * preserving durability without racing rotation. Rotation failure under the
+     * held lock is logged and the append still runs. Callers invoke this only
+     * through `impressionsWriteChain` so the sequence is serialized in-process.
+     */
+    private get impressionsPendingDir();
+    private spillImpression;
+    /**
+     * Recover a claim a crashed drain left mid-flight (#2033): the crash-safe
+     * drain renames `<uuid>.jsonl` -> `<uuid>.jsonl.claimed` BEFORE committing, so
+     * a `.claimed` file with no matching commit is the ONLY durable copy of those
+     * rows. Rename each orphan back to `<uuid>.jsonl` so it re-enters the normal
+     * collect+claim+commit flow. MUST run under the held rotation lock, before
+     * collecting. listContainedSpillFiles skips symlinked/escaping entries.
+     */
+    private recoverOrphanedImpressionClaims;
+    /**
+     * Recover a crash-orphaned spill temp after its write completed but before
+     * the atomic `.tmp` → `.jsonl` rename. Valid JSONL temps are promoted back
+     * into the normal queue; incomplete temps remain pending and keep offline sync
+     * deferred rather than being discarded.
+     */
+    private recoverOrphanedImpressionTemps;
+    private appendImpressionSerialized;
+    /**
+     * Fold any durable pending recall-impression spills into the synced active
+     * `recall_impressions.jsonl` WITHOUT recording a new impression (#2033).
+     *
+     * The pending spill dir is offline-sync-excluded, so an impression that a
+     * lock-timed-out `record()` spilled there is absent from an offline-sync
+     * snapshot and lost if this node is discarded before the next `record()`
+     * folds it back. Offline sync calls this before building a snapshot so a
+     * recorded impression always reaches the remote. Fast no-op — no lock and no
+     * dir/lock-file creation — when nothing is pending.
+     *
+     * Returns a {@link DrainPendingImpressionsResult}: `folded` is true when rows
+     * were folded into the active file; `pendingDeferred` is true when durable
+     * spills still remain in the offline-sync-EXCLUDED queue after this call —
+     * because the rotation lock could not be acquired, a spill could not be
+     * claimed, or the drain-only fold deferred rows that would only fit by
+     * rotating into a sync-excluded archive (#2033). A snapshot taken while
+     * `pendingDeferred` is true would silently drop those rows, so the caller MUST
+     * NOT report a clean snapshot — it either retries or aborts.
+     */
+    drainPendingImpressions(): Promise<DrainPendingImpressionsResult>;
+    /**
+     * Claim/commit fold of durable pending impression spills into the active file
+     * under the held rotation lock (#2033). `line` is a new impression to append
+     * after the drained rows, or null for a drain-only pre-sync fold.
+     *
+     * Each spill is folded as an INDEPENDENT claim -> append -> finalize unit
+     * rather than materializing the whole queue as one joined payload and
+     * splitting it in a single synchronous pass (#2033). A multi-hundred-MB drain
+     * done as one join/split blocks the event loop long enough for
+     * `withHeldFileLock`'s ownership-refresh timer to miss its window, so a peer
+     * stale-breaks the 30s lock and rotates/appends concurrently — defeating the
+     * rotation lock this drain relies on. The per-file `await`s keep the payload
+     * bounded to one spill at a time and let the refresh timer fire between files.
+     *
+     * The DRAIN-ONLY path (`line === null`, run before an offline-sync snapshot)
+     * NEVER rotates a drained row into an archive. `recall_impressions.jsonl.*`
+     * is offline-sync-EXCLUDED, so rotating a just-drained row into `.1`/`.2` and
+     * then deleting its spill would leave that row only in a path sync omits —
+     * silently lost when the node is discarded after a "successful" sync (#2033).
+     * It folds only the rows that fit the synced active file under the cap and
+     * leaves the rest durable in the pending queue; {@link drainPendingImpressions}
+     * then reports the drain DEFERRED so the caller retries or aborts. The
+     * record() path (`line !== null`) keeps rotating normally — its archives stay
+     * on a live node that is not being discarded.
+     *
+     * Recovers any crash-orphaned claim first. Each impression carries a unique
+     * writeNonce, so a crash-recovered re-commit is a collapsible duplicate, never
+     * a lost row. listContainedSpillFiles rejects symlinked/escaping entries; a
+     * spill that cannot be claimed is skipped this pass. An append failure rolls
+     * that spill's claim back so the row retries on the next lock holder's drain.
+     * Returns true when the active file was written. MUST run under the held
+     * rotation lock.
+     */
+    private foldPendingImpressionsAndAppend;
+    /**
+     * Append one whole JSONL unit (a claimed spill's rows or a fresh impression
+     * line) to the active impressions file, returning the resulting active-file
+     * byte size. On the rotating (record) path, when the unit would push the
+     * current active generation to/over `impressionsRotateBytes`, the full active
+     * file is rotated aside FIRST so no generation exceeds the cap (#2033); a lone
+     * unit larger than the cap on an empty active file is written whole because
+     * splitting a JSONL row would corrupt it. `drainOnly` and disabled rotation
+     * (`impressionsRotateBytes <= 0`) both skip rotation — drain-only defers its
+     * overflow in {@link foldPendingImpressionsAndAppend} rather than rotating into
+     * a sync-excluded archive. A rotation error is logged and the append still
+     * runs so a row is never lost; an append failure propagates so the caller
+     * rolls its claim back. MUST run under the held rotation lock.
+     */
+    private appendImpressionUnit;
+    /**
+     * True when any live `<uuid>.jsonl` spill, crash-orphaned `.claimed` file,
+     * or crash-orphaned `.jsonl.tmp` spill remains in the offline-sync-EXCLUDED
+     * pending queue (#2033). After a drain acquires the rotation lock, a spill
+     * the fold could not claim (rename race / read-only dir) or a `.claimed`
+     * orphan a failed commit left behind means durable rows are STILL excluded
+     * from a snapshot — the drain must report itself INCOMPLETE so the caller
+     * retries or aborts rather than snapshotting an active file that omits them.
+     */
+    private pendingSpillsRemain;
+    /**
+     * Shift `.1..N` archives down one slot and move the active file to `.1`,
+     * dropping anything beyond `keep`. Callers invoke this only while holding the
+     * cross-process rotation lock (issue #1910).
+     */
+    private shiftImpressionArchives;
     /**
      * Attach a RecallTierExplain block to the existing snapshot for a
      * session without rewriting the entire snapshot.  Used by the
@@ -218,4 +379,4 @@ declare class RecallHandleHistoryStore {
     private flush;
 }
 
-export { type GraphRecallExpandedEntry, type LastRecallBudgetSummary, type LastRecallSnapshot, LastRecallStore, RecallHandleHistoryStore, type TierMigrationCycleSummary, type TierMigrationStatusSnapshot, TierMigrationStatusStore, clampGraphRecallExpandedEntries };
+export { type DrainPendingImpressionsResult, type GraphRecallExpandedEntry, type LastRecallBudgetSummary, type LastRecallSnapshot, LastRecallStore, RecallHandleHistoryStore, type TierMigrationCycleSummary, type TierMigrationStatusSnapshot, TierMigrationStatusStore, clampGraphRecallExpandedEntries };

package/dist/recall-state.js

@@ -3,9 +3,12 @@ import {
   RecallHandleHistoryStore,
   TierMigrationStatusStore,
   clampGraphRecallExpandedEntries
-} from "./chunk-E5BK6CGV.js";
-import "./chunk-SFQ6QNL7.js";
-import "./chunk-37CTGERM.js";
+} from "./chunk-FMLKOL2Z.js";
+import "./chunk-R6YJI3HE.js";
+import "./chunk-GCASGYIO.js";
+import "./chunk-WL5EBRDH.js";
+import "./chunk-5UZXUTVO.js";
+import "./chunk-3WCASNQZ.js";
 import "./chunk-PZ5AY32C.js";
 export {
   LastRecallStore,

package/dist/recall-tag-filter.d.ts

@@ -1,7 +1,9 @@
 import { RecallFilterTrace } from './recall-xray.js';
 import './memory-provenance.js';
-import './types-Cg8q7W7_.js';
+import './types-D_fG2ix8.js';
 import './message-parts/index.js';
+import './bounded-jsonl-state.js';
+import './types-continuity.js';
 import './user-model.js';
 
 type TagMatchMode = "any" | "all";

package/dist/recall-timings.d.ts

@@ -1,5 +1,7 @@
-import { P as PluginConfig } from './types-Cg8q7W7_.js';
+import { P as PluginConfig } from './types-D_fG2ix8.js';
 import './message-parts/index.js';
+import './bounded-jsonl-state.js';
+import './types-continuity.js';
 
 interface RecallTimingRecord {
     readonly timestamp: string;
@@ -16,10 +18,17 @@ interface RecallTimingStatus {
     readonly order: "newest-first";
     readonly records: RecallTimingRecord[];
 }
+/**
+ * Build the recall `timings` map, seeding the additive queue-wait phase (issue
+ * #1906) when the caller measured a real per-principal slot / single-flight
+ * wait. `queueWaitMs` 0/undefined/non-finite omits the phase so recall-timings
+ * stays byte-identical to the uncontended pre-#1906 path.
+ */
+declare function foldQueueWaitTiming(queueWaitMs?: number): Record<string, string>;
 declare function recordRecallTiming(config: PluginConfig, input: Record<string, unknown>): void;
 declare function resolveRecallTimingsOperatorPrincipal(config: PluginConfig, transportPrincipal?: string): string | undefined;
 declare function isRecallTimingsOperator(config: PluginConfig, authenticatedPrincipal?: string, transportPrincipal?: string): boolean;
 declare function getRecallTimings(config: PluginConfig): RecallTimingRecord[];
 declare function getRecallTimingStatus(config: PluginConfig): RecallTimingStatus;
 
-export { type RecallTimingRecord, type RecallTimingStatus, getRecallTimingStatus, getRecallTimings, isRecallTimingsOperator, recordRecallTiming, resolveRecallTimingsOperatorPrincipal };
+export { type RecallTimingRecord, type RecallTimingStatus, foldQueueWaitTiming, getRecallTimingStatus, getRecallTimings, isRecallTimingsOperator, recordRecallTiming, resolveRecallTimingsOperatorPrincipal };

package/dist/recall-timings.js

@@ -1,12 +1,14 @@
 import {
+  foldQueueWaitTiming,
   getRecallTimingStatus,
   getRecallTimings,
   isRecallTimingsOperator,
   recordRecallTiming,
   resolveRecallTimingsOperatorPrincipal
-} from "./chunk-FTYDWKO6.js";
+} from "./chunk-CEN6DW6X.js";
 import "./chunk-PZ5AY32C.js";
 export {
+  foldQueueWaitTiming,
   getRecallTimingStatus,
   getRecallTimings,
   isRecallTimingsOperator,

package/dist/recall-xray-cli.d.ts

@@ -1,9 +1,11 @@
 import { RecallXrayFormat } from './recall-xray-renderer.js';
-import { R as RecallDisclosure } from './types-Cg8q7W7_.js';
+import { b as RecallDisclosure } from './types-D_fG2ix8.js';
 import './recall-xray.js';
 import './memory-provenance.js';
 import './user-model.js';
 import './message-parts/index.js';
+import './bounded-jsonl-state.js';
+import './types-continuity.js';
 
 /**
  * Input-validation helpers for the `remnic xray` CLI command (issue

package/dist/recall-xray-cli.js

@@ -2,11 +2,11 @@ import {
   parseXrayBudgetFlag,
   parseXrayCliOptions,
   parseXrayDisclosureFlag
-} from "./chunk-HDTQVNWD.js";
-import "./chunk-EHCONI6E.js";
+} from "./chunk-3QAH2S33.js";
+import "./chunk-CQMEM5CC.js";
 import "./chunk-SOBJ6NEY.js";
-import "./chunk-DPAENM7O.js";
-import "./chunk-PBSAPHHA.js";
+import "./chunk-U3ZAVRP3.js";
+import "./chunk-YVKF3HEW.js";
 import "./chunk-I4WBNM3M.js";
 import "./chunk-SOAU2OE2.js";
 import "./chunk-PZ5AY32C.js";

package/dist/recall-xray-renderer.d.ts

@@ -1,7 +1,9 @@
 import { RecallXraySnapshot } from './recall-xray.js';
 import './memory-provenance.js';
-import './types-Cg8q7W7_.js';
+import './types-D_fG2ix8.js';
 import './message-parts/index.js';
+import './bounded-jsonl-state.js';
+import './types-continuity.js';
 import './user-model.js';
 
 /**

package/dist/recall-xray-renderer.js

@@ -5,10 +5,10 @@ import {
   renderXrayJson,
   renderXrayMarkdown,
   renderXrayText
-} from "./chunk-EHCONI6E.js";
+} from "./chunk-CQMEM5CC.js";
 import "./chunk-SOBJ6NEY.js";
-import "./chunk-DPAENM7O.js";
-import "./chunk-PBSAPHHA.js";
+import "./chunk-U3ZAVRP3.js";
+import "./chunk-YVKF3HEW.js";
 import "./chunk-I4WBNM3M.js";
 import "./chunk-SOAU2OE2.js";
 import "./chunk-PZ5AY32C.js";

package/dist/recall-xray.d.ts

@@ -1,7 +1,9 @@
 import { RetrievedMemoryProvenance } from './memory-provenance.js';
-import { s as RecallTierExplain, R as RecallDisclosure } from './types-Cg8q7W7_.js';
+import { g as RecallTierExplain, b as RecallDisclosure } from './types-D_fG2ix8.js';
 import './user-model.js';
 import './message-parts/index.js';
+import './bounded-jsonl-state.js';
+import './types-continuity.js';
 
 /**
  * Recall X-ray snapshot schema (issue #570, PR 1).

package/dist/recall-xray.js

@@ -5,8 +5,8 @@ import {
   estimateRecallTokens,
   isRecallXrayServedBy,
   summarizeDisclosureTokens
-} from "./chunk-DPAENM7O.js";
-import "./chunk-PBSAPHHA.js";
+} from "./chunk-U3ZAVRP3.js";
+import "./chunk-YVKF3HEW.js";
 import "./chunk-I4WBNM3M.js";
 import "./chunk-SOAU2OE2.js";
 import "./chunk-PZ5AY32C.js";

package/dist/relevance.js

@@ -1,8 +1,8 @@
 import {
   RelevanceStore
-} from "./chunk-2IZAGAJR.js";
-import "./chunk-SFQ6QNL7.js";
-import "./chunk-37CTGERM.js";
+} from "./chunk-LULR4IUW.js";
+import "./chunk-R6YJI3HE.js";
+import "./chunk-3WCASNQZ.js";
 import "./chunk-PZ5AY32C.js";
 export {
   RelevanceStore

package/dist/replay/normalizers/chatgpt.d.ts

@@ -1,6 +1,8 @@
 import { ReplayNormalizer } from '../types.js';
 import '../../message-parts/index.js';
-import '../../types-Cg8q7W7_.js';
+import '../../types-D_fG2ix8.js';
+import '../../bounded-jsonl-state.js';
+import '../../types-continuity.js';
 
 declare const chatgptReplayNormalizer: ReplayNormalizer;
 

package/dist/replay/normalizers/claude.d.ts

@@ -1,6 +1,8 @@
 import { ReplayNormalizer } from '../types.js';
 import '../../message-parts/index.js';
-import '../../types-Cg8q7W7_.js';
+import '../../types-D_fG2ix8.js';
+import '../../bounded-jsonl-state.js';
+import '../../types-continuity.js';
 
 declare const claudeReplayNormalizer: ReplayNormalizer;
 

package/dist/replay/normalizers/openclaw.d.ts

@@ -1,6 +1,8 @@
 import { ReplayNormalizer } from '../types.js';
 import '../../message-parts/index.js';
-import '../../types-Cg8q7W7_.js';
+import '../../types-D_fG2ix8.js';
+import '../../bounded-jsonl-state.js';
+import '../../types-continuity.js';
 
 declare const openclawReplayNormalizer: ReplayNormalizer;
 

package/dist/replay/normalizers/shared.d.ts

@@ -1,6 +1,8 @@
 import { ReplayRole } from '../types.js';
 import '../../message-parts/index.js';
-import '../../types-Cg8q7W7_.js';
+import '../../types-D_fG2ix8.js';
+import '../../bounded-jsonl-state.js';
+import '../../types-continuity.js';
 
 type NormalizeRoleOptions = {
     assistantAliases?: string[];

package/dist/replay/runner.d.ts

@@ -1,6 +1,8 @@
 import { ReplaySource, ReplayWarning, ReplayNormalizer, ReplayTurn, ReplayParseOptions } from './types.js';
 import '../message-parts/index.js';
-import '../types-Cg8q7W7_.js';
+import '../types-D_fG2ix8.js';
+import '../bounded-jsonl-state.js';
+import '../types-continuity.js';
 
 interface ReplayRunOptions extends ReplayParseOptions {
     dryRun?: boolean;

package/dist/replay/types.d.ts

@@ -1,5 +1,7 @@
 import { LcmMessagePartInput, MessagePartSourceFormat } from '../message-parts/index.js';
-import { t as SourceConnectorProvenance } from '../types-Cg8q7W7_.js';
+import { r as SourceConnectorProvenance } from '../types-D_fG2ix8.js';
+import '../bounded-jsonl-state.js';
+import '../types-continuity.js';
 
 type ReplaySource = "openclaw" | "claude" | "chatgpt";
 type ReplayRole = "user" | "assistant";

package/dist/rerank.d.ts

@@ -53,5 +53,12 @@ declare function rerankLocalOrNoop(opts: {
     cacheEnabled: boolean;
     cacheTtlMs: number;
 }): Promise<string[] | null>;
+/**
+ * Reorder `results` to match `rankedKeys` (a ranker's output order), keying by
+ * `keyOf`. Items not present in `rankedKeys` are appended in their original
+ * order. `keyOf` must return a stable identity (e.g. namespace-qualified) so
+ * same-relative-path items across namespaces are not conflated.
+ */
+declare function reorderByRankedKeys<T>(results: readonly T[], rankedKeys: readonly string[], keyOf: (item: T) => string): T[];
 
-export { RerankCache, type RerankCacheEntry, type RerankCandidate, type RerankScore, parseRerankResponse, rerankLocalOrNoop };
+export { RerankCache, type RerankCacheEntry, type RerankCandidate, type RerankScore, parseRerankResponse, reorderByRankedKeys, rerankLocalOrNoop };

package/dist/rerank.js

@@ -1,12 +1,14 @@
 import {
   RerankCache,
   parseRerankResponse,
+  reorderByRankedKeys,
   rerankLocalOrNoop
-} from "./chunk-E3VODCC3.js";
+} from "./chunk-LUDXM7MD.js";
 import "./chunk-PZ5AY32C.js";
 export {
   RerankCache,
   parseRerankResponse,
+  reorderByRankedKeys,
   rerankLocalOrNoop
 };
 //# sourceMappingURL=rerank.js.map

package/dist/resolution-3K27T4VO.js

@@ -0,0 +1,18 @@
+import {
+  executeResolution,
+  isValidResolutionVerb
+} from "./chunk-WG5HSQ4P.js";
+import "./chunk-35NN3ZFA.js";
+import "./chunk-CGASUJVP.js";
+import "./chunk-R3DJVOSM.js";
+import "./chunk-BT7NVCML.js";
+import "./chunk-5GKPFL3S.js";
+import "./chunk-JAKIDQB2.js";
+import "./chunk-P7FMDTKL.js";
+import "./chunk-3WCASNQZ.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  executeResolution,
+  isValidResolutionVerb
+};
+//# sourceMappingURL=resolution-3K27T4VO.js.map

package/dist/resolution-3K27T4VO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/resolve-auth-token.d.ts

@@ -1,5 +1,7 @@
-import { a2 as SecretRef, a3 as AgentAccessAuthToken } from './types-Cg8q7W7_.js';
+import { a5 as SecretRef, a6 as AgentAccessAuthToken } from './types-D_fG2ix8.js';
 import './message-parts/index.js';
+import './bounded-jsonl-state.js';
+import './types-continuity.js';
 
 /**
  * Resolve `agentAccessHttp.authToken` (issue #757).

package/dist/resolve-provider-secret.js

@@ -4,9 +4,9 @@ import {
   clearSecretCache,
   getGatewayRuntimeAuthForModel,
   resolveProviderApiKey
-} from "./chunk-K2ZLHESQ.js";
+} from "./chunk-QIEUU4UK.js";
 import "./chunk-JUC24CTX.js";
-import "./chunk-37CTGERM.js";
+import "./chunk-3WCASNQZ.js";
 import "./chunk-PZ5AY32C.js";
 export {
   __setGatewayResolverForTest,

package/dist/resume-bundles.js

@@ -4,40 +4,45 @@ import {
   recordResumeBundle,
   resolveResumeBundleDir,
   validateResumeBundle
-} from "./chunk-FDCTQWLW.js";
+} from "./chunk-6O22TZSB.js";
 import "./chunk-ZRWB5D4H.js";
-import "./chunk-5EZXHU36.js";
+import "./chunk-HYQJQGD3.js";
 import "./chunk-KFY3SGN7.js";
 import "./chunk-LMDRGRJ2.js";
-import "./chunk-INELTPRG.js";
+import "./chunk-EEC7UJPX.js";
 import "./chunk-NDAH7BJ5.js";
 import "./chunk-Z5LAYHGJ.js";
-import "./chunk-G6NKALRN.js";
+import "./chunk-6ZMAMSHS.js";
+import "./chunk-H4WG3UQZ.js";
 import "./chunk-OO42R444.js";
 import "./chunk-K6MV3TRQ.js";
+import "./chunk-PIG4WJFQ.js";
+import "./chunk-KFZY2OFH.js";
 import "./chunk-S4DDLTPX.js";
-import "./chunk-FF4KLI5W.js";
 import "./chunk-6HMYUWXR.js";
-import "./chunk-ZBJMUXZH.js";
+import "./chunk-FF4KLI5W.js";
 import "./chunk-P32IDSHD.js";
-import "./chunk-OEHCMALU.js";
-import "./chunk-PHK3HARR.js";
-import "./chunk-4DJQYKMN.js";
+import "./chunk-5I4M26Q7.js";
 import "./chunk-5GKPFL3S.js";
+import "./chunk-4DJQYKMN.js";
+import "./chunk-PQVCH2AE.js";
 import "./chunk-EYIEWJNI.js";
 import "./chunk-JUC24CTX.js";
-import "./chunk-37CTGERM.js";
-import "./chunk-X64YLC24.js";
+import "./chunk-6MKAMLQL.js";
+import "./chunk-JAKIDQB2.js";
+import "./chunk-ZBJMUXZH.js";
+import "./chunk-72VAXGEI.js";
 import "./chunk-UI3NYK34.js";
 import "./chunk-GCGJW34D.js";
-import "./chunk-J2HSAU72.js";
+import "./chunk-AREGMX2J.js";
+import "./chunk-AIK5W3IW.js";
 import "./chunk-A6XUJE5D.js";
+import "./chunk-5UZXUTVO.js";
 import "./chunk-P7FMDTKL.js";
 import "./chunk-VS2IYZRU.js";
-import "./chunk-6MKAMLQL.js";
-import "./chunk-JAKIDQB2.js";
 import "./chunk-A2IYSXDQ.js";
 import "./chunk-LPSF4OQH.js";
+import "./chunk-3WCASNQZ.js";
 import "./chunk-PZ5AY32C.js";
 export {
   buildResumeBundleFromState,