@openai/agents-openai 0.13.1 → 0.13.2

package/dist/experimental/hostedMultiAgent/model.js

@@ -0,0 +1,677 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIHostedMultiAgentModel = void 0;
+const agents_core_1 = require("@openai/agents-core");
+const openai_1 = __importDefault(require("openai"));
+const ws_1 = require("openai/resources/beta/responses/ws");
+const defaults_1 = require("../../defaults.js");
+const openaiResponsesModel_1 = require("../../openaiResponsesModel.js");
+const responsesTransportUtils_1 = require("../../responsesTransportUtils.js");
+const responsesWebSocketConnection_1 = require("../../responsesWebSocketConnection.js");
+const responsesUtils_1 = require("../../responsesUtils.js");
+const ROOT_AGENT_NAME = '/root';
+const MULTI_AGENT_BETA = 'responses_multi_agent=v1';
+const HOSTED_COLLABORATION_ITEM_TYPES = new Set([
+    'agent_message',
+    'multi_agent_call',
+    'multi_agent_call_output',
+]);
+const HOSTED_TERMINAL_RESPONSE_EVENT_TYPES = new Set([
+    'response.completed',
+    'response.failed',
+    'response.incomplete',
+    'response.error',
+]);
+const WEBSOCKET_CONNECTING_READY_STATE = 0;
+const WEBSOCKET_OPEN_READY_STATE = 1;
+function isReusableWebSocket(webSocket) {
+    return (webSocket.socket.readyState === WEBSOCKET_CONNECTING_READY_STATE ||
+        webSocket.socket.readyState === WEBSOCKET_OPEN_READY_STATE);
+}
+function isHostedTerminalResponseEventType(eventType) {
+    return (typeof eventType === 'string' &&
+        HOSTED_TERMINAL_RESPONSE_EVENT_TYPES.has(eventType));
+}
+class HostedMultiAgentWebSocketClosedError extends Error {
+    frameWasUnsent;
+    constructor(message, frameWasUnsent) {
+        super(message);
+        this.frameWasUnsent = frameWasUnsent;
+        this.name = 'HostedMultiAgentWebSocketClosedError';
+    }
+}
+function createWebSocketClient(client, extraQuery) {
+    const websocketClient = Object.create(client);
+    // ResponsesWS adds client.apiKey after applying the finalized header merge.
+    // Keep authentication entirely in the explicit headers so null unsets survive.
+    websocketClient.apiKey = null;
+    websocketClient.buildURL = (path, query, defaultBaseURL) => {
+        const url = new URL(client.buildURL(path, query, defaultBaseURL));
+        (0, responsesTransportUtils_1.mergeQueryParamsIntoURL)(url, extraQuery);
+        return url.toString();
+    };
+    return websocketClient;
+}
+function mergeResponseUsages(usages) {
+    return new agents_core_1.Usage({
+        requests: usages.length,
+        inputTokens: usages.reduce((total, usage) => total + (usage?.input_tokens ?? 0), 0),
+        outputTokens: usages.reduce((total, usage) => total + (usage?.output_tokens ?? 0), 0),
+        totalTokens: usages.reduce((total, usage) => total + (usage?.total_tokens ?? 0), 0),
+        inputTokensDetails: usages.map((usage) => ({
+            ...usage?.input_tokens_details,
+        })),
+        outputTokensDetails: usages.map((usage) => ({
+            ...usage?.output_tokens_details,
+        })),
+        requestUsageEntries: usages.map((usage) => (0, responsesUtils_1.toRequestUsageEntry)(usage, 'responses.create')),
+    });
+}
+function sortedEntries(record) {
+    return Object.entries(record).sort(([left], [right]) => left.localeCompare(right));
+}
+function getTransportOverridesKey(client, options) {
+    const websocketClient = createWebSocketClient(client, options.extraQuery);
+    const url = websocketClient.buildURL('/responses', {}, undefined);
+    const headerAccumulator = (0, responsesTransportUtils_1.createHeaderAccumulator)();
+    (0, responsesTransportUtils_1.applyHeadersToAccumulator)(headerAccumulator, options.extraHeaders, {
+        allowBlockedOverride: true,
+    });
+    return JSON.stringify([
+        url,
+        sortedEntries((0, responsesTransportUtils_1.headerAccumulatorToRecord)(headerAccumulator)),
+        [...headerAccumulator.blockedLowercaseNames].sort(),
+    ]);
+}
+function validateConfig(config) {
+    const maxConcurrentSubagents = config?.maxConcurrentSubagents;
+    if (typeof maxConcurrentSubagents !== 'undefined' &&
+        (!Number.isInteger(maxConcurrentSubagents) || maxConcurrentSubagents <= 0)) {
+        throw new agents_core_1.UserError('HostedMultiAgentConfig.maxConcurrentSubagents must be a positive integer.');
+    }
+    return Object.freeze(typeof maxConcurrentSubagents === 'undefined'
+        ? {}
+        : { maxConcurrentSubagents });
+}
+function isRootFinalMessage(item) {
+    return (item.type === 'message' &&
+        item.agent?.agent_name === ROOT_AGENT_NAME &&
+        item.phase === 'final_answer');
+}
+function toResponseCreateFrame(requestData) {
+    const { betas: _betas, stream: _stream, ...frame } = requestData;
+    return { ...frame, type: 'response.create' };
+}
+function getFunctionCallOutputs(requestData, pendingCallIds) {
+    if (!Array.isArray(requestData.input)) {
+        return [];
+    }
+    return requestData.input.filter((item) => Boolean(item &&
+        typeof item === 'object' &&
+        item.type === 'function_call_output' &&
+        typeof item.call_id === 'string' &&
+        pendingCallIds.has(item.call_id)));
+}
+/**
+ * Experimental OpenAI Responses model that opts into service-hosted Multi-agent orchestration.
+ *
+ * The hosted beta requires a persistent Responses WebSocket because local tool outputs must be
+ * injected into the active response. Call {@link close} when the model is no longer needed.
+ */
+class OpenAIHostedMultiAgentModel extends openaiResponsesModel_1.OpenAIResponsesModel {
+    config;
+    #webSocket;
+    #webSocketIterator;
+    #webSocketConnectionKey;
+    #webSocketTransportOverridesKey;
+    #activeResponse;
+    #normalizedResponses = new WeakMap();
+    #responseUsages = new WeakMap();
+    #syntheticBoundaryEvents = new WeakSet();
+    #requestInProgress = false;
+    constructor(client, model, config) {
+        super(client, model);
+        this.config = validateConfig(config);
+    }
+    getRetryAdvice(args) {
+        if (args.error instanceof HostedMultiAgentWebSocketClosedError &&
+            args.error.frameWasUnsent) {
+            return {
+                suggested: true,
+                replaySafety: 'safe',
+                reason: args.error.message,
+            };
+        }
+        return super.getRetryAdvice(args);
+    }
+    /** Close the persistent Responses WebSocket owned by this model. */
+    async close() {
+        this.#activeResponse = undefined;
+        this.#dropWebSocketConnection();
+    }
+    #dropWebSocketConnection() {
+        this.#webSocketIterator = undefined;
+        const webSocket = this.#webSocket;
+        this.#webSocket = undefined;
+        this.#webSocketConnectionKey = undefined;
+        this.#webSocketTransportOverridesKey = undefined;
+        webSocket?.close();
+    }
+    /** @internal */
+    _createResponsesWebSocket(options) {
+        return new ws_1.ResponsesWS(options.client, {
+            headers: options.headers,
+        });
+    }
+    _getResponsesCreateRequestOverrides(request, requestData) {
+        if (request.handoffs.length > 0) {
+            throw new agents_core_1.UserError('OpenAIHostedMultiAgentModel does not support SDK handoffs. Remove the Agent handoffs or use OpenAIResponsesModel.');
+        }
+        if (requestData.reasoning?.summary != null) {
+            throw new agents_core_1.UserError('OpenAIHostedMultiAgentModel does not support reasoning.summary. Remove the reasoning summary setting.');
+        }
+        if (requestData.max_tool_calls != null) {
+            throw new agents_core_1.UserError('OpenAIHostedMultiAgentModel does not support max_tool_calls. Remove that provider setting.');
+        }
+        return {
+            multi_agent: {
+                enabled: true,
+                ...(typeof this.config.maxConcurrentSubagents === 'number'
+                    ? {
+                        max_concurrent_subagents: this.config.maxConcurrentSubagents,
+                    }
+                    : {}),
+            },
+        };
+    }
+    _convertResponseOutputItems(items) {
+        const stableItems = items.filter((item) => !HOSTED_COLLABORATION_ITEM_TYPES.has(item.type) &&
+            (item.type !== 'message' || isRootFinalMessage(item)));
+        return (0, openaiResponsesModel_1.convertToOutputItem)(stableItems);
+    }
+    _getResponseForSDKOutput(response) {
+        return this.#normalizedResponses.get(response) ?? response;
+    }
+    _getResponseUsage(response) {
+        return (this.#responseUsages.get(response) ?? super._getResponseUsage(response));
+    }
+    _getStreamedResponseUsage(response) {
+        return (this.#responseUsages.get(response) ??
+            super._getStreamedResponseUsage(response));
+    }
+    _shouldEmitOutputTextDelta(event, outputItem) {
+        const agentName = event.agent?.agent_name;
+        return (Boolean(outputItem && isRootFinalMessage(outputItem)) &&
+            (typeof agentName === 'undefined' || agentName === ROOT_AGENT_NAME));
+    }
+    _shouldEmitRawModelEvent(event) {
+        return !this.#syntheticBoundaryEvents.has(event);
+    }
+    async _fetchResponse(request, stream) {
+        const events = this.#runWebSocketTurn(request);
+        if (stream) {
+            return events;
+        }
+        let response;
+        for await (const event of events) {
+            if (isHostedTerminalResponseEventType(event.type)) {
+                response = event.response;
+            }
+        }
+        if (!response) {
+            throw new Error('Hosted Multi-agent WebSocket turn ended without a response boundary.');
+        }
+        return response;
+    }
+    async *#runWebSocketTurn(request) {
+        if (this.#requestInProgress) {
+            throw new agents_core_1.UserError('OpenAIHostedMultiAgentModel does not support concurrent requests on one model instance.');
+        }
+        this.#requestInProgress = true;
+        const hadActiveResponse = Boolean(this.#activeResponse);
+        let sentWebSocketFrame = false;
+        let sentWebSocketFrameType;
+        let receivedServerMessage = false;
+        let requestMayHaveReachedServer = false;
+        let sentFrameWasReturnedUnsent = false;
+        let reachedResponseBoundary = false;
+        let threwError = false;
+        const requestTimeoutDeadline = this.#createWebSocketRequestTimeoutDeadline();
+        const sendWebSocketFrame = (webSocket, frame, signal) => {
+            if (signal?.aborted) {
+                throw new openai_1.default.APIUserAbortError();
+            }
+            sentWebSocketFrame = true;
+            sentWebSocketFrameType = frame.type;
+            if (webSocket.socket.readyState === WEBSOCKET_OPEN_READY_STATE) {
+                requestMayHaveReachedServer = true;
+            }
+            webSocket.send(frame);
+        };
+        try {
+            const builtRequest = this._buildResponsesCreateRequest(request, true);
+            const requestData = builtRequest.requestData;
+            const webSocket = await this.#ensureWebSocket({
+                extraHeaders: builtRequest.transportExtraHeaders,
+                extraQuery: builtRequest.transportExtraQuery,
+            }, Boolean(this.#activeResponse), builtRequest.signal, requestTimeoutDeadline);
+            let pendingInjections = 0;
+            const injectingCallIds = new Set();
+            if (this.#activeResponse) {
+                const activeResponse = this.#activeResponse;
+                if (activeResponse.pendingContinuationFrame) {
+                    sendWebSocketFrame(webSocket, activeResponse.pendingContinuationFrame, builtRequest.signal);
+                }
+                else {
+                    const outputs = getFunctionCallOutputs(requestData, activeResponse.pendingCallIds);
+                    const outputCallIds = new Set(outputs.map((output) => output.call_id));
+                    const missingCallIds = Array.from(activeResponse.pendingCallIds).filter((callId) => !outputCallIds.has(callId));
+                    if (missingCallIds.length > 0) {
+                        throw new agents_core_1.UserError(`The hosted response is waiting for local function outputs for: ${missingCallIds.join(', ')}. Resume it with the same model instance and RunState.`);
+                    }
+                    if (activeResponse.terminalEvent) {
+                        const continuationFrame = this.#prepareTerminalContinuation(activeResponse, requestData, outputs);
+                        sendWebSocketFrame(webSocket, continuationFrame, builtRequest.signal);
+                    }
+                    else {
+                        if (outputs.length === 0 || !activeResponse.responseId) {
+                            throw new agents_core_1.UserError('The hosted response is waiting for local function outputs. Resume it with the same model instance and RunState.');
+                        }
+                        pendingInjections = 1;
+                        for (const output of outputs) {
+                            injectingCallIds.add(output.call_id);
+                        }
+                        sendWebSocketFrame(webSocket, {
+                            type: 'response.inject',
+                            response_id: activeResponse.responseId,
+                            input: outputs,
+                        }, builtRequest.signal);
+                    }
+                }
+            }
+            else {
+                this.#activeResponse = {
+                    responseCreateInput: Array.isArray(requestData.input)
+                        ? [...requestData.input]
+                        : [],
+                    responseCreatePreviousResponseId: typeof requestData.previous_response_id === 'string'
+                        ? requestData.previous_response_id
+                        : undefined,
+                    responseStored: requestData.store !== false,
+                    pendingCallIds: new Set(),
+                    emittedCallIds: new Set(),
+                    queuedFunctionCalls: [],
+                    fallbackInput: [],
+                    requestUsages: [],
+                };
+                sendWebSocketFrame(webSocket, toResponseCreateFrame(requestData), builtRequest.signal);
+            }
+            while (true) {
+                const message = await this.#nextWebSocketMessage(builtRequest.signal, requestTimeoutDeadline);
+                if (!message) {
+                    throw new Error('Hosted Multi-agent WebSocket closed before a response boundary.');
+                }
+                if (message.type === 'open' || message.type === 'reconnected') {
+                    requestMayHaveReachedServer = true;
+                }
+                if (message.type === 'error') {
+                    throw message.error;
+                }
+                if (message.type === 'close') {
+                    const currentFrameWasReturnedUnsent = sentWebSocketFrame &&
+                        typeof sentWebSocketFrameType === 'string' &&
+                        Array.isArray(message.unsent) &&
+                        message.unsent.some((item) => {
+                            const unsentFrame = item?.type === 'message' ? item.message : item;
+                            return unsentFrame?.type === sentWebSocketFrameType;
+                        });
+                    if (currentFrameWasReturnedUnsent) {
+                        requestMayHaveReachedServer = false;
+                        sentFrameWasReturnedUnsent = true;
+                    }
+                    throw new HostedMultiAgentWebSocketClosedError(`Hosted Multi-agent WebSocket closed (${String(message.code)}): ${String(message.reason ?? '')}`, currentFrameWasReturnedUnsent);
+                }
+                if (message.type !== 'message') {
+                    continue;
+                }
+                receivedServerMessage = true;
+                requestMayHaveReachedServer = true;
+                const event = message.message;
+                const eventType = event.type;
+                const activeResponse = this.#activeResponse;
+                if (!activeResponse) {
+                    throw new Error('Hosted Multi-agent response state was lost.');
+                }
+                if (eventType === 'response.created') {
+                    activeResponse.responseId = event.response?.id;
+                    activeResponse.responseTemplate = event.response;
+                    activeResponse.pendingContinuationFrame = undefined;
+                }
+                else if (eventType === 'response.output_item.done') {
+                    const item = event.item;
+                    if (item) {
+                        if (item.type === 'function_call' &&
+                            typeof item.call_id === 'string') {
+                            activeResponse.pendingCallIds.add(item.call_id);
+                            if (!activeResponse.emittedCallIds.has(item.call_id) &&
+                                !activeResponse.queuedFunctionCalls.some((queued) => queued.call_id === item.call_id)) {
+                                activeResponse.queuedFunctionCalls.push(item);
+                            }
+                        }
+                    }
+                }
+                else if (eventType === 'response.inject.created') {
+                    pendingInjections = Math.max(0, pendingInjections - 1);
+                    for (const callId of injectingCallIds) {
+                        activeResponse.pendingCallIds.delete(callId);
+                    }
+                }
+                else if (eventType === 'response.inject.failed') {
+                    pendingInjections = Math.max(0, pendingInjections - 1);
+                    if (event.error?.code !== 'response_already_completed') {
+                        throw new Error(`Hosted Multi-agent response injection failed: ${JSON.stringify(event.error)}`);
+                    }
+                    if (Array.isArray(event.input)) {
+                        activeResponse.fallbackInput.push(...event.input);
+                    }
+                    for (const callId of injectingCallIds) {
+                        activeResponse.pendingCallIds.delete(callId);
+                    }
+                }
+                else if (isHostedTerminalResponseEventType(eventType)) {
+                    activeResponse.terminalEvent = event;
+                }
+                else if (eventType === 'error') {
+                    throw new Error(`Hosted Multi-agent WebSocket response failed: ${JSON.stringify(event)}`);
+                }
+                if (!isHostedTerminalResponseEventType(eventType)) {
+                    yield event;
+                }
+                if (activeResponse.queuedFunctionCalls.length > 0 &&
+                    pendingInjections === 0) {
+                    const functionCalls = activeResponse.queuedFunctionCalls.splice(0);
+                    const partialResponse = this.#buildBoundaryResponse(functionCalls);
+                    const boundaryEvent = {
+                        type: 'response.completed',
+                        response: partialResponse,
+                    };
+                    this.#syntheticBoundaryEvents.add(boundaryEvent);
+                    reachedResponseBoundary = true;
+                    yield boundaryEvent;
+                    return;
+                }
+                if (activeResponse.terminalEvent && pendingInjections === 0) {
+                    if (activeResponse.fallbackInput.length > 0) {
+                        const continuationFrame = this.#prepareTerminalContinuation(activeResponse, requestData, []);
+                        sendWebSocketFrame(webSocket, continuationFrame, builtRequest.signal);
+                        injectingCallIds.clear();
+                        continue;
+                    }
+                    const terminalEvent = activeResponse.terminalEvent;
+                    const response = terminalEvent.response;
+                    const normalizedResponse = {
+                        ...response,
+                        output: (Array.isArray(response.output)
+                            ? response.output
+                            : []).filter((item) => item.type !== 'function_call' ||
+                            !activeResponse.emittedCallIds.has(item.call_id)),
+                    };
+                    this.#normalizedResponses.set(response, normalizedResponse);
+                    this.#responseUsages.set(response, mergeResponseUsages([
+                        ...activeResponse.requestUsages,
+                        response.usage,
+                    ]));
+                    this.#activeResponse = undefined;
+                    reachedResponseBoundary = true;
+                    yield terminalEvent;
+                    return;
+                }
+            }
+        }
+        catch (error) {
+            threwError = true;
+            if (requestMayHaveReachedServer && error instanceof Error) {
+                error.unsafeToReplay = true;
+            }
+            if (hadActiveResponse && sentFrameWasReturnedUnsent) {
+                const transportOverridesKey = this.#webSocketTransportOverridesKey;
+                this.#dropWebSocketConnection();
+                this.#webSocketTransportOverridesKey = transportOverridesKey;
+            }
+            else if (!hadActiveResponse ||
+                sentWebSocketFrame ||
+                receivedServerMessage) {
+                await this.close();
+            }
+            throw error;
+        }
+        finally {
+            try {
+                if (!threwError && !reachedResponseBoundary) {
+                    await this.close();
+                }
+            }
+            finally {
+                this.#requestInProgress = false;
+            }
+        }
+    }
+    #buildBoundaryResponse(functionCalls) {
+        const activeResponse = this.#activeResponse;
+        if (!activeResponse?.responseTemplate || !activeResponse.responseId) {
+            throw new Error('Hosted Multi-agent function call arrived before response.created.');
+        }
+        for (const functionCall of functionCalls) {
+            activeResponse.emittedCallIds.add(functionCall.call_id);
+        }
+        const boundaryResponse = {
+            ...activeResponse.responseTemplate,
+            id: activeResponse.responseId,
+            status: 'completed',
+            output: functionCalls,
+            usage: undefined,
+        };
+        this.#responseUsages.set(boundaryResponse, new agents_core_1.Usage());
+        return boundaryResponse;
+    }
+    #prepareTerminalContinuation(activeResponse, requestData, functionOutputs) {
+        const terminalResponse = activeResponse.terminalEvent?.response;
+        if (!terminalResponse?.id) {
+            throw new Error('Hosted Multi-agent could not continue after a terminal response.');
+        }
+        const continuationInput = [
+            ...activeResponse.fallbackInput,
+            ...functionOutputs,
+        ];
+        if (continuationInput.length === 0) {
+            throw new Error('Hosted Multi-agent terminal response continuation requires function outputs.');
+        }
+        activeResponse.requestUsages.push(terminalResponse.usage);
+        const terminalResponseStored = typeof terminalResponse.store === 'boolean'
+            ? terminalResponse.store
+            : activeResponse.responseStored;
+        const fallbackFrame = toResponseCreateFrame(requestData);
+        if (fallbackFrame.conversation != null) {
+            fallbackFrame.input = continuationInput;
+            delete fallbackFrame.previous_response_id;
+        }
+        else if (terminalResponseStored) {
+            fallbackFrame.input = continuationInput;
+            fallbackFrame.previous_response_id = terminalResponse.id;
+        }
+        else {
+            fallbackFrame.input = [
+                ...activeResponse.responseCreateInput,
+                ...(Array.isArray(terminalResponse.output)
+                    ? terminalResponse.output
+                    : []),
+                ...continuationInput,
+            ];
+            if (activeResponse.responseCreatePreviousResponseId) {
+                fallbackFrame.previous_response_id =
+                    activeResponse.responseCreatePreviousResponseId;
+            }
+            else {
+                delete fallbackFrame.previous_response_id;
+            }
+        }
+        activeResponse.responseCreateInput = Array.isArray(fallbackFrame.input)
+            ? [...fallbackFrame.input]
+            : [];
+        activeResponse.responseCreatePreviousResponseId =
+            typeof fallbackFrame.previous_response_id === 'string'
+                ? fallbackFrame.previous_response_id
+                : undefined;
+        activeResponse.responseStored = fallbackFrame.store !== false;
+        activeResponse.responseId = undefined;
+        activeResponse.responseTemplate = undefined;
+        activeResponse.pendingCallIds.clear();
+        activeResponse.queuedFunctionCalls = [];
+        activeResponse.terminalEvent = undefined;
+        activeResponse.fallbackInput = [];
+        activeResponse.pendingContinuationFrame = fallbackFrame;
+        return fallbackFrame;
+    }
+    async #ensureWebSocket(transportOptions, activeResponse, signal, requestTimeoutDeadline) {
+        if (signal?.aborted) {
+            throw new openai_1.default.APIUserAbortError();
+        }
+        const transportOverridesKey = getTransportOverridesKey(this._client, transportOptions);
+        if (activeResponse) {
+            if (transportOverridesKey !== this.#webSocketTransportOverridesKey) {
+                throw new agents_core_1.UserError('An active hosted response must be resumed with the same WebSocket transport headers and query.');
+            }
+            if (this.#webSocket) {
+                if (isReusableWebSocket(this.#webSocket)) {
+                    return this.#webSocket;
+                }
+                this.#dropWebSocketConnection();
+                this.#webSocketTransportOverridesKey = transportOverridesKey;
+            }
+        }
+        const creationOptions = await this.#prepareWebSocketCreationOptions(transportOptions, signal, requestTimeoutDeadline);
+        const connectionURL = creationOptions.client.buildURL('/responses', {}, undefined);
+        const connectionKey = JSON.stringify([
+            connectionURL,
+            sortedEntries(creationOptions.headers),
+        ]);
+        if (!activeResponse &&
+            this.#webSocket &&
+            !isReusableWebSocket(this.#webSocket)) {
+            await this.close();
+        }
+        if (this.#webSocket && this.#webSocketConnectionKey !== connectionKey) {
+            await this.close();
+        }
+        if (!this.#webSocket) {
+            this.#webSocket = this._createResponsesWebSocket(creationOptions);
+            this.#webSocketIterator = this.#webSocket[Symbol.asyncIterator]();
+            this.#webSocketConnectionKey = connectionKey;
+        }
+        this.#webSocketTransportOverridesKey = transportOverridesKey;
+        return this.#webSocket;
+    }
+    async #prepareWebSocketCreationOptions(transportOptions, signal, requestTimeoutDeadline) {
+        const client = this._client;
+        if (typeof client._callApiKey === 'function') {
+            await this.#awaitWebSocketRequestTimedOperation(client._callApiKey(), signal, requestTimeoutDeadline, (configuredTimeoutMs) => `Hosted Multi-agent WebSocket auth header preparation timed out after ${configuredTimeoutMs}ms.`);
+        }
+        const websocketClient = createWebSocketClient(client, transportOptions.extraQuery);
+        const websocketURL = new URL(websocketClient.buildURL('/responses', {}, undefined));
+        const authHeaderQuery = (0, responsesUtils_1.searchParamsToAuthHeaderQuery)(websocketURL.searchParams);
+        const authHeaders = typeof client.authHeaders === 'function'
+            ? await this.#awaitWebSocketRequestTimedOperation(client.authHeaders({
+                method: 'get',
+                path: websocketURL.pathname,
+                ...(authHeaderQuery ? { query: authHeaderQuery } : {}),
+            }), signal, requestTimeoutDeadline, (configuredTimeoutMs) => `Hosted Multi-agent WebSocket auth header preparation timed out after ${configuredTimeoutMs}ms.`)
+            : undefined;
+        const headerAccumulator = (0, responsesTransportUtils_1.createHeaderAccumulator)();
+        (0, responsesTransportUtils_1.applyHeadersToAccumulator)(headerAccumulator, authHeaders);
+        if (typeof client.authHeaders !== 'function' &&
+            typeof client.apiKey === 'string' &&
+            client.apiKey.length > 0 &&
+            client.apiKey !== 'Missing Key') {
+            (0, responsesTransportUtils_1.applyHeadersToAccumulator)(headerAccumulator, {
+                Authorization: `Bearer ${client.apiKey}`,
+            });
+        }
+        if (client.organization) {
+            (0, responsesTransportUtils_1.applyHeadersToAccumulator)(headerAccumulator, {
+                'OpenAI-Organization': client.organization,
+            });
+        }
+        if (client.project) {
+            (0, responsesTransportUtils_1.applyHeadersToAccumulator)(headerAccumulator, {
+                'OpenAI-Project': client.project,
+            });
+        }
+        (0, responsesTransportUtils_1.applyHeadersToAccumulator)(headerAccumulator, client._options?.defaultHeaders);
+        (0, responsesTransportUtils_1.applyHeadersToAccumulator)(headerAccumulator, defaults_1.HEADERS);
+        (0, responsesTransportUtils_1.applyHeadersToAccumulator)(headerAccumulator, transportOptions.extraHeaders, { allowBlockedOverride: true });
+        (0, responsesTransportUtils_1.applyHeadersToAccumulator)(headerAccumulator, { 'OpenAI-Beta': MULTI_AGENT_BETA }, { allowBlockedOverride: true });
+        return {
+            client: websocketClient,
+            headers: (0, responsesTransportUtils_1.headerAccumulatorToRecord)(headerAccumulator),
+        };
+    }
+    async #nextWebSocketMessage(signal, requestTimeoutDeadline) {
+        if (signal?.aborted) {
+            throw new openai_1.default.APIUserAbortError();
+        }
+        const iterator = this.#webSocketIterator;
+        if (!iterator) {
+            throw new Error('Hosted Multi-agent WebSocket iterator is unavailable.');
+        }
+        const frameReadTimeout = this.#resolveWebSocketRequestTimeout(requestTimeoutDeadline, (configuredTimeoutMs) => `Hosted Multi-agent WebSocket frame read timed out after ${configuredTimeoutMs}ms.`);
+        const result = await (0, responsesWebSocketConnection_1.withAbortSignal)((0, responsesWebSocketConnection_1.withTimeout)(iterator.next(), frameReadTimeout.timeoutMs, frameReadTimeout.errorMessage), signal);
+        return result.done ? undefined : result.value;
+    }
+    #getWebSocketFrameReadTimeoutMs() {
+        const client = this._client;
+        const timeoutCandidate = typeof client.timeout === 'number'
+            ? client.timeout
+            : client._options?.timeout;
+        if (typeof timeoutCandidate === 'number') {
+            return timeoutCandidate;
+        }
+        return openai_1.default.DEFAULT_TIMEOUT;
+    }
+    #createWebSocketRequestTimeoutDeadline() {
+        const timeoutMs = this.#getWebSocketFrameReadTimeoutMs();
+        if (typeof timeoutMs !== 'number' ||
+            !Number.isFinite(timeoutMs) ||
+            timeoutMs <= 0) {
+            return undefined;
+        }
+        return {
+            configuredTimeoutMs: timeoutMs,
+            deadlineAtMs: Date.now() + timeoutMs,
+        };
+    }
+    #resolveWebSocketRequestTimeout(requestTimeoutDeadline, errorMessageForConfiguredTimeout) {
+        const configuredTimeoutMs = requestTimeoutDeadline?.configuredTimeoutMs ??
+            this.#getWebSocketFrameReadTimeoutMs();
+        const safeConfiguredTimeoutMs = typeof configuredTimeoutMs === 'number'
+            ? configuredTimeoutMs
+            : openai_1.default.DEFAULT_TIMEOUT;
+        const errorMessage = errorMessageForConfiguredTimeout(safeConfiguredTimeoutMs);
+        if (!requestTimeoutDeadline) {
+            return { timeoutMs: configuredTimeoutMs, errorMessage };
+        }
+        const remainingTimeoutMs = Math.ceil(requestTimeoutDeadline.deadlineAtMs - Date.now());
+        if (remainingTimeoutMs <= 0) {
+            throw new Error(errorMessage);
+        }
+        return { timeoutMs: remainingTimeoutMs, errorMessage };
+    }
+    async #awaitWebSocketRequestTimedOperation(promise, signal, requestTimeoutDeadline, errorMessageForConfiguredTimeout) {
+        const timeout = this.#resolveWebSocketRequestTimeout(requestTimeoutDeadline, errorMessageForConfiguredTimeout);
+        return await (0, responsesWebSocketConnection_1.withAbortSignal)((0, responsesWebSocketConnection_1.withTimeout)(promise, timeout.timeoutMs, timeout.errorMessage), signal);
+    }
+}
+exports.OpenAIHostedMultiAgentModel = OpenAIHostedMultiAgentModel;
+//# sourceMappingURL=model.js.map