@jsonstudio/rcc 0.90.814 → 0.90.876

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

@@ -13,8 +13,9 @@ import { isPoolExhaustedPipelineError, mergeMetadataPreservingDefined, resolvePo
 import { resolveProviderRuntimeOrThrow } from './executor/provider-runtime-resolver.js';
 import { resolveProviderRequestContext } from './executor/provider-request-context.js';
 import { isServerToolEnabled } from './servertool-admin-state.js';
-import { registerRequestLogContext } from '../../utils/request-log-color.js';
+import { registerRequestLogContext, resolveSessionLogColor } from '../../utils/request-log-color.js';
 import { STREAM_LOG_FINISH_REASON_KEY } from '../../utils/finish-reason.js';
+import { createNoopProviderTrafficGovernor, getSharedProviderTrafficGovernor } from './provider-traffic-governor.js';
 const DEFAULT_MAX_PROVIDER_ATTEMPTS = 6;
 function readString(value) {
     if (typeof value !== 'string') {
@@ -163,16 +164,304 @@ function extractRetryErrorSnapshot(error) {
         reason
     };
 }
+function readHubStageTop(metadata) {
+    if (!metadata || typeof metadata !== 'object') {
+        return undefined;
+    }
+    const rt = metadata.__rt && typeof metadata.__rt === 'object' && !Array.isArray(metadata.__rt)
+        ? metadata.__rt
+        : undefined;
+    const raw = rt?.hubStageTop;
+    if (!Array.isArray(raw) || raw.length === 0) {
+        return undefined;
+    }
+    const normalized = raw
+        .map((entry) => {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            return null;
+        }
+        const record = entry;
+        const stage = typeof record.stage === 'string' ? record.stage.trim() : '';
+        const totalMs = typeof record.totalMs === 'number' && Number.isFinite(record.totalMs)
+            ? Math.max(0, Math.round(record.totalMs))
+            : undefined;
+        if (!stage || totalMs === undefined) {
+            return null;
+        }
+        const count = typeof record.count === 'number' && Number.isFinite(record.count)
+            ? Math.max(0, Math.floor(record.count))
+            : undefined;
+        const avgMs = typeof record.avgMs === 'number' && Number.isFinite(record.avgMs)
+            ? Math.max(0, Math.round(record.avgMs))
+            : undefined;
+        const maxMs = typeof record.maxMs === 'number' && Number.isFinite(record.maxMs)
+            ? Math.max(0, Math.round(record.maxMs))
+            : undefined;
+        return {
+            stage,
+            totalMs,
+            ...(count !== undefined ? { count } : {}),
+            ...(avgMs !== undefined ? { avgMs } : {}),
+            ...(maxMs !== undefined ? { maxMs } : {})
+        };
+    })
+        .filter((entry) => Boolean(entry));
+    return normalized.length ? normalized : undefined;
+}
 function truncateReason(reason, maxLength = 220) {
     if (reason.length <= maxLength) {
         return reason;
     }
     return `${reason.slice(0, Math.max(0, maxLength - 1))}…`;
 }
+function resolveTrafficRuntimeProfile(runtimeKey, handle, providerKey) {
+    const runtimeCandidate = handle.runtime;
+    if (runtimeCandidate && typeof runtimeCandidate === 'object') {
+        return runtimeCandidate;
+    }
+    const providerIdFallback = (() => {
+        if (typeof handle.providerId === 'string' && handle.providerId.trim()) {
+            return handle.providerId.trim();
+        }
+        if (typeof providerKey === 'string' && providerKey.includes('.')) {
+            const [head] = providerKey.split('.');
+            if (head && head.trim()) {
+                return head.trim();
+            }
+        }
+        return 'unknown';
+    })();
+    const providerTypeFallback = (typeof handle.providerType === 'string' && handle.providerType.trim()
+        ? handle.providerType.trim().toLowerCase()
+        : 'openai');
+    return {
+        runtimeKey,
+        providerId: providerIdFallback,
+        providerKey,
+        providerType: providerTypeFallback,
+        providerFamily: handle.providerFamily,
+        endpoint: '',
+        auth: {
+            type: 'apikey',
+            value: ''
+        }
+    };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function valueHasNonEmptyText(value) {
+    if (typeof value === 'string') {
+        return value.trim().length > 0;
+    }
+    if (Array.isArray(value)) {
+        return value.some((item) => valueHasNonEmptyText(item));
+    }
+    if (!isRecord(value)) {
+        return false;
+    }
+    return (valueHasNonEmptyText(value.text)
+        || valueHasNonEmptyText(value.output_text)
+        || valueHasNonEmptyText(value.content)
+        || valueHasNonEmptyText(value.reasoning_content)
+        || valueHasNonEmptyText(value.reasoning));
+}
+function extractTextFromResponsesOutputItem(item) {
+    if (!isRecord(item)) {
+        return '';
+    }
+    const itemType = readString(item.type)?.toLowerCase();
+    if (itemType === 'output_text' || itemType === 'text' || itemType === 'input_text') {
+        const direct = readString(item.text);
+        if (direct) {
+            return direct;
+        }
+    }
+    if (itemType === 'message') {
+        const content = Array.isArray(item.content) ? item.content : [];
+        const chunks = [];
+        for (const part of content) {
+            if (!isRecord(part)) {
+                continue;
+            }
+            const partType = readString(part.type)?.toLowerCase();
+            if (partType && partType !== 'output_text' && partType !== 'text' && partType !== 'input_text') {
+                continue;
+            }
+            const partText = readString(part.text);
+            if (partText) {
+                chunks.push(partText);
+            }
+        }
+        return chunks.join('');
+    }
+    return '';
+}
+function backfillResponsesOutputTextIfMissing(body) {
+    if (!isRecord(body)) {
+        return;
+    }
+    if (valueHasNonEmptyText(body.output_text)) {
+        return;
+    }
+    const outputItems = Array.isArray(body.output) ? body.output : [];
+    if (outputItems.length <= 0) {
+        return;
+    }
+    const text = outputItems
+        .map((item) => extractTextFromResponsesOutputItem(item))
+        .join('')
+        .trim();
+    if (!text) {
+        return;
+    }
+    body.output_text = text;
+}
+function emitVirtualRouterConcurrencyLog(args) {
+    const timestamp = (() => {
+        const now = new Date();
+        const hh = String(now.getHours()).padStart(2, '0');
+        const mm = String(now.getMinutes()).padStart(2, '0');
+        const ss = String(now.getSeconds()).padStart(2, '0');
+        return `${hh}:${mm}:${ss}`;
+    })();
+    const sessionLabel = args.sessionId ? ` sid=${args.sessionId}` : '';
+    const routeBase = args.routeName && args.routeName.trim() ? args.routeName.trim() : 'route';
+    const routeLabel = args.poolId && args.poolId.trim() ? `${routeBase}/${args.poolId.trim()}` : routeBase;
+    const providerLabel = args.providerKey && args.providerKey.trim() ? args.providerKey.trim() : 'unknown-provider';
+    const modelLabel = args.model && args.model.trim() ? `.${args.model.trim()}` : '';
+    const reasonLabel = args.reason && args.reason.trim() ? ` reason=${args.reason.trim()}` : '';
+    const prefixColor = '\x1b[38;5;208m';
+    const timeColor = '\x1b[90m';
+    const routeColor = resolveSessionLogColor(args.sessionId);
+    const white = '\x1b[97m';
+    const reset = '\x1b[0m';
+    const concurrencyLabel = `${white}[concurrency:${Math.max(0, Math.floor(args.activeInFlight))}/${Math.max(1, Math.floor(args.maxInFlight))}]${reset}`;
+    console.log(`${prefixColor}[virtual-router-hit]${reset} ${concurrencyLabel} ${timeColor}${timestamp}${reset}${sessionLabel} ${routeColor}${routeLabel} -> ${providerLabel}${modelLabel}${reasonLabel}${reset}`);
+}
+function hasNonEmptyToolCalls(value) {
+    if (!Array.isArray(value) || value.length <= 0) {
+        return false;
+    }
+    return value.some((item) => isRecord(item));
+}
+function hasOutputFunctionCalls(value) {
+    if (!Array.isArray(value) || value.length <= 0) {
+        return false;
+    }
+    return value.some((item) => {
+        if (!isRecord(item)) {
+            return false;
+        }
+        const itemType = readString(item.type)?.toLowerCase();
+        if (itemType === 'function_call' || itemType === 'function') {
+            return true;
+        }
+        if (hasNonEmptyToolCalls(item.tool_calls)) {
+            return true;
+        }
+        return false;
+    });
+}
+function containsToolRegistryMissingText(value) {
+    if (!valueHasNonEmptyText(value)) {
+        return false;
+    }
+    const text = String(value ?? '');
+    const pattern = /tool\s+[a-z0-9_.-]+\s+does\s+not\s+exist(?:s)?/ig;
+    let count = 0;
+    while (pattern.exec(text)) {
+        count += 1;
+        if (count >= 1) {
+            return true;
+        }
+    }
+    return false;
+}
+function detectRetryableEmptyAssistantResponse(body) {
+    if (!isRecord(body)) {
+        return null;
+    }
+    if (Object.prototype.hasOwnProperty.call(body, '__sse_responses')) {
+        return null;
+    }
+    const choices = Array.isArray(body.choices) ? body.choices : [];
+    if (choices.length > 0) {
+        const firstChoice = isRecord(choices[0]) ? choices[0] : undefined;
+        if (!firstChoice) {
+            return null;
+        }
+        const finishReason = readString(firstChoice.finish_reason)?.toLowerCase() ?? '';
+        const message = isRecord(firstChoice.message) ? firstChoice.message : undefined;
+        const hasToolCalls = hasNonEmptyToolCalls(message?.tool_calls);
+        const hasText = valueHasNonEmptyText(message?.content)
+            || valueHasNonEmptyText(message?.reasoning_content)
+            || valueHasNonEmptyText(message?.reasoning)
+            || valueHasNonEmptyText(firstChoice.content);
+        const combinedText = [
+            message?.content,
+            message?.reasoning_content,
+            message?.reasoning,
+            firstChoice.content
+        ]
+            .filter((item) => valueHasNonEmptyText(item))
+            .map((item) => String(item))
+            .join('\n');
+        if ((finishReason === 'stop' || finishReason === 'tool_calls' || !finishReason) && !hasToolCalls && !hasText) {
+            return {
+                reason: `finish_reason=${finishReason || 'unknown'} but assistant text/tool_calls are empty`,
+                marker: 'chat_empty_assistant'
+            };
+        }
+        if ((finishReason === 'stop' || finishReason === 'tool_calls' || !finishReason) && !hasToolCalls && containsToolRegistryMissingText(combinedText)) {
+            return {
+                reason: 'assistant emitted textual tool-not-found complaint without structured tool_calls',
+                marker: 'chat_textual_tool_registry_missing'
+            };
+        }
+    }
+    const status = readString(body.status)?.toLowerCase() ?? '';
+    if (status === 'completed' || status === 'stop') {
+        const requiredAction = isRecord(body.required_action) ? body.required_action : undefined;
+        const submitToolOutputs = requiredAction && isRecord(requiredAction.submit_tool_outputs)
+            ? requiredAction.submit_tool_outputs
+            : undefined;
+        const hasRequiredActionToolCalls = hasNonEmptyToolCalls(submitToolOutputs?.tool_calls);
+        const hasFunctionCalls = hasOutputFunctionCalls(body.output);
+        const hasText = valueHasNonEmptyText(body.output_text)
+            || valueHasNonEmptyText(body.output)
+            || valueHasNonEmptyText(body.reasoning);
+        if (!hasRequiredActionToolCalls && !hasFunctionCalls && !hasText) {
+            return {
+                reason: `responses status=${status} but output text/tool_calls are empty`,
+                marker: 'responses_empty_output'
+            };
+        }
+        if (!hasRequiredActionToolCalls &&
+            !hasFunctionCalls &&
+            containsToolRegistryMissingText(body.output_text)) {
+            return {
+                reason: 'responses completed with textual tool-not-found complaint but no function_call output',
+                marker: 'responses_textual_tool_registry_missing'
+            };
+        }
+    }
+    return null;
+}
 export class HubRequestExecutor {
     deps;
+    trafficGovernor;
     constructor(deps) {
         this.deps = deps;
+        if (deps.trafficGovernor) {
+            this.trafficGovernor = deps.trafficGovernor;
+            return;
+        }
+        if (process.env.NODE_ENV === 'test') {
+            this.trafficGovernor = createNoopProviderTrafficGovernor();
+            return;
+        }
+        this.trafficGovernor = getSharedProviderTrafficGovernor();
     }
     logProviderRetrySwitch(args) {
         const providerLabel = args.providerKey || 'unknown-provider';
@@ -249,6 +538,27 @@ export class HubRequestExecutor {
                     if (forcedRouteHint) {
                         metadataForAttempt.routeHint = forcedRouteHint;
                     }
+                    const metadataRt = metadataForAttempt.__rt && typeof metadataForAttempt.__rt === 'object' && !Array.isArray(metadataForAttempt.__rt)
+                        ? metadataForAttempt.__rt
+                        : {};
+                    metadataForAttempt.__rt = {
+                        ...metadataRt,
+                        disableVirtualRouterHitLog: true
+                    };
+                    // llmswitch Hub 仍有一条 legacy virtual-router-hit 调试日志（无 concurrency 信息）。
+                    // 为保证控制台只保留一条统一格式（含 [concurrency:x/y]）的命中日志，这里对
+                    // metadata.logger 做最小化降噪：仅屏蔽 logVirtualRouterHit，不影响其他 logger 能力。
+                    const loggerRecord = metadataForAttempt.logger &&
+                        typeof metadataForAttempt.logger === 'object' &&
+                        !Array.isArray(metadataForAttempt.logger)
+                        ? metadataForAttempt.logger
+                        : undefined;
+                    if (loggerRecord && typeof loggerRecord.logVirtualRouterHit === 'function') {
+                        metadataForAttempt.logger = {
+                            ...loggerRecord,
+                            logVirtualRouterHit: undefined
+                        };
+                    }
                     const clientHeadersForAttempt = cloneClientHeaders(metadataForAttempt?.clientHeaders) || inboundClientHeaders;
                     if (clientHeadersForAttempt) {
                         metadataForAttempt.clientHeaders = clientHeadersForAttempt;
@@ -271,6 +581,13 @@ export class HubRequestExecutor {
                             if (cooldownWaitMs &&
                                 attempt < maxAttempts &&
                                 poolCooldownWaitBudgetMs >= cooldownWaitMs) {
+                                this.logStage(`${pipelineLabel}.completed`, providerRequestId, {
+                                    route: undefined,
+                                    target: undefined,
+                                    elapsedMs: Date.now() - hubStartedAtMs,
+                                    attempt,
+                                    recoverablePoolCooldown: true
+                                });
                                 this.logStage('provider.route_pool_cooldown_wait', providerRequestId, {
                                     attempt,
                                     waitMs: cooldownWaitMs,
@@ -308,6 +625,9 @@ export class HubRequestExecutor {
                     if (!initialRoutePool && Array.isArray(pipelineResult.routingDecision?.pool)) {
                         initialRoutePool = [...pipelineResult.routingDecision.pool];
                     }
+                    const routePoolForAttempt = Array.isArray(pipelineResult.routingDecision?.pool)
+                        ? pipelineResult.routingDecision.pool
+                        : (initialRoutePool ?? []);
                     const providerPayload = pipelineResult.providerPayload;
                     const target = pipelineResult.target;
                     if (!providerPayload || !target?.providerKey) {
@@ -392,11 +712,9 @@ export class HubRequestExecutor {
                             throw error;
                         }
                         recordAttempt({ error: true });
+                        const retryBackoffMs = await waitBeforeRetry(error, { attempt });
                         const singleProviderPool = Boolean(initialRoutePool && initialRoutePool.length === 1 && initialRoutePool[0] === target.providerKey);
-                        if (singleProviderPool) {
-                            await waitBeforeRetry(error);
-                        }
-                        else if (target.providerKey) {
+                        if (!singleProviderPool && target.providerKey) {
                             excludedProviderKeys.add(target.providerKey);
                         }
                         const switchAction = singleProviderPool ? 'retry_same_provider' : 'exclude_and_reroute';
@@ -422,7 +740,8 @@ export class HubRequestExecutor {
                             switchAction,
                             ...(typeof retryError.statusCode === 'number' ? { statusCode: retryError.statusCode } : {}),
                             ...(retryError.errorCode ? { errorCode: retryError.errorCode } : {}),
-                            ...(retryError.upstreamCode ? { upstreamCode: retryError.upstreamCode } : {})
+                            ...(retryError.upstreamCode ? { upstreamCode: retryError.upstreamCode } : {}),
+                            retryBackoffMs
                         });
                         continue;
                     }
@@ -487,18 +806,65 @@ export class HubRequestExecutor {
                         runtimeKey,
                         attempt
                     });
-                    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
-                    });
+                    let trafficPermit = null;
+                    let providerSendStartedAtMs = 0;
                     try {
+                        this.logStage('provider.traffic.acquire.start', input.requestId, {
+                            providerKey: target.providerKey,
+                            runtimeKey,
+                            attempt
+                        });
+                        const trafficAcquired = await this.trafficGovernor.acquire({
+                            runtimeKey,
+                            providerKey: target.providerKey,
+                            requestId: input.requestId,
+                            runtime: resolveTrafficRuntimeProfile(runtimeKey, handle, target.providerKey),
+                            // If current route pool has alternatives, do not stall too long on quota/RPM gating.
+                            // Switch provider after 10s wait so weighted pools can continue serving.
+                            softWaitTimeoutMs: routePoolForAttempt.length > 1 ? 10_000 : undefined
+                        });
+                        trafficPermit = trafficAcquired.permit;
+                        if (trafficAcquired.waitedMs > 0) {
+                            this.logStage('provider.traffic.acquire.wait', input.requestId, {
+                                providerKey: target.providerKey,
+                                runtimeKey,
+                                waitedMs: trafficAcquired.waitedMs,
+                                attempt
+                            });
+                        }
+                        this.logStage('provider.traffic.acquire.completed', input.requestId, {
+                            providerKey: target.providerKey,
+                            runtimeKey,
+                            maxInFlight: trafficAcquired.policy.concurrency.maxInFlight,
+                            requestsPerMinute: trafficAcquired.policy.rpm.requestsPerMinute,
+                            activeInFlight: trafficAcquired.activeInFlight,
+                            rpmInWindow: trafficAcquired.rpmInWindow,
+                            attempt
+                        });
+                        const routingDecisionRecord = pipelineResult.routingDecision && typeof pipelineResult.routingDecision === 'object'
+                            ? pipelineResult.routingDecision
+                            : undefined;
+                        emitVirtualRouterConcurrencyLog({
+                            sessionId: readString(mergedMetadata.sessionId) ?? readString(mergedMetadata.conversationId),
+                            routeName: pipelineResult.routingDecision?.routeName,
+                            poolId: readString(routingDecisionRecord?.poolId),
+                            providerKey: target.providerKey,
+                            model: providerModel,
+                            reason: readString(routingDecisionRecord?.reasoning),
+                            activeInFlight: trafficAcquired.activeInFlight,
+                            maxInFlight: trafficAcquired.policy.concurrency.maxInFlight
+                        });
+                        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
+                        });
                         const providerResponse = await handle.instance.processIncoming(providerPayload);
                         const responseStatus = extractResponseStatus(providerResponse);
                         this.logStage('provider.send.completed', input.requestId, {
@@ -582,6 +948,9 @@ export class HubRequestExecutor {
                         const convertedBodyRecord = converted.body && typeof converted.body === 'object'
                             ? converted.body
                             : undefined;
+                        if (convertedBodyRecord) {
+                            backfillResponsesOutputTextIfMissing(convertedBodyRecord);
+                        }
                         const finishReason = convertedBodyRecord && typeof convertedBodyRecord[STREAM_LOG_FINISH_REASON_KEY] === 'string'
                             ? String(convertedBodyRecord[STREAM_LOG_FINISH_REASON_KEY])
                             : undefined;
@@ -683,6 +1052,22 @@ export class HubRequestExecutor {
                             convertedStatus,
                             attempt
                         });
+                        const emptyAssistantSignal = detectRetryableEmptyAssistantResponse(converted.body);
+                        if (emptyAssistantSignal) {
+                            const bodyForError = converted.body;
+                            const errorToThrow = new Error(`Upstream returned empty assistant payload: ${emptyAssistantSignal.reason}`);
+                            errorToThrow.statusCode = 502;
+                            errorToThrow.status = 502;
+                            errorToThrow.code = 'EMPTY_ASSISTANT_RESPONSE';
+                            errorToThrow.response = { data: bodyForError };
+                            this.logStage('provider.empty_assistant_retry', input.requestId, {
+                                providerKey: target.providerKey,
+                                marker: emptyAssistantSignal.marker,
+                                reason: emptyAssistantSignal.reason,
+                                attempt
+                            });
+                            throw errorToThrow;
+                        }
                         this.logStage('provider.usage_extract.start', input.requestId, {
                             providerKey: target.providerKey,
                             source: 'converted_response',
@@ -711,12 +1096,14 @@ export class HubRequestExecutor {
                             attempt
                         });
                         recordAttempt({ usage: aggregatedUsage, error: false });
+                        const metadataHubStageTop = readHubStageTop(mergedMetadata);
                         return {
                             ...converted,
                             usageLogInfo: {
                                 providerKey: target.providerKey,
                                 model: providerModel,
                                 usage: aggregatedUsage,
+                                hubStageTop: metadataHubStageTop,
                                 requestStartedAtMs: requestStartedAt,
                                 timingRequestIds: Array.from(new Set([providerRequestId, input.requestId].filter((value) => Boolean(value)))),
                                 sessionId: mergedMetadata.sessionId,
@@ -839,13 +1226,11 @@ export class HubRequestExecutor {
                         }
                         // Record this failed provider attempt even if the overall request succeeds later via failover.
                         recordAttempt({ error: true });
+                        const retryBackoffMs = await waitBeforeRetry(error, { attempt });
                         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)) {
@@ -894,10 +1279,49 @@ export class HubRequestExecutor {
                             ...(typeof retryError.statusCode === 'number' ? { statusCode: retryError.statusCode } : {}),
                             ...(retryError.errorCode ? { errorCode: retryError.errorCode } : {}),
                             ...(retryError.upstreamCode ? { upstreamCode: retryError.upstreamCode } : {}),
+                            retryBackoffMs,
                             ...(promptTooLong ? { contextOverflowRetries, maxContextOverflowRetries: MAX_CONTEXT_OVERFLOW_RETRIES } : {})
                         });
                         continue;
                     }
+                    finally {
+                        if (trafficPermit) {
+                            const releaseStartedAtMs = Date.now();
+                            this.logStage('provider.traffic.release.start', input.requestId, {
+                                providerKey: target.providerKey,
+                                runtimeKey,
+                                leaseId: trafficPermit.leaseId,
+                                attempt
+                            });
+                            try {
+                                const released = await this.trafficGovernor.release(trafficPermit);
+                                this.logStage('provider.traffic.release.completed', input.requestId, {
+                                    providerKey: target.providerKey,
+                                    runtimeKey,
+                                    leaseId: trafficPermit.leaseId,
+                                    released: released.released,
+                                    activeInFlight: released.activeInFlight,
+                                    elapsedMs: Date.now() - releaseStartedAtMs,
+                                    attempt
+                                });
+                            }
+                            catch (releaseError) {
+                                this.logStage('provider.traffic.release.error', input.requestId, {
+                                    providerKey: target.providerKey,
+                                    runtimeKey,
+                                    leaseId: trafficPermit.leaseId,
+                                    message: releaseError instanceof Error
+                                        ? releaseError.message
+                                        : String(releaseError ?? 'Unknown release error'),
+                                    elapsedMs: Date.now() - releaseStartedAtMs,
+                                    attempt
+                                });
+                            }
+                            finally {
+                                trafficPermit = null;
+                            }
+                        }
+                    }
                 }
                 throw lastError ?? new Error('Provider execution failed without response');
             }
@@ -924,7 +1348,8 @@ export class HubRequestExecutor {
 export const __requestExecutorTestables = {
     readString,
     extractRetryErrorSnapshot,
-    truncateReason
+    truncateReason,
+    detectRetryableEmptyAssistantResponse
 };
 export function createRequestExecutor(deps) {
     return new HubRequestExecutor(deps);