@minniexcode/codex-switch 0.1.0 → 0.1.2

package/dist/domain/providers.js

@@ -34,6 +34,9 @@ function validateProvidersShape(input) {
         if (typeof provider.apiKey !== "string" || provider.apiKey.trim() === "") {
             throw new Error(`Provider "${name}" is missing a valid apiKey.`);
         }
+        if (provider.model !== undefined && typeof provider.model !== "string") {
+            throw new Error(`Provider "${name}" has an invalid model.`);
+        }
         if (provider.baseUrl !== undefined && typeof provider.baseUrl !== "string") {
             throw new Error(`Provider "${name}" has an invalid baseUrl.`);
         }
@@ -55,6 +58,7 @@ function validateProvidersShape(input) {
         providers[name] = cleanProviderRecord({
             profile: provider.profile,
             apiKey: provider.apiKey,
+            model: provider.model,
             baseUrl: provider.baseUrl,
             note: provider.note,
             tags: provider.tags,
@@ -71,6 +75,9 @@ function cleanProviderRecord(record) {
         profile: record.profile.trim(),
         apiKey: record.apiKey.trim(),
     };
+    if (record.model && record.model.trim() !== "") {
+        next.model = record.model.trim();
+    }
     if (record.baseUrl && record.baseUrl.trim() !== "") {
         next.baseUrl = record.baseUrl.trim();
     }
@@ -161,6 +168,7 @@ function buildCopilotModelProviderProjection(runtime) {
         name: "copilot",
         requiresOpenAiAuth: true,
         wireApi: "responses",
+        streamIdleTimeoutMs: 300000,
     };
 }
 /**

package/dist/domain/runtime-state.js

@@ -90,26 +90,26 @@ function getStorageRoles(args) {
     };
 }
 /**
- * Compares the live active profile against managed providers to detect drift.
+ * Compares the live active model_provider against managed providers to detect drift.
  */
-function inspectLiveStateDrift(currentProfile, providers) {
-    if (currentProfile === null) {
+function inspectLiveStateDrift(currentModelProvider, providers) {
+    if (currentModelProvider === null) {
         return {
-            currentProfile,
+            currentModelProvider,
             mappedProvider: null,
             mappedProviders: [],
-            profileMapped: false,
+            modelProviderMapped: false,
             providerResolvable: false,
             canBackfillActiveProvider: false,
-            reason: providers ? "profile-missing" : "config-missing",
+            reason: providers ? "model-provider-missing" : "config-missing",
         };
     }
     if (!providers) {
         return {
-            currentProfile,
+            currentModelProvider,
             mappedProvider: null,
             mappedProviders: [],
-            profileMapped: false,
+            modelProviderMapped: false,
             providerResolvable: false,
             canBackfillActiveProvider: false,
             reason: "providers-missing",
@@ -117,16 +117,16 @@ function inspectLiveStateDrift(currentProfile, providers) {
     }
     const mappedProviders = [];
     for (const [name, provider] of Object.entries(providers.providers)) {
-        if (provider.profile === currentProfile) {
+        if (provider.profile === currentModelProvider) {
             mappedProviders.push(name);
         }
     }
     if (mappedProviders.length === 1) {
         return {
-            currentProfile,
+            currentModelProvider,
             mappedProvider: mappedProviders[0],
             mappedProviders,
-            profileMapped: true,
+            modelProviderMapped: true,
             providerResolvable: true,
             canBackfillActiveProvider: false,
             reason: "ok",
@@ -134,20 +134,20 @@ function inspectLiveStateDrift(currentProfile, providers) {
     }
     if (mappedProviders.length > 1) {
         return {
-            currentProfile,
+            currentModelProvider,
             mappedProvider: null,
             mappedProviders,
-            profileMapped: true,
+            modelProviderMapped: true,
             providerResolvable: false,
             canBackfillActiveProvider: false,
             reason: "shared-profile",
         };
     }
     return {
-        currentProfile,
+        currentModelProvider,
         mappedProvider: null,
         mappedProviders: [],
-        profileMapped: false,
+        modelProviderMapped: false,
         providerResolvable: false,
         canBackfillActiveProvider: true,
         reason: "provider-unmapped",

package/dist/domain/setup.js

@@ -16,8 +16,9 @@ function buildSetupDrafts(profiles, detailsByProfile, runtimeByProfile) {
         return {
             providerName,
             record: (0, providers_1.cleanProviderRecord)({
-                profile,
+                profile: runtime?.modelProvider ?? profile,
                 apiKey: detail.apiKey ?? "",
+                model: runtime?.model,
                 baseUrl: detail.baseUrl ?? runtime?.baseUrl,
                 note: detail.note,
                 tags: detail.tags,
@@ -71,6 +72,7 @@ function collectMigrateAdoptability(document, providers) {
             adoptableProfileDetails.push({
                 name: view.name,
                 model: view.model,
+                modelProvider: view.modelProvider,
                 baseUrl: view.baseUrl,
             });
             continue;

package/dist/interaction/interactive.js

@@ -70,8 +70,8 @@ function canPrompt(runtime, jsonMode) {
  */
 async function promptForProviderSelection(runtime, providersPath, configPath, message) {
     const providers = (0, providers_repo_1.readProvidersFile)(providersPath);
-    const currentProfile = fs.existsSync(configPath) ? (0, config_repo_1.readStructuredConfig)(configPath).activeProfile : null;
-    const liveState = (0, runtime_state_1.inspectLiveStateDrift)(currentProfile, providers);
+    const currentModelProvider = fs.existsSync(configPath) ? (0, config_repo_1.readStructuredConfig)(configPath).currentModelProvider : null;
+    const liveState = (0, runtime_state_1.inspectLiveStateDrift)(currentModelProvider, providers);
     const choices = Object.entries(providers.providers)
         .sort(([left], [right]) => left.localeCompare(right))
         .map(([providerName, provider]) => {

package/dist/runtime/codex-version.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIN_SUPPORTED_CODEX_VERSION = void 0;
+/**
+ * Minimum Codex CLI version supported by the managed runtime workflow.
+ */
+exports.MIN_SUPPORTED_CODEX_VERSION = "0.134.0";

package/dist/runtime/copilot-adapter.js

@@ -1,16 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventEmitter = void 0;
 exports.probeCopilotSdkRuntime = probeCopilotSdkRuntime;
 exports.requireCopilotSdk = requireCopilotSdk;
 exports.readCopilotAuthState = readCopilotAuthState;
+exports.createCopilotRuntimeClient = createCopilotRuntimeClient;
+exports.startCopilotRuntimeClient = startCopilotRuntimeClient;
+exports.stopCopilotRuntimeClient = stopCopilotRuntimeClient;
 exports.sendCopilotChatCompletion = sendCopilotChatCompletion;
+const node_events_1 = require("node:events");
+Object.defineProperty(exports, "EventEmitter", { enumerable: true, get: function () { return node_events_1.EventEmitter; } });
 const errors_1 = require("../domain/errors");
 const copilot_sdk_loader_1 = require("./copilot-sdk-loader");
 const copilot_installer_1 = require("./copilot-installer");
+const copilot_cli_1 = require("./copilot-cli");
+const DEFAULT_UPSTREAM_TIMEOUT_MS = 300000;
 /**
- * Probes whether the optional Copilot SDK runtime is installed and loadable.
+ * Probes whether the optional Copilot SDK runtime is installed, supported, and shaped correctly.
  */
 function probeCopilotSdkRuntime(runtimesDir) {
+    const nodeStatus = safeCopilotNodeRuntimeStatus();
+    if (!nodeStatus.ok) {
+        return nodeStatus.availability;
+    }
     const status = (0, copilot_installer_1.probeCopilotSdkInstall)(runtimesDir);
     if (!status.installed) {
         return {
@@ -24,6 +36,21 @@ function probeCopilotSdkRuntime(runtimesDir) {
             },
         };
     }
+    if (!(0, copilot_installer_1.isSupportedCopilotSdkVersion)(status.packageVersion)) {
+        return {
+            ok: false,
+            runtime: "copilot-sdk",
+            reason: "unsupported",
+            version: status.packageVersion ?? undefined,
+            cause: `The installed Copilot SDK version is unsupported. Install ${status.packageName}@${(0, copilot_installer_1.getSupportedCopilotSdkVersion)()}.`,
+            details: {
+                installDir: status.installDir,
+                packageName: status.packageName,
+                packageVersion: status.packageVersion,
+                supportedVersion: (0, copilot_installer_1.getSupportedCopilotSdkVersion)(),
+            },
+        };
+    }
     return {
         ok: true,
         runtime: "copilot-sdk",
@@ -41,55 +68,83 @@ async function requireCopilotSdk(runtimesDir) {
     return (0, copilot_sdk_loader_1.loadCopilotSdk)(runtimesDir);
 }
 /**
- * Probes whether the lazily installed Copilot SDK can create a usable session.
+ * Probes Copilot auth readiness through the SDK client status endpoint.
  */
 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);
+        throw (0, errors_1.cliError)(runtime.reason === "unsupported" ? "COPILOT_SDK_VERSION_UNSUPPORTED" : "COPILOT_SDK_MISSING", runtime.cause, runtime.details);
     }
-    const { client, session } = await createCopilotSession(runtimesDir);
-    await stopCopilotClient(client);
-    return {
-        ready: Boolean(session),
-        source: "official-sdk",
-        mode: "session",
-    };
+    const runtimeClient = await createCopilotRuntimeClient(runtimesDir);
+    try {
+        await startCopilotClient(runtimeClient.client);
+        const getAuthStatus = resolveCallable(runtimeClient.client, "getAuthStatus");
+        if (!getAuthStatus) {
+            throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK does not expose CopilotClient.getAuthStatus().", {});
+        }
+        const status = await Promise.resolve(getAuthStatus());
+        if (!isAuthReady(status)) {
+            throw (0, errors_1.cliError)("COPILOT_AUTH_REQUIRED", "Copilot authentication is required before the local bridge can be used.", {
+                status,
+            });
+        }
+        return {
+            ready: true,
+            source: "official-sdk",
+            mode: "auth-status",
+        };
+    }
+    finally {
+        await stopCopilotClient(runtimeClient.client);
+    }
+}
+/**
+ * Creates one long-lived Copilot SDK client for bridge workers.
+ */
+async function createCopilotRuntimeClient(runtimesDir) {
+    (0, copilot_installer_1.assertCopilotNodeRuntimeSupported)();
+    const runtime = probeCopilotSdkRuntime(runtimesDir);
+    if (!runtime.ok) {
+        throw (0, errors_1.cliError)(runtime.reason === "unsupported" ? "COPILOT_SDK_VERSION_UNSUPPORTED" : "COPILOT_SDK_MISSING", runtime.cause, runtime.details);
+    }
+    const sdk = (await requireCopilotSdk(runtimesDir));
+    const client = createCopilotClient(sdk, runtimesDir);
+    assertCopilotSdkApiContract(sdk, client);
+    return { sdk, client };
+}
+/**
+ * Starts a Copilot SDK client if the installed SDK exposes an explicit start hook.
+ */
+async function startCopilotRuntimeClient(runtimeClient) {
+    await startCopilotClient(runtimeClient.client);
 }
 /**
- * Executes a single chat-completions style request through the optional Copilot SDK when available.
+ * Stops a Copilot SDK client.
+ */
+async function stopCopilotRuntimeClient(runtimeClient) {
+    await stopCopilotClient(runtimeClient.client);
+}
+/**
+ * Executes one OpenAI-compatible request through a fresh Copilot session.
  */
 async function sendCopilotChatCompletion(args) {
-    const { client, session, sdk } = await createCopilotSession(args.runtimesDir);
+    const ownsClient = !args.runtimeClient;
+    const runtimeClient = args.runtimeClient ?? await createCopilotRuntimeClient(args.runtimesDir);
+    if (ownsClient) {
+        await startCopilotRuntimeClient(runtimeClient);
+    }
+    let session = null;
     try {
-        const sendAndWait = resolveCallable(session, "sendAndWait") ?? resolveCallable(sdk, "sendAndWait");
-        if (!sendAndWait) {
-            throw (0, errors_1.cliError)("COPILOT_SDK_UNSUPPORTED", "The installed Copilot SDK does not expose a supported sendAndWait API.", {
-                provider: args.provider,
-            });
-        }
-        const prompt = Array.isArray(args.payload.messages)
-            ? args.payload.messages
-                .map((entry) => {
-                const message = entry;
-                return `${String(message.role ?? "user")}: ${String(message.content ?? "")}`;
-            })
-                .join("\n")
-            : "";
-        const result = await Promise.resolve(sendAndWait({ model: args.payload.model, prompt }));
-        const content = typeof result === "string"
-            ? result
-            : typeof result?.content === "string"
-                ? String(result.content)
-                : typeof result?.data === "object" &&
-                    typeof result.data.content === "string"
-                    ? String(result.data.content)
-                    : JSON.stringify(result);
+        session = await createCopilotSession(runtimeClient, args.payload);
+        const prompt = buildPrompt(args.payload);
+        const timeoutMs = args.timeoutMs ?? DEFAULT_UPSTREAM_TIMEOUT_MS;
+        const result = await sendSessionRequest(session, prompt, timeoutMs, args.onStreamEvent);
+        const content = extractCopilotContent(result);
         return {
             id: `copilot-${Date.now()}`,
             object: "chat.completion",
             created: Math.floor(Date.now() / 1000),
-            model: args.payload.model ?? "copilot",
+            model: typeof args.payload.model === "string" ? args.payload.model : "copilot",
             choices: [
                 {
                     index: 0,
@@ -103,27 +158,36 @@ async function sendCopilotChatCompletion(args) {
         };
     }
     finally {
-        await stopCopilotClient(client);
+        if (session) {
+            await disconnectCopilotSession(session);
+        }
+        if (ownsClient) {
+            await stopCopilotRuntimeClient(runtimeClient);
+        }
     }
 }
-async function createCopilotSession(runtimesDir) {
-    const sdk = (await requireCopilotSdk(runtimesDir));
-    const client = createCopilotClient(sdk);
-    const createSession = resolveCallable(client ? client : null, "createSession") ?? resolveCallable(sdk, "createSession");
+async function createCopilotSession(runtimeClient, payload) {
+    const createSession = resolveCallable(runtimeClient.client, "createSession");
     if (!createSession) {
-        throw (0, errors_1.cliError)("COPILOT_SDK_UNSUPPORTED", "The installed Copilot SDK does not expose a supported createSession API.", {});
+        throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK does not expose CopilotClient.createSession().", {});
     }
     try {
-        const session = (await Promise.resolve(createSession(createSessionOptions(sdk))));
-        return {
-            sdk,
-            client,
-            session,
-        };
+        const session = await Promise.resolve(createSession({
+            model: typeof payload.model === "string" ? payload.model : undefined,
+            ...createSessionOptions(runtimeClient.sdk),
+        }));
+        if (!session || typeof session !== "object") {
+            throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK returned an invalid CopilotSession.", {});
+        }
+        assertCopilotSessionContract(session);
+        return session;
     }
     catch (error) {
+        if (isCliError(error)) {
+            throw 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.", {
+            throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK does not expose a compatible session API.", {
                 cause: error instanceof Error ? error.message : String(error),
             });
         }
@@ -132,9 +196,61 @@ async function createCopilotSession(runtimesDir) {
         });
     }
 }
-/**
- * Builds the session options used consistently across auth probes and request execution.
- */
+async function sendSessionRequest(session, prompt, timeoutMs, onStreamEvent) {
+    const sendAndWait = resolveCallable(session, "sendAndWait");
+    const send = resolveCallable(session, "send");
+    if (!sendAndWait && !send) {
+        throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK session does not expose sendAndWait() or send().", {});
+    }
+    const deltaHandler = (event) => {
+        const delta = extractDelta(event);
+        if (delta) {
+            onStreamEvent?.({ type: "delta", delta });
+        }
+    };
+    if (onStreamEvent && session.on) {
+        session.on("data", deltaHandler);
+        session.on("message", deltaHandler);
+        session.on("delta", deltaHandler);
+    }
+    try {
+        const sendPromise = Promise.resolve(sendAndWait ? sendAndWait({ prompt }, timeoutMs) : send({ prompt }));
+        const result = await withTimeout(sendPromise, timeoutMs, async () => {
+            await abortCopilotSession(session);
+        });
+        if (onStreamEvent) {
+            onStreamEvent({ type: "done", text: extractCopilotContent(result) });
+        }
+        return result;
+    }
+    finally {
+        if (onStreamEvent && session.off) {
+            session.off("data", deltaHandler);
+            session.off("message", deltaHandler);
+            session.off("delta", deltaHandler);
+        }
+    }
+}
+async function withTimeout(promise, timeoutMs, onTimeout) {
+    let timeout = null;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_resolve, reject) => {
+                timeout = setTimeout(() => {
+                    void onTimeout().finally(() => {
+                        reject((0, errors_1.cliError)("BRIDGE_UPSTREAM_TIMEOUT", "Copilot upstream request timed out.", { timeoutMs }));
+                    });
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+    }
+}
 function createSessionOptions(sdk) {
     const approveAll = resolveApproveAll(sdk);
     if (approveAll) {
@@ -142,35 +258,153 @@ function createSessionOptions(sdk) {
             onPermissionRequest: (request) => approveAll(request),
         };
     }
-    return {
-        onPermissionRequest: () => true,
-    };
+    throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK does not expose an approveAll permission handler.", {});
 }
-function createCopilotClient(sdk) {
+function createCopilotClient(sdk, runtimesDir) {
     const ClientCtor = resolveConstructor(sdk, "CopilotClient");
     if (!ClientCtor) {
-        return null;
+        throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK does not expose CopilotClient.", {});
     }
+    const invocation = (0, copilot_cli_1.resolveCopilotCliInvocation)([], runtimesDir);
+    const clientOptions = {
+        copilotCommand: invocation.command,
+        command: invocation.command,
+        executable: invocation.command,
+    };
     try {
-        return new ClientCtor();
+        return new ClientCtor(clientOptions);
     }
     catch (error) {
-        throw (0, errors_1.cliError)("COPILOT_SDK_UNSUPPORTED", "The installed Copilot SDK CopilotClient could not be constructed.", {
+        throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK CopilotClient could not be constructed.", {
             cause: error instanceof Error ? error.message : String(error),
         });
     }
 }
+function assertCopilotSdkApiContract(sdk, client) {
+    const createSession = resolveCallable(client, "createSession");
+    const getAuthStatus = resolveCallable(client, "getAuthStatus");
+    if (!createSession || !getAuthStatus) {
+        throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK does not expose the required CopilotClient API.", {
+            hasCreateSession: Boolean(createSession),
+            hasGetAuthStatus: Boolean(getAuthStatus),
+        });
+    }
+    if (!resolveApproveAll(sdk)) {
+        throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK does not expose a supported permission handler.", {});
+    }
+}
+function assertCopilotSessionContract(session) {
+    const hasSendAndWait = typeof session.sendAndWait === "function";
+    const hasSend = typeof session.send === "function";
+    const hasAbort = typeof session.abort === "function";
+    if ((!hasSendAndWait && !hasSend) || !hasAbort) {
+        throw (0, errors_1.cliError)("COPILOT_SDK_API_UNSUPPORTED", "The installed Copilot SDK session does not expose the required request API.", {
+            hasSendAndWait,
+            hasSend,
+            hasAbort,
+        });
+    }
+}
+async function startCopilotClient(client) {
+    const start = resolveCallable(client, "start");
+    if (start) {
+        await Promise.resolve(start());
+    }
+}
 async function stopCopilotClient(client) {
-    if (client && typeof client.stop === "function") {
-        await Promise.resolve(client.stop());
+    const stop = resolveCallable(client, "stop");
+    if (stop) {
+        await Promise.resolve(stop());
     }
 }
-/**
- * Distinguishes true auth failures from SDK API-shape mismatches.
- */
+async function abortCopilotSession(session) {
+    const abort = resolveCallable(session, "abort");
+    if (abort) {
+        await Promise.resolve(abort());
+    }
+}
+async function disconnectCopilotSession(session) {
+    const disconnect = resolveCallable(session, "disconnect");
+    if (disconnect) {
+        await Promise.resolve(disconnect());
+    }
+}
+function buildPrompt(payload) {
+    if (Array.isArray(payload.messages)) {
+        return payload.messages
+            .map((entry) => {
+            const message = entry;
+            return `${String(message.role ?? "user")}: ${String(message.content ?? "")}`;
+        })
+            .join("\n");
+    }
+    if (typeof payload.prompt === "string") {
+        return payload.prompt;
+    }
+    return "";
+}
+function extractCopilotContent(result) {
+    if (typeof result === "string") {
+        return result;
+    }
+    if (!result || typeof result !== "object") {
+        return JSON.stringify(result);
+    }
+    const record = result;
+    if (typeof record.content === "string") {
+        return record.content;
+    }
+    if (typeof record.text === "string") {
+        return record.text;
+    }
+    if (typeof record.message === "string") {
+        return record.message;
+    }
+    if (record.data && typeof record.data === "object") {
+        const data = record.data;
+        if (typeof data.content === "string") {
+            return data.content;
+        }
+        if (typeof data.text === "string") {
+            return data.text;
+        }
+    }
+    return JSON.stringify(result);
+}
+function extractDelta(event) {
+    if (typeof event === "string") {
+        return event;
+    }
+    if (!event || typeof event !== "object") {
+        return null;
+    }
+    const record = event;
+    for (const key of ["delta", "text", "content"]) {
+        if (typeof record[key] === "string") {
+            return record[key];
+        }
+    }
+    return null;
+}
+function isAuthReady(status) {
+    if (status === true) {
+        return true;
+    }
+    if (!status || typeof status !== "object") {
+        return false;
+    }
+    const record = status;
+    if (record.ready === true || record.isAuthenticated === true || record.authenticated === true) {
+        return true;
+    }
+    if (typeof record.status === "string" && /^(ok|ready|authenticated|logged_in)$/i.test(record.status)) {
+        return true;
+    }
+    return false;
+}
 function classifyCopilotSessionError(error) {
     const message = error instanceof Error ? error.message : String(error);
-    if (/onPermissionRequest/i.test(message) || /permission/i.test(message)) {
+    if (/onPermissionRequest|permission|sendAndWait|createSession|unsupported/i.test(message)) {
         return "unsupported";
     }
     return "auth";
@@ -200,17 +434,39 @@ 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 permissionHandler = target.PermissionHandler;
+    if (permissionHandler && typeof permissionHandler === "object" && typeof permissionHandler.approveAll === "function") {
+        return permissionHandler.approveAll;
+    }
     const nestedDefault = target.default;
-    if (nestedDefault && typeof nestedDefault.approveAll === "function") {
-        return nestedDefault.approveAll;
+    if (nestedDefault) {
+        return resolveApproveAll(nestedDefault);
     }
     return null;
 }
+function isCliError(error) {
+    return Boolean(error && typeof error === "object" && typeof error.code === "string");
+}
+function safeCopilotNodeRuntimeStatus() {
+    try {
+        (0, copilot_installer_1.assertCopilotNodeRuntimeSupported)();
+        return { ok: true };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            availability: {
+                ok: false,
+                runtime: "copilot-sdk",
+                reason: "unsupported",
+                cause: error instanceof Error ? error.message : String(error),
+                details: isCliError(error) ? error.details : undefined,
+            },
+        };
+    }
+}