UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

538 lines (530 loc) • 27.5 kB
import { rotateAnthropicAccountOnResponse } from "../../oauth/anthropic-account-refusal"; import type { ResponsesRequestContext } from "./core-options"; import type { PreparedResponsesRequest } from "./request-prepare"; import type { ResponsesTransport } from "./request-transport"; import type { ResponsesSidecarAuth } from "./request-sidecar-auth"; import type { ResponsesEffects } from "./response-effects"; import type { ResponsesSendBudget } from "./request-send-budget"; import { formatErrorResponse } from "../../bridge"; import { planWebSearch, buildWebSearchTool, runWithWebSearch } from "../../web-search"; import { planImageBridge, planVideoBridge, IMAGE_GEN_TOOL_NAME, buildImageTool, VIDEO_GEN_TOOL_NAME, buildVideoTool, runWithImageBridge, clampImageMaxRounds, } from "../../images"; import type { ProviderAdapter } from "../../adapters/base"; import type { OcxParsedRequest } from "../../types"; import { rotateProviderTransportOn429, rateLimitRetryPolicyFor } from "../../providers/key-failover"; import { isGenericOAuthFailoverEnabled, rotateGenericOAuthAccountOn429, rotateGenericOAuthAccountOnRefusal, quarantineKiroSuspendedAccount, failoverAccountSnapshot, } from "../../oauth/generic-account-failover"; import { classifyKiroRefusal } from "../../adapters/kiro-refusal"; import { noteKiroMonthlyRefusal, noteKiroServedSuccess } from "../../providers/kiro-usage"; import { persistKiroAccountState } from "../../providers/kiro-account-state-disk"; import { readDisplaySafeErrorText } from "./core-errors"; import { ANTHROPIC_POOL_MAX_FAILOVERS_PER_REQUEST, getAnthropicPoolAccessSnapshot, formatAnthropicProviderForLog, } from "../../oauth/anthropic-routing"; import { resolveWireProtocolOverride } from "../adapter-resolve"; import { bindRouteReasoningReplayScope, adapterNeedsForcedContinuation } from "./core-replay"; import { namespacedToolName } from "../../types"; import { providerFetch } from "./fetch-helpers"; import type { AttemptRecoveryKind } from "../../usage/log"; import { recordAdapterReasoning, recordAdapterTier } from "../request-log"; import { normalizeLogConversationId } from "../request-log-conversation"; import { rememberResponseState } from "../../responses/state"; import { trackStreamLifetime } from "../lifecycle"; /** One responsibility of the Responses request pipeline; state owners are explicit. */ export async function executeResponsesSidecars( requestContext: Pick<ResponsesRequestContext, "config" | "options" | "logCtx">, requestState: Pick< PreparedResponsesRequest, | "parsed" | "route" | "inboundWire" | "selectedForwardHeaders" | "translatorBudget" | "rememberKiroDeliveredFinalAnswer" | "responseStateOptions" >, transportState: Pick< ResponsesTransport, | "adapter" | "genericFailoverAccountId" | "genericFailovers" | "genericFailoverLimit" | "replayOAuthCredentialSnapshot" | "applyFailoverSnapshot" | "anthropicRouteDecision" | "anthropicPoolAccountId" | "anthropicPoolFailovers" | "anthropicSessionKey" | "commitResolvedOAuthSelection" | "resolveSelectionAdapter" | "oauthDispatch" | "noteRoutedAttemptSend" | "bindKeyUsageFromBridge" >, sidecarState: Pick<ResponsesSidecarAuth, "routedCompaction" | "openAiSidecar">, responseEffects: Pick< ResponsesEffects, | "commitReasoningReplayServingRoute" | "continuationStateForResponse" | "notifyResponseComplete" | "cancelResponseCompletion" >, sendBudgetState: Pick<ResponsesSendBudget, "reserveCredentialHop">, ) { const { config, options, logCtx } = requestContext; const { applyFailoverSnapshot, anthropicSessionKey, commitResolvedOAuthSelection, resolveSelectionAdapter, oauthDispatch, } = transportState; const { parsed, route, inboundWire, translatorBudget, rememberKiroDeliveredFinalAnswer, responseStateOptions, } = requestState; const { routedCompaction, openAiSidecar } = sidecarState; const { reserveCredentialHop } = sendBudgetState; const { commitReasoningReplayServingRoute, continuationStateForResponse, notifyResponseComplete, cancelResponseCompletion, } = responseEffects; // Resolving the OpenAI search credential may hold the account's sole // cooldown-recovery probe lease. A streamed sidecar result keeps it until the // stream settles — completion or client cancel — so a later in-stream search // outcome can still clear the cooldown; a response with no live body is // terminal, so the lease is handed back before returning it. A recorded // search outcome already settled the lease, making each release a // generation-bound no-op. const releaseSearchProbeLease = (): void => { openAiSidecar?.releaseProbeLease?.(); }; // Tool results are PAIRED by call_id. parseRequest writes it into OcxToolResultMessage.toolCallId // (parser.ts:738/752) without validating it, because inputItemSchema's permissive catch-all // (schema.ts:106) accepts a tool item whose strict schema failed only for a missing call_id. A // translating adapter then consumes `toolCallId: string` holding undefined: kiro-wire.ts:32 // TypeErrors, ollama-native.ts:334 throws, and anthropic.ts:775 sends // "[tool_result without adjacent tool_use: undefined]" upstream (issue #3259). // // This CANNOT move into the schema. parseRequest (:2812) runs before the passthrough branch // (:3719), so a parse-time rejection would also kill forward/key passthrough and routed // compaction — paths that never read context.messages, build from _rawBody, and already // degrade an unpaired output to "[tool output for unknown call]" on their own. // // Keyed on the adapter, not on position: routedCompaction skips the passthrough branch above // yet still builds from _rawBody (see the :3703 comment). if (!("passthrough" in transportState.adapter && transportState.adapter.passthrough)) { const unpaired = parsed.context.messages.find( message => message.role === "toolResult" && (typeof (message as { toolCallId?: unknown }).toolCallId !== "string" || (message as { toolCallId: string }).toolCallId.length === 0), ); if (unpaired) { // Local validation has no running sidecar body to own this lease. releaseSearchProbeLease(); // Never interpolate the tool output: this message reaches the client and the logs. return formatErrorResponse( 400, "invalid_request_error", "tool result requires a non-empty string call_id", ); } } // Image / web-search sidecars: plan once, then dispatch with runTurn-aware priority. // Routed-compaction turns must NOT hit the image bridge: compaction clears tools/_webSearch but // leaves _imageGeneration, so planImageBridge would activate and return a normal Responses // completion instead of the synthetic compaction item Codex expects (#424). // // Web-search's loop only supports buildRequest/fetch/parseStream — NOT adapter.runTurn. Sending // Cursor/runTurn requests into runWithWebSearch produces empty HTTP failures. So: // - non-runTurn: web-search wins over image when both eligible (documented priority) // - runTurn: a search plan takes priority over media bridges and is executed // by executeResponsesRunTurn; the fetch loop below remains fetch-only. // LOCAL PATCH (runturn-websearch): runTurn adapters run their own web-search // loop inside executeResponsesRunTurn (src/web-search/run-turn-loop.ts); the // fetch-path loop below stays non-runTurn-only. const wsPlan = !routedCompaction ? planWebSearch(config, parsed, false, route.provider, route.modelId, openAiSidecar, { admission: options.admission, codexAuthPolicy: options.codexAuthPolicy, providerName: route.providerName, }) : undefined; const imgPlan = !routedCompaction ? await planImageBridge(config, parsed, route.provider) : undefined; const vidPlan = !routedCompaction ? await planVideoBridge(config, parsed, route.provider) : undefined; const canRunWebSearch = !!wsPlan && !transportState.adapter.runTurn; const rotateSidecarProviderOn429 = async ( retryAfter: string | null, responseHeaders?: Headers, retryParsed?: OcxParsedRequest, originalResponse?: Response, ): Promise<{ adapter: ProviderAdapter; recoveryKind: AttemptRecoveryKind } | null> => { if (route.providerName !== "kiro" && !(route.providerName === "anthropic" && originalResponse?.status === 403) && originalResponse && originalResponse.status !== 429) return null; const refusal = route.providerName === "kiro" && originalResponse ? classifyKiroRefusal(originalResponse.status, await readDisplaySafeErrorText(originalResponse.clone(), options.abortSignal ?? new AbortController().signal, "")).kind : "rate"; if (refusal === "other") return null; const sent = transportState.replayOAuthCredentialSnapshot; const monthlyCooldownMs = route.providerName === "kiro" && refusal === "monthly_quota" && sent ? noteKiroMonthlyRefusal(sent.accountId, sent.generation, Date.now()) : undefined; if (monthlyCooldownMs !== undefined) persistKiroAccountState(); if (route.providerName === "kiro" && refusal === "suspended" && transportState.genericFailoverAccountId) quarantineKiroSuspendedAccount(transportState.genericFailoverAccountId, sent?.generation); // Which credential axis actually moved. The main routed path already reports these three // separately (`adapter-dispatch`: key-429 / anthropic-oauth-429 / oauth-account-429); the // sidecar loops used to flatten all three to `key-429`, so an account rotation read as a key // rotation in the attempt row and in the Logs UI. let recoveryKind: AttemptRecoveryKind = "key-429"; const rotated = !originalResponse || originalResponse.status === 429 ? rotateProviderTransportOn429(config, route.providerName, route.provider, { retryAfter, now: Date.now(), attemptedKey: route.provider.apiKey, promptCacheKey: parsed.options.promptCacheKey, }) : null; if (rotated) { route.provider = rotated; } else if ( // A POSITIVE gate, not an early return. An early `return null` here made every later arm // unreachable: Anthropic never has a genericFailoverAccountId (isGenericFailoverProvider // excludes it), so its sidecar 429s died on this guard before the Anthropic arm below // could ever be considered. transportState.genericFailoverAccountId && transportState.genericFailovers < transportState.genericFailoverLimit && isGenericOAuthFailoverEnabled(config, route.providerName) ) { // Intersection with the request's shared budget. The sidecar replay is dispatched by the // web-search/image loop and never reaches `onSendsConsumed`, so this reservation is the // charge; a refusal returns null and the caller keeps the real 429 it already has. const hop = reserveCredentialHop( "auth-recovery", `${route.providerName}|${route.modelId}|sidecar-oauth-429`, ); if (!hop.allowed) return null; const nextAccountId = route.providerName === "kiro" ? rotateGenericOAuthAccountOnRefusal( config, route.providerName, transportState.genericFailoverAccountId, refusal, retryAfter, Date.now(), route.modelId, monthlyCooldownMs, ) : rotateGenericOAuthAccountOn429( config, route.providerName, transportState.genericFailoverAccountId, retryAfter, Date.now(), route.modelId, ); if (!nextAccountId) { hop.permit?.release(); return null; } try { const snapshot = await failoverAccountSnapshot(route.providerName, nextAccountId); if (route.providerName !== "kiro") transportState.genericFailovers += 1; if (!await applyFailoverSnapshot(snapshot, retryParsed)) { hop.permit?.release(); return null; } if (route.providerName === "kiro") transportState.genericFailovers += 1; } catch { hop.permit?.release(); return null; } recoveryKind = "oauth-account-429"; hop.permit?.use(); } else if ( // Anthropic's pool is excluded from generic failover, so without this arm a 429 inside a // web-search or image-bridge turn was terminal even with the pool fully enabled -- while // the very same 429 on the main response path rotated. transportState.anthropicPoolAccountId ) { // Same intersection for the Anthropic roster: its own per-request bound still applies, // and the shared budget decides whether this request may spend another send at all. const hop = reserveCredentialHop( "auth-recovery", `${route.providerName}|${route.modelId}|sidecar-anthropic-429`, ); const nextAccountId = await rotateAnthropicAccountOnResponse( originalResponse ?? new Response(null, { status: 429, headers: responseHeaders ?? (retryAfter ? { "retry-after": retryAfter } : undefined) }), { config, accountId: transportState.anthropicPoolAccountId, sessionKey: anthropicSessionKey, decision: transportState.anthropicRouteDecision, signal: options.abortSignal, canRetry: hop.allowed && transportState.anthropicPoolFailovers < ANTHROPIC_POOL_MAX_FAILOVERS_PER_REQUEST, }); if (!nextAccountId) { hop.permit?.release(); return null; } try { // Deliberately NOT applyFailoverSnapshot: that helper exists to pair per-account routing // metadata (Copilot origin, Antigravity project, Kiro context) with its bearer. Anthropic // carries none, and getAnthropicPoolAccessToken is what enforces its fail-closed // local-cli credential rule. Both existing Anthropic rotation sites apply the token the // same way. const admitted = await commitResolvedOAuthSelection(await getAnthropicPoolAccessSnapshot(nextAccountId)); if (!admitted) throw new Error("OAuth selection changed during recovery"); transportState.anthropicPoolAccountId = admitted.accountId; transportState.anthropicPoolFailovers += 1; route.provider = { ...route.provider, apiKey: admitted.accessToken }; logCtx.provider = formatAnthropicProviderForLog("anthropic", admitted.accountId, config); } catch { hop.permit?.release(); return null; } recoveryKind = "anthropic-oauth-429"; hop.permit?.use(); } else { // No key pool, no generic OAuth roster, no Anthropic pool could produce a replacement // credential. The 429 is terminal for this sidecar turn. return null; } const rotatedAdapter = resolveSelectionAdapter( resolveWireProtocolOverride(route.providerName, route.modelId, route.provider, inboundWire, route.staticPolicy), config.cacheRetention, ); // The sidecar loops build each attempt from an iteration-local shallow copy of parsed, so a // rebind that lands only on the outer request never reaches the wire: the retry would pair // the new bearer with the previous account's Kiro routing metadata and continuation identity. // Rebind the exact request the rotated adapter will be built from (same pattern as the // continuation loop's nextParsed); when the hook ran without one, the outer bind below stands. if (retryParsed && retryParsed !== parsed) { bindRouteReasoningReplayScope({ parsed: retryParsed, providerName: route.providerName, provider: route.provider, adapterName: rotatedAdapter.name, }); } bindRouteReasoningReplayScope({ parsed, providerName: route.providerName, provider: route.provider, adapterName: rotatedAdapter.name, }); return { adapter: rotatedAdapter, recoveryKind }; }; if ((imgPlan || vidPlan) && wsPlan) { // Web search takes priority when both are active — the media bridge cannot run // alongside runWithWebSearch. Surface a runtime signal so the user knows their // configured video/image bridge was skipped for this turn, rather than silently // dropping a paid capability. if (vidPlan) console.warn("[videos] video bridge skipped: web search is active for this turn"); if (imgPlan) console.warn("[images] image bridge skipped: web search is active for this turn"); } if ((imgPlan || vidPlan) && !wsPlan) { // The image bridge detects a hosted image_generation tool and requires streaming. // The video bridge activates from config and injects a tool — it also needs streaming // (the loop returns SSE). For video-only (no imgPlan) on a non-streaming request, skip // the bridge entirely so enabling the feature doesn't break ordinary non-streaming traffic. if (!parsed.stream) { if (imgPlan) { releaseSearchProbeLease(); return formatErrorResponse(400, "invalid_request_error", "image bridge requires stream=true"); } // Video-only: skip bridge for non-streaming requests } else { // Replace any pre-existing image_gen/video_gen aliases instead of appending duplicate wire names. const priorTools = parsed.context.tools ?? []; const bridgeTools = [...priorTools.filter(t => { if (t.imageGeneration) return false; if (t.videoGeneration) return false; if (imgPlan && imgPlan.toolNames.has(t.name)) return false; if (imgPlan && t.namespace && imgPlan.toolNames.has(namespacedToolName(t.namespace, t.name))) return false; // Only strip unnamespaced video_gen aliases — a namespaced MCP video_gen is left alone. if (vidPlan && !t.namespace && vidPlan.toolNames.has(t.name)) return false; return true; })]; const existingNames = new Set(bridgeTools.map(t => t.name)); if (imgPlan && !existingNames.has(IMAGE_GEN_TOOL_NAME)) bridgeTools.push(buildImageTool()); if (vidPlan && !existingNames.has(VIDEO_GEN_TOOL_NAME)) bridgeTools.push(buildVideoTool()); parsed.context.tools = bridgeTools; // Hosted image_generation tool_choice / allowed_tools must target the synthetic function name. // Gate on imgPlan — in a video-only turn buildImageTool() was never injected, so rewriting // image_generation/image_gen aliases would add an undeclared tool that strict upstreams reject. const tc = parsed.options.toolChoice; if (imgPlan && tc && typeof tc === "object" && "allowedTools" in tc && Array.isArray(tc.allowedTools)) { const mapped = tc.allowedTools.map(name => name === "image_generation" || name === "image_gen" || (imgPlan.toolNames.has(name) ?? false) ? IMAGE_GEN_TOOL_NAME : name, ); parsed.options.toolChoice = { ...tc, allowedTools: [...new Set(mapped)] }; } else if (imgPlan && tc && typeof tc === "object" && "name" in tc && typeof tc.name === "string" && (tc.name === "image_generation" || imgPlan.toolNames.has(tc.name))) { parsed.options.toolChoice = { ...tc, name: IMAGE_GEN_TOOL_NAME }; } const imageProviderFetch = providerFetch( route.provider, options.codexWsRuntimeIdentity, { providerName: route.providerName, modelId: route.modelId }, ); const imgResponse = await runWithImageBridge({ parsed, adapter: transportState.adapter, incomingMeta: { headers: requestState.selectedForwardHeaders, providerName: route.providerName, abortSignal: options.abortSignal, translatorBudget }, ...(imgPlan ? { plan: imgPlan } : {}), ...(vidPlan ? { videoPlan: vidPlan } : {}), forwardHeaders: requestState.selectedForwardHeaders, onAttemptSend: (recovery?: AttemptRecoveryKind) => transportState.noteRoutedAttemptSend(logCtx.usageLogInputTokens, recovery), abortSignal: options.abortSignal, maxRounds: imgPlan && vidPlan ? clampImageMaxRounds(Math.min(config.images?.maxRounds ?? 3, config.images?.videoMaxRounds ?? 2)) : imgPlan ? clampImageMaxRounds(config.images?.maxRounds) : clampImageMaxRounds(config.images?.videoMaxRounds ?? 2), connectTimeoutMs: config.connectTimeoutMs ?? 200_000, stallTimeoutSec: config.stallTimeoutSec, waitForRequestSlot: imageProviderFetch.waitForPacing, fetchImpl: imageProviderFetch.unpacedFetch ?? imageProviderFetch, fetchForRequest: (request, iterParsed) => { const fetch = providerFetch(route.provider, options.codexWsRuntimeIdentity, { dispatchOverride: oauthDispatch(request, iterParsed), providerName: route.providerName, modelId: route.modelId, }); return fetch.unpacedFetch ?? fetch; }, onRequestBuilt: request => { recordAdapterReasoning(logCtx, request); recordAdapterTier(logCtx, request); }, ...(vidPlan?.timeoutMs ? { videoTimeoutMs: vidPlan.timeoutMs } : {}), onUsage: usage => { // Cursor may assign _cursorConversationId inside the image loop's first runTurn; // backfill so Logs can filter/total that opening request (parity with the normal // runTurn branch). if (!logCtx.conversationId && parsed._cursorConversationId) { logCtx.conversationId = normalizeLogConversationId(parsed._cursorConversationId); } transportState.bindKeyUsageFromBridge(usage); }, on429: rotateSidecarProviderOn429, retryOn429Policy: route.providerName === "kiro" && isGenericOAuthFailoverEnabled(config, "kiro") ? null : rateLimitRetryPolicyFor(route.provider), ...(options.onFirstOutput ? { onFirstOutput: options.onFirstOutput } : {}), ...(options.forceEmptyResponseId ? { forceEmptyResponseId: true } : {}), onCompletedResponse: (response, providerState) => { const served = transportState.replayOAuthCredentialSnapshot; if (route.providerName === "kiro" && response.status === "completed" && served && noteKiroServedSuccess(served.accountId, served.generation)) persistKiroAccountState(); commitReasoningReplayServingRoute(); rememberKiroDeliveredFinalAnswer(transportState.adapter.name, response); rememberResponseState( parsed._rawBody, response, continuationStateForResponse(providerState), responseStateOptions(adapterNeedsForcedContinuation(transportState.adapter.name)), ); notifyResponseComplete(response); }, }); if (imgResponse.body) { const imgTurnAc = new AbortController(); imgTurnAc.signal.addEventListener("abort", cancelResponseCompletion, { once: true }); return new Response(trackStreamLifetime(imgResponse.body, imgTurnAc, releaseSearchProbeLease, options.turnAdmissionLease), { status: imgResponse.status, headers: imgResponse.headers, }); } releaseSearchProbeLease(); return imgResponse; } // end else (streaming bridge) } // Web-search sidecar: Codex enabled web_search but this is a routed (non-OpenAI) model that can't // run it server-side. Expose web_search as a function tool and run searches via the gpt-mini sidecar // through the ChatGPT passthrough, looping until the model answers. Otherwise take the normal path. // Placed BEFORE the runTurn early-return for non-runTurn adapters so dual-tool turns dispatch // through web-search instead of being swallowed. runTurn adapters never enter this branch. if (canRunWebSearch && wsPlan) { parsed.context.tools = [...(parsed.context.tools ?? []), buildWebSearchTool()]; // Resolve the mutable route at send time: a 429 rotation replaces route.provider, so retaining // one pre-rotation providerFetch would keep the old credential and transport pin. const routedProviderFetch = ((input: Parameters<typeof globalThis.fetch>[0], init?: RequestInit) => providerFetch(route.provider, options.codexWsRuntimeIdentity, { providerName: route.providerName, modelId: route.modelId, })(input, init)) as typeof globalThis.fetch; const wsResponse = await runWithWebSearch({ parsed, adapter: transportState.adapter, fetchForRequest: (request, iterParsed) => providerFetch(route.provider, options.codexWsRuntimeIdentity, { dispatchOverride: oauthDispatch(request, iterParsed), providerName: route.providerName, modelId: route.modelId, }), incomingMeta: { headers: requestState.selectedForwardHeaders, providerName: route.providerName, abortSignal: options.abortSignal, translatorBudget, providerFetch: routedProviderFetch, }, backend: wsPlan.backend, forwardProvider: wsPlan.forwardSidecar?.provider, anthropicSidecar: wsPlan.anthropicSidecar, xaiSidecar: wsPlan.xaiSidecar, geminiSidecar: wsPlan.geminiSidecar, xaiSearchOptions: wsPlan.xaiSearchOptions, // The exa key never rides the plan: read it from config at unpack time (L9). ...(wsPlan.exaConfigured ? { exaApiKey: config.webSearchSidecar?.exaApiKey } : {}), hostedTool: wsPlan.hostedTool, selectedForwardHeaders: wsPlan.forwardSidecar?.headers ?? requestState.selectedForwardHeaders, settings: wsPlan.settings, maxSearches: wsPlan.maxSearches, forceEmptyResponseId: true, abortSignal: options.abortSignal, ...(options.onFirstOutput ? { onFirstOutput: options.onFirstOutput } : {}), onRequestBuilt: request => { recordAdapterReasoning(logCtx, request); recordAdapterTier(logCtx, request); }, onAttemptSend: (recovery?: AttemptRecoveryKind) => transportState.noteRoutedAttemptSend(logCtx.usageLogInputTokens, recovery), onUsage: usage => { transportState.bindKeyUsageFromBridge(usage); }, recordSidecarOutcome: wsPlan.forwardSidecar?.recordOutcome, connectTimeoutMs: config.connectTimeoutMs ?? 200_000, routedModelStallTimeoutMs: wsPlan.routedModelStallTimeoutMs, stallTimeoutSec: wsPlan.stallTimeoutSec, streamRoutedModelOutput: wsPlan.streamRoutedModelOutput, on429: rotateSidecarProviderOn429, retryOn429Policy: route.providerName === "kiro" && isGenericOAuthFailoverEnabled(config, "kiro") ? null : rateLimitRetryPolicyFor(route.provider), onCompletedResponse: response => { const served = transportState.replayOAuthCredentialSnapshot; if (route.providerName === "kiro" && response.status === "completed" && served && noteKiroServedSuccess(served.accountId, served.generation)) persistKiroAccountState(); commitReasoningReplayServingRoute(); notifyResponseComplete(response); }, }); // Register the sidecar stream as an active turn so drainAndShutdown waits for (or aborts) // in-flight web-search turns instead of skipping them during graceful shutdown. if (wsResponse.body) { const wsTurnAc = new AbortController(); wsTurnAc.signal.addEventListener("abort", cancelResponseCompletion, { once: true }); return new Response(trackStreamLifetime(wsResponse.body, wsTurnAc, releaseSearchProbeLease, options.turnAdmissionLease), { status: wsResponse.status, headers: wsResponse.headers, }); } releaseSearchProbeLease(); return wsResponse; } return undefined; }