npm - @yeaft/webchat-agent - Versions diffs - 1.0.379 → 1.0.381 - Mend

@yeaft/webchat-agent 1.0.379 → 1.0.381

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/connection/message-router.js +3 -3
package/local-runtime/version.json +1 -1
package/local-runtime/web/app.bundle.js +4 -3
package/local-runtime/web/app.bundle.js.gz +0 -0
package/local-runtime/web/index.html +1 -1
package/package.json +1 -1
package/yeaft/engine.js +104 -39
package/yeaft/llm/adapter.js +15 -0
package/yeaft/llm/router.js +83 -24
package/yeaft/llm/usage-accounting.js +28 -2
package/yeaft/sessions/session-config.js +0 -2
package/yeaft/web-bridge.js +54 -21
package/yeaft/work-center/runner.js +51 -3
package/yeaft/work-center/store.js +3 -1

package/local-runtime/web/app.bundle.js.gz CHANGED Viewed

Binary file

package/local-runtime/web/index.html CHANGED Viewed

@@ -16,6 +16,6 @@
 </head>
 <body>
   <div id="app"></div>
-  <script type="module" src="app.bundle.js?v=334e9e23"></script>
+  <script type="module" src="app.bundle.js?v=22a8b637"></script>
 </body>
 </html>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.379",
+  "version": "1.0.381",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/engine.js CHANGED Viewed

