Method tryModelFallbackAfterRefusal

src/node/services/streamManager.ts:2149–2328

* Attempt a refusal-fallback model swap in place of a terminal model_refusal. * * This runs entirely inside the active stream loop, BEFORE any error event or * partial error state is committed, so TaskService/waiters never observe an * intermediate refusal while the chain is being attemp

(
    workspaceId: WorkspaceId,
    streamInfo: WorkspaceStreamInfo,
    refusalFinishReason: string,
    options?: { preserveParts?: boolean }
  )

   * fallback model — which intentionally fails instead of skipping ahead).
   */
  private async tryModelFallbackAfterRefusal(
    workspaceId: WorkspaceId,
    streamInfo: WorkspaceStreamInfo,
    refusalFinishReason: string,
    options?: { preserveParts?: boolean }
  ): Promise<{ kind: "swapped" } | { kind: "terminal"; terminalNote?: string }> {
    const fallbackState = streamInfo.modelFallback;
    const preserveParts = options?.preserveParts === true;
    const refusedModel = normalizeToCanonical(streamInfo.model);

    if (!fallbackState) {
      await this.recordTerminalRefusalUsage(workspaceId, streamInfo, refusedModel);
      return { kind: "terminal" };
    }

    fallbackState.refusedModels.push(refusedModel);
    streamInfo.initialMetadata = {
      ...streamInfo.initialMetadata,
      modelFallback: {
        requestedModel: fallbackState.requestedModel,
        refusedModels: [...fallbackState.refusedModels],
      },
    };

    if (streamInfo.abortController.signal.aborted || streamInfo.softInterrupt.pending) {
      await this.recordRefusedAttemptUsage(workspaceId, streamInfo, refusedModel);
      return { kind: "terminal" };
    }

    // Attribute this refused attempt's usage to the refusing model for EVERY
    // chain outcome (swap, exhaustion, unstartable fallback) before any state
    // reset. Chains that end in a terminal failure must not drop the final
    // hop's tokens from session usage / cost accounting.
    await this.recordRefusedAttemptUsage(workspaceId, streamInfo, refusedModel);

    const nextModelString = fallbackState.options.chain[fallbackState.refusedModels.length - 1];
    if (nextModelString === undefined) {
      return {
        kind: "terminal",
        terminalNote: `Model fallback chain exhausted; refused models: ${fallbackState.refusedModels.join(", ")}.`,
      };
    }

    if (preserveParts && hasIncompleteToolCallPart(streamInfo.parts)) {
      return {
        kind: "terminal",
        terminalNote:
          "Model fallback was skipped because the refused partial response had an incomplete tool call.",
      };
    }

    const continuation = preserveParts
      ? this.buildPartialRefusalContinuationMessage(streamInfo, refusalFinishReason)
      : undefined;
    if (continuation != null && !continuation.success) {
      return {
        kind: "terminal",
        terminalNote: `Model fallback was skipped because ${continuation.error}.`,