opencode-copilot-responses 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Nate Smyth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,21 @@
+# Copilot Responses API Provider for OpenCode
+
+This plugin provides access to `api.githubcopilot.com/responses` for accessing OpenAI models (GPT-5.x) via your Copilot subscription.
+
+## Setup
+
+1. Add to the `plugin` array in `opencode.json` or `opencode.jsonc`:
+
+```json
+  "plugin": [
+    "opencode-copilot-responses@latest"
+  ]
+```
+
+2. Run `opencode auth login`
+3. Search or scroll to "other"
+4. Enter "copilot-responses"
+5. Finish OAuth flow in browser
+6. Launch opencode
+
+You will now see a new "copilot-responses" provider populated with all available models that support `/responses`, obtained from Copilot's `/models` endpoint.

package/dist/auth/entitlement.d.ts

@@ -0,0 +1,9 @@
+export declare function fetchEntitlement(input: {
+    token: string;
+    fetch?: typeof fetch;
+    url?: string;
+}): Promise<{
+    baseUrl: string;
+    login: string;
+}>;
+//# sourceMappingURL=entitlement.d.ts.map

package/dist/auth/entitlement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entitlement.d.ts","sourceRoot":"","sources":["../../src/auth/entitlement.ts"],"names":[],"mappings":"AAEA,wBAAsB,gBAAgB,CAAC,KAAK,EAAE;IAC7C,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,OAAO,KAAK,CAAA;IACpB,GAAG,CAAC,EAAE,MAAM,CAAA;CACZ;;WAyB4C,MAAM;GAClD"}

package/dist/auth/entitlement.js

@@ -0,0 +1,23 @@
+import { AUTH_AGENT } from "./headers";
+export async function fetchEntitlement(input) {
+    const base = input.url ?? "https://api.github.com";
+    const run = input.fetch ?? fetch;
+    const endpoint = new URL("/copilot_internal/user", base);
+    const res = await run(endpoint, {
+        headers: {
+            Authorization: `Bearer ${input.token}`,
+            Accept: "application/json",
+            "User-Agent": AUTH_AGENT,
+        },
+    });
+    if (!res.ok) {
+        throw new Error(`entitlement check failed (${res.status}) ${endpoint.pathname}`);
+    }
+    const data = (await res.json());
+    const endpoints = data.endpoints;
+    const api = endpoints?.api;
+    if (typeof api !== "string" || api.length === 0) {
+        throw new Error("entitlement response missing endpoints.api");
+    }
+    return { baseUrl: api, login: data.login };
+}

package/dist/auth/headers.d.ts

@@ -0,0 +1,5 @@
+export declare const COPILOT_CLI_VERSION = "0.0.411";
+export declare const MODELS_AGENT: string;
+export declare const RESPONSES_AGENT: string;
+export declare const AUTH_AGENT = "undici";
+//# sourceMappingURL=headers.d.ts.map

package/dist/auth/headers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers.d.ts","sourceRoot":"","sources":["../../src/auth/headers.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,YAAY,CAAA;AAI5C,eAAO,MAAM,YAAY,QAAyF,CAAA;AAClH,eAAO,MAAM,eAAe,QAAoG,CAAA;AAChI,eAAO,MAAM,UAAU,WAAW,CAAA"}

package/dist/auth/headers.js

@@ -0,0 +1,5 @@
+export const COPILOT_CLI_VERSION = "0.0.411";
+const term = process.env.TERM_PROGRAM ?? "xterm-256color";
+export const MODELS_AGENT = `copilot/${COPILOT_CLI_VERSION} (${process.platform} ${process.version}) term/${term}`;
+export const RESPONSES_AGENT = `copilot/${COPILOT_CLI_VERSION} (client/cli ${process.platform} ${process.version}) term/${term}`;
+export const AUTH_AGENT = "undici";

package/dist/auth/index.d.ts

@@ -0,0 +1,4 @@
+export { fetchEntitlement } from "./entitlement";
+export { authorizeDeviceCode, CLIENT_ID, pollForToken } from "./oauth";
+export type { StoredAuth } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/auth/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/auth/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAChD,OAAO,EAAE,mBAAmB,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AACtE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA"}

package/dist/auth/index.js

@@ -0,0 +1,2 @@
+export { fetchEntitlement } from "./entitlement";
+export { authorizeDeviceCode, CLIENT_ID, pollForToken } from "./oauth";