@@ -2073,7 +2073,8 @@ export class Engine {
     // openai-responses.js:#translateUserContent).
     // task-327b: `/max` / `/high` / `/medium` / `/low` prefix override.
-    // Explicit caller-supplied userEffort wins over the prefix.
+    // Explicit caller-supplied userEffort wins over the prefix. Session config
+    // is deliberately excluded here because it may refresh between loops.
     // task-327c nit: defensively normalize caller-supplied userEffort BEFORE
     // the merge, so an invalid caller value (e.g. 'ULTRA') does not shadow a
     // valid prompt prefix.
@@ -2083,8 +2084,10 @@ export class Engine {
     const effectivePromptParts = parsedSkill.skillName
       ? stripLeadingSkillCommandFromPromptParts(promptParts, this.#skillManager)
       : promptParts;
-    const configuredEffort = normalizeEffort(this.#config?.modelEffort);
-    const effectiveUserEffort = normalizeEffort(userEffort) || parsed.effort || configuredEffort || null;
+    // Only actual caller input and a prompt prefix are per-query overrides.
+    // Session-configured effort belongs to the live config and is resolved at
+    // each provider-request boundary, just like the live model snapshot.
+    const explicitUserEffort = normalizeEffort(userEffort) || parsed.effort || null;
     const effectiveCollabToolPolicy = collabToolPolicy === COLLAB_TOOL_POLICY.SINGLE_VP || collabToolPolicy === COLLAB_TOOL_POLICY.MULTI_VP
       ? collabToolPolicy
       : null;
@@ -2131,7 +2134,7 @@ export class Engine {
     };
     try {
       this.#currentThreadId = threadId || MAIN_THREAD_ID;
-      yield* this.#runQuery({ prompt: effectivePrompt, promptParts: effectivePromptParts, messages, signal: runSignal, userEffort: effectiveUserEffort, scenario, vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, sessionMembers, projectSessionIds, projectInstruction, projectLabel, vpPlan, sessionAnnouncement, workCenterInstructions, workDir, userAlreadyPersisted, getCurrentTodos, setCurrentTodos, askUser, threadId: this.#currentThreadId, vpTurnId, drainPendingUserMessages, prepareProviderRequest, startProviderRequest, finishProviderRequest, failProviderRequest, closePendingUserInput, collabToolPolicy: effectiveCollabToolPolicy, explicitSkillName: parsedSkill.skillName, retryLifecycle });
+      yield* this.#runQuery({ prompt: effectivePrompt, promptParts: effectivePromptParts, messages, signal: runSignal, userEffort: explicitUserEffort, scenario, vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, sessionMembers, projectSessionIds, projectInstruction, projectLabel, vpPlan, sessionAnnouncement, workCenterInstructions, workDir, userAlreadyPersisted, getCurrentTodos, setCurrentTodos, askUser, threadId: this.#currentThreadId, vpTurnId, drainPendingUserMessages, prepareProviderRequest, startProviderRequest, finishProviderRequest, failProviderRequest, closePendingUserInput, collabToolPolicy: effectiveCollabToolPolicy, explicitSkillName: parsedSkill.skillName, retryLifecycle });
     } finally {
       // Closing the async generator at a visible retry boundary means the
       // continuation never reached a provider. Keep it out of history and
@@ -2697,7 +2700,11 @@ export class Engine {
     let displayImageAnchorMessage = null;
     let lastPersistedAssistantMessage = null;
     let lastPersistedAssistantTextMessage = null;
+    // `refreshConfig()` may publish a new Session model while a stream or a
+    // tool is running. Apply it only before the next provider request; the
+    // current request keeps the snapshot captured below.
     let currentModel = this.#config.model;
+    let primaryModelAtLastBoundary = currentModel;
     let cumulativeInputTokens = 0;
     let cumulativeOutputTokens = 0;
     let activeProviderRequest = null;
@@ -2722,13 +2729,39 @@ export class Engine {
     // gives up: we either fall back to a backup model or surface the
     // error to the user. LLMContextError has its own compact-retry path
     // and does NOT count against this budget.
-    const retryPolicy = resolveRetryPolicy(this.#config);
+    let retryPolicy = resolveRetryPolicy(this.#config);
     let consecutiveRetryableErrors = 0;
     let consecutiveForbiddenErrors = 0;
     while (true) {
       turnNumber++;
+      // `refreshConfig()` is called by the bridge after a persisted Session or
+      // Agent config update. This is the only point a running query adopts the
+      // new primary model, so an in-flight provider stream is never switched.
+      // Keep a retry fallback selected by this query; replacing it here would
+      // turn an exhausted primary into an endless retry loop.
+      if (currentModel === primaryModelAtLastBoundary) {
+        const refreshedPrimaryModel = this.#config.model;
+        if (refreshedPrimaryModel !== primaryModelAtLastBoundary) {
+          currentModel = refreshedPrimaryModel;
+          primaryModelAtLastBoundary = refreshedPrimaryModel;
+        }
+      }
+      // Take one immutable runtime snapshot before any request-specific work.
+      // A Session save racing preflight must be picked up by the next loop, not
+      // this request. Fallback retries intentionally retain their selected
+      // model, but still use the current policy and configured effort.
+      const requestConfig = { ...this.#config };
+      // Capture the matching provider catalog in the same synchronous boundary
+      // as config/model. Preflight may yield user/task events before the stream
+      // is built, but one request must never mix two refresh revisions.
+      const requestAdapter = typeof this.#adapter.captureRequest === 'function'
+        ? this.#adapter.captureRequest()
+        : this.#adapter;
+      retryPolicy = resolveRetryPolicy(requestConfig);
       // task-324: no hard MAX_TURNS cap. Loop terminates on end_turn,
       // non-retryable error, LLMContextError (after compact retry), or
       // caller abort. Keeping this comment so the removal is traceable.
@@ -2825,9 +2858,7 @@ export class Engine {
       // actually about to call. Single resolver in models.js owns the
       // fallback ladder (registry → config → default) so engine.js and
       // tools/registry.js can never disagree.
-      const currentContextWindow = resolveContextWindow(currentModel, this.#config);
-      yield { type: 'turn_start', turnNumber, threadId };
+      const currentContextWindow = resolveContextWindow(currentModel, requestConfig);
       const appendedBeforeStream = this.#drainPendingUserMessages(drainPendingUserMessages);
       if (appendedBeforeStream.length > 0) {
@@ -2887,9 +2918,12 @@ export class Engine {
       systemPrompt = buildCurrentSystemPrompt();
       try {
-        // task-327b: resolve effort per-turn so the long-loop auto-bump
-        // kicks in once toolLoopTurns crosses the threshold.
-        let resolvedEffort = pickEffort({ scenario, toolLoopTurns, userEffort });
+        // Resolve effort per provider request so a saved Session effort takes
+        // effect at the next loop. A caller override or `/effort` prefix stays
+        // fixed for this query and still wins over live Session config.
+        const configuredEffort = normalizeEffort(requestConfig.modelEffort);
+        const requestUserEffort = userEffort || configuredEffort || null;
+        let resolvedEffort = pickEffort({ scenario, toolLoopTurns, userEffort: requestUserEffort });
         // DESIGN.md §9.16: thinking-mode precedence chain. When a VP
         // persona is active, the router/continuity bookkeeping has more
@@ -2911,7 +2945,7 @@ export class Engine {
             ? vpPlan.thinking
             : null;
           const resolved = resolveThinking({
-            uiOverride: (userEffort === 'max' || userEffort === 'high') ? userEffort : null,
+            uiOverride: (requestUserEffort === 'max' || requestUserEffort === 'high') ? requestUserEffort : null,
             routerPlan: liveRouterThinking,
             priorPlan: priorPlan && priorPlan.thinking ? priorPlan.thinking : null,
             vpDefault: typeof vpPersona.thinking === 'string' ? vpPersona.thinking : null,
@@ -3006,47 +3040,78 @@ export class Engine {
           }
         }
-        // Do not durably publish a model-only continuation until every
-        // pre-request await is complete and the fresh provider request is about
-        // to start. Stop at the visible loop boundary must leave no
-        // continuation that the provider never received.
-        if (signal?.aborted) throw new LLMAbortError();
-        if (pendingContinuationForRequest
-            && retryLifecycle.pendingContinuation === pendingContinuationForRequest) {
-          this.#persistConversationMessage(pendingContinuationForRequest, { sessionId: runtimeSessionId });
+        // Capture only the provider route before the visible boundary. The
+        // returned async iterable must not make a request or write durable
+        // state; both the retry continuation and Work Center EngineTurn remain
+        // uncommitted until the consumer resumes this `turn_start`.
+        //
+        // Engine configuration and AdapterRouter catalog were captured together
+        // at the loop boundary above. Building the stream here and refreshing
+        // while `turn_start` is visible cannot alter this request revision.
+        const hasCaptureStream = typeof requestAdapter.captureStream === 'function';
+        const captureStream = hasCaptureStream
+          ? requestAdapter.captureStream.bind(requestAdapter)
+          : requestAdapter.stream.bind(requestAdapter);
+        let continuationCommitted = false;
+        const commitRetryContinuation = () => {
+          if (continuationCommitted
+              || !pendingContinuationForRequest
+              || retryLifecycle.pendingContinuation !== pendingContinuationForRequest) return;
+          const persisted = this.#persistConversationMessage(pendingContinuationForRequest, {
+            sessionId: runtimeSessionId,
+          });
+          if (persisted) pendingContinuationForRequest._persistedMessageId = persisted.id;
           conversationMessages.push(pendingContinuationForRequest);
           retryLifecycle.pendingContinuation = null;
-        }
-        activeProviderRequest = typeof prepareProviderRequest === 'function'
-          ? prepareProviderRequest({
+          continuationCommitted = true;
+        };
+        const commitDispatch = () => {
+          if (!activeProviderRequest && typeof prepareProviderRequest === 'function') {
+            activeProviderRequest = prepareProviderRequest({
               turnNumber,
               entries: appendedBeforeStream,
               system: systemPrompt,
               messages: wireMessages.map(mapDebugMessage),
               model: currentModel,
-            }) || null
-          : null;
-        // Snapshot task results carried by this exact request. Request start
-        // is not delivery: fetch may remain pending and then be aborted before
-        // the provider processes anything. Ack only after a normal stream end
-        // that included the provider's terminal stop event.
-        const requestAsyncTaskIds = Array.from(this.#pendingAsyncTaskConfirmIds);
-        let sawProviderStop = false;
-        for await (const event of this.#adapter.stream({
+            }) || null;
+          }
+          startProviderRequest?.(activeProviderRequest);
+          commitRetryContinuation();
+        };
+        const providerStream = captureStream({
           model: currentModel,
           system: systemPrompt,
           messages: wireMessages,
           tools: toolDefs.length > 0 ? toolDefs : undefined,
-          maxTokens: this.#config.maxOutputTokens || 16384,
+          maxTokens: requestConfig.maxOutputTokens || 16384,
           effort: resolvedEffort,
-          effortSource: userEffort ? 'user' : 'auto',
+          effortSource: requestUserEffort ? 'user' : 'auto',
           signal,
           onRawExchange: captureRawExchange,
           rawExchangeMaxBytes,
-          onRequestStart: () => startProviderRequest?.(activeProviderRequest),
-        })) {
+          onRequestStart: () => {
+            // Native adapters invoke this immediately before fetch(). A retry
+            // continuation and Work Center EngineTurn become durable only when
+            // their request crosses dispatch, never when turn_start is shown.
+            commitDispatch();
+          },
+        });
+        yield { type: 'turn_start', turnNumber, threadId };
+        // Provider iteration begins after the visible boundary. Native adapters
+        // commit in onRequestStart immediately before fetch. A plain legacy
+        // adapter only enters its generator at iteration, so preserve its old
+        // dispatch semantics while keeping captured Router requests inert.
+        if (signal?.aborted) throw new LLMAbortError();
+        if (!hasCaptureStream) commitDispatch();
+        // Snapshot task results carried by this exact request. Request start
+        // is not delivery: fetch may remain pending and then be aborted before
+        // the provider processes anything. Ack only after a normal stream end
+        // that included the provider's terminal stop event.
+        const requestAsyncTaskIds = Array.from(this.#pendingAsyncTaskConfirmIds);
+        let sawProviderStop = false;
+        for await (const event of providerStream) {
           // task-325a (abort-stop fix): per-event abort short-circuit.
           // The adapter is expected to throw AbortError when fetch's
           // signal fires, but in practice undici/HTTP-2/proxy layers
@@ -3398,7 +3463,7 @@ export class Engine {
           }
         }
-        const earlyFallbackModel = this.#config.fallbackModel;
+        const earlyFallbackModel = requestConfig.fallbackModel;
         if (earlyFallbackModel && earlyFallbackModel !== currentModel
           && (earlyIsRateLimit || earlyIsTransient) && canReplayProviderRequest) {
           endAttemptTrace('fallback_retry');

package/yeaft/llm/adapter.js CHANGED Viewed

@@ -609,6 +609,21 @@ export class LLMAdapter {
     throw new Error('stream() must be implemented by subclass');
   }
+  /**
+   * Capture a stream request before a caller crosses an async boundary.
+   *
+   * Implementations with mutable runtime routing should override this to freeze
+   * their dispatch table at capture time. The base implementation retains
+   * compatibility with legacy adapters by calling stream() without advancing
+   * its async iterator.
+   *
+   * @param {object} params
+   * @returns {AsyncGenerator<StreamEvent>}
+   */
+  captureStream(params) {
+    return this.stream(params);
+  }
   /**
    * Make a single model call without tools (for side queries like summarization).
    *

package/yeaft/llm/router.js CHANGED Viewed

@@ -301,6 +301,22 @@ export class AdapterRouter extends LLMAdapter {
     }
   }
+  /**
+   * Capture the current routing table for one request before it reaches an
+   * async boundary. A later config save may replace the live catalog, but an
+   * already-created stream must dispatch through this immutable revision.
+   *
+   * @returns {{providers: object[], modelToProvider: Map<string, {provider: object, entry: {id: string, protocol?: string}}>, authoritativeManagedProviders: Set<string>, adapterCache: Map<string, LLMAdapter>}}
+   */
+  #captureDispatchSnapshot() {
+    return {
+      providers: this.#providers,
+      modelToProvider: this.#modelToProvider,
+      authoritativeManagedProviders: this.#authoritativeManagedProviders,
+      adapterCache: this.#adapterCache,
+    };
+  }
   /**
    * Resolve an explicit provider/model ref against a provider row even when
    * the local model catalog is stale. The provider name still must exist; the
@@ -309,16 +325,19 @@ export class AdapterRouter extends LLMAdapter {
    * @param {string} modelRef
    * @returns {{provider: object, entry: {id: string, protocol?: string}} | null}
    */
-  #resolveProviderQualifiedFallback(modelRef) {
+  #resolveProviderQualifiedFallback(modelRef, snapshot = null) {
     const parsed = parseModelRef(modelRef);
     if (!parsed.providerName || !parsed.modelId) return null;
-    const candidates = this.#providers.filter(p => p && p.name === parsed.providerName);
+    const providers = snapshot?.providers || this.#providers;
+    const authoritativeManagedProviders = snapshot?.authoritativeManagedProviders
+      || this.#authoritativeManagedProviders;
+    const candidates = providers.filter(p => p && p.name === parsed.providerName);
     if (candidates.length === 0) return null;
     // An explicit managed catalog is authoritative. A qualified ref is not
     // permission to resurrect a model that catalog just removed. Legacy rows
     // with no models still use the bundled fallback catalog above.
-    if (this.#authoritativeManagedProviders.has(parsed.providerName)) return null;
+    if (authoritativeManagedProviders.has(parsed.providerName)) return null;
     const inferred = inferProtocolFromModelId(parsed.modelId);
     if (!inferred) return null;
@@ -355,12 +374,14 @@ export class AdapterRouter extends LLMAdapter {
     return null;
   }
-  #unknownModelError(modelRef) {
+  #unknownModelError(modelRef, snapshot = null) {
     const parsed = parseModelRef(modelRef);
+    const providers = snapshot?.providers || this.#providers;
+    const modelToProvider = snapshot?.modelToProvider || this.#modelToProvider;
     if (parsed.providerName) {
       const providerModels = [];
       let sawProvider = false;
-      for (const provider of this.#providers) {
+      for (const provider of providers) {
         if (!provider || provider.name !== parsed.providerName) continue;
         sawProvider = true;
         for (const raw of Array.isArray(provider.models) ? provider.models : []) {
@@ -378,7 +399,7 @@ export class AdapterRouter extends LLMAdapter {
     }
     return new Error(
       `Model "${modelRef}" not found in any provider. ` +
-      `Available models: ${[...this.#modelToProvider.keys()].join(', ') || '(none)'}. ` +
+      `Available models: ${[...modelToProvider.keys()].join(', ') || '(none)'}. ` +
       `Check your config.json providers[].models arrays.`
     );
   }
@@ -434,10 +455,11 @@ export class AdapterRouter extends LLMAdapter {
    * @param {string} modelId
    * @returns {Promise<{adapter: LLMAdapter, modelId: string}>}
    */
-  async #resolveAdapter(modelRef) {
-    const hit = this.#modelToProvider.get(modelRef) || this.#resolveProviderQualifiedFallback(modelRef);
+  async #resolveAdapter(modelRef, snapshot = null) {
+    const modelToProvider = snapshot?.modelToProvider || this.#modelToProvider;
+    const hit = modelToProvider.get(modelRef) || this.#resolveProviderQualifiedFallback(modelRef, snapshot);
     if (!hit) {
-      throw this.#unknownModelError(modelRef);
+      throw this.#unknownModelError(modelRef, snapshot);
     }
     const { provider, entry } = hit;
@@ -463,7 +485,8 @@ export class AdapterRouter extends LLMAdapter {
       : null;
     const authModeKey = anthropicAuthHeaderMode || 'default';
     const cacheKey = `${provider.name}::${protocol}::${authModeKey}::${apiKeyFp}`;
-    const cached = this.#adapterCache.get(cacheKey);
+    const adapterCache = snapshot?.adapterCache || this.#adapterCache;
+    const cached = adapterCache.get(cacheKey);
     if (cached) return { adapter: cached, modelId: entry.id, protocol, entry };
     // Token rotation eviction: when a credential provider hands us a NEW
@@ -473,8 +496,8 @@ export class AdapterRouter extends LLMAdapter {
     // change fingerprint, so this loop never finds anything to evict for
     // them — back-compat preserved.
     const prefix = `${provider.name}::${protocol}::${authModeKey}::`;
-    for (const key of this.#adapterCache.keys()) {
-      if (key.startsWith(prefix)) this.#adapterCache.delete(key);
+    for (const key of adapterCache.keys()) {
+      if (key.startsWith(prefix)) adapterCache.delete(key);
     }
     let adapter;
@@ -503,7 +526,7 @@ export class AdapterRouter extends LLMAdapter {
       );
     }
-    this.#adapterCache.set(cacheKey, adapter);
+    adapterCache.set(cacheKey, adapter);
     return { adapter, modelId: entry.id, protocol, entry };
   }
@@ -563,7 +586,7 @@ export class AdapterRouter extends LLMAdapter {
    * @param {import('./adapter.js').StreamParams} params
    * @returns {AsyncGenerator<import('./adapter.js').StreamEvent>}
    */
-  async #refreshRejectedCredential(provider, model) {
+  async #refreshRejectedCredential(provider, model, adapterCache = this.#adapterCache) {
     if (!provider?.credentialProvider) return false;
     try {
       if (provider.credentialProvider === 'github-copilot' && provider.githubToken) {
@@ -584,7 +607,7 @@ export class AdapterRouter extends LLMAdapter {
         credentialRefreshable: true,
       });
     }
-    this.#adapterCache.clear();
+    adapterCache.clear();
     return true;
   }
@@ -595,11 +618,32 @@ export class AdapterRouter extends LLMAdapter {
     err.credentialRefreshable = Boolean(provider?.credentialProvider);
   }
-  async *stream(params) {
+  captureRequest() {
+    // Engine captures this object in the same synchronous boundary as its
+    // config snapshot. The returned closure keeps the matching provider
+    // catalog even when request preflight yields before stream construction.
+    const dispatchSnapshot = this.#captureDispatchSnapshot();
+    return {
+      captureStream: params => this.#streamWithSnapshot(params, dispatchSnapshot),
+    };
+  }
+  captureStream(params) {
+    // `async *stream()` does not execute until its first `next()`. Capture the
+    // route in this ordinary method so a config save after capture returns
+    // cannot replace the catalog before the request actually dispatches.
+    return this.captureRequest().captureStream(params);
+  }
+  stream(params) {
+    return this.captureStream(params);
+  }
+  async *#streamWithSnapshot(params, dispatchSnapshot) {
     let refreshedCredential = false;
     while (true) {
-      const resolved = await this.#resolveAdapter(params.model);
-      const provider = this.getProviderForModel(params.model);
+      const resolved = await this.#resolveAdapter(params.model, dispatchSnapshot);
+      const provider = this.#getProviderForModel(params.model, dispatchSnapshot);
       const effortContext = {
         protocol: resolved.protocol,
         supportsEffort: resolved.entry?.supportsEffort,
@@ -615,7 +659,7 @@ export class AdapterRouter extends LLMAdapter {
       } catch (err) {
         this.#annotateAuthError(err, provider, params.model);
         if (err?.statusCode !== 401 || refreshedCredential
-          || !(await this.#refreshRejectedCredential(provider, params.model))) throw err;
+          || !(await this.#refreshRejectedCredential(provider, params.model, dispatchSnapshot.adapterCache))) throw err;
         refreshedCredential = true;
       }
     }
@@ -628,10 +672,11 @@ export class AdapterRouter extends LLMAdapter {
    * @returns {Promise<{ text: string, usage: { inputTokens: number, outputTokens: number } }>}
    */
   async call(params) {
+    const dispatchSnapshot = this.#captureDispatchSnapshot();
     let refreshedCredential = false;
     while (true) {
-      const resolved = await this.#resolveAdapter(params.model);
-      const provider = this.getProviderForModel(params.model);
+      const resolved = await this.#resolveAdapter(params.model, dispatchSnapshot);
+      const provider = this.#getProviderForModel(params.model, dispatchSnapshot);
       const effortContext = {
         protocol: resolved.protocol,
         supportsEffort: resolved.entry?.supportsEffort,
@@ -646,12 +691,27 @@ export class AdapterRouter extends LLMAdapter {
       } catch (err) {
         this.#annotateAuthError(err, provider, params.model);
         if (err?.statusCode !== 401 || refreshedCredential
-          || !(await this.#refreshRejectedCredential(provider, params.model))) throw err;
+          || !(await this.#refreshRejectedCredential(provider, params.model, dispatchSnapshot.adapterCache))) throw err;
         refreshedCredential = true;
       }
     }
   }
+  /**
+   * Resolve a provider from either the live routing table or a captured
+   * request snapshot. Keeping this lookup private prevents callers from
+   * accidentally retaining a mutable catalog reference.
+   *
+   * @param {string} modelId
+   * @param {{modelToProvider?: Map<string, {provider: object, entry: object}>}|null} snapshot
+   * @returns {object|null}
+   */
+  #getProviderForModel(modelId, snapshot = null) {
+    const modelToProvider = snapshot?.modelToProvider || this.#modelToProvider;
+    const hit = modelToProvider.get(modelId) || this.#resolveProviderQualifiedFallback(modelId, snapshot);
+    return hit ? hit.provider : null;
+  }
   /**
    * Get the provider config for a given model.
    *
@@ -659,8 +719,7 @@ export class AdapterRouter extends LLMAdapter {
    * @returns {object|null} — Provider config or null
    */
   getProviderForModel(modelId) {
-    const hit = this.#modelToProvider.get(modelId) || this.#resolveProviderQualifiedFallback(modelId);
-    return hit ? hit.provider : null;
+    return this.#getProviderForModel(modelId);
   }
   /**

package/yeaft/llm/usage-accounting.js CHANGED Viewed

@@ -90,10 +90,36 @@ export class UsageAccountingAdapter extends LLMAdapter {
     }
   }
-  async *stream(params) {
+  captureRequest() {
+    const captured = typeof this.#adapter.captureRequest === 'function'
+      ? this.#adapter.captureRequest()
+      : null;
+    return {
+      captureStream: params => {
+        const requestParams = this.#requestParams(params);
+        const capture = captured?.captureStream
+          || (typeof this.#adapter.captureStream === 'function'
+            ? this.#adapter.captureStream.bind(this.#adapter)
+            : this.#adapter.stream.bind(this.#adapter));
+        return this.#streamWithAccounting(capture(requestParams));
+      },
+    };
+  }
+  captureStream(params) {
+    // Preserve the wrapped adapter's request-capture boundary. In particular,
+    // AdapterRouter freezes its provider catalog before the stream is iterated.
+    return this.captureRequest().captureStream(params);
+  }
+  stream(params) {
+    return this.captureStream(params);
+  }
+  async *#streamWithAccounting(upstreamStream) {
     const total = normalizeTokenUsage();
     try {
-      for await (const event of this.#adapter.stream(this.#requestParams(params))) {
+      for await (const event of upstreamStream) {
         if (event?.type === 'usage') addUsage(total, event);
         yield event;
       }

package/yeaft/sessions/session-config.js CHANGED Viewed

@@ -256,8 +256,6 @@ export function resolveSessionConfig(userConfig, sessionConfig) {
   }
   if (overrides.modelEffort && typeof overrides.modelEffort === 'string' && ALLOWED_EFFORTS.has(overrides.modelEffort)) {
     base.modelEffort = overrides.modelEffort;
-  } else {
-    delete base.modelEffort;
   }
   return base;
 }