@jsonstudio/rcc 0.90.367 → 0.90.701

package/dist/server/runtime/http-server/request-executor.js

@@ -14,6 +14,7 @@ import { resolveProviderRuntimeOrThrow } from './executor/provider-runtime-resol
 import { resolveProviderRequestContext } from './executor/provider-request-context.js';
 import { isServerToolEnabled } from './servertool-admin-state.js';
 import { registerRequestLogContext } from '../../utils/request-log-color.js';
+import { STREAM_LOG_FINISH_REASON_KEY } from '../../utils/finish-reason.js';
 const DEFAULT_MAX_PROVIDER_ATTEMPTS = 6;
 export class HubRequestExecutor {
     deps;
@@ -23,6 +24,7 @@ export class HubRequestExecutor {
     async execute(input) {
         // Stats must remain stable across provider retries and requestId enhancements.
         const statsRequestId = input.requestId;
+        const executorRequestId = input.requestId;
         this.deps.stats.recordRequestStart(statsRequestId);
         const requestStartedAt = Date.now();
         let recordedAnyAttempt = false;
@@ -33,540 +35,620 @@ export class HubRequestExecutor {
         try {
             const hubPipeline = ensureHubPipeline(this.deps.getHubPipeline);
             const initialMetadata = buildRequestMetadata(input);
-            bindSessionConversationSession(initialMetadata);
-            registerRequestLogContext(input.requestId, {
-                sessionId: initialMetadata.sessionId,
-                conversationId: initialMetadata.conversationId
-            });
-            const inboundClientHeaders = cloneClientHeaders(initialMetadata?.clientHeaders);
-            const providerRequestId = input.requestId;
-            const clientRequestId = resolveClientRequestId(initialMetadata, providerRequestId);
-            this.logStage('request.received', providerRequestId, {
-                endpoint: input.entryEndpoint,
-                stream: initialMetadata.stream === true
-            });
-            this.logStage('request.snapshot.start', providerRequestId, {
-                endpoint: input.entryEndpoint
-            });
-            await writeInboundClientSnapshot({ input, initialMetadata, clientRequestId });
-            this.logStage('request.snapshot.completed', providerRequestId, {
-                endpoint: input.entryEndpoint
-            });
-            const pipelineLabel = 'hub';
-            let aggregatedUsage;
-            const excludedProviderKeys = new Set();
-            let maxAttempts = resolveMaxProviderAttempts();
-            const originalRequestSnapshot = cloneRequestPayload(input.body);
-            let attempt = 0;
-            let lastError;
-            let initialRoutePool = null;
-            let antigravityRetrySignal = null;
-            let poolCooldownWaitBudgetMs = 60 * 1000;
-            let forcedRouteHint;
-            let contextOverflowRetries = 0;
-            const MAX_CONTEXT_OVERFLOW_RETRIES = 3;
-            while (attempt < maxAttempts) {
-                attempt += 1;
-                // Ensure each attempt starts from the base requestId so pipeline snapshots
-                // don't inherit a provider-specific id from a previous attempt.
-                input.requestId = providerRequestId;
-                if (originalRequestSnapshot && typeof originalRequestSnapshot === 'object') {
-                    const cloned = cloneRequestPayload(originalRequestSnapshot) ??
-                        { ...originalRequestSnapshot };
-                    input.body = cloned;
-                }
-                const metadataForAttempt = decorateMetadataForAttempt(initialMetadata, attempt, excludedProviderKeys);
-                if (forcedRouteHint) {
-                    metadataForAttempt.routeHint = forcedRouteHint;
-                }
-                const clientHeadersForAttempt = cloneClientHeaders(metadataForAttempt?.clientHeaders) || inboundClientHeaders;
-                if (clientHeadersForAttempt) {
-                    metadataForAttempt.clientHeaders = clientHeadersForAttempt;
-                }
-                metadataForAttempt.clientRequestId = clientRequestId;
-                injectAntigravityRetrySignal(metadataForAttempt, antigravityRetrySignal);
-                const hubStartedAtMs = Date.now();
-                this.logStage(`${pipelineLabel}.start`, providerRequestId, {
-                    endpoint: input.entryEndpoint,
-                    stream: metadataForAttempt.stream,
-                    attempt
-                });
-                let pipelineResult;
-                try {
-                    pipelineResult = await runHubPipeline(hubPipeline, input, metadataForAttempt);
-                }
-                catch (pipelineError) {
-                    if (isPoolExhaustedPipelineError(pipelineError)) {
-                        const cooldownWaitMs = resolvePoolCooldownWaitMs(pipelineError);
-                        if (cooldownWaitMs &&
-                            attempt < maxAttempts &&
-                            poolCooldownWaitBudgetMs >= cooldownWaitMs) {
-                            this.logStage('provider.route_pool_cooldown_wait', providerRequestId, {
-                                attempt,
-                                waitMs: cooldownWaitMs,
-                                waitBudgetMs: poolCooldownWaitBudgetMs,
-                                reason: 'provider_pool_cooling_down'
-                            });
-                            poolCooldownWaitBudgetMs -= cooldownWaitMs;
-                            await new Promise((resolve) => setTimeout(resolve, cooldownWaitMs));
-                            attempt = Math.max(0, attempt - 1);
-                            continue;
-                        }
-                        if (lastError) {
-                            throw lastError;
-                        }
-                    }
-                    throw pipelineError;
-                }
-                const pipelineMetadata = pipelineResult.metadata ?? {};
-                const mergedMetadata = mergeMetadataPreservingDefined(metadataForAttempt, pipelineMetadata);
+            await this.deps.onRequestStart?.({ requestId: executorRequestId, metadata: initialMetadata });
+            try {
+                bindSessionConversationSession(initialMetadata);
                 registerRequestLogContext(input.requestId, {
-                    sessionId: mergedMetadata.sessionId,
-                    conversationId: mergedMetadata.conversationId
-                });
-                const mergedClientHeaders = cloneClientHeaders(mergedMetadata?.clientHeaders) || clientHeadersForAttempt;
-                if (mergedClientHeaders) {
-                    mergedMetadata.clientHeaders = mergedClientHeaders;
-                }
-                mergedMetadata.clientRequestId = clientRequestId;
-                this.logStage(`${pipelineLabel}.completed`, providerRequestId, {
-                    route: pipelineResult.routingDecision?.routeName,
-                    target: pipelineResult.target?.providerKey,
-                    elapsedMs: Date.now() - hubStartedAtMs,
-                    attempt
-                });
-                if (!initialRoutePool && Array.isArray(pipelineResult.routingDecision?.pool)) {
-                    initialRoutePool = [...pipelineResult.routingDecision.pool];
-                }
-                const providerPayload = pipelineResult.providerPayload;
-                const target = pipelineResult.target;
-                if (!providerPayload || !target?.providerKey) {
-                    throw Object.assign(new Error('Virtual router did not produce a provider target'), {
-                        code: 'ERR_NO_PROVIDER_TARGET',
-                        requestId: input.requestId
-                    });
-                }
-                // Ensure response-side conversion always uses the route-selected target metadata.
-                // ServerTool followups may carry stale metadata from the previous hop; response compat
-                // must follow the current target/provider, not the inherited request profile.
-                mergedMetadata.target = target;
-                if (typeof target.compatibilityProfile === 'string' && target.compatibilityProfile.trim()) {
-                    mergedMetadata.compatibilityProfile = target.compatibilityProfile.trim();
-                }
-                else if (Object.prototype.hasOwnProperty.call(mergedMetadata, 'compatibilityProfile')) {
-                    delete mergedMetadata.compatibilityProfile;
-                }
-                this.logStage('provider.runtime_resolve.start', providerRequestId, {
-                    providerKey: target.providerKey,
-                    route: pipelineResult.routingDecision?.routeName,
-                    attempt
+                    sessionId: initialMetadata.sessionId,
+                    conversationId: initialMetadata.conversationId
                 });
-                const { runtimeKey, handle } = await resolveProviderRuntimeOrThrow({
-                    requestId: input.requestId,
-                    target: {
-                        providerKey: target.providerKey,
-                        outboundProfile: String(target.outboundProfile || ''),
-                        providerType: String(target.providerType || '')
-                    },
-                    routeName: pipelineResult.routingDecision?.routeName,
-                    runtimeKeyHint: target.runtimeKey,
-                    runtimeManager: this.deps.runtimeManager,
-                    dependencies: this.deps.getModuleDependencies()
-                });
-                this.logStage('provider.runtime_resolve.completed', providerRequestId, {
-                    providerKey: target.providerKey,
-                    runtimeKey,
-                    providerType: handle.providerType,
-                    providerFamily: handle.providerFamily,
-                    attempt
-                });
-                this.logStage('provider.context_resolve.start', providerRequestId, {
-                    providerKey: target.providerKey,
-                    runtimeKey,
-                    attempt
-                });
-                const providerContext = resolveProviderRequestContext({
-                    providerRequestId,
-                    entryEndpoint: input.entryEndpoint,
-                    target: {
-                        providerKey: target.providerKey,
-                        outboundProfile: target.outboundProfile
-                    },
-                    handle,
-                    runtimeKey,
-                    providerPayload,
-                    mergedMetadata
-                });
-                const previousRequestId = input.requestId;
-                if (providerContext.requestId !== input.requestId) {
-                    input.requestId = providerContext.requestId;
-                }
-                this.logStage('provider.context_resolve.completed', input.requestId, {
-                    providerKey: target.providerKey,
-                    runtimeKey,
-                    providerProtocol: providerContext.providerProtocol,
-                    model: providerContext.providerModel,
-                    requestIdChanged: previousRequestId !== input.requestId,
-                    previousRequestId,
-                    requestId: input.requestId,
-                    attempt
-                });
-                registerRequestLogContext(providerContext.requestId, {
-                    sessionId: mergedMetadata.sessionId,
-                    conversationId: mergedMetadata.conversationId
-                });
-                const { providerProtocol, providerModel, providerLabel } = providerContext;
-                if (clientHeadersForAttempt) {
-                    ensureClientHeadersOnPayload(providerPayload, clientHeadersForAttempt);
-                }
-                this.deps.stats.bindProvider(statsRequestId, {
-                    providerKey: target.providerKey,
-                    providerType: handle.providerType,
-                    model: providerModel
-                });
-                this.logStage('provider.prepare', input.requestId, {
-                    providerKey: target.providerKey,
-                    runtimeKey,
-                    protocol: providerProtocol,
-                    providerType: handle.providerType,
-                    providerFamily: handle.providerFamily,
-                    model: providerModel,
-                    providerLabel,
-                    attempt
-                });
-                this.logStage('provider.metadata_attach.start', input.requestId, {
-                    providerKey: target.providerKey,
-                    runtimeKey,
-                    attempt
-                });
-                attachProviderRuntimeMetadata(providerPayload, {
-                    requestId: input.requestId,
-                    providerId: handle.providerId,
-                    providerKey: target.providerKey,
-                    providerType: handle.providerType,
-                    providerFamily: handle.providerFamily,
-                    providerProtocol,
-                    pipelineId: target.providerKey,
-                    routeName: pipelineResult.routingDecision?.routeName,
-                    runtimeKey,
-                    target,
-                    metadata: mergedMetadata,
-                    compatibilityProfile: target.compatibilityProfile
+                const inboundClientHeaders = cloneClientHeaders(initialMetadata?.clientHeaders);
+                const providerRequestId = input.requestId;
+                const clientRequestId = resolveClientRequestId(initialMetadata, providerRequestId);
+                this.logStage('request.received', providerRequestId, {
+                    endpoint: input.entryEndpoint,
+                    stream: initialMetadata.stream === true
                 });
-                this.logStage('provider.metadata_attach.completed', input.requestId, {
-                    providerKey: target.providerKey,
-                    runtimeKey,
-                    attempt
+                this.logStage('request.snapshot.start', providerRequestId, {
+                    endpoint: input.entryEndpoint
                 });
-                const providerSendStartedAtMs = Date.now();
-                this.logStage('provider.send.start', input.requestId, {
-                    providerKey: target.providerKey,
-                    runtimeKey,
-                    protocol: providerProtocol,
-                    providerType: handle.providerType,
-                    providerFamily: handle.providerFamily,
-                    model: providerModel,
-                    providerLabel,
-                    attempt
+                await writeInboundClientSnapshot({ input, initialMetadata, clientRequestId });
+                this.logStage('request.snapshot.completed', providerRequestId, {
+                    endpoint: input.entryEndpoint
                 });
-                try {
-                    const providerResponse = await handle.instance.processIncoming(providerPayload);
-                    const responseStatus = extractResponseStatus(providerResponse);
-                    this.logStage('provider.send.completed', input.requestId, {
-                        providerKey: target.providerKey,
-                        status: responseStatus,
-                        elapsedMs: Date.now() - providerSendStartedAtMs,
-                        providerType: handle.providerType,
-                        providerFamily: handle.providerFamily,
-                        model: providerModel,
-                        providerLabel,
-                        attempt
-                    });
-                    const wantsStreamBase = Boolean(input.metadata?.inboundStream ?? input.metadata?.stream);
-                    this.logStage('provider.response_normalize.start', input.requestId, {
-                        providerKey: target.providerKey,
-                        attempt
-                    });
-                    const normalized = normalizeProviderResponse(providerResponse);
-                    this.logStage('provider.response_normalize.completed', input.requestId, {
-                        providerKey: target.providerKey,
-                        status: normalized.status,
+                const pipelineLabel = 'hub';
+                let aggregatedUsage;
+                const excludedProviderKeys = new Set();
+                let maxAttempts = resolveMaxProviderAttempts();
+                const originalRequestSnapshot = cloneRequestPayload(input.body);
+                let attempt = 0;
+                let lastError;
+                let initialRoutePool = null;
+                let antigravityRetrySignal = null;
+                let poolCooldownWaitBudgetMs = 60 * 1000;
+                let forcedRouteHint;
+                let contextOverflowRetries = 0;
+                const MAX_CONTEXT_OVERFLOW_RETRIES = 3;
+                while (attempt < maxAttempts) {
+                    attempt += 1;
+                    // Ensure each attempt starts from the base requestId so pipeline snapshots
+                    // don't inherit a provider-specific id from a previous attempt.
+                    input.requestId = providerRequestId;
+                    if (originalRequestSnapshot && typeof originalRequestSnapshot === 'object') {
+                        const cloned = cloneRequestPayload(originalRequestSnapshot) ??
+                            { ...originalRequestSnapshot };
+                        input.body = cloned;
+                    }
+                    const metadataForAttempt = decorateMetadataForAttempt(initialMetadata, attempt, excludedProviderKeys);
+                    if (forcedRouteHint) {
+                        metadataForAttempt.routeHint = forcedRouteHint;
+                    }
+                    const clientHeadersForAttempt = cloneClientHeaders(metadataForAttempt?.clientHeaders) || inboundClientHeaders;
+                    if (clientHeadersForAttempt) {
+                        metadataForAttempt.clientHeaders = clientHeadersForAttempt;
+                    }
+                    metadataForAttempt.clientRequestId = clientRequestId;
+                    injectAntigravityRetrySignal(metadataForAttempt, antigravityRetrySignal);
+                    const hubStartedAtMs = Date.now();
+                    this.logStage(`${pipelineLabel}.start`, providerRequestId, {
+                        endpoint: input.entryEndpoint,
+                        stream: metadataForAttempt.stream,
                         attempt
                     });
-                    this.logStage('provider.usage_extract.start', input.requestId, {
-                        providerKey: target.providerKey,
-                        source: 'provider_response',
-                        attempt
+                    let pipelineResult;
+                    try {
+                        pipelineResult = await runHubPipeline(hubPipeline, input, metadataForAttempt);
+                    }
+                    catch (pipelineError) {
+                        if (isPoolExhaustedPipelineError(pipelineError)) {
+                            const cooldownWaitMs = resolvePoolCooldownWaitMs(pipelineError);
+                            if (cooldownWaitMs &&
+                                attempt < maxAttempts &&
+                                poolCooldownWaitBudgetMs >= cooldownWaitMs) {
+                                this.logStage('provider.route_pool_cooldown_wait', providerRequestId, {
+                                    attempt,
+                                    waitMs: cooldownWaitMs,
+                                    waitBudgetMs: poolCooldownWaitBudgetMs,
+                                    reason: 'provider_pool_cooling_down'
+                                });
+                                poolCooldownWaitBudgetMs -= cooldownWaitMs;
+                                await new Promise((resolve) => setTimeout(resolve, cooldownWaitMs));
+                                attempt = Math.max(0, attempt - 1);
+                                continue;
+                            }
+                            if (lastError) {
+                                throw lastError;
+                            }
+                        }
+                        throw pipelineError;
+                    }
+                    const pipelineMetadata = pipelineResult.metadata ?? {};
+                    const mergedMetadata = mergeMetadataPreservingDefined(metadataForAttempt, pipelineMetadata);
+                    registerRequestLogContext(input.requestId, {
+                        sessionId: mergedMetadata.sessionId,
+                        conversationId: mergedMetadata.conversationId
                     });
-                    const usageFromProvider = extractUsageFromResult(normalized, mergedMetadata);
-                    this.logStage('provider.usage_extract.completed', input.requestId, {
-                        providerKey: target.providerKey,
-                        source: 'provider_response',
-                        hasUsage: Boolean(usageFromProvider),
+                    const mergedClientHeaders = cloneClientHeaders(mergedMetadata?.clientHeaders) || clientHeadersForAttempt;
+                    if (mergedClientHeaders) {
+                        mergedMetadata.clientHeaders = mergedClientHeaders;
+                    }
+                    mergedMetadata.clientRequestId = clientRequestId;
+                    this.logStage(`${pipelineLabel}.completed`, providerRequestId, {
+                        route: pipelineResult.routingDecision?.routeName,
+                        target: pipelineResult.target?.providerKey,
+                        elapsedMs: Date.now() - hubStartedAtMs,
                         attempt
                     });
-                    this.logStage('provider.request_semantics.start', input.requestId, {
+                    if (!initialRoutePool && Array.isArray(pipelineResult.routingDecision?.pool)) {
+                        initialRoutePool = [...pipelineResult.routingDecision.pool];
+                    }
+                    const providerPayload = pipelineResult.providerPayload;
+                    const target = pipelineResult.target;
+                    if (!providerPayload || !target?.providerKey) {
+                        throw Object.assign(new Error('Virtual router did not produce a provider target'), {
+                            code: 'ERR_NO_PROVIDER_TARGET',
+                            requestId: input.requestId
+                        });
+                    }
+                    // Ensure response-side conversion always uses the route-selected target metadata.
+                    // ServerTool followups may carry stale metadata from the previous hop; response compat
+                    // must follow the current target/provider, not the inherited request profile.
+                    mergedMetadata.target = target;
+                    if (typeof target.compatibilityProfile === 'string' && target.compatibilityProfile.trim()) {
+                        mergedMetadata.compatibilityProfile = target.compatibilityProfile.trim();
+                    }
+                    else if (Object.prototype.hasOwnProperty.call(mergedMetadata, 'compatibilityProfile')) {
+                        delete mergedMetadata.compatibilityProfile;
+                    }
+                    this.logStage('provider.runtime_resolve.start', providerRequestId, {
                         providerKey: target.providerKey,
+                        route: pipelineResult.routingDecision?.routeName,
                         attempt
                     });
-                    const requestSemantics = resolveRequestSemantics(pipelineResult.processedRequest, pipelineResult.standardizedRequest);
-                    this.logStage('provider.request_semantics.completed', input.requestId, {
-                        providerKey: target.providerKey,
-                        hasSemantics: Boolean(requestSemantics && Object.keys(requestSemantics).length),
-                        attempt
+                    const { runtimeKey, handle } = await resolveProviderRuntimeOrThrow({
+                        requestId: input.requestId,
+                        target: {
+                            providerKey: target.providerKey,
+                            outboundProfile: String(target.outboundProfile || ''),
+                            providerType: String(target.providerType || '')
+                        },
+                        routeName: pipelineResult.routingDecision?.routeName,
+                        runtimeKeyHint: target.runtimeKey,
+                        runtimeManager: this.deps.runtimeManager,
+                        dependencies: this.deps.getModuleDependencies()
                     });
-                    const serverToolsEnabled = isServerToolEnabled();
-                    this.logStage('provider.response_convert.start', input.requestId, {
+                    this.logStage('provider.runtime_resolve.completed', providerRequestId, {
                         providerKey: target.providerKey,
-                        protocol: providerProtocol,
-                        processMode: pipelineResult.processMode,
-                        wantsStream: wantsStreamBase,
-                        serverToolsEnabled,
+                        runtimeKey,
+                        providerType: handle.providerType,
+                        providerFamily: handle.providerFamily,
                         attempt
                     });
-                    const hubResponseStartedAtMs = Date.now();
-                    this.logStage('hub.response.start', input.requestId, {
+                    this.logStage('provider.context_resolve.start', providerRequestId, {
                         providerKey: target.providerKey,
-                        protocol: providerProtocol,
-                        processMode: pipelineResult.processMode,
+                        runtimeKey,
                         attempt
                     });
-                    const converted = await this.convertProviderResponseIfNeeded({
+                    const providerContext = resolveProviderRequestContext({
+                        providerRequestId,
                         entryEndpoint: input.entryEndpoint,
-                        providerProtocol,
-                        providerType: handle.providerType,
-                        requestId: input.requestId,
-                        serverToolsEnabled,
-                        wantsStream: wantsStreamBase,
-                        originalRequest: originalRequestSnapshot,
-                        requestSemantics,
-                        processMode: pipelineResult.processMode,
-                        response: normalized,
-                        pipelineMetadata: mergedMetadata
-                    });
-                    this.logStage('provider.response_convert.completed', input.requestId, {
-                        providerKey: target.providerKey,
-                        status: converted.status,
-                        hasBody: converted.body !== undefined && converted.body !== null,
-                        attempt
+                        target: {
+                            providerKey: target.providerKey,
+                            outboundProfile: target.outboundProfile
+                        },
+                        handle,
+                        runtimeKey,
+                        providerPayload,
+                        mergedMetadata
                     });
-                    this.logStage('hub.response.completed', input.requestId, {
+                    const previousRequestId = input.requestId;
+                    if (providerContext.requestId !== input.requestId) {
+                        input.requestId = providerContext.requestId;
+                    }
+                    this.logStage('provider.context_resolve.completed', input.requestId, {
                         providerKey: target.providerKey,
-                        status: converted.status,
-                        elapsedMs: Date.now() - hubResponseStartedAtMs,
-                        hasBody: converted.body !== undefined && converted.body !== null,
+                        runtimeKey,
+                        providerProtocol: providerContext.providerProtocol,
+                        model: providerContext.providerModel,
+                        requestIdChanged: previousRequestId !== input.requestId,
+                        previousRequestId,
+                        requestId: input.requestId,
                         attempt
                     });
-                    // Treat upstream 429 as provider failure across protocols to avoid
-                    // silently returning success and to let Virtual Router failover to other candidates.
-                    // Keep existing Gemini compatibility behavior for 400/4xx thoughtSignature-like failures.
-                    const convertedStatus = typeof converted.status === 'number' ? converted.status : undefined;
-                    this.logStage('provider.response_status_check.start', input.requestId, {
-                        providerKey: target.providerKey,
-                        convertedStatus,
-                        attempt
+                    registerRequestLogContext(providerContext.requestId, {
+                        sessionId: mergedMetadata.sessionId,
+                        conversationId: mergedMetadata.conversationId
                     });
-                    this.logStage('provider.response_status_check.completed', input.requestId, {
+                    const { providerProtocol, providerModel, providerLabel } = providerContext;
+                    if (clientHeadersForAttempt) {
+                        ensureClientHeadersOnPayload(providerPayload, clientHeadersForAttempt);
+                    }
+                    this.deps.stats.bindProvider(statsRequestId, {
                         providerKey: target.providerKey,
-                        convertedStatus,
-                        attempt
+                        providerType: handle.providerType,
+                        model: providerModel
                     });
-                    this.logStage('provider.usage_extract.start', input.requestId, {
+                    this.logStage('provider.prepare', input.requestId, {
                         providerKey: target.providerKey,
-                        source: 'converted_response',
+                        runtimeKey,
+                        protocol: providerProtocol,
+                        providerType: handle.providerType,
+                        providerFamily: handle.providerFamily,
+                        model: providerModel,
+                        providerLabel,
                         attempt
                     });
-                    const usage = extractUsageFromResult(converted, mergedMetadata) ?? usageFromProvider;
-                    this.logStage('provider.usage_extract.completed', input.requestId, {
+                    this.logStage('provider.metadata_attach.start', input.requestId, {
                         providerKey: target.providerKey,
-                        source: 'converted_response',
-                        hasUsage: Boolean(usage),
+                        runtimeKey,
                         attempt
                     });
-                    aggregatedUsage = mergeUsageMetrics(aggregatedUsage, usage);
-                    this.logStage('provider.tool_usage_record.start', input.requestId, {
+                    attachProviderRuntimeMetadata(providerPayload, {
+                        requestId: input.requestId,
+                        providerId: handle.providerId,
                         providerKey: target.providerKey,
-                        attempt
+                        providerType: handle.providerType,
+                        providerFamily: handle.providerFamily,
+                        providerProtocol,
+                        pipelineId: target.providerKey,
+                        routeName: pipelineResult.routingDecision?.routeName,
+                        runtimeKey,
+                        target,
+                        metadata: mergedMetadata,
+                        compatibilityProfile: target.compatibilityProfile
                     });
-                    if (converted.body && typeof converted.body === 'object') {
-                        const body = converted.body;
-                        if (!('__sse_responses' in body)) {
-                            this.deps.stats.recordToolUsage({ providerKey: target.providerKey, model: providerModel }, body);
-                        }
-                    }
-                    this.logStage('provider.tool_usage_record.completed', input.requestId, {
+                    this.logStage('provider.metadata_attach.completed', input.requestId, {
                         providerKey: target.providerKey,
+                        runtimeKey,
                         attempt
                     });
-                    recordAttempt({ usage: aggregatedUsage, error: false });
-                    return {
-                        ...converted,
-                        usageLogInfo: {
-                            providerKey: target.providerKey,
-                            model: providerModel,
-                            usage: aggregatedUsage,
-                            requestStartedAtMs: requestStartedAt,
-                            timingRequestIds: Array.from(new Set([providerRequestId, input.requestId].filter((value) => Boolean(value)))),
-                            sessionId: mergedMetadata.sessionId,
-                            conversationId: mergedMetadata.conversationId
-                        }
-                    };
-                }
-                catch (error) {
-                    const errorMessage = error instanceof Error ? error.message : String(error ?? 'Unknown error');
-                    this.logStage('provider.send.error', input.requestId, {
+                    const providerSendStartedAtMs = Date.now();
+                    this.logStage('provider.send.start', input.requestId, {
                         providerKey: target.providerKey,
-                        message: errorMessage,
+                        runtimeKey,
+                        protocol: providerProtocol,
                         providerType: handle.providerType,
                         providerFamily: handle.providerFamily,
                         model: providerModel,
                         providerLabel,
                         attempt
                     });
-                    lastError = error;
-                    if (isAntigravityProviderKey(target.providerKey)) {
-                        const signature = extractRetryErrorSignature(error);
-                        const consecutive = antigravityRetrySignal && antigravityRetrySignal.signature === signature
-                            ? antigravityRetrySignal.consecutive + 1
-                            : 1;
-                        antigravityRetrySignal = { signature, consecutive };
-                    }
-                    else {
-                        antigravityRetrySignal = null;
-                    }
-                    const status = extractStatusCodeFromError(error);
-                    if (isSseDecodeRateLimitError(error, status)) {
-                        try {
-                            const { emitProviderError } = await import('../../../providers/core/utils/provider-error-reporter.js');
-                            emitProviderError({
-                                error,
-                                stage: 'provider.sse_decode',
-                                runtime: {
-                                    requestId: input.requestId,
-                                    providerKey: target.providerKey,
-                                    providerId: handle.providerId,
-                                    providerType: handle.providerType,
-                                    providerFamily: handle.providerFamily,
-                                    providerProtocol,
-                                    routeName: pipelineResult.routingDecision?.routeName,
-                                    pipelineId: target.providerKey,
-                                    target,
-                                    runtimeKey
-                                },
-                                dependencies: this.deps.getModuleDependencies(),
-                                statusCode: 429,
-                                recoverable: true,
-                                affectsHealth: true,
-                                details: {
-                                    source: 'sse_decode_rate_limit',
-                                    errorCode: typeof error?.code === 'string' ? String(error.code) : undefined,
-                                    upstreamCode: typeof error?.upstreamCode === 'string' ? String(error.upstreamCode) : undefined,
-                                    message: errorMessage
-                                }
+                    try {
+                        const providerResponse = await handle.instance.processIncoming(providerPayload);
+                        const responseStatus = extractResponseStatus(providerResponse);
+                        this.logStage('provider.send.completed', input.requestId, {
+                            providerKey: target.providerKey,
+                            status: responseStatus,
+                            elapsedMs: Date.now() - providerSendStartedAtMs,
+                            providerType: handle.providerType,
+                            providerFamily: handle.providerFamily,
+                            model: providerModel,
+                            providerLabel,
+                            attempt
+                        });
+                        const wantsStreamBase = Boolean(input.metadata?.inboundStream ?? input.metadata?.stream);
+                        this.logStage('provider.response_normalize.start', input.requestId, {
+                            providerKey: target.providerKey,
+                            attempt
+                        });
+                        const normalized = normalizeProviderResponse(providerResponse);
+                        this.logStage('provider.response_normalize.completed', input.requestId, {
+                            providerKey: target.providerKey,
+                            status: normalized.status,
+                            attempt
+                        });
+                        this.logStage('provider.usage_extract.start', input.requestId, {
+                            providerKey: target.providerKey,
+                            source: 'provider_response',
+                            attempt
+                        });
+                        const usageFromProvider = extractUsageFromResult(normalized, mergedMetadata);
+                        this.logStage('provider.usage_extract.completed', input.requestId, {
+                            providerKey: target.providerKey,
+                            source: 'provider_response',
+                            hasUsage: Boolean(usageFromProvider),
+                            attempt
+                        });
+                        this.logStage('provider.request_semantics.start', input.requestId, {
+                            providerKey: target.providerKey,
+                            attempt
+                        });
+                        const requestSemantics = resolveRequestSemantics(pipelineResult.processedRequest, pipelineResult.standardizedRequest);
+                        this.logStage('provider.request_semantics.completed', input.requestId, {
+                            providerKey: target.providerKey,
+                            hasSemantics: Boolean(requestSemantics && Object.keys(requestSemantics).length),
+                            attempt
+                        });
+                        const serverToolsEnabled = isServerToolEnabled();
+                        this.logStage('provider.response_convert.start', input.requestId, {
+                            providerKey: target.providerKey,
+                            protocol: providerProtocol,
+                            processMode: pipelineResult.processMode,
+                            wantsStream: wantsStreamBase,
+                            serverToolsEnabled,
+                            attempt
+                        });
+                        const hubResponseStartedAtMs = Date.now();
+                        this.logStage('hub.response.start', input.requestId, {
+                            providerKey: target.providerKey,
+                            protocol: providerProtocol,
+                            processMode: pipelineResult.processMode,
+                            attempt
+                        });
+                        const converted = await this.convertProviderResponseIfNeeded({
+                            entryEndpoint: input.entryEndpoint,
+                            providerProtocol,
+                            providerType: handle.providerType,
+                            requestId: input.requestId,
+                            serverToolsEnabled,
+                            wantsStream: wantsStreamBase,
+                            originalRequest: originalRequestSnapshot,
+                            requestSemantics,
+                            processMode: pipelineResult.processMode,
+                            response: normalized,
+                            pipelineMetadata: mergedMetadata
+                        });
+                        const clientInjectWaitMsRaw = converted.timingBreakdown?.hubResponseExcludedMs;
+                        const clientInjectWaitMs = typeof clientInjectWaitMsRaw === 'number' && Number.isFinite(clientInjectWaitMsRaw)
+                            ? Math.max(0, Math.floor(clientInjectWaitMsRaw))
+                            : 0;
+                        const hubResponseElapsedMsRaw = Date.now() - hubResponseStartedAtMs;
+                        const hubResponseElapsedMs = Math.max(0, hubResponseElapsedMsRaw - clientInjectWaitMs);
+                        const convertedBodyRecord = converted.body && typeof converted.body === 'object'
+                            ? converted.body
+                            : undefined;
+                        const finishReason = convertedBodyRecord && typeof convertedBodyRecord[STREAM_LOG_FINISH_REASON_KEY] === 'string'
+                            ? String(convertedBodyRecord[STREAM_LOG_FINISH_REASON_KEY])
+                            : undefined;
+                        this.logStage('provider.response_convert.completed', input.requestId, {
+                            providerKey: target.providerKey,
+                            status: converted.status,
+                            hasBody: converted.body !== undefined && converted.body !== null,
+                            attempt
+                        });
+                        if (clientInjectWaitMs > 0) {
+                            this.logStage('client.inject_wait.start', input.requestId, {
+                                providerKey: target.providerKey,
+                                attempt
+                            });
+                            this.logStage('client.inject_wait.completed', input.requestId, {
+                                providerKey: target.providerKey,
+                                elapsedMs: clientInjectWaitMs,
+                                attempt
                             });
                         }
-                        catch {
-                            // best-effort; never block retry/failover path
+                        this.logStage('hub.response.completed', input.requestId, {
+                            providerKey: target.providerKey,
+                            status: converted.status,
+                            elapsedMs: hubResponseElapsedMs,
+                            ...(clientInjectWaitMs > 0 ? { excludedClientInjectWaitMs: clientInjectWaitMs } : {}),
+                            hasBody: converted.body !== undefined && converted.body !== null,
+                            ...(finishReason ? { finishReason } : {}),
+                            attempt
+                        });
+                        // Treat upstream 429 as provider failure across protocols to avoid
+                        // silently returning success and to let Virtual Router failover to other candidates.
+                        // Keep existing Gemini compatibility behavior for 400/4xx thoughtSignature-like failures.
+                        const convertedStatus = typeof converted.status === 'number' ? converted.status : undefined;
+                        this.logStage('provider.response_status_check.start', input.requestId, {
+                            providerKey: target.providerKey,
+                            convertedStatus,
+                            attempt
+                        });
+                        const isGlobalRetryable429 = convertedStatus === 429;
+                        const isGeminiCompatFailure = typeof convertedStatus === 'number' &&
+                            convertedStatus >= 400 &&
+                            (isAntigravityProviderKey(target.providerKey) ||
+                                (typeof target.providerKey === 'string' && target.providerKey.startsWith('gemini-cli.'))) &&
+                            providerProtocol === 'gemini-chat';
+                        if (isGlobalRetryable429 || isGeminiCompatFailure) {
+                            const bodyForError = converted.body && typeof converted.body === 'object' ? converted.body : undefined;
+                            const errMsg = bodyForError && bodyForError.error && typeof bodyForError.error === 'object'
+                                ? String(bodyForError.error.message || bodyForError.error || '')
+                                : '';
+                            const statusCode = typeof convertedStatus === 'number' ? convertedStatus : 500;
+                            const errorToThrow = new Error(errMsg && errMsg.trim().length ? errMsg : `HTTP ${statusCode}`);
+                            errorToThrow.statusCode = statusCode;
+                            errorToThrow.status = statusCode;
+                            errorToThrow.response = { data: bodyForError };
+                            try {
+                                const { emitProviderError } = await import('../../../providers/core/utils/provider-error-reporter.js');
+                                emitProviderError({
+                                    error: errorToThrow,
+                                    stage: 'provider.http',
+                                    runtime: {
+                                        requestId: input.requestId,
+                                        providerKey: target.providerKey,
+                                        providerId: handle.providerId,
+                                        providerType: handle.providerType,
+                                        providerFamily: handle.providerFamily,
+                                        providerProtocol,
+                                        routeName: pipelineResult.routingDecision?.routeName,
+                                        pipelineId: target.providerKey,
+                                        target,
+                                        runtimeKey
+                                    },
+                                    dependencies: this.deps.getModuleDependencies(),
+                                    statusCode,
+                                    recoverable: statusCode === 429,
+                                    affectsHealth: true,
+                                    details: {
+                                        source: 'converted_response_status',
+                                        convertedStatus: statusCode,
+                                        wrappedErrorResponse: true
+                                    }
+                                });
+                            }
+                            catch {
+                                // best-effort; never block retry/failover path
+                            }
+                            throw errorToThrow;
+                        }
+                        this.logStage('provider.response_status_check.completed', input.requestId, {
+                            providerKey: target.providerKey,
+                            convertedStatus,
+                            attempt
+                        });
+                        this.logStage('provider.usage_extract.start', input.requestId, {
+                            providerKey: target.providerKey,
+                            source: 'converted_response',
+                            attempt
+                        });
+                        const usage = extractUsageFromResult(converted, mergedMetadata) ?? usageFromProvider;
+                        this.logStage('provider.usage_extract.completed', input.requestId, {
+                            providerKey: target.providerKey,
+                            source: 'converted_response',
+                            hasUsage: Boolean(usage),
+                            attempt
+                        });
+                        aggregatedUsage = mergeUsageMetrics(aggregatedUsage, usage);
+                        this.logStage('provider.tool_usage_record.start', input.requestId, {
+                            providerKey: target.providerKey,
+                            attempt
+                        });
+                        if (converted.body && typeof converted.body === 'object') {
+                            const body = converted.body;
+                            if (!('__sse_responses' in body)) {
+                                this.deps.stats.recordToolUsage({ providerKey: target.providerKey, model: providerModel }, body);
+                            }
                         }
+                        this.logStage('provider.tool_usage_record.completed', input.requestId, {
+                            providerKey: target.providerKey,
+                            attempt
+                        });
+                        recordAttempt({ usage: aggregatedUsage, error: false });
+                        return {
+                            ...converted,
+                            usageLogInfo: {
+                                providerKey: target.providerKey,
+                                model: providerModel,
+                                usage: aggregatedUsage,
+                                requestStartedAtMs: requestStartedAt,
+                                timingRequestIds: Array.from(new Set([providerRequestId, input.requestId].filter((value) => Boolean(value)))),
+                                sessionId: mergedMetadata.sessionId,
+                                conversationId: mergedMetadata.conversationId
+                            }
+                        };
                     }
-                    else if (isSseDecodeRetryableNetworkError(error, status)) {
-                        try {
-                            const { emitProviderError } = await import('../../../providers/core/utils/provider-error-reporter.js');
-                            emitProviderError({
-                                error,
-                                stage: 'provider.sse_decode',
-                                runtime: {
-                                    requestId: input.requestId,
-                                    providerKey: target.providerKey,
-                                    providerId: handle.providerId,
-                                    providerType: handle.providerType,
-                                    providerFamily: handle.providerFamily,
-                                    providerProtocol,
-                                    routeName: pipelineResult.routingDecision?.routeName,
-                                    pipelineId: target.providerKey,
-                                    target,
-                                    runtimeKey
-                                },
-                                dependencies: this.deps.getModuleDependencies(),
-                                statusCode: 502,
-                                recoverable: true,
-                                affectsHealth: true,
-                                details: {
-                                    source: 'sse_decode_network_error',
-                                    errorCode: typeof error?.code === 'string' ? String(error.code) : undefined,
-                                    upstreamCode: typeof error?.upstreamCode === 'string' ? String(error.upstreamCode) : undefined,
-                                    message: errorMessage
-                                }
-                            });
+                    catch (error) {
+                        const errorMessage = error instanceof Error ? error.message : String(error ?? 'Unknown error');
+                        this.logStage('provider.send.error', input.requestId, {
+                            providerKey: target.providerKey,
+                            message: errorMessage,
+                            providerType: handle.providerType,
+                            providerFamily: handle.providerFamily,
+                            model: providerModel,
+                            providerLabel,
+                            attempt
+                        });
+                        lastError = error;
+                        if (isAntigravityProviderKey(target.providerKey)) {
+                            const signature = extractRetryErrorSignature(error);
+                            const consecutive = antigravityRetrySignal && antigravityRetrySignal.signature === signature
+                                ? antigravityRetrySignal.consecutive + 1
+                                : 1;
+                            antigravityRetrySignal = { signature, consecutive };
                         }
-                        catch {
-                            // best-effort; never block retry/failover path
+                        else {
+                            antigravityRetrySignal = null;
                         }
-                    }
-                    const isVerify = status === 403 && isGoogleAccountVerificationRequiredError(error);
-                    const isReauth = status === 403 && isAntigravityReauthRequired403(error);
-                    const promptTooLong = isPromptTooLongError(error);
-                    if (promptTooLong) {
-                        contextOverflowRetries += 1;
-                        if (forcedRouteHint !== 'longcontext') {
-                            forcedRouteHint = 'longcontext';
+                        const status = extractStatusCodeFromError(error);
+                        if (isSseDecodeRateLimitError(error, status)) {
+                            try {
+                                const { emitProviderError } = await import('../../../providers/core/utils/provider-error-reporter.js');
+                                emitProviderError({
+                                    error,
+                                    stage: 'provider.sse_decode',
+                                    runtime: {
+                                        requestId: input.requestId,
+                                        providerKey: target.providerKey,
+                                        providerId: handle.providerId,
+                                        providerType: handle.providerType,
+                                        providerFamily: handle.providerFamily,
+                                        providerProtocol,
+                                        routeName: pipelineResult.routingDecision?.routeName,
+                                        pipelineId: target.providerKey,
+                                        target,
+                                        runtimeKey
+                                    },
+                                    dependencies: this.deps.getModuleDependencies(),
+                                    statusCode: 429,
+                                    recoverable: true,
+                                    affectsHealth: true,
+                                    details: {
+                                        source: 'sse_decode_rate_limit',
+                                        errorCode: typeof error?.code === 'string' ? String(error.code) : undefined,
+                                        upstreamCode: typeof error?.upstreamCode === 'string' ? String(error.upstreamCode) : undefined,
+                                        message: errorMessage
+                                    }
+                                });
+                            }
+                            catch {
+                                // best-effort; never block retry/failover path
+                            }
                         }
-                    }
-                    const shouldRetry = attempt < maxAttempts &&
-                        (promptTooLong
-                            ? contextOverflowRetries < MAX_CONTEXT_OVERFLOW_RETRIES
-                            : (shouldRetryProviderError(error) ||
-                                (isAntigravityProviderKey(target.providerKey) && (isVerify || isReauth))));
-                    if (!shouldRetry) {
-                        recordAttempt({ error: true });
-                        throw error;
-                    }
-                    // Record this failed provider attempt even if the overall request succeeds later via failover.
-                    recordAttempt({ error: true });
-                    const singleProviderPool = Boolean(initialRoutePool && initialRoutePool.length === 1 && initialRoutePool[0] === target.providerKey);
-                    if (promptTooLong && target.providerKey) {
-                        excludedProviderKeys.add(target.providerKey);
-                    }
-                    else if (singleProviderPool) {
-                        await waitBeforeRetry(error);
-                    }
-                    if (!promptTooLong && !singleProviderPool && target.providerKey) {
-                        const is429 = status === 429;
-                        if (isAntigravityProviderKey(target.providerKey) && (isVerify || is429)) {
-                            // For Antigravity 403 verify / 429 states:
-                            // - exclude the current providerKey so we don't immediately retry the same account
-                            // - avoid ALL other Antigravity aliases on retry (prefer non-Antigravity fallbacks)
-                            excludedProviderKeys.add(target.providerKey);
-                            if (antigravityRetrySignal) {
-                                antigravityRetrySignal.avoidAllOnRetry = true;
+                        else if (isSseDecodeRetryableNetworkError(error, status)) {
+                            try {
+                                const { emitProviderError } = await import('../../../providers/core/utils/provider-error-reporter.js');
+                                emitProviderError({
+                                    error,
+                                    stage: 'provider.sse_decode',
+                                    runtime: {
+                                        requestId: input.requestId,
+                                        providerKey: target.providerKey,
+                                        providerId: handle.providerId,
+                                        providerType: handle.providerType,
+                                        providerFamily: handle.providerFamily,
+                                        providerProtocol,
+                                        routeName: pipelineResult.routingDecision?.routeName,
+                                        pipelineId: target.providerKey,
+                                        target,
+                                        runtimeKey
+                                    },
+                                    dependencies: this.deps.getModuleDependencies(),
+                                    statusCode: 502,
+                                    recoverable: true,
+                                    affectsHealth: true,
+                                    details: {
+                                        source: 'sse_decode_network_error',
+                                        errorCode: typeof error?.code === 'string' ? String(error.code) : undefined,
+                                        upstreamCode: typeof error?.upstreamCode === 'string' ? String(error.upstreamCode) : undefined,
+                                        message: errorMessage
+                                    }
+                                });
                             }
-                            else {
-                                antigravityRetrySignal = { signature: extractRetryErrorSignature(error), consecutive: 1, avoidAllOnRetry: true };
+                            catch {
+                                // best-effort; never block retry/failover path
                             }
                         }
-                        else if (isAntigravityProviderKey(target.providerKey) && isReauth) {
-                            // Antigravity OAuth reauth-required 403:
-                            // - exclude the current providerKey so router can pick another alias
-                            // - DO NOT avoid all Antigravity on retry; switching aliases is the intended recovery path.
-                            excludedProviderKeys.add(target.providerKey);
+                        const isVerify = status === 403 && isGoogleAccountVerificationRequiredError(error);
+                        const isReauth = status === 403 && isAntigravityReauthRequired403(error);
+                        const promptTooLong = isPromptTooLongError(error);
+                        if (promptTooLong) {
+                            contextOverflowRetries += 1;
+                            if (forcedRouteHint !== 'longcontext') {
+                                forcedRouteHint = 'longcontext';
+                            }
+                        }
+                        const shouldRetry = attempt < maxAttempts &&
+                            (promptTooLong
+                                ? contextOverflowRetries < MAX_CONTEXT_OVERFLOW_RETRIES
+                                : (shouldRetryProviderError(error) ||
+                                    (isAntigravityProviderKey(target.providerKey) && (isVerify || isReauth))));
+                        if (!shouldRetry) {
+                            recordAttempt({ error: true });
+                            throw error;
                         }
-                        else if (!isAntigravityProviderKey(target.providerKey) || shouldRotateAntigravityAliasOnRetry(error)) {
+                        // Record this failed provider attempt even if the overall request succeeds later via failover.
+                        recordAttempt({ error: true });
+                        const singleProviderPool = Boolean(initialRoutePool && initialRoutePool.length === 1 && initialRoutePool[0] === target.providerKey);
+                        if (promptTooLong && target.providerKey) {
                             excludedProviderKeys.add(target.providerKey);
                         }
+                        else if (singleProviderPool) {
+                            await waitBeforeRetry(error);
+                        }
+                        if (!promptTooLong && !singleProviderPool && target.providerKey) {
+                            const is429 = status === 429;
+                            if (isAntigravityProviderKey(target.providerKey) && (isVerify || is429)) {
+                                // For Antigravity 403 verify / 429 states:
+                                // - exclude the current providerKey so we don't immediately retry the same account
+                                // - avoid ALL other Antigravity aliases on retry (prefer non-Antigravity fallbacks)
+                                excludedProviderKeys.add(target.providerKey);
+                                if (antigravityRetrySignal) {
+                                    antigravityRetrySignal.avoidAllOnRetry = true;
+                                }
+                                else {
+                                    antigravityRetrySignal = { signature: extractRetryErrorSignature(error), consecutive: 1, avoidAllOnRetry: true };
+                                }
+                            }
+                            else if (isAntigravityProviderKey(target.providerKey) && isReauth) {
+                                // Antigravity OAuth reauth-required 403:
+                                // - exclude the current providerKey so router can pick another alias
+                                // - DO NOT avoid all Antigravity on retry; switching aliases is the intended recovery path.
+                                excludedProviderKeys.add(target.providerKey);
+                            }
+                            else if (!isAntigravityProviderKey(target.providerKey) || shouldRotateAntigravityAliasOnRetry(error)) {
+                                excludedProviderKeys.add(target.providerKey);
+                            }
+                        }
+                        this.logStage('provider.retry', input.requestId, {
+                            providerKey: target.providerKey,
+                            attempt,
+                            nextAttempt: attempt + 1,
+                            excluded: Array.from(excludedProviderKeys),
+                            reason: describeRetryReason(error),
+                            routeHint: forcedRouteHint,
+                            ...(promptTooLong ? { contextOverflowRetries, maxContextOverflowRetries: MAX_CONTEXT_OVERFLOW_RETRIES } : {})
+                        });
+                        continue;
                     }
-                    this.logStage('provider.retry', input.requestId, {
-                        providerKey: target.providerKey,
-                        attempt,
-                        nextAttempt: attempt + 1,
-                        excluded: Array.from(excludedProviderKeys),
-                        reason: describeRetryReason(error),
-                        routeHint: forcedRouteHint,
-                        ...(promptTooLong ? { contextOverflowRetries, maxContextOverflowRetries: MAX_CONTEXT_OVERFLOW_RETRIES } : {})
-                    });
-                    continue;
                 }
+                throw lastError ?? new Error('Provider execution failed without response');
+            }
+            finally {
+                await this.deps.onRequestEnd?.({ requestId: executorRequestId });
             }
-            throw lastError ?? new Error('Provider execution failed without response');
         }
         catch (error) {
             // If we failed before selecting a provider (no bindProvider/recordAttempt),