subharness 0.0.3 → 0.0.5

package/dist/adapters/copilot.js

@@ -0,0 +1,819 @@
+import { CopilotClient, RuntimeConnection } from "@github/copilot-sdk";
+import { chmod, mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { AgentError } from "../errors.js";
+import { CopilotPermissions } from "./copilot-permissions.js";
+import { copilotTools } from "./copilot-tools.js";
+const GATEWAY_URL = "https://ai-gateway.vercel.sh/coding-agent/v1";
+const dependencies = {
+    createClient: options => new CopilotClient(options),
+};
+export const openCopilot = createCopilotOpener(dependencies);
+/** Dependency injection replaces only the native SDK/runtime boundary in tests. */
+export function createCopilotOpener(deps) {
+    return async (options) => {
+        const route = validateOptions(options);
+        const tools = copilotTools(options.agent);
+        const cleanupTimeoutMs = deps.cleanupTimeoutMs ?? 25_000;
+        const healthIntervalMs = Math.max(1, deps.healthIntervalMs ?? 1_000);
+        const healthTimeoutMs = Math.max(1, deps.healthTimeoutMs ?? 1_000);
+        const stateDirectory = await privateStateDirectory();
+        const queuedEvents = [];
+        let runtimeEventHandler;
+        const onEvent = (event) => {
+            if (runtimeEventHandler)
+                runtimeEventHandler(event);
+            else
+                queuedEvents.push(event);
+        };
+        let client;
+        let native;
+        const environment = isolatedEnvironment(options.env, route.kind === "subscription");
+        try {
+            client = deps.createClient({
+                connection: RuntimeConnection.forStdio({ env: environment }),
+                mode: "copilot-cli",
+                workingDirectory: options.cwd,
+                baseDirectory: route.kind === "subscription" ? undefined : stateDirectory,
+                useLoggedInUser: route.kind === "subscription",
+                gitHubToken: route.kind === "github" ? route.token : undefined,
+                logLevel: "none",
+            });
+            await client.start();
+        }
+        catch {
+            if (await cleanup(client, undefined, stateDirectory, cleanupTimeoutMs))
+                throw cleanupError();
+            throw new AgentError("HARNESS_UNAVAILABLE", "The Copilot native runtime is missing or incompatible.");
+        }
+        try {
+            await verifyClientAccess(client, route);
+            native = await client.createSession({
+                model: route.model,
+                workingDirectory: options.cwd,
+                configDirectory: stateDirectory,
+                enableConfigDiscovery: false,
+                ...(route.kind === "github" ? { enableManagedSettings: true } : {}),
+                enableSessionStore: false,
+                skipEmbeddingRetrieval: true,
+                embeddingCacheStorage: "in-memory",
+                remoteSession: "off",
+                onEvent,
+                systemMessage: options.agent.instructions
+                    ? { mode: "append", content: options.agent.instructions }
+                    : undefined,
+                ...tools.config,
+                gitHubToken: route.kind === "github" ? route.token : undefined,
+                provider: providerConfiguration(route),
+            });
+        }
+        catch (error) {
+            const failure = classifySessionStartup(error);
+            if (await cleanup(client, undefined, stateDirectory, cleanupTimeoutMs))
+                throw cleanupError();
+            throw failure;
+        }
+        try {
+            if (queuedEvents.some(requiresInput))
+                throw inputRequired();
+            await verifyNativeSelection(client, native, route);
+            await verifyNativeTools(native, tools.names);
+            if (queuedEvents.some(requiresInput))
+                throw inputRequired();
+        }
+        catch (error) {
+            const cleanupFailed = await cleanup(client, native, stateDirectory, cleanupTimeoutMs);
+            if (cleanupFailed)
+                throw cleanupError();
+            if (error instanceof AgentError)
+                throw error;
+            throw new AgentError("HARNESS_ERROR", "Copilot startup verification failed.");
+        }
+        let closed = false;
+        let closing;
+        let active;
+        let selectionChanged = false;
+        let poisoned = false;
+        const cancellationTimeoutMs = deps.cancellationTimeoutMs ?? 3_000;
+        let stopAffectedWork;
+        const permissions = new CopilotPermissions(options.onApproval, error => {
+            if (active) {
+                active.terminalError = error;
+                stopAffectedWork?.(active);
+            }
+        });
+        const finish = async (current) => {
+            if (current.settled)
+                return;
+            current.settled = true;
+            current.stopHealth?.();
+            tools.stopAdmission();
+            permissions.clear();
+            try {
+                await tools.drain();
+                if (current.closing)
+                    throw new AgentError("SESSION_CLOSED", "The Copilot session closed during the turn.");
+                if (current.interrupted)
+                    throw new AgentError("INTERRUPTED", "The Copilot turn was interrupted.");
+                await verifyPinnedSelection(client, native, route);
+                if (selectionChanged)
+                    throw selectionError();
+                if (current.terminalError)
+                    throw current.terminalError;
+                if (Buffer.byteLength(current.response, "utf8") > 1024 * 1024) {
+                    throw new AgentError("RESPONSE_TOO_LARGE", "The Copilot response exceeds 1 MiB.");
+                }
+                current.resolve(current.response);
+            }
+            catch (error) {
+                current.reject(error instanceof AgentError
+                    ? error
+                    : new AgentError("HARNESS_ERROR", "Copilot could not complete the turn."));
+            }
+            finally {
+                if (active === current)
+                    active = undefined;
+            }
+        };
+        const stopActiveTurn = async (current) => {
+            tools.stopAdmission();
+            permissions.clear();
+            let acknowledgement;
+            try {
+                acknowledgement = await boundedNativeCall(native.rpc.abort({}), cancellationTimeoutMs);
+            }
+            catch {
+                throw cleanupError();
+            }
+            if (!acknowledgement.success)
+                throw cleanupError();
+            await waitForNativeIdle(native, cancellationTimeoutMs);
+            await tools.drain();
+            await finish(current);
+            await current.completion.catch(() => { });
+        };
+        const ensureStopped = (current) => current.stopping ??= stopActiveTurn(current);
+        const failUnconfirmedAffectedWork = async (current) => {
+            if (current.settled)
+                return;
+            poisoned = true;
+            current.stopHealth?.();
+            tools.stopAdmission();
+            permissions.clear();
+            current.settled = true;
+            current.terminalError = cleanupError();
+            await tools.drain();
+            current.reject(current.terminalError);
+        };
+        const failTerminalTurn = async (current, error) => {
+            if (current.settled)
+                return;
+            poisoned = true;
+            current.stopHealth?.();
+            tools.stopAdmission();
+            permissions.clear();
+            current.settled = true;
+            await tools.drain();
+            current.reject(error);
+            if (active === current)
+                active = undefined;
+        };
+        const startHealthMonitor = (current) => {
+            const controller = new AbortController();
+            current.stopHealth = () => controller.abort();
+            void (async () => {
+                while (await monitorDelay(healthIntervalMs, controller.signal)) {
+                    if (current.settled || closed)
+                        return;
+                    try {
+                        await boundedNativeCall(client.ping(), healthTimeoutMs, controller.signal);
+                    }
+                    catch {
+                        if (controller.signal.aborted || current.settled || closed)
+                            return;
+                        await failTerminalTurn(current, new AgentError("HARNESS_ERROR", "The Copilot native transport became unavailable."));
+                        return;
+                    }
+                }
+            })();
+        };
+        stopAffectedWork = current => {
+            void ensureStopped(current).catch(() => failUnconfirmedAffectedWork(current));
+        };
+        const handleEvent = (event) => {
+            if (event.type === "session.model_change" && event.agentId === undefined) {
+                const changed = event.data.newModel;
+                if (changed !== route.model)
+                    selectionChanged = true;
+            }
+            const current = active;
+            if (event.type === "session.shutdown") {
+                if (current && !current.settled) {
+                    void failTerminalTurn(current, new AgentError("HARNESS_ERROR", "The Copilot native session shut down unexpectedly."));
+                }
+                return;
+            }
+            if (event.type === "permission.completed") {
+                permissions.withdraw(event.data.requestId);
+                return;
+            }
+            if (event.type === "permission.requested") {
+                if (current && !current.settled)
+                    permissions.handle(native.rpc.permissions, event.data);
+                else if (!event.data.resolvedByHook) {
+                    void native.rpc.permissions.handlePendingPermissionRequest({
+                        requestId: event.data.requestId,
+                        result: { kind: "user-not-available" },
+                    }).catch(() => { });
+                }
+                return;
+            }
+            if (!current || current.settled)
+                return;
+            if (requiresInput(event)) {
+                current.terminalError = inputRequired();
+                stopAffectedWork?.(current);
+                return;
+            }
+            if (event.agentId !== undefined)
+                return;
+            if (current.messageId === undefined) {
+                current.buffered.push(event);
+                return;
+            }
+            if (event.type === "user.message") {
+                if (event.data.messageId === current.messageId) {
+                    current.started = true;
+                    current.turnId = event.data.turnId;
+                }
+                return;
+            }
+            if (event.type === "assistant.message") {
+                if (event.data.originatingMessageId !== current.messageId)
+                    return;
+                current.started = true;
+                current.turnId = event.data.turnId ?? current.turnId;
+                // BYOK reports the provider-facing model/deployment here, not the separately pinned behavior model.
+                if (route.kind !== "byok" && event.data.model !== undefined && event.data.model !== route.model) {
+                    current.terminalError = selectionError();
+                    return;
+                }
+                if (event.data.chunkCount !== undefined && event.data.chunkIndex !== undefined) {
+                    current.chunks ??= [];
+                    current.chunks[event.data.chunkIndex] = event.data.content;
+                    current.response = current.chunks.join("");
+                }
+                else {
+                    current.chunks = undefined;
+                    current.response = event.data.content;
+                }
+                if (Buffer.byteLength(current.response, "utf8") > 1024 * 1024) {
+                    current.terminalError = new AgentError("RESPONSE_TOO_LARGE", "The Copilot response exceeds 1 MiB.");
+                }
+            }
+            else if (event.type === "session.error") {
+                current.terminalError = new AgentError("HARNESS_ERROR", "Copilot reported a native execution error.");
+            }
+            else if (event.type === "session.idle") {
+                if (!current.started)
+                    return;
+                if (event.data.aborted)
+                    current.interrupted = true;
+                void waitForNativeIdle(native, cancellationTimeoutMs)
+                    .then(() => finish(current), () => failUnconfirmedAffectedWork(current));
+            }
+        };
+        runtimeEventHandler = handleEvent;
+        for (const event of queuedEvents.splice(0))
+            handleEvent(event);
+        return {
+            async turn(prompt) {
+                if (closed)
+                    throw new AgentError("SESSION_CLOSED", "The Copilot session has closed.");
+                if (poisoned)
+                    throw cleanupError();
+                if (active)
+                    throw new AgentError("SESSION_BUSY", "Copilot already has an active turn.");
+                selectionChanged = false;
+                await verifyPinnedSelection(client, native, route);
+                let resolve;
+                let reject;
+                const current = {
+                    buffered: [], response: "", started: false, interrupted: false, closing: false, settled: false,
+                    completion: new Promise((onResolve, onReject) => { resolve = onResolve; reject = onReject; }),
+                    resolve: value => resolve(value), reject: error => reject(error),
+                };
+                active = current;
+                tools.start();
+                startHealthMonitor(current);
+                void (async () => {
+                    try {
+                        const messageId = await native.send({ prompt, mode: "enqueue" });
+                        if (current.settled || closed || active !== current) {
+                            current.buffered.length = 0;
+                            return;
+                        }
+                        current.messageId = messageId;
+                        for (const event of current.buffered.splice(0))
+                            handleEvent(event);
+                    }
+                    catch {
+                        current.buffered.length = 0;
+                        if (current.settled)
+                            return;
+                        current.settled = true;
+                        current.stopHealth?.();
+                        tools.stopAdmission();
+                        permissions.clear();
+                        await tools.drain();
+                        current.reject(new AgentError("HARNESS_ERROR", "Copilot could not submit the native turn."));
+                        if (active === current)
+                            active = undefined;
+                    }
+                })();
+                return await current.completion;
+            },
+            async steer() {
+                throw new AgentError("UNSUPPORTED_DELIVERY", "Copilot does not expose verified active steering.");
+            },
+            async interrupt() {
+                const current = active;
+                if (!current)
+                    return;
+                current.interrupted = true;
+                try {
+                    await ensureStopped(current);
+                }
+                catch {
+                    await failUnconfirmedAffectedWork(current);
+                    throw cleanupError();
+                }
+            },
+            async resume() {
+                throw new AgentError("RECOVERY_UNSUPPORTED", "Copilot cannot retry failed execution without replaying input.");
+            },
+            async close() {
+                if (closing)
+                    return await closing;
+                closed = true;
+                if (active)
+                    active.closing = true;
+                active?.stopHealth?.();
+                tools.stopAdmission();
+                permissions.clear();
+                closing = (async () => {
+                    runtimeEventHandler = () => { };
+                    let activeStopFailed = false;
+                    if (active) {
+                        try {
+                            await ensureStopped(active);
+                        }
+                        catch {
+                            activeStopFailed = true;
+                        }
+                    }
+                    const cleanupFailed = await cleanup(client, native, stateDirectory, cleanupTimeoutMs);
+                    await tools.drain();
+                    if (active && !active.settled)
+                        await finish(active);
+                    if (cleanupFailed || activeStopFailed)
+                        throw cleanupError();
+                })();
+                return await closing;
+            },
+        };
+    };
+}
+function validateOptions(options) {
+    const harness = options.harness;
+    if (harness.kind !== "copilot")
+        throw new AgentError("INVALID_CONFIG", "Copilot received configuration for a different harness.");
+    if (typeof harness.model !== "string" || !harness.model.trim() || /\s/u.test(harness.model)) {
+        throw new AgentError("INVALID_CONFIG", "Copilot requires an explicit model identifier.");
+    }
+    if (harness.model === "auto")
+        throw new AgentError("INVALID_CONFIG", "Copilot does not support native automatic model routing.");
+    const access = options.access;
+    if (access.type === "subscription") {
+        if (access.provider !== undefined || hasProviderOptions(access))
+            unsupportedAccessOption();
+        return { kind: "subscription", model: harness.model };
+    }
+    if (options.access.type === "api-key") {
+        const token = requiredToken(access.token);
+        if (access.provider === "github") {
+            if (hasProviderOptions(access))
+                unsupportedAccessOption();
+            return { kind: "github", model: harness.model, token };
+        }
+        if (access.provider !== "openai" && access.provider !== "anthropic" && access.provider !== "azure") {
+            throw new AgentError("UNSUPPORTED_OPTION", "Copilot requires a supported explicit API-key provider.");
+        }
+        if (access.provider === "anthropic" && (access.wireApi !== undefined || access.apiVersion !== undefined))
+            unsupportedAccessOption();
+        if (access.provider === "openai" && access.apiVersion !== undefined)
+            unsupportedAccessOption();
+        if (access.provider === "azure" && access.baseUrl === undefined) {
+            throw new AgentError("INVALID_CONFIG", "Copilot Azure access requires an explicit base URL.");
+        }
+        return {
+            kind: "byok",
+            model: harness.model,
+            token,
+            provider: access.provider,
+            baseUrl: access.baseUrl ?? (access.provider === "openai"
+                ? "https://api.openai.com/v1"
+                : "https://api.anthropic.com"),
+            wireApi: access.provider === "anthropic" ? undefined : (access.wireApi ?? "completions"),
+            apiVersion: access.apiVersion,
+            wireModel: access.wireModel,
+        };
+    }
+    if (access.type !== "vercel-api-key" && access.type !== "vercel-oidc") {
+        throw new AgentError("UNSUPPORTED_OPTION", "Copilot received an unsupported access route.");
+    }
+    if (access.provider !== undefined || hasProviderOptions(access))
+        unsupportedAccessOption();
+    if (!/^[^\s/]+\/[^\s/]+$/u.test(harness.model)) {
+        throw new AgentError("INVALID_CONFIG", "Copilot Gateway access requires an explicit creator/model identifier.");
+    }
+    return {
+        kind: "gateway",
+        model: harness.model,
+        token: requiredToken(access.token),
+        bearer: access.type === "vercel-oidc",
+    };
+}
+function hasProviderOptions(access) {
+    return access.baseUrl !== undefined || access.wireApi !== undefined
+        || access.apiVersion !== undefined || access.wireModel !== undefined;
+}
+function unsupportedAccessOption() {
+    throw new AgentError("UNSUPPORTED_OPTION", "Copilot received an option that is not supported for the selected access route.");
+}
+function requiredToken(token) {
+    if (!token?.trim())
+        throw new AgentError("ACCESS_UNAVAILABLE", "The selected Copilot credential is unavailable.");
+    return token;
+}
+async function privateStateDirectory() {
+    try {
+        const directory = await mkdtemp(join(tmpdir(), "subharness-copilot-"));
+        await chmod(directory, 0o700);
+        return directory;
+    }
+    catch {
+        throw new AgentError("HARNESS_UNAVAILABLE", "Copilot could not create private native state.");
+    }
+}
+function isolatedEnvironment(source, preserveNativeHome) {
+    const environment = {};
+    for (const [name, value] of Object.entries(source))
+        if (value !== undefined)
+            environment[name] = value;
+    for (const name of Object.keys(environment)) {
+        if (/^COPILOT_PROVIDER_/u.test(name) || [
+            "COPILOT_CLI_PATH", "COPILOT_MODEL", "COPILOT_API_URL", "COPILOT_SDK_AUTH_TOKEN", "COPILOT_GITHUB_TOKEN",
+            "GITHUB_COPILOT_API_TOKEN", "GH_TOKEN", "GITHUB_TOKEN", "OPENAI_API_KEY", "OPENAI_BASE_URL",
+            "ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_BASE_URL", "GOOGLE_API_KEY", "GEMINI_API_KEY",
+            "AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT", "AI_GATEWAY_API_KEY", "VERCEL_OIDC_TOKEN",
+        ].includes(name))
+            delete environment[name];
+    }
+    if (!preserveNativeHome || !environment.COPILOT_HOME?.trim())
+        delete environment.COPILOT_HOME;
+    environment.COPILOT_ALLOW_GET_PROVIDER_ENDPOINT = "true";
+    return environment;
+}
+function providerConfiguration(route) {
+    if (route.kind === "gateway") {
+        return {
+            type: "openai",
+            wireApi: "completions",
+            baseUrl: GATEWAY_URL,
+            ...(route.bearer ? { bearerToken: route.token } : { apiKey: route.token }),
+        };
+    }
+    if (route.kind === "byok") {
+        return {
+            type: route.provider,
+            ...(route.wireApi === undefined ? {} : { wireApi: route.wireApi }),
+            transport: "http",
+            baseUrl: route.baseUrl,
+            apiKey: route.token,
+            ...(route.provider === "azure" && route.apiVersion !== undefined
+                ? { azure: { apiVersion: route.apiVersion } }
+                : {}),
+            modelId: route.model,
+            ...(route.wireModel === undefined ? {} : { wireModel: route.wireModel }),
+        };
+    }
+    return undefined;
+}
+async function verifyClientAccess(client, route) {
+    if (route.kind !== "subscription" && route.kind !== "github")
+        return;
+    await verifyAuthStatus(client, route);
+    let models;
+    try {
+        models = await client.listModels();
+    }
+    catch {
+        throw new AgentError("HARNESS_ERROR", "Copilot could not verify the native model catalog.");
+    }
+    if (!Array.isArray(models) || models.some(model => !plainObject(model) || typeof model.id !== "string" || !model.id)) {
+        throw new AgentError("PROTOCOL_ERROR", "Copilot returned malformed native model metadata.");
+    }
+    const matches = models.filter(model => model.id === route.model);
+    if (matches.length === 0)
+        throw selectionError();
+    if (matches.length !== 1)
+        throw new AgentError("PROTOCOL_ERROR", "Copilot returned ambiguous native model metadata.");
+}
+async function verifyAuthStatus(client, route) {
+    let status;
+    try {
+        status = await client.getAuthStatus();
+    }
+    catch {
+        throw new AgentError("HARNESS_ERROR", "Copilot could not verify native authentication.");
+    }
+    if (!plainObject(status) || typeof status.isAuthenticated !== "boolean"
+        || (status.authType !== undefined && typeof status.authType !== "string")) {
+        throw new AgentError("PROTOCOL_ERROR", "Copilot returned malformed native authentication metadata.");
+    }
+    if (status.authType !== undefined && !new Set(["user", "env", "gh-cli", "hmac", "api-key", "token"]).has(status.authType)) {
+        throw new AgentError("PROTOCOL_ERROR", "Copilot returned unknown native authentication metadata.");
+    }
+    if (!status.isAuthenticated)
+        throw new AgentError("ACCESS_UNAVAILABLE", "The selected Copilot authentication is unavailable.");
+    const expected = route.kind === "subscription"
+        ? status.authType === "user" || status.authType === "gh-cli"
+        : status.authType === "token";
+    if (!expected)
+        throw new AgentError("INVALID_CONFIG", "Copilot native authentication does not match the selected access route.");
+}
+function plainObject(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+async function verifyNativeSelection(client, native, route) {
+    try {
+        const mode = await native.rpc.permissions.setMode({ mode: "manual" });
+        if (!mode.success || mode.mode !== "manual")
+            throw selectionError();
+        const permissionEvents = await native.rpc.permissions.setRequired({ required: true });
+        if (!permissionEvents.success)
+            throw selectionError();
+        const before = await native.rpc.model.getCurrent();
+        if (before.modelId !== route.model)
+            throw selectionError();
+        const policy = await native.rpc.model.setAllowedModels({ allowedModels: [route.model] });
+        if (!exactModels(policy.allowedModels, route.model) || !exactModels(policy.effectiveAllowedModels, route.model)
+            || policy.modelId !== route.model || policy.fallbackModel !== route.model)
+            throw selectionError();
+        const after = await native.rpc.model.getCurrent();
+        if (after.modelId !== route.model)
+            throw selectionError();
+        await verifyPinnedSelection(client, native, route);
+        const [processing, activity] = await Promise.all([
+            native.rpc.metadata.isProcessing(),
+            native.rpc.metadata.activity(),
+        ]);
+        if (processing.processing || activity.hasActiveWork)
+            throw selectionError();
+    }
+    catch (error) {
+        if (error instanceof AgentError)
+            throw error;
+        throw selectionError();
+    }
+}
+async function verifyPinnedSelection(client, native, route) {
+    try {
+        const current = await native.rpc.model.getCurrent();
+        if (current.modelId !== route.model)
+            throw selectionError();
+        if (route.kind === "subscription" || route.kind === "github") {
+            await verifyAuthStatus(client, route);
+            return;
+        }
+        const endpoint = await native.rpc.provider.getEndpoint({ modelId: route.model });
+        if (!plainObject(endpoint) || !plainObject(endpoint.headers)
+            || Object.values(endpoint.headers).some(value => value !== undefined && typeof value !== "string")) {
+            throw new AgentError("PROTOCOL_ERROR", "Copilot returned malformed native provider metadata.");
+        }
+        const expectedType = route.kind === "gateway" ? "openai" : route.provider;
+        const expectedWireApi = route.kind === "gateway" ? "completions" : route.wireApi;
+        const expectedBaseUrl = route.kind === "gateway" ? GATEWAY_URL : route.baseUrl;
+        if (endpoint.type !== expectedType || endpoint.wireApi !== expectedWireApi
+            || (endpoint.transport !== undefined && endpoint.transport !== "http")
+            || endpoint.baseUrl !== expectedBaseUrl || endpoint.apiKey !== route.token
+            || !authorizationMatches(endpoint.headers, route.token)
+            || endpoint.sessionToken !== undefined)
+            throw selectionError();
+    }
+    catch (error) {
+        if (error instanceof AgentError)
+            throw error;
+        if (isMethodUnavailable(error)) {
+            throw new AgentError("HARNESS_UNAVAILABLE", "The Copilot native runtime lacks required protocol capabilities.");
+        }
+        throw new AgentError("HARNESS_ERROR", "Copilot could not verify the pinned native selection.");
+    }
+}
+async function verifyNativeTools(native, declaredNames) {
+    if (declaredNames.length === 0)
+        return;
+    try {
+        const builtins = await native.rpc.tools.getBuiltinDescriptors({});
+        const builtinNames = new Set(builtins.tools.map(tool => tool.name));
+        if (declaredNames.some(name => builtinNames.has(name))) {
+            throw new AgentError("INVALID_CONFIG", "A declared Copilot tool conflicts with a native built-in tool.");
+        }
+        await native.rpc.tools.initializeAndValidate();
+        const current = await native.rpc.tools.getCurrentMetadata();
+        const currentNames = new Set(current.tools?.map(tool => tool.name) ?? []);
+        if (declaredNames.some(name => !currentNames.has(name))) {
+            throw new AgentError("HARNESS_ERROR", "Copilot could not verify the declared native tools.");
+        }
+    }
+    catch (error) {
+        if (error instanceof AgentError)
+            throw error;
+        if (isMethodUnavailable(error)) {
+            throw new AgentError("HARNESS_UNAVAILABLE", "The Copilot native runtime lacks required tool protocol capabilities.");
+        }
+        throw new AgentError("HARNESS_ERROR", "Copilot could not initialize the declared native tools.");
+    }
+}
+function exactModels(models, selected) {
+    return models?.length === 1 && models[0] === selected;
+}
+function selectionError() {
+    return new AgentError("INVALID_CONFIG", "Copilot could not verify the requested model and provider selection.");
+}
+function authorizationMatches(headers, token) {
+    const authorizations = Object.entries(headers)
+        .filter(([name]) => name.toLowerCase() === "authorization")
+        .map(([, value]) => value);
+    return authorizations.length <= 1
+        && (authorizations.length === 0 || authorizations[0] === `Bearer ${token}`);
+}
+function classifySessionStartup(error) {
+    if (error instanceof AgentError)
+        return error;
+    if (isMethodUnavailable(error)) {
+        return new AgentError("HARNESS_UNAVAILABLE", "The Copilot native runtime lacks required session capabilities.");
+    }
+    if (typeof error === "object" && error !== null && error.code === -32602) {
+        return new AgentError("INVALID_CONFIG", "Copilot rejected the explicit native session configuration.");
+    }
+    return new AgentError("HARNESS_ERROR", "Copilot could not create the explicitly configured native session.");
+}
+function isMethodUnavailable(error) {
+    if (typeof error !== "object" || error === null)
+        return false;
+    const code = error.code;
+    return code === -32601 || code === "METHOD_NOT_FOUND" || code === "UNSUPPORTED_METHOD";
+}
+async function cleanup(client, native, directory, timeoutMs) {
+    let failed = false;
+    if (native) {
+        try {
+            await boundedNativeCall(native.disconnect(), timeoutMs);
+        }
+        catch {
+            failed = true;
+        }
+        if (client) {
+            try {
+                await boundedNativeCall(client.deleteSession(native.sessionId), timeoutMs);
+            }
+            catch {
+                failed = true;
+            }
+        }
+    }
+    if (client) {
+        let force = false;
+        try {
+            const errors = await boundedNativeCall(client.stop(), timeoutMs);
+            if (errors.length > 0) {
+                failed = true;
+                force = true;
+            }
+        }
+        catch {
+            failed = true;
+            force = true;
+        }
+        if (force) {
+            try {
+                await boundedNativeCall(client.forceStop(), timeoutMs);
+            }
+            catch {
+                failed = true;
+            }
+        }
+    }
+    try {
+        await rm(directory, { recursive: true });
+    }
+    catch {
+        failed = true;
+    }
+    return failed;
+}
+function cleanupError() {
+    return new AgentError("CANCELLATION_FAILED", "Copilot native process cleanup could not be confirmed.");
+}
+function inputRequired() {
+    return new AgentError("INPUT_REQUIRED", "Copilot requested unsupported interactive input.");
+}
+function requiresInput(event) {
+    if (event.type === "permission.requested")
+        return event.data.resolvedByHook !== true;
+    return new Set([
+        "user_input.requested",
+        "elicitation.requested",
+        "sampling.requested",
+        "mcp.oauth_required",
+        "mcp.headers_refresh_required",
+        "external_tool.requested",
+        "ui.ephemeral_query",
+        "auto_mode_switch.requested",
+        "session_limits_exhausted.requested",
+        "exit_plan_mode.requested",
+    ]).has(event.type);
+}
+async function waitForNativeIdle(native, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0)
+            throw cleanupError();
+        try {
+            const [processing, activity] = await boundedNativeCall(Promise.all([
+                native.rpc.metadata.isProcessing(),
+                native.rpc.metadata.activity(),
+            ]), remaining);
+            if (!processing.processing && !activity.hasActiveWork)
+                return;
+        }
+        catch {
+            throw cleanupError();
+        }
+        const pause = Math.min(10, deadline - Date.now());
+        if (pause <= 0)
+            throw cleanupError();
+        await new Promise(resolve => setTimeout(resolve, pause));
+    }
+}
+async function boundedNativeCall(call, timeoutMs, signal) {
+    let timer;
+    let abort;
+    try {
+        const pending = [
+            call,
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(cleanupError()), timeoutMs);
+            }),
+        ];
+        if (signal) {
+            pending.push(new Promise((_resolve, reject) => {
+                abort = () => reject(new Error("native-call-monitor-stopped"));
+                if (signal.aborted)
+                    abort();
+                else
+                    signal.addEventListener("abort", abort, { once: true });
+            }));
+        }
+        return await Promise.race(pending);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        if (signal && abort)
+            signal.removeEventListener("abort", abort);
+    }
+}
+async function monitorDelay(delayMs, signal) {
+    if (signal.aborted)
+        return false;
+    return await new Promise(resolve => {
+        const timer = setTimeout(() => {
+            signal.removeEventListener("abort", stop);
+            resolve(true);
+        }, delayMs);
+        const stop = () => {
+            clearTimeout(timer);
+            resolve(false);
+        };
+        signal.addEventListener("abort", stop, { once: true });
+    });
+}
+//# sourceMappingURL=copilot.js.map