@a5c-ai/transport-adapter 5.1.1-staging.00ceebd28cf2

package/dist/server.js

@@ -0,0 +1,1428 @@
+import * as http from 'node:http';
+import { randomUUID } from 'node:crypto';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { WebSocketServer } from 'ws';
+import { Hono } from 'hono';
+import { getCodec } from './codecs/index.js';
+const STREAMING_TRANSPORTS = new Set([
+    'anthropic',
+    'openai-chat',
+    'openai-responses',
+    'google',
+    'bedrock-converse',
+    'passthrough',
+]);
+function headerValue(req, name) {
+    const value = req.headers.get(name);
+    return value && value.length > 0 ? value : undefined;
+}
+function costFeedbackMetadataFromRequest(req, defaults) {
+    return {
+        ...defaults,
+        runId: headerValue(req, 'x-babysitter-run-id') ?? defaults?.runId,
+        sessionId: headerValue(req, 'x-babysitter-session-id') ?? defaults?.sessionId,
+        effectId: headerValue(req, 'x-babysitter-effect-id') ?? defaults?.effectId,
+        taskId: headerValue(req, 'x-babysitter-task-id') ?? defaults?.taskId,
+        taskKind: headerValue(req, 'x-babysitter-task-kind') ?? defaults?.taskKind,
+        source: headerValue(req, 'x-babysitter-cost-source') ?? defaults?.source,
+        idempotencyKey: headerValue(req, 'x-babysitter-cost-idempotency-key') ?? defaults?.idempotencyKey,
+    };
+}
+function shouldEmitCostFeedback(metadata) {
+    return Boolean(metadata?.runId || metadata?.sessionId || metadata?.effectId || metadata?.idempotencyKey);
+}
+function buildCostFeedbackRecord(result, config, metadata) {
+    const inputTokens = result.costRecord?.inputTokens ?? result.usage.promptTokens;
+    const outputTokens = result.costRecord?.outputTokens ?? result.usage.completionTokens;
+    return {
+        ...metadata,
+        provider: config.targetProvider,
+        model: result.costRecord ? (result.model || config.targetModel) : (result.model || config.targetModel),
+        inputTokens,
+        outputTokens,
+        cacheReadTokens: result.costRecord?.cacheReadTokens,
+        cacheCreationTokens: result.costRecord?.cacheWriteTokens,
+    };
+}
+async function emitCostFeedback(sink, result, config, metadata) {
+    if (!sink || !shouldEmitCostFeedback(metadata))
+        return;
+    await sink(buildCostFeedbackRecord(result, config, metadata));
+}
+async function emitUsageCostFeedback(sink, usage, config, metadata) {
+    if (!sink || !usage || !shouldEmitCostFeedback(metadata))
+        return;
+    await sink({
+        ...metadata,
+        provider: config.targetProvider,
+        model: config.targetModel,
+        inputTokens: usage.promptTokens,
+        outputTokens: usage.completionTokens,
+    });
+}
+class MetricsTracker {
+    totalInputTokens = 0;
+    totalOutputTokens = 0;
+    totalRequests = 0;
+    totalErrors = 0;
+    startedAt = Date.now();
+    record(inputTokens, outputTokens) {
+        this.totalInputTokens += inputTokens;
+        this.totalOutputTokens += outputTokens;
+        this.totalRequests += 1;
+    }
+    recordRequest() {
+        this.totalRequests += 1;
+    }
+    recordError() {
+        this.totalErrors += 1;
+    }
+    toJSON() {
+        const uptimeSeconds = Math.max(0, (Date.now() - this.startedAt) / 1000);
+        return {
+            total_input_tokens: this.totalInputTokens,
+            total_output_tokens: this.totalOutputTokens,
+            total_requests: this.totalRequests,
+            total_errors: this.totalErrors,
+            uptime_seconds: Math.round(uptimeSeconds * 10) / 10,
+            avg_tokens_per_request: Math.round(((this.totalInputTokens + this.totalOutputTokens) / Math.max(this.totalRequests, 1)) * 10) / 10,
+        };
+    }
+}
+function firstHeaderValue(value) {
+    return Array.isArray(value) ? value[0] : value;
+}
+function isAuthorizedHeaderValues(apiKey, authorization, authToken) {
+    if (!authToken) {
+        return true;
+    }
+    if (apiKey === authToken) {
+        return true;
+    }
+    if (!authorization) {
+        return false;
+    }
+    const [scheme, value] = authorization.split(/\s+/, 2);
+    return scheme?.toLowerCase() === 'bearer' && value === authToken;
+}
+function isAuthorized(req, authToken) {
+    return isAuthorizedHeaderValues(req.headers.get('x-api-key'), req.headers.get('authorization'), authToken);
+}
+function isAuthorizedUpgrade(req, authToken) {
+    return isAuthorizedHeaderValues(firstHeaderValue(req.headers['x-api-key']), firstHeaderValue(req.headers['authorization']), authToken);
+}
+function parseMessageContent(content) {
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => {
+            if (typeof part === 'string') {
+                return part;
+            }
+            if (part && typeof part === 'object' && 'text' in part && typeof part.text === 'string') {
+                return part.text;
+            }
+            return '';
+        })
+            .filter(Boolean)
+            .join(' ');
+    }
+    return '';
+}
+function normalizeMessages(raw) {
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    return raw.map((entry) => {
+        const record = entry;
+        return {
+            role: typeof record.role === 'string' ? record.role : 'user',
+            content: parseMessageContent(record.content ?? record.parts),
+            rawContent: record.content,
+        };
+    });
+}
+function normalizeInput(input) {
+    if (typeof input === 'string') {
+        return input;
+    }
+    if (Array.isArray(input)) {
+        return input
+            .map((entry) => {
+            if (typeof entry === 'string') {
+                return entry;
+            }
+            if (entry && typeof entry === 'object' && 'text' in entry && typeof entry.text === 'string') {
+                return entry.text;
+            }
+            return '';
+        })
+            .filter(Boolean)
+            .join(' ');
+    }
+    return '';
+}
+function toRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function usageShape(result) {
+    return {
+        prompt_tokens: result.usage.promptTokens,
+        completion_tokens: result.usage.completionTokens,
+        total_tokens: result.usage.totalTokens,
+    };
+}
+async function readJsonBody(req) {
+    try {
+        const body = await req.json();
+        if (!body || typeof body !== 'object') {
+            return {};
+        }
+        return body;
+    }
+    catch {
+        return {};
+    }
+}
+async function readStrictJsonBody(req) {
+    try {
+        const body = await req.json();
+        if (!body || typeof body !== 'object' || Array.isArray(body)) {
+            return createErrorResponse('Request body must be a JSON object.');
+        }
+        return body;
+    }
+    catch {
+        return createErrorResponse('Request body must be valid JSON.');
+    }
+}
+function isStreamingRequestedByBody(body) {
+    return body.stream === true;
+}
+function createErrorResponse(message, status = 400) {
+    return new Response(JSON.stringify({ error: { message } }), {
+        status,
+        headers: { 'content-type': 'application/json' },
+    });
+}
+function supportsStreaming(transport) {
+    return STREAMING_TRANSPORTS.has(transport);
+}
+function buildCompletionRequest(body, transport, stream, thoughtSignatureStore) {
+    const codec = getCodec(transport);
+    if (codec) {
+        const decoded = codec.decodeRequest(body);
+        const rawMessages = Array.isArray(body.messages)
+            ? body.messages
+            : Array.isArray(body.contents)
+                ? body.contents
+                : undefined;
+        const messages = rawMessages
+            ? decoded.messages.map((message, index) => {
+                const raw = rawMessages[index];
+                return {
+                    ...message,
+                    rawContent: message.rawContent ?? raw?.content ?? raw?.parts,
+                };
+            })
+            : decoded.messages;
+        return {
+            ...decoded,
+            transport,
+            messages,
+            model: typeof body.model === 'string'
+                ? body.model
+                : typeof body.modelId === 'string'
+                    ? body.modelId
+                    : decoded.model,
+            stream,
+            input: transport === 'openai-responses'
+                ? decoded.input ?? normalizeInput(body.input)
+                : decoded.input,
+            thoughtSignatureStore,
+        };
+    }
+    const messages = transport === 'google' || transport === 'vertex-native'
+        ? normalizeMessages(body.contents)
+        : transport === 'openai-responses'
+            ? [{ role: 'user', content: normalizeInput(body.input) }]
+            : transport === 'bedrock-converse'
+                ? normalizeMessages(Array.isArray(body.messages)
+                    ? body.messages.map((message) => ({
+                        role: message.role,
+                        content: Array.isArray(message.content) ? message.content : message.content,
+                    }))
+                    : [])
+                : normalizeMessages(body.messages);
+    return {
+        model: typeof body.model === 'string'
+            ? body.model
+            : typeof body.modelId === 'string'
+                ? body.modelId
+                : 'mock-model',
+        transport,
+        messages,
+        tools: Array.isArray(body.tools) ? body.tools : undefined,
+        toolChoice: body.tool_choice ?? body.toolChoice ?? undefined,
+        stream,
+        input: transport === 'openai-responses' ? normalizeInput(body.input) : undefined,
+        raw: body,
+        thoughtSignatureStore,
+    };
+}
+async function createExecutionPlan(req, transport, options = {}) {
+    const body = await readJsonBody(req.clone());
+    const bodyRequestedStream = isStreamingRequestedByBody(body);
+    if (transport === 'google' && bodyRequestedStream && !options.forceStreaming) {
+        return createErrorResponse('Google streaming requires the dedicated :streamGenerateContent route.');
+    }
+    const streamRequested = options.forceStreaming === true || bodyRequestedStream;
+    return {
+        body,
+        request: buildCompletionRequest(body, transport, streamRequested, options.thoughtSignatureStore),
+        streamRequested,
+    };
+}
+function normalizeProviderId(provider) {
+    return provider.trim().toLowerCase().replace(/[_\s]+/g, '-');
+}
+function resolvePassthroughApiBase(config, env = process.env) {
+    if (config.apiBase) {
+        return config.apiBase;
+    }
+    const legacyOverride = env.AGENT_MUX_PROXY_TARGET_API_BASE?.trim();
+    if (legacyOverride) {
+        return legacyOverride;
+    }
+    const provider = normalizeProviderId(config.targetProvider);
+    switch (provider) {
+        case 'anthropic':
+            return 'https://api.anthropic.com';
+        case 'openai':
+            return 'https://api.openai.com';
+        case 'google':
+            return 'https://generativelanguage.googleapis.com';
+        case 'openrouter':
+            return 'https://openrouter.ai/api';
+        case 'groq':
+            return 'https://api.groq.com/openai';
+        case 'fireworks':
+        case 'fireworks-ai':
+            return 'https://api.fireworks.ai/inference';
+        case 'together':
+        case 'together-ai':
+            return 'https://api.together.xyz';
+        case 'deepseek':
+            return 'https://api.deepseek.com';
+        case 'mistral':
+            return 'https://api.mistral.ai';
+        case 'cerebras':
+            return 'https://api.cerebras.ai';
+        case 'sambanova':
+            return 'https://api.sambanova.ai';
+        case 'nvidia-nim':
+            return 'https://integrate.api.nvidia.com';
+        case 'perplexity':
+            return 'https://api.perplexity.ai';
+        case 'cohere':
+            return 'https://api.cohere.com';
+        case 'ollama':
+            return 'http://localhost:11434';
+        case 'local':
+            return 'http://localhost:8080';
+        case 'lmstudio':
+            return 'http://localhost:1234';
+        case 'vllm':
+            return 'http://localhost:8000';
+        default:
+            return undefined;
+    }
+}
+function injectPassthroughProviderAuth(config, headers, env = process.env) {
+    const provider = normalizeProviderId(config.targetProvider);
+    switch (provider) {
+        case 'anthropic': {
+            const apiKey = env.ANTHROPIC_API_KEY?.trim();
+            if (apiKey) {
+                headers.set('x-api-key', apiKey);
+                headers.set('anthropic-version', '2023-06-01');
+            }
+            return;
+        }
+        case 'google': {
+            const apiKey = env.GOOGLE_API_KEY?.trim() || env.GEMINI_API_KEY?.trim();
+            if (apiKey) {
+                headers.set('x-goog-api-key', apiKey);
+            }
+            return;
+        }
+        case 'openai':
+        case 'openrouter':
+        case 'groq':
+        case 'fireworks':
+        case 'fireworks-ai':
+        case 'together':
+        case 'together-ai':
+        case 'deepseek':
+        case 'mistral':
+        case 'cerebras':
+        case 'sambanova':
+        case 'nvidia-nim':
+        case 'perplexity':
+        case 'cohere':
+        case 'custom': {
+            const envKeysByProvider = {
+                openai: ['OPENAI_API_KEY'],
+                openrouter: ['OPENROUTER_API_KEY', 'OPENAI_API_KEY'],
+                groq: ['GROQ_API_KEY', 'OPENAI_API_KEY'],
+                fireworks: ['FIREWORKS_API_KEY', 'OPENAI_API_KEY'],
+                'fireworks-ai': ['FIREWORKS_API_KEY', 'OPENAI_API_KEY'],
+                together: ['TOGETHER_API_KEY', 'OPENAI_API_KEY'],
+                'together-ai': ['TOGETHER_API_KEY', 'OPENAI_API_KEY'],
+                deepseek: ['DEEPSEEK_API_KEY', 'OPENAI_API_KEY'],
+                mistral: ['MISTRAL_API_KEY', 'OPENAI_API_KEY'],
+                cerebras: ['CEREBRAS_API_KEY', 'OPENAI_API_KEY'],
+                sambanova: ['SAMBANOVA_API_KEY', 'OPENAI_API_KEY'],
+                'nvidia-nim': ['NVIDIA_API_KEY', 'OPENAI_API_KEY'],
+                perplexity: ['PERPLEXITY_API_KEY', 'OPENAI_API_KEY'],
+                cohere: ['COHERE_API_KEY', 'OPENAI_API_KEY'],
+                custom: ['OPENAI_API_KEY'],
+            };
+            const apiKey = envKeysByProvider[provider]
+                ?.map((envKey) => env[envKey]?.trim())
+                .find(Boolean);
+            if (apiKey) {
+                headers.set('authorization', `Bearer ${apiKey}`);
+            }
+            return;
+        }
+    }
+}
+function redactPassthroughInternalHeaders(headers) {
+    for (const key of Array.from(headers.keys())) {
+        if (key.toLowerCase().startsWith('x-babysitter-')) {
+            headers.delete(key);
+        }
+    }
+}
+async function proxyUpstream(req, config, forwardedPath) {
+    const apiBase = resolvePassthroughApiBase(config);
+    if (!apiBase) {
+        return new Response(JSON.stringify({ error: 'No completion engine or apiBase configured.' }), {
+            status: 501,
+            headers: { 'content-type': 'application/json' },
+        });
+    }
+    const requestUrl = new URL(req.url);
+    const upstreamUrl = new URL(forwardedPath ?? requestUrl.pathname, apiBase);
+    upstreamUrl.search = requestUrl.search;
+    const headers = new Headers(req.headers);
+    headers.delete('host');
+    headers.delete('x-api-key');
+    headers.delete('authorization');
+    redactPassthroughInternalHeaders(headers);
+    injectPassthroughProviderAuth(config, headers);
+    const init = {
+        method: req.method,
+        headers,
+    };
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+        init.body = await req.arrayBuffer();
+    }
+    return fetch(upstreamUrl, init);
+}
+function encodeSseChunk(prefix, payload) {
+    return `${prefix}${JSON.stringify(payload)}\n\n`;
+}
+function parseJsonObject(value) {
+    try {
+        const parsed = JSON.parse(value || '{}');
+        return toRecord(parsed) ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+function openAiResponsesUsage(result) {
+    if (!result)
+        return null;
+    return {
+        input_tokens: result.usage.promptTokens,
+        output_tokens: result.usage.completionTokens,
+        total_tokens: result.usage.totalTokens,
+    };
+}
+function openAiResponsesMessageItem(itemId, text, status) {
+    return {
+        id: itemId,
+        type: 'message',
+        status,
+        role: 'assistant',
+        content: status === 'completed'
+            ? [{ type: 'output_text', text, annotations: [] }]
+            : [],
+    };
+}
+function openAiResponsesFunctionCallItem(input) {
+    const itemId = input.itemId ?? `fc_${randomUUID()}`;
+    return {
+        type: 'function_call',
+        id: itemId,
+        call_id: input.id || itemId,
+        name: input.name,
+        arguments: input.arguments,
+        status: input.status ?? 'completed',
+        ...input.metadata,
+    };
+}
+function openAiResponsesShape(input) {
+    return {
+        id: input.id,
+        object: 'response',
+        created_at: input.createdAt,
+        status: input.status,
+        model: input.config.targetModel,
+        output: input.output ?? [],
+        parallel_tool_calls: true,
+        tool_choice: 'auto',
+        tools: [],
+        usage: input.usage ?? null,
+    };
+}
+function anthropicStreamResponse(stream, config) {
+    const encoder = new TextEncoder();
+    const messageId = `msg_${randomUUID()}`;
+    return new Response(new ReadableStream({
+        async start(controller) {
+            controller.enqueue(encoder.encode(encodeSseChunk('event: message_start\ndata: ', {
+                type: 'message_start',
+                message: {
+                    id: messageId,
+                    type: 'message',
+                    role: 'assistant',
+                    content: [],
+                    model: config.targetModel,
+                },
+            })));
+            controller.enqueue(encoder.encode(encodeSseChunk('event: content_block_start\ndata: ', {
+                type: 'content_block_start',
+                index: 0,
+                content_block: { type: 'text', text: '' },
+            })));
+            let contentIndex = 0;
+            let hasToolUse = false;
+            for await (const event of stream) {
+                if (event.type === 'text-delta' && event.text) {
+                    controller.enqueue(encoder.encode(encodeSseChunk('event: content_block_delta\ndata: ', {
+                        type: 'content_block_delta',
+                        index: contentIndex,
+                        delta: { type: 'text_delta', text: event.text },
+                    })));
+                }
+                else if (event.type === 'tool-call') {
+                    // Close text block before first tool_use
+                    if (!hasToolUse) {
+                        controller.enqueue(encoder.encode(encodeSseChunk('event: content_block_stop\ndata: ', { type: 'content_block_stop', index: contentIndex })));
+                        contentIndex++;
+                        hasToolUse = true;
+                    }
+                    // Anthropic streaming format: content_block_start with empty input,
+                    // then input_json_delta with the full JSON, then content_block_stop.
+                    const toolUseBlock = { type: 'tool_use', id: event.id, name: event.name, input: {} };
+                    if (event.metadata)
+                        Object.assign(toolUseBlock, event.metadata);
+                    controller.enqueue(encoder.encode(encodeSseChunk('event: content_block_start\ndata: ', {
+                        type: 'content_block_start',
+                        index: contentIndex,
+                        content_block: toolUseBlock,
+                    })));
+                    controller.enqueue(encoder.encode(encodeSseChunk('event: content_block_delta\ndata: ', {
+                        type: 'content_block_delta',
+                        index: contentIndex,
+                        delta: { type: 'input_json_delta', partial_json: event.arguments },
+                    })));
+                    controller.enqueue(encoder.encode(encodeSseChunk('event: content_block_stop\ndata: ', { type: 'content_block_stop', index: contentIndex })));
+                    contentIndex++;
+                }
+            }
+            if (!hasToolUse) {
+                controller.enqueue(encoder.encode(encodeSseChunk('event: content_block_stop\ndata: ', { type: 'content_block_stop', index: contentIndex })));
+            }
+            controller.enqueue(encoder.encode(encodeSseChunk('event: message_delta\ndata: ', {
+                type: 'message_delta',
+                delta: { stop_reason: hasToolUse ? 'tool_use' : 'end_turn' },
+            })));
+            controller.enqueue(encoder.encode(encodeSseChunk('event: message_stop\ndata: ', { type: 'message_stop' })));
+            controller.close();
+        },
+    }), { headers: { 'content-type': 'text/event-stream; charset=utf-8', 'cache-control': 'no-cache' } });
+}
+function openAiChatStreamResponse(stream, config) {
+    const encoder = new TextEncoder();
+    const responseId = `chatcmpl_${randomUUID()}`;
+    const created = Math.floor(Date.now() / 1000);
+    return new Response(new ReadableStream({
+        async start(controller) {
+            controller.enqueue(encoder.encode(encodeSseChunk('data: ', {
+                id: responseId,
+                object: 'chat.completion.chunk',
+                created,
+                model: config.targetModel,
+                choices: [{ index: 0, delta: { role: 'assistant' }, finish_reason: null }],
+            })));
+            let finishReason = 'stop';
+            let toolCallIndex = 0;
+            for await (const event of stream) {
+                if (event.type === 'text-delta' && event.text) {
+                    controller.enqueue(encoder.encode(encodeSseChunk('data: ', {
+                        id: responseId,
+                        object: 'chat.completion.chunk',
+                        created,
+                        model: config.targetModel,
+                        choices: [{ index: 0, delta: { content: event.text }, finish_reason: null }],
+                    })));
+                    continue;
+                }
+                if (event.type === 'tool-call') {
+                    controller.enqueue(encoder.encode(encodeSseChunk('data: ', {
+                        id: responseId,
+                        object: 'chat.completion.chunk',
+                        created,
+                        model: config.targetModel,
+                        choices: [{
+                                index: 0,
+                                delta: {
+                                    tool_calls: [{
+                                            index: toolCallIndex,
+                                            id: event.id,
+                                            type: 'function',
+                                            function: { name: event.name, arguments: event.arguments },
+                                        }],
+                                },
+                                finish_reason: null,
+                            }],
+                    })));
+                    toolCallIndex++;
+                    continue;
+                }
+                if (event.type === 'done' && event.finishReason) {
+                    finishReason = event.finishReason;
+                }
+            }
+            controller.enqueue(encoder.encode(encodeSseChunk('data: ', {
+                id: responseId,
+                object: 'chat.completion.chunk',
+                created,
+                model: config.targetModel,
+                choices: [{ index: 0, delta: {}, finish_reason: finishReason }],
+            })));
+            controller.enqueue(encoder.encode('data: [DONE]\n\n'));
+            controller.close();
+        },
+    }), { headers: { 'content-type': 'text/event-stream; charset=utf-8', 'cache-control': 'no-cache' } });
+}
+function openAiResponsesStreamResponse(stream, config) {
+    const encoder = new TextEncoder();
+    const responseId = `resp_${randomUUID()}`;
+    const itemId = `msg_${randomUUID()}`;
+    const createdAt = Math.floor(Date.now() / 1000);
+    return new Response(new ReadableStream({
+        async start(controller) {
+            let outputText = '';
+            controller.enqueue(encoder.encode(encodeSseChunk('event: response.created\ndata: ', {
+                type: 'response.created',
+                response: openAiResponsesShape({ id: responseId, createdAt, config, status: 'in_progress' }),
+            })));
+            controller.enqueue(encoder.encode(encodeSseChunk('event: response.output_item.added\ndata: ', {
+                type: 'response.output_item.added',
+                output_index: 0,
+                item: openAiResponsesMessageItem(itemId, '', 'in_progress'),
+            })));
+            controller.enqueue(encoder.encode(encodeSseChunk('event: response.content_part.added\ndata: ', {
+                type: 'response.content_part.added',
+                item_id: itemId,
+                output_index: 0,
+                content_index: 0,
+                part: { type: 'output_text', text: '', annotations: [] },
+            })));
+            let toolCallIndex = 0;
+            const toolItems = [];
+            try {
+                for await (const event of stream) {
+                    if (event.type === 'text-delta' && event.text) {
+                        outputText += event.text;
+                        controller.enqueue(encoder.encode(encodeSseChunk('event: response.output_text.delta\ndata: ', {
+                            type: 'response.output_text.delta',
+                            item_id: itemId,
+                            output_index: 0,
+                            content_index: 0,
+                            delta: event.text,
+                        })));
+                    }
+                    else if (event.type === 'tool-call') {
+                        const toolItemId = `fc_${randomUUID()}`;
+                        const outputIndex = toolCallIndex + 1;
+                        const toolItem = openAiResponsesFunctionCallItem({
+                            ...event,
+                            itemId: toolItemId,
+                            status: 'completed',
+                        });
+                        toolItems.push(toolItem);
+                        controller.enqueue(encoder.encode(encodeSseChunk('event: response.output_item.added\ndata: ', {
+                            type: 'response.output_item.added',
+                            output_index: outputIndex,
+                            item: openAiResponsesFunctionCallItem({
+                                ...event,
+                                itemId: toolItemId,
+                                arguments: '',
+                                status: 'in_progress',
+                            }),
+                        })));
+                        if (event.arguments) {
+                            controller.enqueue(encoder.encode(encodeSseChunk('event: response.function_call_arguments.delta\ndata: ', {
+                                type: 'response.function_call_arguments.delta',
+                                item_id: toolItemId,
+                                output_index: outputIndex,
+                                delta: event.arguments,
+                            })));
+                        }
+                        controller.enqueue(encoder.encode(encodeSseChunk('event: response.function_call_arguments.done\ndata: ', {
+                            type: 'response.function_call_arguments.done',
+                            item_id: toolItemId,
+                            output_index: outputIndex,
+                            arguments: event.arguments,
+                        })));
+                        controller.enqueue(encoder.encode(encodeSseChunk('event: response.output_item.done\ndata: ', {
+                            type: 'response.output_item.done',
+                            output_index: outputIndex,
+                            item: toolItem,
+                        })));
+                        toolCallIndex++;
+                    }
+                }
+            }
+            catch (streamError) {
+                const errorMsg = streamError instanceof Error ? streamError.message : String(streamError);
+                console.error(`[transport-adapter] SSE stream error: ${errorMsg}`);
+                controller.enqueue(encoder.encode(encodeSseChunk('event: error\ndata: ', {
+                    type: 'error',
+                    error: { type: 'server_error', message: `Upstream stream error: ${errorMsg}` },
+                })));
+            }
+            const messageItem = openAiResponsesMessageItem(itemId, outputText, 'completed');
+            controller.enqueue(encoder.encode(encodeSseChunk('event: response.output_text.done\ndata: ', {
+                type: 'response.output_text.done',
+                item_id: itemId,
+                output_index: 0,
+                content_index: 0,
+                text: outputText,
+            })));
+            controller.enqueue(encoder.encode(encodeSseChunk('event: response.content_part.done\ndata: ', {
+                type: 'response.content_part.done',
+                item_id: itemId,
+                output_index: 0,
+                content_index: 0,
+                part: { type: 'output_text', text: outputText, annotations: [] },
+            })));
+            controller.enqueue(encoder.encode(encodeSseChunk('event: response.output_item.done\ndata: ', {
+                type: 'response.output_item.done',
+                output_index: 0,
+                item: messageItem,
+            })));
+            controller.enqueue(encoder.encode(encodeSseChunk('event: response.completed\ndata: ', {
+                type: 'response.completed',
+                response: openAiResponsesShape({ id: responseId, createdAt, config, status: 'completed', output: [messageItem, ...toolItems] }),
+            })));
+            controller.enqueue(encoder.encode('data: [DONE]\n\n'));
+            controller.close();
+        },
+    }), { headers: { 'content-type': 'text/event-stream; charset=utf-8', 'cache-control': 'no-cache' } });
+}
+function completionResultToResponseEvent(result, config) {
+    return {
+        type: 'response.completed',
+        response: openAiResponsesResponse(result, config),
+    };
+}
+async function sendOpenAiResponsesWebSocketStream(ws, stream, config) {
+    const responseId = `resp_${randomUUID()}`;
+    const itemId = `msg_${randomUUID()}`;
+    const createdAt = Math.floor(Date.now() / 1000);
+    let outputText = '';
+    const toolItems = [];
+    ws.send(JSON.stringify({
+        type: 'response.created',
+        response: openAiResponsesShape({ id: responseId, createdAt, config, status: 'in_progress' }),
+    }));
+    ws.send(JSON.stringify({
+        type: 'response.output_item.added',
+        output_index: 0,
+        item: openAiResponsesMessageItem(itemId, '', 'in_progress'),
+    }));
+    ws.send(JSON.stringify({
+        type: 'response.content_part.added',
+        item_id: itemId,
+        output_index: 0,
+        content_index: 0,
+        part: { type: 'output_text', text: '', annotations: [] },
+    }));
+    for await (const event of stream) {
+        if (event.type === 'text-delta' && event.text) {
+            outputText += event.text;
+            ws.send(JSON.stringify({
+                type: 'response.output_text.delta',
+                item_id: itemId,
+                output_index: 0,
+                content_index: 0,
+                delta: event.text,
+            }));
+        }
+        else if (event.type === 'tool-call') {
+            const toolItemId = `fc_${randomUUID()}`;
+            const outputIndex = toolItems.length + 1;
+            const toolItem = openAiResponsesFunctionCallItem({
+                ...event,
+                itemId: toolItemId,
+                status: 'completed',
+            });
+            toolItems.push(toolItem);
+            ws.send(JSON.stringify({
+                type: 'response.output_item.added',
+                output_index: outputIndex,
+                item: openAiResponsesFunctionCallItem({
+                    ...event,
+                    itemId: toolItemId,
+                    arguments: '',
+                    status: 'in_progress',
+                }),
+            }));
+            if (event.arguments) {
+                ws.send(JSON.stringify({
+                    type: 'response.function_call_arguments.delta',
+                    item_id: toolItemId,
+                    output_index: outputIndex,
+                    delta: event.arguments,
+                }));
+            }
+            ws.send(JSON.stringify({
+                type: 'response.function_call_arguments.done',
+                item_id: toolItemId,
+                output_index: outputIndex,
+                arguments: event.arguments,
+            }));
+            ws.send(JSON.stringify({
+                type: 'response.output_item.done',
+                output_index: outputIndex,
+                item: toolItem,
+            }));
+        }
+    }
+    const messageItem = openAiResponsesMessageItem(itemId, outputText, 'completed');
+    ws.send(JSON.stringify({
+        type: 'response.output_text.done',
+        item_id: itemId,
+        output_index: 0,
+        content_index: 0,
+        text: outputText,
+    }));
+    ws.send(JSON.stringify({
+        type: 'response.content_part.done',
+        item_id: itemId,
+        output_index: 0,
+        content_index: 0,
+        part: { type: 'output_text', text: outputText, annotations: [] },
+    }));
+    ws.send(JSON.stringify({
+        type: 'response.output_item.done',
+        output_index: 0,
+        item: messageItem,
+    }));
+    ws.send(JSON.stringify({
+        type: 'response.completed',
+        response: openAiResponsesShape({ id: responseId, createdAt, config, status: 'completed', output: [messageItem, ...toolItems] }),
+    }));
+}
+async function handleOpenAiResponsesWebSocketMessage(ws, data, config, completionEngine, metrics, thoughtSignatureStore) {
+    let envelope;
+    try {
+        envelope = JSON.parse(data.toString('utf8'));
+    }
+    catch {
+        ws.send(JSON.stringify({ type: 'error', error: { message: 'WebSocket message must be valid JSON.' } }));
+        return;
+    }
+    if (!envelope || typeof envelope !== 'object') {
+        ws.send(JSON.stringify({ type: 'error', error: { message: 'WebSocket message must be a JSON object.' } }));
+        return;
+    }
+    const record = envelope;
+    if (record['type'] !== 'response.create') {
+        ws.send(JSON.stringify({ type: 'error', error: { message: `Unsupported WebSocket event type: ${String(record['type'])}` } }));
+        return;
+    }
+    const body = toRecord(record['response']) ?? toRecord(record['payload']) ?? record;
+    const plan = {
+        body,
+        request: buildCompletionRequest(body, 'openai-responses', true, thoughtSignatureStore),
+        streamRequested: true,
+    };
+    plan.request.model = config.targetModel;
+    try {
+        if (!completionEngine) {
+            ws.send(JSON.stringify({ type: 'error', error: { message: 'Responses WebSocket requires a configured completion engine.' } }));
+            metrics.recordError();
+            return;
+        }
+        if (completionEngine.stream) {
+            await sendOpenAiResponsesWebSocketStream(ws, trackCompletionStream(completionEngine.stream(plan.request), metrics, config), config);
+            return;
+        }
+        const result = await completionEngine.complete(plan.request);
+        metrics.record(result.usage.promptTokens, result.usage.completionTokens);
+        ws.send(JSON.stringify(completionResultToResponseEvent(result, config)));
+    }
+    catch (error) {
+        metrics.recordError();
+        const errMsg = error instanceof Error ? error.message : String(error);
+        console.error(`[transport-adapter] WebSocket completion error: ${errMsg}`);
+        ws.send(JSON.stringify({
+            type: 'error',
+            error: { message: error instanceof Error ? error.message : String(error) },
+        }));
+    }
+}
+function googleStreamResponse(stream) {
+    const encoder = new TextEncoder();
+    return new Response(new ReadableStream({
+        async start(controller) {
+            for await (const event of stream) {
+                if (event.type === 'text-delta' && event.text) {
+                    controller.enqueue(encoder.encode(`data: ${JSON.stringify({
+                        candidates: [{ content: { parts: [{ text: event.text }], role: 'model' } }],
+                    })}\n\n`));
+                }
+                else if (event.type === 'tool-call') {
+                    controller.enqueue(encoder.encode(`data: ${JSON.stringify({
+                        candidates: [{ content: { parts: [{ functionCall: { name: event.name, args: parseJsonObject(event.arguments) } }], role: 'model' } }],
+                    })}\n\n`));
+                }
+                else if (event.type === 'done') {
+                    controller.enqueue(encoder.encode(`data: ${JSON.stringify({
+                        candidates: [{ content: { parts: [], role: 'model' }, finishReason: event.finishReason?.toUpperCase() || 'STOP' }],
+                        usageMetadata: event.usage ? { promptTokenCount: event.usage.promptTokens, candidatesTokenCount: event.usage.completionTokens, totalTokenCount: event.usage.totalTokens } : undefined,
+                    })}\n\n`));
+                }
+            }
+            controller.close();
+        },
+    }), { headers: { 'content-type': 'text/event-stream; charset=utf-8', 'cache-control': 'no-cache' } });
+}
+function renderStreamResponse(transport, stream, config) {
+    switch (transport) {
+        case 'anthropic':
+            return anthropicStreamResponse(stream, config);
+        case 'openai-chat':
+            return openAiChatStreamResponse(stream, config);
+        case 'openai-responses':
+            return openAiResponsesStreamResponse(stream, config);
+        case 'google':
+            return googleStreamResponse(stream);
+        case 'bedrock-converse':
+            return codecStreamResponse(transport, stream, 'application/x-ndjson; charset=utf-8');
+        default:
+            return createErrorResponse(`Streaming is not supported for ${transport}.`);
+    }
+}
+function codecStreamResponse(transport, stream, contentType) {
+    const codec = getCodec(transport);
+    if (!codec) {
+        return createErrorResponse(`Streaming is not supported for ${transport}.`);
+    }
+    const encoder = new TextEncoder();
+    return new Response(new ReadableStream({
+        async start(controller) {
+            for await (const event of stream) {
+                const chunk = codec.encodeStreamChunk(event);
+                if (chunk) {
+                    controller.enqueue(encoder.encode(chunk));
+                }
+            }
+            controller.close();
+        },
+    }), { headers: { 'content-type': contentType, 'cache-control': 'no-cache' } });
+}
+function trackCompletionStream(stream, metrics, config, costFeedbackSink, costFeedbackMetadata) {
+    return {
+        async *[Symbol.asyncIterator]() {
+            let recorded = false;
+            try {
+                for await (const event of stream) {
+                    if (event.type === 'done') {
+                        if (event.usage) {
+                            metrics.record(event.usage.promptTokens, event.usage.completionTokens);
+                            await emitUsageCostFeedback(costFeedbackSink, event.usage, config, costFeedbackMetadata);
+                        }
+                        else {
+                            metrics.recordRequest();
+                        }
+                        recorded = true;
+                    }
+                    yield event;
+                }
+                if (!recorded) {
+                    metrics.recordRequest();
+                }
+            }
+            catch (error) {
+                metrics.recordError();
+                throw error;
+            }
+        },
+    };
+}
+async function trackCompletionOutcome(result, metrics, options = {}) {
+    if (result instanceof Response) {
+        if (result.status >= 400) {
+            metrics.recordError();
+        }
+        else if (options.countSuccessResponse) {
+            metrics.recordRequest();
+        }
+        return result;
+    }
+    metrics.record(result.usage.promptTokens, result.usage.completionTokens);
+    if (options.config) {
+        await emitCostFeedback(options.costFeedbackSink, result, options.config, options.costFeedbackMetadata);
+    }
+    return result;
+}
+async function resolveCompletion(req, config, completionEngine, plan, metrics, options = {}) {
+    if (plan.streamRequested) {
+        if (!config.stream) {
+            return createErrorResponse('Streaming was requested but is disabled by proxy configuration.');
+        }
+        if (!supportsStreaming(config.exposedTransport)) {
+            return createErrorResponse(`Streaming is not supported for ${config.exposedTransport}.`);
+        }
+        if (!completionEngine) {
+            return proxyUpstream(req, config, options.forceStreaming ? new URL(req.url).pathname : undefined);
+        }
+        if (!completionEngine.stream) {
+            return createErrorResponse(`Streaming was requested for ${config.exposedTransport}, but the configured completion engine cannot stream.`, 501);
+        }
+        return renderStreamResponse(config.exposedTransport, trackCompletionStream(completionEngine.stream(plan.request), metrics, config, options.costFeedbackSink, options.costFeedbackMetadata), config);
+    }
+    if (!completionEngine) {
+        return proxyUpstream(req, config);
+    }
+    plan.request.model = config.targetModel;
+    return completionEngine.complete(plan.request);
+}
+function anthropicResponse(result, config) {
+    const content = [];
+    if (result.text) {
+        content.push({ type: 'text', text: result.text });
+    }
+    if (result.toolCalls) {
+        for (const tc of result.toolCalls) {
+            let input;
+            try {
+                input = JSON.parse(tc.arguments);
+            }
+            catch (e) {
+                process.stderr.write(`[transport-adapter] tool call arguments parse failed for ${tc.name}: ${e instanceof Error ? e.message : String(e)}\n`);
+                input = { _parseError: true, _rawArguments: tc.arguments };
+            }
+            const block = { type: 'tool_use', id: tc.id, name: tc.name, input };
+            if (tc.metadata)
+                Object.assign(block, tc.metadata);
+            content.push(block);
+        }
+    }
+    if (content.length === 0) {
+        content.push({ type: 'text', text: '' });
+    }
+    return {
+        id: result.id,
+        type: 'message',
+        role: 'assistant',
+        model: config.targetModel,
+        stop_reason: result.toolCalls?.length ? 'tool_use' : result.finishReason,
+        content,
+        usage: {
+            input_tokens: result.usage.promptTokens,
+            output_tokens: result.usage.completionTokens,
+        },
+    };
+}
+function openAiChatResponse(result, config) {
+    const message = { role: 'assistant', content: result.text || null };
+    if (result.toolCalls?.length) {
+        message.tool_calls = result.toolCalls.map(tc => ({
+            id: tc.id,
+            type: 'function',
+            function: { name: tc.name, arguments: tc.arguments },
+        }));
+    }
+    return {
+        id: result.id,
+        object: 'chat.completion',
+        created: Math.floor(Date.now() / 1000),
+        model: config.targetModel,
+        choices: [
+            {
+                index: 0,
+                message,
+                finish_reason: result.toolCalls?.length ? 'tool_calls' : result.finishReason,
+            },
+        ],
+        usage: usageShape(result),
+    };
+}
+function openAiResponsesResponse(result, config) {
+    const createdAt = Math.floor(Date.now() / 1000);
+    const item = openAiResponsesMessageItem(`msg_${randomUUID()}`, result.text, 'completed');
+    const toolItems = result.toolCalls?.map(openAiResponsesFunctionCallItem) ?? [];
+    return openAiResponsesShape({
+        id: result.id,
+        createdAt,
+        config,
+        status: 'completed',
+        output: [item, ...toolItems],
+        usage: openAiResponsesUsage(result),
+    });
+}
+function googleResponse(result) {
+    const parts = [];
+    if (result.text)
+        parts.push({ text: result.text });
+    if (result.toolCalls && result.toolCalls.length > 0) {
+        for (const tc of result.toolCalls) {
+            try {
+                parts.push({ functionCall: { name: tc.name, args: JSON.parse(tc.arguments || '{}') } });
+            }
+            catch {
+                parts.push({ functionCall: { name: tc.name, args: {} } });
+            }
+        }
+    }
+    if (parts.length === 0)
+        parts.push({ text: result.text ?? '' });
+    return {
+        candidates: [
+            {
+                content: {
+                    role: 'model',
+                    parts,
+                },
+                finishReason: result.toolCalls?.length ? 'STOP' : 'STOP',
+            },
+        ],
+        usageMetadata: {
+            promptTokenCount: result.usage.promptTokens,
+            candidatesTokenCount: result.usage.completionTokens,
+            totalTokenCount: result.usage.totalTokens,
+        },
+    };
+}
+function bedrockResponse(result) {
+    return {
+        output: {
+            message: {
+                role: 'assistant',
+                content: [{ text: result.text }],
+            },
+        },
+        stopReason: 'end_turn',
+        usage: {
+            inputTokens: result.usage.promptTokens,
+            outputTokens: result.usage.completionTokens,
+            totalTokens: result.usage.totalTokens,
+        },
+    };
+}
+async function resolveTokenCount(body, config, completionEngine) {
+    if (!completionEngine?.countTokens) {
+        return createErrorResponse(`Token counting is not supported for provider ${config.targetProvider}.`, 501);
+    }
+    const request = buildCompletionRequest(body, config.exposedTransport, false);
+    request.model = config.targetModel;
+    try {
+        return await completionEngine.countTokens(request);
+    }
+    catch (error) {
+        return createErrorResponse(error instanceof Error ? error.message : String(error));
+    }
+}
+export function createTransportMuxApp({ config, completionEngine, costFeedbackSink, costFeedbackMetadata }) {
+    const app = new Hono();
+    const metrics = new MetricsTracker();
+    const thoughtSignatureStore = new Map();
+    app.onError((error, c) => {
+        metrics.recordError();
+        return c.json({ error: { message: error instanceof Error ? error.message : String(error) } }, 500);
+    });
+    app.use('*', async (c, next) => {
+        if (c.req.path === '/'
+            || c.req.path === '/health'
+            || c.req.path === '/v1/models'
+            || c.req.path === '/metrics'
+            || c.req.path === '/cache/stats') {
+            await next();
+            return;
+        }
+        if (!isAuthorized(c.req.raw, config.authToken)) {
+            // Gemini CLI sends the API key as a ?key= query parameter
+            const queryKey = c.req.query('key');
+            if (!queryKey || queryKey !== config.authToken) {
+                console.error(`[transport-adapter] AUTH REJECT: path=${c.req.path} queryKey=${queryKey ? queryKey.slice(0, 8) + '...' : 'null'} expectedToken=${config.authToken?.slice(0, 8)}... headers: x-api-key=${c.req.header('x-api-key')?.slice(0, 8) ?? 'null'} auth=${c.req.header('authorization')?.slice(0, 20) ?? 'null'}`);
+                return c.json({ error: { message: 'Unauthorized' } }, 401);
+            }
+        }
+        await next();
+    });
+    app.get('/health', (c) => c.json({ ok: true, transport: config.exposedTransport }));
+    app.get('/v1/models', (c) => c.json({
+        object: 'list',
+        data: [{ id: config.targetModel, object: 'model', owned_by: config.targetProvider }],
+    }));
+    app.get('/metrics', (c) => c.json(metrics.toJSON()));
+    app.get('/cache/stats', (c) => c.json({ enabled: false }));
+    app.post('/v1/count_tokens', async (c) => {
+        const body = await readStrictJsonBody(c.req.raw);
+        if (body instanceof Response) {
+            return body;
+        }
+        const result = await resolveTokenCount(body, config, completionEngine);
+        if (result instanceof Response) {
+            return result;
+        }
+        return c.json(result);
+    });
+    app.post('/v1/messages', async (c) => {
+        const plan = await createExecutionPlan(c.req.raw, 'anthropic', { thoughtSignatureStore });
+        if (plan instanceof Response) {
+            return plan;
+        }
+        plan.request.model = config.targetModel;
+        const feedbackMetadata = costFeedbackMetadataFromRequest(c.req.raw, costFeedbackMetadata);
+        const result = await trackCompletionOutcome(await resolveCompletion(c.req.raw, config, completionEngine, plan, metrics, { costFeedbackSink, costFeedbackMetadata: feedbackMetadata }), metrics, { countSuccessResponse: !plan.streamRequested || !completionEngine, config, costFeedbackSink, costFeedbackMetadata: feedbackMetadata });
+        if (result instanceof Response) {
+            return result;
+        }
+        return c.json(anthropicResponse(result, config));
+    });
+    app.post('/v1/chat/completions', async (c) => {
+        const plan = await createExecutionPlan(c.req.raw, 'openai-chat');
+        if (plan instanceof Response) {
+            return plan;
+        }
+        plan.request.model = config.targetModel;
+        const feedbackMetadata = costFeedbackMetadataFromRequest(c.req.raw, costFeedbackMetadata);
+        const result = await trackCompletionOutcome(await resolveCompletion(c.req.raw, config, completionEngine, plan, metrics, { costFeedbackSink, costFeedbackMetadata: feedbackMetadata }), metrics, { countSuccessResponse: !plan.streamRequested || !completionEngine, config, costFeedbackSink, costFeedbackMetadata: feedbackMetadata });
+        if (result instanceof Response) {
+            return result;
+        }
+        return c.json(openAiChatResponse(result, config));
+    });
+    app.post('/v1/responses', async (c) => {
+        console.error(`[transport-adapter] POST /v1/responses (HTTP SSE)`);
+        const plan = await createExecutionPlan(c.req.raw, 'openai-responses', { thoughtSignatureStore });
+        if (plan instanceof Response) {
+            return plan;
+        }
+        plan.request.model = config.targetModel;
+        const feedbackMetadata = costFeedbackMetadataFromRequest(c.req.raw, costFeedbackMetadata);
+        const result = await trackCompletionOutcome(await resolveCompletion(c.req.raw, config, completionEngine, plan, metrics, { costFeedbackSink, costFeedbackMetadata: feedbackMetadata }), metrics, { countSuccessResponse: !plan.streamRequested || !completionEngine, config, costFeedbackSink, costFeedbackMetadata: feedbackMetadata });
+        if (result instanceof Response) {
+            return result;
+        }
+        return c.json(openAiResponsesResponse(result, config));
+    });
+    app.post('/v1beta/models/*', async (c) => {
+        const forceStreaming = c.req.path.endsWith(':streamGenerateContent');
+        const plan = await createExecutionPlan(c.req.raw, 'google', { forceStreaming });
+        if (plan instanceof Response) {
+            return plan;
+        }
+        plan.request.model = config.targetModel;
+        const feedbackMetadata = costFeedbackMetadataFromRequest(c.req.raw, costFeedbackMetadata);
+        const result = await trackCompletionOutcome(await resolveCompletion(c.req.raw, config, completionEngine, plan, metrics, { forceStreaming, costFeedbackSink, costFeedbackMetadata: feedbackMetadata }), metrics, { countSuccessResponse: !plan.streamRequested || !completionEngine, config, costFeedbackSink, costFeedbackMetadata: feedbackMetadata });
+        if (result instanceof Response) {
+            return result;
+        }
+        return c.json(googleResponse(result));
+    });
+    // Vertex AI paths: gemini-cli in Vertex AI mode sends to /v1beta1/projects/*/...
+    for (const prefix of ['/v1/projects/*', '/v1beta/projects/*', '/v1beta1/projects/*']) {
+        app.post(prefix, vertexNativeHandler);
+    }
+    async function vertexNativeHandler(c) {
+        const forceStreaming = c.req.path.endsWith(':streamGenerateContent');
+        const plan = await createExecutionPlan(c.req.raw, 'google', { forceStreaming });
+        if (plan instanceof Response) {
+            return plan;
+        }
+        plan.request.model = config.targetModel;
+        const feedbackMetadata = costFeedbackMetadataFromRequest(c.req.raw, costFeedbackMetadata);
+        const result = await trackCompletionOutcome(await resolveCompletion(c.req.raw, config, completionEngine, plan, metrics, { costFeedbackSink, costFeedbackMetadata: feedbackMetadata }), metrics, { countSuccessResponse: !plan.streamRequested || !completionEngine, config, costFeedbackSink, costFeedbackMetadata: feedbackMetadata });
+        if (result instanceof Response) {
+            return result;
+        }
+        return forceStreaming
+            ? renderStreamResponse('google', result, config)
+            : c.json(googleResponse(result));
+    }
+    app.post('/converse', async (c) => {
+        const plan = await createExecutionPlan(c.req.raw, 'bedrock-converse');
+        if (plan instanceof Response) {
+            return plan;
+        }
+        plan.request.model = config.targetModel;
+        const feedbackMetadata = costFeedbackMetadataFromRequest(c.req.raw, costFeedbackMetadata);
+        const result = await trackCompletionOutcome(await resolveCompletion(c.req.raw, config, completionEngine, plan, metrics, { costFeedbackSink, costFeedbackMetadata: feedbackMetadata }), metrics, { countSuccessResponse: !plan.streamRequested || !completionEngine, config, costFeedbackSink, costFeedbackMetadata: feedbackMetadata });
+        if (result instanceof Response) {
+            return result;
+        }
+        return c.json(bedrockResponse(result));
+    });
+    app.post('/models/chat/completions', async (c) => {
+        const plan = await createExecutionPlan(c.req.raw, 'azure-foundry');
+        if (plan instanceof Response) {
+            return plan;
+        }
+        plan.request.model = config.targetModel;
+        const feedbackMetadata = costFeedbackMetadataFromRequest(c.req.raw, costFeedbackMetadata);
+        const result = await trackCompletionOutcome(await resolveCompletion(c.req.raw, config, completionEngine, plan, metrics, { costFeedbackSink, costFeedbackMetadata: feedbackMetadata }), metrics, { countSuccessResponse: !plan.streamRequested || !completionEngine, config, costFeedbackSink, costFeedbackMetadata: feedbackMetadata });
+        if (result instanceof Response) {
+            return result;
+        }
+        return c.json(openAiChatResponse(result, config));
+    });
+    app.all('/passthrough/*', async (c) => {
+        const forwardedPath = c.req.path.replace(/^\/passthrough/, '') || '/';
+        return trackCompletionOutcome(await proxyUpstream(c.req.raw, config, forwardedPath), metrics, {
+            countSuccessResponse: true,
+        });
+    });
+    return app;
+}
+async function nodeRequestBody(req) {
+    if (req.method === 'GET' || req.method === 'HEAD') {
+        return undefined;
+    }
+    const chunks = [];
+    for await (const chunk of req) {
+        if (Buffer.isBuffer(chunk)) {
+            chunks.push(chunk);
+            continue;
+        }
+        if (chunk instanceof Uint8Array) {
+            chunks.push(Buffer.from(chunk));
+            continue;
+        }
+        if (typeof chunk === 'string') {
+            chunks.push(Buffer.from(chunk));
+        }
+    }
+    return Buffer.concat(chunks);
+}
+async function writeNodeResponse(res, response) {
+    res.statusCode = response.status;
+    response.headers.forEach((value, key) => {
+        res.setHeader(key, value);
+    });
+    if (!response.body) {
+        res.end();
+        return;
+    }
+    try {
+        await pipeline(Readable.fromWeb(response.body), res);
+    }
+    catch (err) {
+        if (!res.writableEnded) {
+            res.end();
+        }
+    }
+}
+export async function startProxyServer(config, completionEngine) {
+    const webSocketMetrics = new MetricsTracker();
+    const webSocketThoughtSignatureStore = new Map();
+    const app = createTransportMuxApp({ config, completionEngine });
+    const server = http.createServer((req, res) => {
+        void (async () => {
+            const url = new URL(req.url ?? '/', `http://${config.host}:${config.port}`);
+            const body = await nodeRequestBody(req);
+            const request = new Request(url, {
+                method: req.method,
+                headers: new Headers(req.headers),
+                body: body == null ? undefined : new Blob([new Uint8Array(body)]),
+            });
+            const response = await app.fetch(request);
+            await writeNodeResponse(res, response);
+        })().catch((error) => {
+            if (!res.headersSent) {
+                res.statusCode = 500;
+                res.setHeader('content-type', 'application/json');
+                res.end(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
+            }
+            else if (!res.writableEnded) {
+                res.end();
+            }
+        });
+    });
+    const webSocketServer = new WebSocketServer({ noServer: true });
+    server.on('upgrade', (req, socket, head) => {
+        const url = new URL(req.url ?? '/', `http://${config.host}:${config.port}`);
+        console.error(`[transport-adapter] WebSocket upgrade: ${url.pathname} transport=${config.exposedTransport}`);
+        if (url.pathname !== '/v1/responses' || config.exposedTransport !== 'openai-responses') {
+            console.error(`[transport-adapter] WebSocket rejected: wrong path or transport`);
+            socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
+            socket.destroy();
+            return;
+        }
+        if (!isAuthorizedUpgrade(req, config.authToken)) {
+            console.error(`[transport-adapter] WebSocket rejected: unauthorized`);
+            socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
+            socket.destroy();
+            return;
+        }
+        webSocketServer.handleUpgrade(req, socket, head, (ws) => {
+            webSocketServer.emit('connection', ws, req);
+        });
+    });
+    webSocketServer.on('connection', (ws) => {
+        ws.on('message', (data) => {
+            void handleOpenAiResponsesWebSocketMessage(ws, data, config, completionEngine, webSocketMetrics, webSocketThoughtSignatureStore);
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(config.port, config.host, () => resolve());
+    });
+    const address = server.address();
+    if (!address || typeof address === 'string') {
+        throw new Error('Failed to resolve bound proxy server address.');
+    }
+    return {
+        url: `http://${config.host}:${address.port}`,
+        port: address.port,
+        async stop() {
+            await new Promise((resolve, reject) => {
+                webSocketServer.close((wsError) => {
+                    if (wsError) {
+                        reject(wsError);
+                        return;
+                    }
+                    server.close((error) => (error ? reject(error) : resolve()));
+                });
+            });
+        },
+    };
+}
+//# sourceMappingURL=server.js.map