@minniexcode/codex-switch 0.0.9 → 0.0.11

package/dist/runtime/copilot-adapter.js

@@ -10,8 +10,8 @@ const copilot_installer_1 = require("./copilot-installer");
 /**
  * Probes whether the optional Copilot SDK runtime is installed and loadable.
  */
-function probeCopilotSdkRuntime() {
-    const status = (0, copilot_installer_1.probeCopilotSdkInstall)();
+function probeCopilotSdkRuntime(runtimesDir) {
+    const status = (0, copilot_installer_1.probeCopilotSdkInstall)(runtimesDir);
     if (!status.installed) {
         return {
             ok: false,
@@ -37,18 +37,18 @@ function probeCopilotSdkRuntime() {
 /**
  * Loads the lazily installed Copilot SDK and returns the module.
  */
-async function requireCopilotSdk() {
-    return (0, copilot_sdk_loader_1.loadCopilotSdk)();
+async function requireCopilotSdk(runtimesDir) {
+    return (0, copilot_sdk_loader_1.loadCopilotSdk)(runtimesDir);
 }
 /**
  * Probes whether the lazily installed Copilot SDK can create a usable session.
  */
-async function readCopilotAuthState() {
-    const runtime = probeCopilotSdkRuntime();
+async function readCopilotAuthState(runtimesDir) {
+    const runtime = probeCopilotSdkRuntime(runtimesDir);
     if (!runtime.ok) {
         throw (0, errors_1.cliError)("COPILOT_SDK_MISSING", "The optional Copilot SDK runtime is not installed.", runtime.details);
     }
-    const { client, session } = await createCopilotSession();
+    const { client, session } = await createCopilotSession(runtimesDir);
     await stopCopilotClient(client);
     return {
         ready: Boolean(session),
@@ -60,7 +60,7 @@ async function readCopilotAuthState() {
  * Executes a single chat-completions style request through the optional Copilot SDK when available.
  */
 async function sendCopilotChatCompletion(args) {
-    const { client, session, sdk } = await createCopilotSession();
+    const { client, session, sdk } = await createCopilotSession(args.runtimesDir);
     try {
         const sendAndWait = resolveCallable(session, "sendAndWait") ?? resolveCallable(sdk, "sendAndWait");
         if (!sendAndWait) {
@@ -106,15 +106,15 @@ async function sendCopilotChatCompletion(args) {
         await stopCopilotClient(client);
     }
 }
-async function createCopilotSession() {
-    const sdk = (await requireCopilotSdk());
+async function createCopilotSession(runtimesDir) {
+    const sdk = (await requireCopilotSdk(runtimesDir));
     const client = createCopilotClient(sdk);
     const createSession = resolveCallable(client ? client : null, "createSession") ?? resolveCallable(sdk, "createSession");
     if (!createSession) {
         throw (0, errors_1.cliError)("COPILOT_SDK_UNSUPPORTED", "The installed Copilot SDK does not expose a supported createSession API.", {});
     }
     try {
-        const session = (await Promise.resolve(createSession({})));
+        const session = (await Promise.resolve(createSession(createSessionOptions(sdk))));
         return {
             sdk,
             client,
@@ -122,11 +122,30 @@ async function createCopilotSession() {
         };
     }
     catch (error) {
+        if (classifyCopilotSessionError(error) === "unsupported") {
+            throw (0, errors_1.cliError)("COPILOT_SDK_UNSUPPORTED", "The installed Copilot SDK does not expose a compatible permission-handling session API.", {
+                cause: error instanceof Error ? error.message : String(error),
+            });
+        }
         throw (0, errors_1.cliError)("COPILOT_AUTH_REQUIRED", "Copilot authentication is required before the local bridge can be used.", {
             cause: error instanceof Error ? error.message : String(error),
         });
     }
 }
+/**
+ * Builds the session options used consistently across auth probes and request execution.
+ */
+function createSessionOptions(sdk) {
+    const approveAll = resolveApproveAll(sdk);
+    if (approveAll) {
+        return {
+            onPermissionRequest: (request) => approveAll(request),
+        };
+    }
+    return {
+        onPermissionRequest: () => true,
+    };
+}
 function createCopilotClient(sdk) {
     const ClientCtor = resolveConstructor(sdk, "CopilotClient");
     if (!ClientCtor) {
@@ -146,17 +165,27 @@ async function stopCopilotClient(client) {
         await Promise.resolve(client.stop());
     }
 }
+/**
+ * Distinguishes true auth failures from SDK API-shape mismatches.
+ */
+function classifyCopilotSessionError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/onPermissionRequest/i.test(message) || /permission/i.test(message)) {
+        return "unsupported";
+    }
+    return "auth";
+}
 function resolveCallable(target, name) {
     if (!target) {
         return null;
     }
     const direct = target[name];
     if (typeof direct === "function") {
-        return direct;
+        return direct.bind(target);
     }
     const nestedDefault = target.default;
     if (nestedDefault && typeof nestedDefault[name] === "function") {
-        return nestedDefault[name];
+        return nestedDefault[name].bind(nestedDefault);
     }
     return null;
 }
@@ -171,3 +200,17 @@ function resolveConstructor(target, name) {
     }
     return null;
 }
+/**
+ * Resolves the SDK-provided permission helper when available.
+ */
+function resolveApproveAll(target) {
+    const direct = target.approveAll;
+    if (typeof direct === "function") {
+        return direct;
+    }
+    const nestedDefault = target.default;
+    if (nestedDefault && typeof nestedDefault.approveAll === "function") {
+        return nestedDefault.approveAll;
+    }
+    return null;
+}

package/dist/runtime/copilot-bridge.js

@@ -45,11 +45,13 @@ exports.stopCopilotBridge = stopCopilotBridge;
 const http = __importStar(require("node:http"));
 const net = __importStar(require("node:net"));
 const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const providers_1 = require("../domain/providers");
 const errors_1 = require("../domain/errors");
 const runtime_state_repo_1 = require("../storage/runtime-state-repo");
 let spawnImplementation = node_child_process_1.spawn;
+let cachedBridgeWorkerBuildId = null;
 /**
  * Overrides the spawn implementation for bridge runtime tests.
  */
@@ -65,8 +67,8 @@ function resetCopilotBridgeSpawnImplementation() {
 /**
  * Returns the last known Copilot bridge runtime status.
  */
-async function probeCopilotBridgeRuntime(provider) {
-    const state = (0, runtime_state_repo_1.readCopilotBridgeState)();
+async function probeCopilotBridgeRuntime(provider, persistedState, runtimeDir) {
+    const state = persistedState === undefined ? (0, runtime_state_repo_1.readCopilotBridgeState)(runtimeDir) : persistedState;
     if (state && (!provider || !(0, providers_1.isCopilotBridgeProvider)(provider))) {
         return {
             ok: false,
@@ -126,7 +128,7 @@ async function probeCopilotBridgeRuntime(provider) {
     (0, runtime_state_repo_1.writeCopilotBridgeState)({
         ...state,
         lastHealthcheckAt: new Date().toISOString(),
-    });
+    }, runtimeDir);
     return {
         ok: true,
         runtime: "copilot-bridge",
@@ -136,13 +138,13 @@ async function probeCopilotBridgeRuntime(provider) {
 /**
  * Starts or reuses a Copilot bridge worker, then verifies its health before returning.
  */
-async function ensureCopilotBridge(providerName, provider) {
-    return startOrReuseCopilotBridge(providerName, provider);
+async function ensureCopilotBridge(providerName, provider, runtimeDir) {
+    return startOrReuseCopilotBridge(providerName, provider, runtimeDir);
 }
 /**
  * Starts or reuses a Copilot bridge worker and reports the chosen port.
  */
-async function startOrReuseCopilotBridge(providerName, provider) {
+async function startOrReuseCopilotBridge(providerName, provider, runtimeDir) {
     if (!(0, providers_1.isCopilotBridgeProvider)(provider)) {
         throw (0, errors_1.cliError)("RUNTIME_PROVIDER_INVALID", "Provider is not backed by a Copilot bridge runtime.", {
             provider: providerName,
@@ -155,27 +157,40 @@ async function startOrReuseCopilotBridge(providerName, provider) {
         });
     }
     const expectedBaseUrl = (0, providers_1.buildCopilotBridgeBaseUrl)(runtime);
-    const current = (0, runtime_state_repo_1.readCopilotBridgeState)();
+    const current = (0, runtime_state_repo_1.readCopilotBridgeState)(runtimeDir);
+    const workerBuildId = getCopilotBridgeWorkerBuildId();
     let replaced = false;
     if (current && current.provider === providerName && current.baseUrl === expectedBaseUrl) {
-        const healthy = await healthcheckCopilotBridge(current.host, current.port);
-        if (healthy.ok) {
-            (0, runtime_state_repo_1.writeCopilotBridgeState)({
-                ...current,
-                lastHealthcheckAt: new Date().toISOString(),
-            });
-            return {
-                baseUrl: expectedBaseUrl,
-                host: current.host,
-                port: current.port,
-                reused: true,
-                portChanged: false,
-                replaced: false,
-            };
+        if (current.workerBuildId === workerBuildId) {
+            const healthy = await healthcheckCopilotBridge(current.host, current.port);
+            if (healthy.ok) {
+                const compatible = await verifyCopilotBridgeAuthorization(current.host, current.port, provider.apiKey);
+                if (compatible.ok) {
+                    (0, runtime_state_repo_1.writeCopilotBridgeState)({
+                        ...current,
+                        lastHealthcheckAt: new Date().toISOString(),
+                        workerBuildId,
+                    }, runtimeDir);
+                    return {
+                        baseUrl: expectedBaseUrl,
+                        host: current.host,
+                        port: current.port,
+                        reused: true,
+                        portChanged: false,
+                        replaced: false,
+                    };
+                }
+            }
+            stopCopilotBridge(runtimeDir);
+            replaced = true;
+        }
+        else {
+            stopCopilotBridge(runtimeDir);
+            replaced = true;
         }
     }
     if (current && current.provider !== providerName) {
-        stopCopilotBridge();
+        stopCopilotBridge(runtimeDir);
         replaced = true;
     }
     const selectedPort = await selectBridgePort(runtime.bridgeHost, runtime.bridgePort);
@@ -208,7 +223,7 @@ async function startOrReuseCopilotBridge(providerName, provider) {
     const startedAt = new Date().toISOString();
     const healthy = await waitForCopilotBridgeStartup(child, runtime.bridgeHost, selectedPort, 15, 200);
     if (!healthy.ok) {
-        (0, runtime_state_repo_1.clearCopilotBridgeState)();
+        (0, runtime_state_repo_1.clearCopilotBridgeState)(runtimeDir);
         if (healthy.reason === "start-failed") {
             throw (0, errors_1.cliError)("BRIDGE_START_FAILED", "Copilot bridge worker exited before becoming healthy.", {
                 provider: providerName,
@@ -232,8 +247,9 @@ async function startOrReuseCopilotBridge(providerName, provider) {
         baseUrl: selectedBaseUrl,
         startedAt,
         lastHealthcheckAt: new Date().toISOString(),
+        workerBuildId,
     };
-    (0, runtime_state_repo_1.writeCopilotBridgeState)(state);
+    (0, runtime_state_repo_1.writeCopilotBridgeState)(state, runtimeDir);
     return {
         baseUrl: selectedBaseUrl,
         host: runtime.bridgeHost,
@@ -266,34 +282,329 @@ function createCopilotBridgeRequestHandler(context) {
                 response.end(JSON.stringify({ object: "list", data: [] }));
                 return;
             }
-            if (method !== "POST" || url !== "/v1/chat/completions") {
-                response.writeHead(404, { "content-type": "application/json" });
-                response.end(JSON.stringify({ error: { message: "Not found" } }));
+            if (method === "POST" && url === "/v1/chat/completions") {
+                const body = await readJsonBody(request);
+                const stream = Boolean(body.stream);
+                const payload = await context.executeChatCompletion(body);
+                if (stream) {
+                    response.writeHead(200, {
+                        "content-type": "text/event-stream",
+                        "cache-control": "no-cache",
+                        connection: "keep-alive",
+                    });
+                    response.write(`data: ${JSON.stringify(payload)}\n\n`);
+                    response.write("data: [DONE]\n\n");
+                    response.end();
+                    return;
+                }
+                response.writeHead(200, { "content-type": "application/json" });
+                response.end(JSON.stringify(payload));
                 return;
             }
-            const body = await readJsonBody(request);
-            const stream = Boolean(body.stream);
-            const payload = await context.executeChatCompletion(body);
-            if (stream) {
-                response.writeHead(200, {
-                    "content-type": "text/event-stream",
-                    "cache-control": "no-cache",
-                    connection: "keep-alive",
+            if (method === "POST" && url === "/v1/responses") {
+                const body = await readJsonBody(request);
+                const normalized = normalizeResponsesRequest(body);
+                const payload = await context.executeChatCompletion({
+                    model: normalized.model,
+                    messages: normalized.messages,
                 });
-                response.write(`data: ${JSON.stringify(payload)}\n\n`);
-                response.write("data: [DONE]\n\n");
-                response.end();
+                if (normalized.stream) {
+                    response.writeHead(200, {
+                        "content-type": "text/event-stream",
+                        "cache-control": "no-cache",
+                        connection: "keep-alive",
+                    });
+                    writeResponsesStream(response, payload);
+                    response.end();
+                    return;
+                }
+                response.writeHead(200, { "content-type": "application/json" });
+                response.end(JSON.stringify(buildResponsesPayload(payload)));
+                return;
+            }
+            if (method !== "POST") {
+                response.writeHead(404, { "content-type": "application/json" });
+                response.end(JSON.stringify({ error: { message: "Not found" } }));
                 return;
             }
-            response.writeHead(200, { "content-type": "application/json" });
-            response.end(JSON.stringify(payload));
+            response.writeHead(404, { "content-type": "application/json" });
+            response.end(JSON.stringify({ error: { message: "Not found" } }));
         }
         catch (error) {
-            response.writeHead(500, { "content-type": "application/json" });
+            const statusCode = isCliError(error) && error.code === "BRIDGE_UNSUPPORTED_REQUEST" ? 400 : 500;
+            response.writeHead(statusCode, { "content-type": "application/json" });
             response.end(JSON.stringify({ error: { message: error instanceof Error ? error.message : String(error) } }));
         }
     };
 }
+/**
+ * Converts one minimal Responses API payload into the existing chat-completions bridge call shape.
+ */
+function normalizeResponsesRequest(body) {
+    const payload = body;
+    if (typeof payload.model !== "string" || payload.model.trim() === "") {
+        throw (0, errors_1.cliError)("BRIDGE_UNSUPPORTED_REQUEST", "Copilot bridge /v1/responses requires a non-empty string model.");
+    }
+    const messages = normalizeResponsesInput(payload.input);
+    if (messages.length === 0) {
+        throw (0, errors_1.cliError)("BRIDGE_UNSUPPORTED_REQUEST", "Copilot bridge /v1/responses requires at least one input message.");
+    }
+    return {
+        model: payload.model,
+        messages,
+        stream: payload.stream === true,
+    };
+}
+function normalizeResponsesInput(input) {
+    if (typeof input === "string") {
+        return [{ role: "user", content: input }];
+    }
+    if (!Array.isArray(input)) {
+        throw (0, errors_1.cliError)("BRIDGE_UNSUPPORTED_REQUEST", "Copilot bridge /v1/responses expects input as a string or message array.");
+    }
+    if (input.length === 0) {
+        return [];
+    }
+    const entryKinds = input.map(classifyResponsesInputEntry);
+    const hasMessages = entryKinds.includes("message");
+    const hasContentItems = entryKinds.includes("content-item");
+    if (hasMessages && hasContentItems) {
+        throw (0, errors_1.cliError)("BRIDGE_UNSUPPORTED_REQUEST", "Copilot bridge /v1/responses input array must contain either message objects or content items, not both.");
+    }
+    if (hasContentItems) {
+        return [
+            {
+                role: "user",
+                content: extractResponsesTextContent(input, 0),
+            },
+        ];
+    }
+    return input.map((entry, index) => normalizeResponsesMessage(entry, index));
+}
+function normalizeResponsesMessage(entry, index) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+        throw (0, errors_1.cliError)("BRIDGE_UNSUPPORTED_REQUEST", `Copilot bridge /v1/responses input[${String(index)}] must be an object message.`);
+    }
+    const message = entry;
+    const role = typeof message.role === "string" && message.role.trim() !== "" ? message.role : "user";
+    const content = extractResponsesTextContent(message.content, index);
+    return { role, content };
+}
+/**
+ * Classifies one top-level Responses input entry so mixed array shapes can be rejected clearly.
+ */
+function classifyResponsesInputEntry(entry) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+        throw (0, errors_1.cliError)("BRIDGE_UNSUPPORTED_REQUEST", "Copilot bridge /v1/responses input entries must be objects.");
+    }
+    const record = entry;
+    if ("content" in record || "role" in record) {
+        return "message";
+    }
+    if (typeof record.type === "string") {
+        return "content-item";
+    }
+    throw (0, errors_1.cliError)("BRIDGE_UNSUPPORTED_REQUEST", "Copilot bridge /v1/responses input entries must be message objects or typed content items.");
+}
+function extractResponsesTextContent(content, index) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        throw (0, errors_1.cliError)("BRIDGE_UNSUPPORTED_REQUEST", `Copilot bridge /v1/responses input[${String(index)}].content must be a string or content item array.`);
+    }
+    const parts = content.map((item, itemIndex) => {
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+            throw (0, errors_1.cliError)("BRIDGE_UNSUPPORTED_REQUEST", `Copilot bridge /v1/responses input[${String(index)}].content[${String(itemIndex)}] must be an object item.`);
+        }
+        return renderResponsesContentItem(item);
+    });
+    return parts.join("\n");
+}
+/**
+ * Converts one Responses content item into the text-only prompt representation required by the Copilot SDK bridge.
+ */
+function renderResponsesContentItem(item) {
+    const type = typeof item.type === "string" ? item.type : null;
+    const text = typeof item.text === "string" ? item.text : null;
+    if ((type === "input_text" || type === "text" || type === "output_text") && text !== null) {
+        return text;
+    }
+    if (type === "input_image") {
+        return buildResponsesPlaceholder("input_image", item.image_url, item.file_id);
+    }
+    if (type === "input_file") {
+        return buildResponsesPlaceholder("input_file", item.filename, item.file_id);
+    }
+    if (type !== null) {
+        return `[unsupported content type: ${type}]`;
+    }
+    throw (0, errors_1.cliError)("BRIDGE_UNSUPPORTED_REQUEST", "Copilot bridge /v1/responses content items must declare a string type.");
+}
+/**
+ * Builds a readable placeholder for non-text Responses content items preserved as text-only context.
+ */
+function buildResponsesPlaceholder(type, ...candidates) {
+    for (const candidate of candidates) {
+        if (typeof candidate === "string" && candidate.trim() !== "") {
+            return `[${type}: ${candidate}]`;
+        }
+    }
+    return `[${type} omitted]`;
+}
+/**
+ * Converts the existing chat-completions response into a minimal Responses API payload.
+ */
+function buildResponsesPayload(payload) {
+    const firstChoice = Array.isArray(payload.choices) ? payload.choices[0] : null;
+    const outputText = firstChoice?.message?.content ?? "";
+    return {
+        id: payload.id ?? `resp_${Date.now()}`,
+        object: "response",
+        created_at: payload.created ?? Math.floor(Date.now() / 1000),
+        model: payload.model ?? "copilot",
+        status: "completed",
+        output: [
+            {
+                type: "message",
+                id: `${payload.id ?? "resp"}_msg_0`,
+                role: "assistant",
+                content: [
+                    {
+                        type: "output_text",
+                        text: outputText,
+                    },
+                ],
+            },
+        ],
+        output_text: outputText,
+    };
+}
+/**
+ * Emits a minimal OpenAI-compatible Responses API event stream.
+ */
+function writeResponsesStream(response, payload) {
+    const responsePayload = buildResponsesPayload(payload);
+    const responseId = typeof responsePayload.id === "string" ? responsePayload.id : `resp_${Date.now()}`;
+    const messageId = buildResponsesMessageId(responseId);
+    const outputText = typeof responsePayload.output_text === "string" ? responsePayload.output_text : "";
+    const inProgressResponse = {
+        ...responsePayload,
+        status: "in_progress",
+        output: [],
+    };
+    const completedMessage = {
+        id: messageId,
+        type: "message",
+        status: "completed",
+        role: "assistant",
+        content: [
+            {
+                type: "output_text",
+                text: outputText,
+                annotations: [],
+            },
+        ],
+    };
+    writeSseEvent(response, "response.created", {
+        type: "response.created",
+        response: inProgressResponse,
+    });
+    writeSseEvent(response, "response.in_progress", {
+        type: "response.in_progress",
+        response: inProgressResponse,
+    });
+    writeSseEvent(response, "response.output_item.added", {
+        type: "response.output_item.added",
+        output_index: 0,
+        item: {
+            id: messageId,
+            type: "message",
+            status: "in_progress",
+            role: "assistant",
+            content: [],
+        },
+    });
+    writeSseEvent(response, "response.content_part.added", {
+        type: "response.content_part.added",
+        item_id: messageId,
+        output_index: 0,
+        content_index: 0,
+        part: {
+            type: "output_text",
+            text: "",
+            annotations: [],
+        },
+    });
+    writeSseEvent(response, "response.output_text.delta", {
+        type: "response.output_text.delta",
+        item_id: messageId,
+        output_index: 0,
+        content_index: 0,
+        delta: outputText,
+    });
+    writeSseEvent(response, "response.output_text.done", {
+        type: "response.output_text.done",
+        item_id: messageId,
+        output_index: 0,
+        content_index: 0,
+        text: outputText,
+    });
+    writeSseEvent(response, "response.content_part.done", {
+        type: "response.content_part.done",
+        item_id: messageId,
+        output_index: 0,
+        content_index: 0,
+        part: {
+            type: "output_text",
+            text: outputText,
+            annotations: [],
+        },
+    });
+    writeSseEvent(response, "response.output_item.done", {
+        type: "response.output_item.done",
+        output_index: 0,
+        item: completedMessage,
+    });
+    writeSseEvent(response, "response.completed", {
+        type: "response.completed",
+        response: {
+            ...responsePayload,
+            output: [completedMessage],
+        },
+    });
+}
+/**
+ * Formats and writes one server-sent event frame.
+ */
+function writeSseEvent(response, eventName, data) {
+    response.write(`event: ${eventName}\n`);
+    response.write(`data: ${JSON.stringify(data)}\n\n`);
+}
+/**
+ * Derives a stable message identifier for synthesized Responses output items.
+ */
+function buildResponsesMessageId(responseId) {
+    if (responseId.startsWith("resp_")) {
+        return `msg_${responseId.slice("resp_".length)}_0`;
+    }
+    return `${responseId}_msg_0`;
+}
+function isCliError(error) {
+    return Boolean(error && typeof error === "object" && typeof error.code === "string");
+}
+/**
+ * Returns a stable build identifier for the compiled bridge worker bundle.
+ */
+function getCopilotBridgeWorkerBuildId() {
+    if (cachedBridgeWorkerBuildId) {
+        return cachedBridgeWorkerBuildId;
+    }
+    const workerPath = path.join(__dirname, "copilot-bridge-worker.js");
+    const stats = fs.statSync(workerPath);
+    cachedBridgeWorkerBuildId = `${stats.size}:${stats.mtimeMs}`;
+    return cachedBridgeWorkerBuildId;
+}
 /**
  * Starts an in-process local bridge server. Primarily used by the worker entrypoint and tests.
  */
@@ -329,8 +640,8 @@ async function waitForCopilotBridgeHealth(host, port, attempts = 10, delayMs = 1
 /**
  * Stops the currently persisted Copilot bridge worker when possible.
  */
-function stopCopilotBridge() {
-    const state = (0, runtime_state_repo_1.readCopilotBridgeState)();
+function stopCopilotBridge(runtimeDir) {
+    const state = (0, runtime_state_repo_1.readCopilotBridgeState)(runtimeDir);
     if (state?.pid) {
         try {
             process.kill(state.pid);
@@ -339,7 +650,7 @@ function stopCopilotBridge() {
             // Ignore best-effort bridge cleanup failures.
         }
     }
-    (0, runtime_state_repo_1.clearCopilotBridgeState)();
+    (0, runtime_state_repo_1.clearCopilotBridgeState)(runtimeDir);
 }
 async function checkPortAvailability(host, port) {
     return new Promise((resolve) => {
@@ -457,6 +768,43 @@ async function healthcheckCopilotBridge(host, port) {
         request.end();
     });
 }
+/**
+ * Checks whether a healthy bridge still accepts the provider's current bearer secret.
+ */
+async function verifyCopilotBridgeAuthorization(host, port, apiKey) {
+    return new Promise((resolve) => {
+        const request = http.request({
+            host,
+            port,
+            method: "GET",
+            path: "/v1/models",
+            timeout: 1000,
+            headers: {
+                authorization: `Bearer ${apiKey}`,
+            },
+        }, (response) => {
+            response.resume();
+            if (response.statusCode === 200) {
+                resolve({ ok: true });
+                return;
+            }
+            resolve({
+                ok: false,
+                cause: `Authorization probe returned status ${String(response.statusCode ?? 0)}.`,
+            });
+        });
+        request.on("error", (error) => {
+            resolve({
+                ok: false,
+                cause: error.message,
+            });
+        });
+        request.on("timeout", () => {
+            request.destroy(new Error("Authorization probe timed out."));
+        });
+        request.end();
+    });
+}
 async function readJsonBody(request) {
     const chunks = [];
     for await (const chunk of request) {