package/dist/auth/oauth.d.ts

@@ -0,0 +1,28 @@
+export declare const CLIENT_ID = "Ov23ctDVkRmgkPke0Mmm";
+export declare function authorizeDeviceCode(input?: {
+    fetch?: typeof fetch;
+    url?: string;
+    clientId?: string;
+    scope?: string;
+}): Promise<{
+    device_code: string;
+    user_code: string;
+    verification_uri: string;
+    expires_in: number;
+    interval: number;
+}>;
+export declare function pollForToken(input: {
+    deviceCode: string;
+    interval: number;
+    expiresAt: number;
+    fetch?: typeof fetch;
+    url?: string;
+    clientId?: string;
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => number;
+}): Promise<{
+    access_token: string;
+    token_type: string;
+    scope: string;
+}>;
+//# sourceMappingURL=oauth.d.ts.map

package/dist/auth/oauth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oauth.d.ts","sourceRoot":"","sources":["../../src/auth/oauth.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS,yBAAyB,CAAA;AAE/C,wBAAsB,mBAAmB,CAAC,KAAK,CAAC,EAAE;IACjD,KAAK,CAAC,EAAE,OAAO,KAAK,CAAA;IACpB,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;CACd;iBAsBc,MAAM;eACR,MAAM;sBACC,MAAM;gBACZ,MAAM;cACR,MAAM;GAEjB;AAED,wBAAsB,YAAY,CAAC,KAAK,EAAE;IACzC,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,OAAO,KAAK,CAAA;IACpB,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACrC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;CAClB;kBAWe,MAAM;gBACR,MAAM;WACX,MAAM;GAiDd"}

package/dist/auth/oauth.js

@@ -0,0 +1,68 @@
+import { AUTH_AGENT } from "./headers";
+export const CLIENT_ID = "Ov23ctDVkRmgkPke0Mmm";
+export async function authorizeDeviceCode(input) {
+    const base = input?.url ?? "https://github.com";
+    const id = input?.clientId ?? CLIENT_ID;
+    const scope = input?.scope ?? "read:user";
+    const run = input?.fetch ?? fetch;
+    const endpoint = new URL("/login/device/code", base);
+    const res = await run(endpoint, {
+        method: "POST",
+        headers: {
+            Accept: "application/json",
+            "Content-Type": "application/x-www-form-urlencoded",
+            "User-Agent": AUTH_AGENT,
+        },
+        body: new URLSearchParams({ client_id: id, scope }).toString(),
+    });
+    if (!res.ok) {
+        throw new Error(`device code request failed (${res.status}) ${endpoint.pathname}`);
+    }
+    return (await res.json());
+}
+export async function pollForToken(input) {
+    const base = input.url ?? "https://github.com";
+    const id = input.clientId ?? CLIENT_ID;
+    const run = input.fetch ?? fetch;
+    const sleep = input.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const now = input.now ?? (() => Date.now());
+    const endpoint = new URL("/login/oauth/access_token", base);
+    const step = async (interval) => {
+        if (Math.floor(now() / 1000) >= input.expiresAt) {
+            throw new Error("expired_token");
+        }
+        const res = await run(endpoint, {
+            method: "POST",
+            headers: {
+                Accept: "application/json",
+                "Content-Type": "application/x-www-form-urlencoded",
+                "User-Agent": AUTH_AGENT,
+            },
+            body: new URLSearchParams({
+                client_id: id,
+                device_code: input.deviceCode,
+                grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+            }).toString(),
+        });
+        const data = (await res.json());
+        if ("access_token" in data) {
+            return data;
+        }
+        if (data.error === "authorization_pending") {
+            await sleep(interval * 1000);
+            return step(interval);
+        }
+        if (data.error === "slow_down") {
+            const next = typeof data.interval === "number" ? data.interval : interval + 5;
+            await sleep(next * 1000);
+            return step(next);
+        }
+        if (data.error === "expired_token")
+            throw new Error("expired_token");
+        if (data.error === "access_denied")
+            throw new Error("access_denied");
+        const detail = data.error_description ? ` ${data.error_description}` : "";
+        throw new Error(`${String(data.error)}${detail}`);
+    };
+    return step(input.interval);
+}

package/dist/auth/types.d.ts

