diff --git a/packages/core/src/plugin/provider/github-copilot.ts b/packages/core/src/plugin/provider/github-copilot.ts index 9e4e0bb5bb7..8a2e9690077 100644 --- a/packages/core/src/plugin/provider/github-copilot.ts +++ b/packages/core/src/plugin/provider/github-copilot.ts @@ -1,5 +1,5 @@ import type { IntegrationOAuthMethodRegistration } from "@opencode/plugin/effect/integration" -import type { SessionRequestKind } from "@opencode/plugin/effect/session" +import type { SessionRequestKind, SessionTitle } from "@opencode/plugin/effect/session" import { Effect, Option, Schema, Semaphore, Stream } from "effect" import { IntegrationConnection } from "../../integration/connection.js" import { Credential } from "../../credential.js" @@ -8,6 +8,7 @@ import { CopilotModels } from "../../github-copilot/models.js" import { App } from "../../app.js" import { Integration } from "../../integration.js" import { Model } from "../../model.js" +import { Agent } from "../../agent.js" import { define } from "@opencode/plugin/effect/plugin" import { Provider } from "../../provider.js" import type { PluginInternal } from "../internal.js" @@ -162,6 +163,7 @@ export const GithubCopilotPlugin = define({ const loading = Semaphore.makeUnsafe(1) const loaded: { baseURL?: string + token?: string models?: CopilotModels.Snapshot connection?: Effect.Success> } = {} @@ -173,6 +175,7 @@ export const GithubCopilotPlugin = define({ : undefined if (credential?.type !== "oauth") { loaded.baseURL = undefined + loaded.token = undefined loaded.models = undefined loaded.connection = undefined return @@ -200,6 +203,7 @@ export const GithubCopilotPlugin = define({ ) return loaded.baseURL = url + loaded.token = credential.refresh loaded.models = remote loaded.connection = connection }) @@ -273,6 +277,29 @@ export const GithubCopilotPlugin = define({ }), { providerID: Provider.ID.githubCopilot }, ) + // GitHub's integration guide designates session naming as a utility scenario served by + // free, rate-limited utility models. Any failure leaves the result unset so the normal + // billable title path still runs. + yield* ctx.session.hook( + "title", + (evt) => + Effect.gen(function* () { + if (evt.model.providerID !== Provider.ID.githubCopilot) return + if (!loaded.baseURL || !loaded.token || !loaded.models) return + const agent = yield* ctx.agent.get({ agentID: Agent.ID.make("title") }).pipe(Effect.orElseSucceed(() => undefined)) + if (agent?.data.model) return + const model = utilityTitleModels.find((id) => loaded.models?.has(id)) + if (!model) return + evt.result = yield* utilityTitle( + { baseURL: loaded.baseURL, token: loaded.token, model, app: ctx.app }, + evt, + ).pipe( + Effect.tapError((cause) => Effect.logDebug("Copilot utility title failed", { model, cause })), + Effect.orElseSucceed(() => undefined), + ) + }), + { providerID: Provider.ID.githubCopilot }, + ) yield* ctx.session.hook( "http.request", (evt) => @@ -369,6 +396,70 @@ function request(url: string, init: RequestInit) { type Fetch = (input: Parameters[0], init?: RequestInit) => Promise +// Matches the Copilot client: gpt-4o-mini is the "small utility" model; when an account +// lacks it the request falls through to the regular title path instead of another guess. +export const utilityTitleModels = ["gpt-4o-mini"] + +const UtilityCompletion = Schema.Struct({ + choices: Schema.Array(Schema.Struct({ message: Schema.Struct({ content: Schema.NullOr(Schema.String) }) })), +}) +const decodeUtilityCompletion = Schema.decodeUnknownEffect(Schema.fromJsonString(UtilityCompletion)) + +// This issues its own /chat/completions call instead of steering core's title request. +// The `session.title` hook exposes `model` read-only, so pointing core at another model +// would mean widening that contract and re-resolving inside SessionModelRequest; rewriting +// the body in `http.request` is worse still, since the endpoint (/responses for GPT-5, +// /v1/messages for Claude) is fixed before that hook runs and gpt-4o-mini only serves +// /chat/completions. Utility titles are Copilot-specific, stateless, non-streaming, and +// free, so a small request here costs less than a core seam. Trade-offs: no session +// usage record for the title step (the call bills nothing) and no `http.*` hook visibility. +export function utilityTitle( + input: { baseURL: string; token: string; model: string; app: App.Info; fetch?: Fetch }, + request: Pick, +) { + const send = input.fetch ?? fetch + const text = (parts: ReadonlyArray<{ type: string; text?: string | null }>) => + parts.flatMap((part) => (part.type === "text" && typeof part.text === "string" ? [part.text] : [])).join("\n") + const messages = [ + ...(request.system.length ? [{ role: "system", content: text(request.system) }] : []), + ...request.messages.map((message) => ({ role: message.role, content: text(message.content) })), + ] + return Effect.tryPromise({ + try: async (signal) => { + const response = await send(`${input.baseURL}/chat/completions`, { + method: "POST", + signal, + headers: { + Authorization: `Bearer ${input.token}`, + "Content-Type": "application/json", + "User-Agent": App.useragent(input.app), + "X-GitHub-Api-Version": apiVersion, + "Openai-Intent": "conversation-edits", + "X-Interaction-Type": "agent-session-name-generation", + "X-Interaction-Id": request.sessionID, + "x-initiator": "agent", + }, + body: JSON.stringify({ + model: input.model, + messages, + stream: false, + ...(typeof request.options.maxTokens === "number" ? { max_tokens: request.options.maxTokens } : {}), + }), + }) + if (!response.ok) throw new Error(`Utility title request failed: ${response.status}`) + return response.text() + }, + catch: (cause) => cause, + }).pipe( + Effect.timeout("20 seconds"), + Effect.flatMap(decodeUtilityCompletion), + Effect.flatMap((completion) => { + const title = completion.choices[0]?.message.content?.trim() + return title ? Effect.succeed(title) : Effect.fail(new Error("Utility title response was empty")) + }), + ) +} + export function copilotFetch(token: string | undefined, upstream: Fetch | undefined, app: App.Info): Fetch { const send = upstream ?? fetch return async (input, init) => { diff --git a/packages/core/test/plugin/provider-github-copilot.test.ts b/packages/core/test/plugin/provider-github-copilot.test.ts index fa8cb8487dc..69dc2f008b6 100644 --- a/packages/core/test/plugin/provider-github-copilot.test.ts +++ b/packages/core/test/plugin/provider-github-copilot.test.ts @@ -15,7 +15,9 @@ import { copilotEntitlementError, copilotFetch, GithubCopilotPlugin, + utilityTitle, } from "@opencode/core/plugin/provider/github-copilot" +import { Message, SystemPart } from "@opencode/ai" import { Provider } from "@opencode/core/provider" import { Integration } from "@opencode/core/integration" import type { SessionRequestKind } from "@opencode/plugin/effect/session" @@ -237,6 +239,73 @@ describe("GithubCopilotPlugin", () => { }), ) + const titleRequest = { + sessionID: Session.ID.make("ses_title"), + system: [SystemPart.make("You are a title generator.")], + messages: [Message.user("how do I make my python script faster")], + options: { maxTokens: 32 }, + } + const utilityInput = (send: (init?: RequestInit) => Response | Promise) => ({ + baseURL: "https://api.individual.githubcopilot.com", + token: "token", + model: "gpt-4o-mini", + app: App.make({ name: "test", version: "1.2.3", channel: "beta" }), + fetch: async (_input: Parameters[0], init?: RequestInit) => send(init), + }) + + it.live("names sessions with the utility model as a free background request", () => + Effect.gen(function* () { + const seen: Array<{ url?: string; init?: RequestInit }> = [] + const title = yield* utilityTitle( + { + ...utilityInput(() => Response.json({ choices: [{ message: { content: " Speed Up Python Script\n" } }] })), + fetch: async (input: Parameters[0], init?: RequestInit) => { + seen.push({ url: String(input), init }) + return Response.json({ choices: [{ message: { content: " Speed Up Python Script\n" } }] }) + }, + }, + titleRequest, + ) + expect(title).toBe("Speed Up Python Script") + expect(seen[0]?.url).toBe("https://api.individual.githubcopilot.com/chat/completions") + const headers = new Headers(seen[0]?.init?.headers) + expect(headers.get("authorization")).toBe("Bearer token") + expect(headers.get("x-interaction-type")).toBe("agent-session-name-generation") + expect(headers.get("x-interaction-id")).toBe("ses_title") + expect(headers.get("x-initiator")).toBe("agent") + expect(headers.get("x-github-api-version")).toBe("2026-08-01") + expect(JSON.parse(String(seen[0]?.init?.body))).toEqual({ + model: "gpt-4o-mini", + stream: false, + max_tokens: 32, + messages: [ + { role: "system", content: "You are a title generator." }, + { role: "user", content: "how do I make my python script faster" }, + ], + }) + }), + ) + + it.live("fails the utility title on rate limits so the billable path can run", () => + Effect.gen(function* () { + const error = yield* utilityTitle( + utilityInput(() => new Response("slow down", { status: 429 })), + titleRequest, + ).pipe(Effect.flip) + expect(String(error)).toContain("429") + }), + ) + + it.live("fails the utility title on an empty completion", () => + Effect.gen(function* () { + const error = yield* utilityTitle( + utilityInput(() => Response.json({ choices: [{ message: { content: null } }] })), + titleRequest, + ).pipe(Effect.flip) + expect(String(error)).toContain("empty") + }), + ) + it.live("keeps a declared agent initiator when the body looks user-initiated", () => Effect.gen(function* () { const requests: Headers[] = []