@@ -0,0 +1,8 @@
+export interface StoredAuth {
+    type: "oauth";
+    refresh: string;
+    access: string;
+    expires: 0;
+    baseUrl: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/auth/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/auth/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IAC1B,IAAI,EAAE,OAAO,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,CAAC,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;CACf"}

package/dist/auth/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { CopilotResponsesPlugin } from "./plugin";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAA"}

package/dist/index.js

@@ -0,0 +1 @@
+export { CopilotResponsesPlugin } from "./plugin";

package/dist/models/registry.d.ts

@@ -0,0 +1,37 @@
+import type { Model } from "@opencode-ai/sdk";
+export interface CopilotModel {
+    id: string;
+    name: string;
+    vendor: string;
+    preview?: boolean;
+    capabilities?: {
+        family?: string;
+        limits?: {
+            max_context_window_tokens?: number;
+            max_output_tokens?: number;
+            max_prompt_tokens?: number;
+            vision?: {
+                max_prompt_image_size?: number;
+                max_prompt_images?: number;
+                supported_media_types?: string[];
+            };
+        };
+        supports?: {
+            structured_outputs?: boolean;
+            max_thinking_budget?: number;
+            min_thinking_budget?: number;
+            streaming?: boolean;
+            tool_calls?: boolean;
+            vision?: boolean;
+            parallel_tool_calls?: boolean;
+        };
+    };
+    supported_endpoints?: string[];
+}
+export declare function mapToOpencodeModel(model: CopilotModel, baseUrl: string): Model;
+export declare function fetchModels(input: {
+    token: string;
+    baseUrl: string;
+    fetch?: typeof fetch;
+}): Promise<Model[]>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/models/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/models/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAG7C,MAAM,WAAW,YAAY;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,YAAY,CAAC,EAAE;QACd,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,MAAM,CAAC,EAAE;YACR,yBAAyB,CAAC,EAAE,MAAM,CAAA;YAClC,iBAAiB,CAAC,EAAE,MAAM,CAAA;YAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAA;YAC1B,MAAM,CAAC,EAAE;gBACR,qBAAqB,CAAC,EAAE,MAAM,CAAA;gBAC9B,iBAAiB,CAAC,EAAE,MAAM,CAAA;gBAC1B,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAA;aAChC,CAAA;SACD,CAAA;QACD,QAAQ,CAAC,EAAE;YACV,kBAAkB,CAAC,EAAE,OAAO,CAAA;YAC5B,mBAAmB,CAAC,EAAE,MAAM,CAAA;YAC5B,mBAAmB,CAAC,EAAE,MAAM,CAAA;YAC5B,SAAS,CAAC,EAAE,OAAO,CAAA;YACnB,UAAU,CAAC,EAAE,OAAO,CAAA;YACpB,MAAM,CAAC,EAAE,OAAO,CAAA;YAChB,mBAAmB,CAAC,EAAE,OAAO,CAAA;SAC7B,CAAA;KACD,CAAA;IACD,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC9B;AAaD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,GAAG,KAAK,CAmD9E;AAED,wBAAsB,WAAW,CAAC,KAAK,EAAE;IACxC,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,OAAO,KAAK,CAAA;CACpB,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC,CAsBnB"}

package/dist/models/registry.js

@@ -0,0 +1,86 @@
+import { MODELS_AGENT } from "../auth/headers";
+const RESPONSES_ENDPOINT = "/responses";
+function parseModels(value) {
+    if (Array.isArray(value))
+        return value;
+    if (!value || typeof value !== "object")
+        return [];
+    const record = value;
+    if (Array.isArray(record.data))
+        return record.data;
+    if (Array.isArray(record.models))
+        return record.models;
+    return [];
+}
+export function mapToOpencodeModel(model, baseUrl) {
+    const caps = model.capabilities ?? {};
+    const limits = caps.limits ?? {};
+    const supports = caps.supports ?? {};
+    const vision = !!supports.vision;
+    return {
+        id: model.id,
+        providerID: "copilot-responses",
+        name: model.name,
+        api: {
+            id: model.id,
+            url: baseUrl,
+            npm: "@ai-sdk/openai",
+        },
+        capabilities: {
+            temperature: true,
+            reasoning: true,
+            attachment: vision,
+            toolcall: !!supports.tool_calls,
+            input: {
+                text: true,
+                audio: false,
+                image: vision,
+                video: false,
+                pdf: false,
+            },
+            output: {
+                text: true,
+                audio: false,
+                image: false,
+                video: false,
+                pdf: false,
+            },
+        },
+        cost: {
+            input: 0,
+            output: 0,
+            cache: {
+                read: 0,
+                write: 0,
+            },
+        },
+        limit: {
+            context: limits.max_context_window_tokens ?? 200000,
+            output: limits.max_output_tokens ?? 64000,
+        },
+        status: model.preview ? "beta" : "active",
+        options: {},
+        headers: {},
+    };
+}
+export async function fetchModels(input) {
+    const run = input.fetch ?? fetch;
+    const url = new URL("/models", input.baseUrl);
+    const headers = {
+        authorization: `Bearer ${input.token}`,
+        "user-agent": MODELS_AGENT,
+        "copilot-integration-id": "copilot-developer-cli",
+        "x-github-api-version": "2025-05-01",
+        "x-interaction-type": "model-access",
+        "openai-intent": "model-access",
+        "x-request-id": crypto.randomUUID(),
+    };
+    const res = await run(url, { method: "GET", headers });
+    if (!res.ok)
+        return [];
+    const data = (await res.json());
+    const models = parseModels(data);
+    return models
+        .filter((m) => Array.isArray(m.supported_endpoints) && m.supported_endpoints.includes(RESPONSES_ENDPOINT))
+        .map((m) => mapToOpencodeModel(m, input.baseUrl));
+}

package/dist/plugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const CopilotResponsesPlugin: Plugin;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAiBxD,eAAO,MAAM,sBAAsB,EAAE,MA4FpC,CAAA"}

package/dist/plugin.js

@@ -0,0 +1,114 @@
+import { authorizeDeviceCode, fetchEntitlement, pollForToken } from "./auth";
+import { fetchModels } from "./models/registry";
+import { copilotResponsesFetch } from "./provider/fetch";
+export const CopilotResponsesPlugin = async (input) => {
+    return {
+        config: async (config) => {
+            if (!config.provider)
+                config.provider = {};
+            if (!config.provider["copilot-responses"]) {
+                config.provider["copilot-responses"] = {
+                    npm: "@ai-sdk/openai",
+                    name: "Copilot Responses",
+                    models: {},
+                };
+            }
+        },
+        "chat.headers": async (data, output) => {
+            if (data.model.providerID !== "copilot-responses")
+                return;
+            const session = await input.client.session
+                .get({ path: { id: data.sessionID }, throwOnError: true })
+                .catch(() => undefined);
+            if (!session?.data?.parentID)
+                return;
+            output.headers["x-initiator"] = "agent";
+        },
+        auth: {
+            provider: "copilot-responses",
+            methods: [
+                {
+                    type: "oauth",
+                    label: "Login with GitHub (Copilot CLI)",
+                    authorize: async () => {
+                        const device = await authorizeDeviceCode();
+                        return {
+                            url: device.verification_uri,
+                            instructions: `Enter code: ${device.user_code}`,
+                            method: "auto",
+                            callback: async () => {
+                                const expiresAt = Math.floor(Date.now() / 1000) + device.expires_in;
+                                const token = await pollForToken({
+                                    deviceCode: device.device_code,
+                                    interval: device.interval,
+                                    expiresAt,
+                                });
+                                const entitlement = await fetchEntitlement({
+                                    token: token.access_token,
+                                });
+                                return {
+                                    type: "success",
+                                    refresh: token.access_token,
+                                    access: token.access_token,
+                                    expires: 0,
+                                    baseUrl: entitlement.baseUrl,
+                                };
+                            },
+                        };
+                    },
+                },
+            ],
+            loader: async (getAuth, provider) => {
+                const stored = (await getAuth());
+                if (!stored || stored.type !== "oauth")
+                    return {};
+                const token = typeof stored.access === "string" && stored.access.startsWith("gho_")
+                    ? stored.access
+                    : typeof stored.refresh === "string" && stored.refresh.startsWith("gho_")
+                        ? stored.refresh
+                        : null;
+                if (!token)
+                    return {};
+                const base = await resolveBaseUrl(stored, token, input);
+                const models = await fetchModels({ token, baseUrl: base });
+                const target = provider;
+                if (!target.models)
+                    target.models = {};
+                for (const model of models) {
+                    const existing = target.models[model.id];
+                    if (!existing) {
+                        target.models[model.id] = model;
+                        continue;
+                    }
+                    target.models[model.id] = mergeModel(model, existing);
+                }
+                return {
+                    name: "openai",
+                    apiKey: "",
+                    baseURL: base,
+                    fetch: (req, init) => copilotResponsesFetch(req, init, { token }),
+                };
+            },
+        },
+    };
+};
+async function resolveBaseUrl(stored, token, input) {
+    if (typeof stored.baseUrl === "string" && stored.baseUrl.length > 0)
+        return stored.baseUrl;
+    const entitlement = await fetchEntitlement({ token });
+    // auth.set body type is opaque to the plugin; cast is unavoidable here
+    await input.client.auth.set({
+        path: { id: "copilot-responses" },
+        body: { ...stored, baseUrl: entitlement.baseUrl },
+    });
+    return entitlement.baseUrl;
+}
+function mergeModel(model, existing) {
+    return {
+        ...model,
+        limit: { ...model.limit, ...existing.limit },
+        options: { ...model.options, ...existing.options },
+        headers: { ...model.headers, ...existing.headers },
+        variants: { ...model.variants, ...existing.variants },
+    };
+}

package/dist/provider/fetch.d.ts

@@ -0,0 +1,5 @@
+export interface FetchContext {
+    token: string;
+}
+export declare function copilotResponsesFetch(input: string | URL | Request, init: RequestInit | undefined, context: FetchContext): Promise<Response>;
+//# sourceMappingURL=fetch.d.ts.map

package/dist/provider/fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../src/provider/fetch.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,YAAY;IAC5B,KAAK,EAAE,MAAM,CAAA;CACb;AAED,wBAAsB,qBAAqB,CAC1C,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,EAC7B,IAAI,EAAE,WAAW,GAAG,SAAS,EAC7B,OAAO,EAAE,YAAY,GACnB,OAAO,CAAC,QAAQ,CAAC,CA2BnB"}

package/dist/provider/fetch.js

@@ -0,0 +1,107 @@
+import { buildHeaders } from "./headers";
+import { determineInitiator, hasImageContent } from "./initiator";
+import { normalizeReasoningIds } from "./normalize";
+export async function copilotResponsesFetch(input, init, context) {
+    const headers = merge(input, init);
+    headers.delete("x-api-key");
+    const body = readBody(init?.body);
+    const initiator = forced(headers.get("x-initiator")) ??
+        (isInternalAgent(body) ? "agent" : determineInitiator(body.input));
+    const images = hasImageContent(body.input);
+    const copilot = buildHeaders({
+        token: context.token,
+        initiator,
+        hasImages: images,
+    });
+    for (const [key, value] of Object.entries(copilot)) {
+        headers.set(key, value);
+    }
+    const response = await fetch(input, {
+        ...init,
+        headers,
+        body: stripIds(init?.body),
+    });
+    if (!response.body || !isSSE(response))
+        return response;
+    return new Response(normalizeReasoningIds(response.body), {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+    });
+}
+const decoder = new TextDecoder();
+function merge(input, init) {
+    const headers = new Headers(input instanceof Request ? input.headers : undefined);
+    if (!init?.headers)
+        return headers;
+    const incoming = new Headers(init.headers);
+    for (const [key, value] of incoming.entries()) {
+        headers.set(key, value);
+    }
+    return headers;
+}
+function readBody(body) {
+    if (!body)
+        return { input: [] };
+    if (typeof body === "string")
+        return parse(body);
+    if (body instanceof ArrayBuffer)
+        return parse(decoder.decode(body));
+    if (ArrayBuffer.isView(body))
+        return parse(decoder.decode(body));
+    return { input: [] };
+}
+function parse(text) {
+    try {
+        const parsed = JSON.parse(text);
+        return {
+            input: Array.isArray(parsed.input) ? parsed.input : [],
+            instructions: parsed.instructions,
+            system: parsed.system,
+        };
+    }
+    catch {
+        return { input: [] };
+    }
+}
+function isSSE(response) {
+    return (response.headers.get("content-type") ?? "").includes("text/event-stream");
+}
+// Strip stale IDs from input items; item_reference keeps its id.
+function stripIds(body) {
+    if (typeof body !== "string")
+        return body;
+    try {
+        const parsed = JSON.parse(body);
+        if (!Array.isArray(parsed.input))
+            return body;
+        for (const item of parsed.input) {
+            if (item.type === "item_reference")
+                continue;
+            delete item.id;
+        }
+        return JSON.stringify(parsed);
+    }
+    catch {
+        return body;
+    }
+}
+function isInternalAgent(body) {
+    const prompt = body.instructions ?? body.system;
+    if (!prompt)
+        return false;
+    if (typeof prompt === "string")
+        return prompt.startsWith("You are a title generator");
+    if (Array.isArray(prompt) && prompt.length > 0) {
+        const first = prompt[0];
+        if (typeof first === "object" && typeof first.text === "string") {
+            return first.text.startsWith("You are a title generator");
+        }
+    }
+    return false;
+}
+function forced(value) {
+    if (value === "user" || value === "agent")
+        return value;
+    return null;
+}

package/dist/provider/headers.d.ts

@@ -0,0 +1,7 @@
+export interface HeaderContext {
+    token: string;
+    initiator: "user" | "agent";
+    hasImages?: boolean;
+}
+export declare function buildHeaders(context: HeaderContext): Record<string, string>;
+//# sourceMappingURL=headers.d.ts.map

package/dist/provider/headers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers.d.ts","sourceRoot":"","sources":["../../src/provider/headers.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,aAAa;IAC7B,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,GAAG,OAAO,CAAA;IAC3B,SAAS,CAAC,EAAE,OAAO,CAAA;CACnB;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAgB3E"}

package/dist/provider/headers.js

@@ -0,0 +1,18 @@
+import { RESPONSES_AGENT } from "../auth/headers";
+export function buildHeaders(context) {
+    const headers = {
+        authorization: `Bearer ${context.token}`,
+        "user-agent": RESPONSES_AGENT,
+        "copilot-integration-id": "copilot-developer-cli",
+        "x-github-api-version": "2025-05-01",
+        "x-interaction-type": "conversation-agent",
+        "openai-intent": "conversation-agent",
+        "x-interaction-id": crypto.randomUUID(),
+        "x-request-id": crypto.randomUUID(),
+        "x-initiator": context.initiator,
+    };
+    if (context.hasImages) {
+        headers["Copilot-Vision-Request"] = "true";
+    }
+    return headers;
+}

package/dist/provider/initiator.d.ts

@@ -0,0 +1,3 @@
+export declare function determineInitiator(input: unknown): "user" | "agent";
+export declare function hasImageContent(input: unknown): boolean;
+//# sourceMappingURL=initiator.d.ts.map

package/dist/provider/initiator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initiator.d.ts","sourceRoot":"","sources":["../../src/provider/initiator.ts"],"names":[],"mappings":"AAAA,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,CASnE;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAWvD"}

package/dist/provider/initiator.js

@@ -0,0 +1,37 @@
+export function determineInitiator(input) {
+    if (!Array.isArray(input) || input.length === 0)
+        return "agent";
+    const last = input[input.length - 1];
+    if (typed(last, "function_call_output"))
+        return "agent";
+    if (!has(last, "role", "user"))
+        return "agent";
+    const content = last.content;
+    if (!Array.isArray(content) || content.length === 0)
+        return "agent";
+    if (content.some((p) => typed(p, "input_text")))
+        return "user";
+    return "agent";
+}
+export function hasImageContent(input) {
+    if (!Array.isArray(input))
+        return false;
+    for (const item of input) {
+        const content = item !== null && typeof item === "object"
+            ? item.content
+            : undefined;
+        if (!Array.isArray(content))
+            continue;
+        if (content.some((p) => typed(p, "input_image")))
+            return true;
+    }
+    return false;
+}
+function typed(value, kind) {
+    return (value !== null && typeof value === "object" && value.type === kind);
+}
+function has(value, key, expected) {
+    return (value !== null &&
+        typeof value === "object" &&
+        value[key] === expected);
+}

package/dist/provider/normalize.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeReasoningIds(stream: ReadableStream<Uint8Array>): ReadableStream<Uint8Array>;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/provider/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../src/provider/normalize.ts"],"names":[],"mappings":"AAmBA,wBAAgB,qBAAqB,CACpC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,GAChC,cAAc,CAAC,UAAU,CAAC,CAsB5B"}

package/dist/provider/normalize.js

@@ -0,0 +1,80 @@
+// Normalizes rotated item IDs from the Copilot proxy.
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+// SSE event types whose top-level `item_id` should be rewritten.
+const ITEM_ID_EVENTS = new Set([
+    "response.reasoning_summary_text.delta",
+    "response.reasoning_summary_text.done",
+    "response.reasoning_summary_part.added",
+    "response.reasoning_summary_part.done",
+    "response.output_text.delta",
+    "response.output_text.done",
+    "response.content_part.added",
+    "response.content_part.done",
+    "response.function_call_arguments.delta",
+    "response.function_call_arguments.done",
+]);
+export function normalizeReasoningIds(stream) {
+    const canonical = {};
+    let buffer = "";
+    return stream.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            buffer += decoder.decode(chunk, { stream: true });
+            const parts = buffer.split("\n\n");
+            // keep incomplete trailing block in buffer
+            buffer = parts.pop() ?? "";
+            for (const block of parts) {
+                controller.enqueue(encoder.encode(`${rewrite(block, canonical)}\n\n`));
+            }
+        },
+        flush(controller) {
+            if (buffer.trim()) {
+                controller.enqueue(encoder.encode(`${rewrite(buffer, canonical)}\n\n`));
+            }
+        },
+    }));
+}
+function rewrite(block, canonical) {
+    const dataMatch = block.match(/^data: (.+)$/m);
+    if (!dataMatch)
+        return block;
+    try {
+        const data = JSON.parse(dataMatch[1]);
+        const type = data.type;
+        if (!type)
+            return block;
+        let changed = false;
+        // Record canonical id from output_item.added
+        if (type === "response.output_item.added") {
+            const item = data.item;
+            const idx = data.output_index;
+            if (item && idx !== undefined && typeof item.id === "string") {
+                canonical[idx] = item.id;
+            }
+            return block;
+        }
+        // Rewrite item.id in output_item.done
+        if (type === "response.output_item.done") {
+            const item = data.item;
+            const idx = data.output_index;
+            if (item && idx !== undefined && canonical[idx] && item.id !== canonical[idx]) {
+                item.id = canonical[idx];
+                changed = true;
+            }
+        }
+        // Rewrite top-level item_id
+        if (ITEM_ID_EVENTS.has(type)) {
+            const idx = data.output_index;
+            if (idx !== undefined && canonical[idx] && data.item_id !== canonical[idx]) {
+                data.item_id = canonical[idx];
+                changed = true;
+            }
+        }
+        if (!changed)
+            return block;
+        return block.replace(/^data: .+$/m, `data: ${JSON.stringify(data)}`);
+    }
+    catch {
+        return block;
+    }
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+	"name": "opencode-copilot-responses",
+	"version": "0.0.1",
+	"description": "OpenCode plugin for Copilot via the OpenAI Responses API",
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"license": "MIT",
+	"publishConfig": {
+		"access": "public"
+	},
+	"files": [
+		"dist/",
+		"README.md",
+		"LICENSE"
+	],
+	"scripts": {
+		"build": "bun run clean:dist && tsc -p tsconfig.build.json",
+		"clean:dist": "bun -e \"import { rm } from 'node:fs/promises'; await rm('dist', { recursive: true, force: true })\"",
+		"check": "tsc --noEmit",
+		"lint": "biome check .",
+		"lint:fix": "biome check --write .",
+		"format": "biome format --write .",
+		"test": "bun test",
+		"preflight": "bun test && bun run check && bun run lint",
+		"release:patch": "bun run preflight && bun pm version patch && bun publish && git push --follow-tags",
+		"release:minor": "bun run preflight && bun pm version minor && bun publish && git push --follow-tags",
+		"release:major": "bun run preflight && bun pm version major && bun publish && git push --follow-tags",
+		"prepublishOnly": "bun run build"
+	},
+	"dependencies": {
+		"@opencode-ai/plugin": "^1.1.48"
+	},
+	"devDependencies": {
+		"@opencode-ai/sdk": "1.1.48",
+		"@types/bun": "latest",
+		"typescript": "^5.0.0"
+	},
+	"peerDependencies": {
+		"typescript": "^5"
+	}
+}