onlycode 1.18.0 → 1.20.0

package/src/plugin/github-copilot/copilot.ts

@@ -1,414 +0,0 @@
-import type { Hooks, PluginInput } from "@opencode-ai/plugin"
-import type { Model } from "@opencode-ai/sdk/v2"
-import { InstallationVersion } from "@opencode-ai/core/installation/version"
-import { iife } from "@/util/iife"
-import { setTimeout as sleep } from "node:timers/promises"
-import { CopilotModels } from "./models"
-import { MessageV2 } from "@/session/message-v2"
-
-const CLIENT_ID = "Ov23li8tweQw6odWQebz"
-const API_VERSION = "2026-06-01"
-const UTILITY_MODELS = ["gpt-5.4-nano", "gpt-4.1", "gpt-4o", "gpt-4o-mini"]
-// Add a small safety buffer when polling to avoid hitting the server
-// slightly too early due to clock skew / timer drift.
-const OAUTH_POLLING_SAFETY_MARGIN_MS = 3000 // 3 seconds
-function normalizeDomain(url: string) {
-  return url.replace(/^https?:\/\//, "").replace(/\/$/, "")
-}
-
-function getUrls(domain: string) {
-  return {
-    DEVICE_CODE_URL: `https://${domain}/login/device/code`,
-    ACCESS_TOKEN_URL: `https://${domain}/login/oauth/access_token`,
-  }
-}
-
-function base(enterpriseUrl?: string) {
-  return enterpriseUrl ? `https://copilot-api.${normalizeDomain(enterpriseUrl)}` : "https://api.githubcopilot.com"
-}
-
-// Check if a message is a synthetic user msg used to attach an image from a tool call
-function imgMsg(msg: any): boolean {
-  if (msg?.role !== "user") return false
-
-  // Handle the 3 api formats
-
-  const content = msg.content
-  if (typeof content === "string") return content === MessageV2.SYNTHETIC_ATTACHMENT_PROMPT
-  if (!Array.isArray(content)) return false
-  return content.some(
-    (part: any) =>
-      (part?.type === "text" || part?.type === "input_text") && part.text === MessageV2.SYNTHETIC_ATTACHMENT_PROMPT,
-  )
-}
-
-function fix(model: Model, url: string): Model {
-  return {
-    ...model,
-    api: {
-      ...model.api,
-      url,
-      npm: "@ai-sdk/github-copilot",
-    },
-  }
-}
-
-export async function CopilotAuthPlugin(input: PluginInput): Promise<Hooks> {
-  const sdk = input.client
-  let models: Record<string, Model> = {}
-  return {
-    provider: {
-      id: "github-copilot",
-      async models(provider, ctx) {
-        if (ctx.auth?.type !== "oauth") {
-          models = {}
-          return Object.fromEntries(Object.entries(provider.models).map(([id, model]) => [id, fix(model, base())]))
-        }
-
-        const auth = ctx.auth
-
-        return CopilotModels.get(
-          base(auth.enterpriseUrl),
-          {
-            ...(provider.options?.headers as Record<string, string> | undefined),
-            Authorization: `Bearer ${auth.refresh}`,
-            "User-Agent": `opencode/${InstallationVersion}`,
-            "X-GitHub-Api-Version": API_VERSION,
-          },
-          provider.models,
-        )
-          .then((result) => {
-            models = result.models
-            return Object.fromEntries(
-              Object.entries(result.models).filter(([, model]) => result.pickerEnabled.has(model.api.id)),
-            )
-          })
-          .catch((error) => {
-            models = {}
-            return Object.fromEntries(
-              Object.entries(provider.models).map(([id, model]) => [id, fix(model, base(auth.enterpriseUrl))]),
-            )
-          })
-      },
-    },
-    auth: {
-      provider: "github-copilot",
-      async loader(getAuth) {
-        const info = await getAuth()
-        if (!info || info.type !== "oauth") return {}
-
-        return {
-          apiKey: "",
-          async fetch(request: RequestInfo | URL, init?: RequestInit) {
-            const info = await getAuth()
-            if (info.type !== "oauth") return fetch(request, init)
-
-            const url = request instanceof URL ? request.href : typeof request === "string" ? request : request.url
-            const { isVision, isAgent } = iife(() => {
-              try {
-                const body = typeof init?.body === "string" ? JSON.parse(init.body) : init?.body
-
-                // Completions API
-                if (body?.messages && url.includes("completions")) {
-                  const last = body.messages[body.messages.length - 1]
-                  return {
-                    isVision: body.messages.some(
-                      (msg: any) =>
-                        Array.isArray(msg.content) && msg.content.some((part: any) => part.type === "image_url"),
-                    ),
-                    isAgent: last?.role !== "user" || imgMsg(last),
-                  }
-                }
-
-                // Responses API
-                if (body?.input) {
-                  const last = body.input[body.input.length - 1]
-                  return {
-                    isVision: body.input.some(
-                      (item: any) =>
-                        Array.isArray(item?.content) && item.content.some((part: any) => part.type === "input_image"),
-                    ),
-                    isAgent: last?.role !== "user" || imgMsg(last),
-                  }
-                }
-
-                // Messages API
-                if (body?.messages) {
-                  const last = body.messages[body.messages.length - 1]
-                  const hasNonToolCalls =
-                    Array.isArray(last?.content) && last.content.some((part: any) => part?.type !== "tool_result")
-                  return {
-                    isVision: body.messages.some(
-                      (item: any) =>
-                        Array.isArray(item?.content) &&
-                        item.content.some(
-                          (part: any) =>
-                            part?.type === "image" ||
-                            // images can be nested inside tool_result content
-                            (part?.type === "tool_result" &&
-                              Array.isArray(part?.content) &&
-                              part.content.some((nested: any) => nested?.type === "image")),
-                        ),
-                    ),
-                    isAgent: !(last?.role === "user" && hasNonToolCalls) || imgMsg(last),
-                  }
-                }
-              } catch {}
-              return { isVision: false, isAgent: false }
-            })
-
-            const headers: Record<string, string> = {
-              "x-initiator": isAgent ? "agent" : "user",
-              ...(init?.headers as Record<string, string>),
-              "User-Agent": `opencode/${InstallationVersion}`,
-              Authorization: `Bearer ${info.refresh}`,
-              "Openai-Intent": "conversation-edits",
-            }
-
-            if (isVision) {
-              headers["Copilot-Vision-Request"] = "true"
-            }
-
-            delete headers["x-api-key"]
-            delete headers["authorization"]
-
-            return fetch(request, {
-              ...init,
-              headers,
-            })
-          },
-        }
-      },
-      methods: [
-        {
-          type: "oauth",
-          label: "Login with GitHub Copilot",
-          prompts: [
-            {
-              type: "select",
-              key: "deploymentType",
-              message: "Select GitHub deployment type",
-              options: [
-                {
-                  label: "GitHub.com",
-                  value: "github.com",
-                  hint: "Public",
-                },
-                {
-                  label: "GitHub Enterprise",
-                  value: "enterprise",
-                  hint: "Data residency or self-hosted",
-                },
-              ],
-            },
-            {
-              type: "text",
-              key: "enterpriseUrl",
-              message: "Enter your GitHub Enterprise URL or domain",
-              placeholder: "company.ghe.com or https://company.ghe.com",
-              when: { key: "deploymentType", op: "eq", value: "enterprise" },
-              validate: (value) => {
-                if (!value) return "URL or domain is required"
-                try {
-                  const url = value.includes("://") ? new URL(value) : new URL(`https://${value}`)
-                  if (!url.hostname) return "Please enter a valid URL or domain"
-                  return undefined
-                } catch {
-                  return "Please enter a valid URL (e.g., company.ghe.com or https://company.ghe.com)"
-                }
-              },
-            },
-          ],
-          async authorize(inputs = {}) {
-            const deploymentType = inputs.deploymentType || "github.com"
-
-            let domain = "github.com"
-
-            if (deploymentType === "enterprise") {
-              const enterpriseUrl = inputs.enterpriseUrl
-              domain = normalizeDomain(enterpriseUrl!)
-            }
-
-            const urls = getUrls(domain)
-
-            const deviceResponse = await fetch(urls.DEVICE_CODE_URL, {
-              method: "POST",
-              headers: {
-                Accept: "application/json",
-                "Content-Type": "application/json",
-                "User-Agent": `opencode/${InstallationVersion}`,
-              },
-              body: JSON.stringify({
-                client_id: CLIENT_ID,
-                scope: "read:user",
-              }),
-            })
-
-            if (!deviceResponse.ok) {
-              throw new Error("Failed to initiate device authorization")
-            }
-
-            const deviceData = (await deviceResponse.json()) as {
-              verification_uri: string
-              user_code: string
-              device_code: string
-              interval: number
-            }
-
-            return {
-              url: deviceData.verification_uri,
-              instructions: `Enter code: ${deviceData.user_code}`,
-              method: "auto" as const,
-              async callback() {
-                while (true) {
-                  const response = await fetch(urls.ACCESS_TOKEN_URL, {
-                    method: "POST",
-                    headers: {
-                      Accept: "application/json",
-                      "Content-Type": "application/json",
-                      "User-Agent": `opencode/${InstallationVersion}`,
-                    },
-                    body: JSON.stringify({
-                      client_id: CLIENT_ID,
-                      device_code: deviceData.device_code,
-                      grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-                    }),
-                  })
-
-                  if (!response.ok) return { type: "failed" as const }
-
-                  const data = (await response.json()) as {
-                    access_token?: string
-                    error?: string
-                    interval?: number
-                  }
-
-                  if (data.access_token) {
-                    const result: {
-                      type: "success"
-                      refresh: string
-                      access: string
-                      expires: number
-                      provider?: string
-                      enterpriseUrl?: string
-                    } = {
-                      type: "success",
-                      refresh: data.access_token,
-                      access: data.access_token,
-                      expires: 0,
-                    }
-
-                    if (deploymentType === "enterprise") {
-                      result.enterpriseUrl = domain
-                    }
-
-                    return result
-                  }
-
-                  if (data.error === "authorization_pending") {
-                    await sleep(deviceData.interval * 1000 + OAUTH_POLLING_SAFETY_MARGIN_MS)
-                    continue
-                  }
-
-                  if (data.error === "slow_down") {
-                    // Based on the RFC spec, we must add 5 seconds to our current polling interval.
-                    // (See https://www.rfc-editor.org/rfc/rfc8628#section-3.5)
-                    let newInterval = (deviceData.interval + 5) * 1000
-
-                    // GitHub OAuth API may return the new interval in seconds in the response.
-                    // We should try to use that if provided with safety margin.
-                    const serverInterval = data.interval
-                    if (serverInterval && typeof serverInterval === "number" && serverInterval > 0) {
-                      newInterval = serverInterval * 1000
-                    }
-
-                    await sleep(newInterval + OAUTH_POLLING_SAFETY_MARGIN_MS)
-                    continue
-                  }
-
-                  if (data.error) return { type: "failed" as const }
-
-                  await sleep(deviceData.interval * 1000 + OAUTH_POLLING_SAFETY_MARGIN_MS)
-                  continue
-                }
-              },
-            }
-          },
-        },
-      ],
-    },
-    "chat.params": async (incoming, output) => {
-      if (!incoming.model.providerID.includes("github-copilot")) return
-
-      // Match github copilot cli, omit maxOutputTokens for gpt models
-      if (incoming.model.api.id.includes("gpt")) {
-        output.maxOutputTokens = undefined
-      }
-
-      // GitHub Copilot's /v1/messages shim rejects the GA `eager_input_streaming`
-      // field on tool definitions ("Extra inputs are not permitted"). Opt out of
-      // the @ai-sdk/anthropic default so it stops injecting the field.
-      if (incoming.model.api.npm === "@ai-sdk/anthropic") {
-        output.options.toolStreaming = false
-      }
-    },
-    "experimental.provider.small_model": async (incoming, output) => {
-      if (incoming.provider.id !== "github-copilot") return
-      // GitHub exposes utility models for title generation without including them in the picker.
-      output.model = UTILITY_MODELS.map((id) => models[id]).find((model) => model !== undefined)
-    },
-    "chat.headers": async (incoming, output) => {
-      if (!incoming.model.providerID.includes("github-copilot")) return
-
-      output.headers["X-GitHub-Api-Version"] = API_VERSION
-      if (incoming.agent === "title") {
-        output.headers["X-Interaction-Type"] = "agent-session-name-generation"
-      }
-
-      if (incoming.model.api.npm === "@ai-sdk/anthropic") {
-        output.headers["anthropic-beta"] = "interleaved-thinking-2025-05-14"
-      }
-
-      const parts = await sdk.session
-        .message({
-          path: {
-            id: incoming.message.sessionID,
-            messageID: incoming.message.id,
-          },
-          query: {
-            directory: input.directory,
-          },
-          throwOnError: true,
-        })
-        .catch(() => undefined)
-
-      if (
-        parts?.data.parts?.some(
-          (part) =>
-            part.type === "compaction" ||
-            // Auto-compaction resumes via a synthetic user text part. Treat only
-            // that marked followup as agent-initiated so manual prompts stay user-initiated.
-            (part.type === "text" && part.synthetic && part.metadata?.compaction_continue === true),
-        )
-      ) {
-        output.headers["x-initiator"] = "agent"
-        return
-      }
-
-      const session = await sdk.session
-        .get({
-          path: {
-            id: incoming.sessionID,
-          },
-          query: {
-            directory: input.directory,
-          },
-          throwOnError: true,
-        })
-        .catch(() => undefined)
-      if (!session || !session.data.parentID) return
-      // mark subagent sessions as agent initiated matching standard that other copilot tools have
-      output.headers["x-initiator"] = "agent"
-    },
-  }
-}

package/src/plugin/github-copilot/models.ts

@@ -1,246 +0,0 @@
-import type { Model } from "@opencode-ai/sdk/v2"
-import { Option, Schema } from "effect"
-
-const item = Schema.Struct({
-  model_picker_enabled: Schema.Boolean,
-  id: Schema.String,
-  name: Schema.String,
-  // every version looks like: `{model.id}-YYYY-MM-DD`
-  version: Schema.String,
-  supported_endpoints: Schema.optional(Schema.Array(Schema.String)),
-  policy: Schema.optional(
-    Schema.Struct({
-      state: Schema.optional(Schema.String),
-    }),
-  ),
-  billing: Schema.optional(
-    Schema.Struct({
-      token_prices: Schema.optional(
-        Schema.Struct({
-          batch_size: Schema.Number,
-          default: Schema.Struct({
-            cache_price: Schema.Number,
-            input_price: Schema.Number,
-            output_price: Schema.Number,
-          }),
-        }),
-      ),
-    }),
-  ),
-  capabilities: Schema.Struct({
-    family: Schema.String,
-    limits: Schema.optional(
-      Schema.Struct({
-        max_context_window_tokens: Schema.optional(Schema.Number),
-        max_output_tokens: Schema.optional(Schema.Number),
-        max_prompt_tokens: Schema.optional(Schema.Number),
-        vision: Schema.optional(
-          Schema.Struct({
-            max_prompt_image_size: Schema.Number,
-            max_prompt_images: Schema.Number,
-            supported_media_types: Schema.Array(Schema.String),
-          }),
-        ),
-      }),
-    ),
-    supports: Schema.Struct({
-      adaptive_thinking: Schema.optional(Schema.Boolean),
-      max_thinking_budget: Schema.optional(Schema.Number),
-      min_thinking_budget: Schema.optional(Schema.Number),
-      reasoning_effort: Schema.optional(Schema.Array(Schema.String)),
-      streaming: Schema.optional(Schema.Boolean),
-      structured_outputs: Schema.optional(Schema.Boolean),
-      tool_calls: Schema.optional(Schema.Boolean),
-      vision: Schema.optional(Schema.Boolean),
-    }),
-  }),
-})
-
-export const schema = Schema.Struct({
-  data: Schema.Array(Schema.Unknown),
-})
-
-type Item = Schema.Schema.Type<typeof item>
-type SelectableItem = Item & {
-  capabilities: Item["capabilities"] & {
-    limits: NonNullable<Item["capabilities"]["limits"]> & {
-      max_output_tokens: number
-      max_prompt_tokens: number
-    }
-    supports: Item["capabilities"]["supports"] & {
-      tool_calls: boolean
-    }
-  }
-}
-const decodeModels = Schema.decodeUnknownSync(schema)
-const decodeItem = Schema.decodeUnknownOption(item)
-
-function build(key: string, remote: SelectableItem, url: string, prev?: Model): Model {
-  const reasoning =
-    !!remote.capabilities.supports.adaptive_thinking ||
-    !!remote.capabilities.supports.reasoning_effort?.length ||
-    remote.capabilities.supports.max_thinking_budget !== undefined ||
-    remote.capabilities.supports.min_thinking_budget !== undefined
-  const image =
-    (remote.capabilities.supports.vision ?? false) ||
-    (remote.capabilities.limits.vision?.supported_media_types ?? []).some((item) => item.startsWith("image/"))
-
-  const isMsgApi = remote.supported_endpoints?.includes("/v1/messages")
-  const prices = remote.billing?.token_prices
-  // Copilot prices are AIC per billing batch; OnlyCode stores USD per million tokens.
-  const usdPerMillion = prices ? 10_000 / prices.batch_size : 0
-
-  const model: Model = {
-    id: key,
-    providerID: "github-copilot",
-    api: {
-      id: remote.id,
-      url: isMsgApi ? `${url}/v1` : url,
-      npm: isMsgApi ? "@ai-sdk/anthropic" : "@ai-sdk/github-copilot",
-    },
-    // API response wins
-    status: "active",
-    limit: {
-      context: remote.capabilities.limits.max_context_window_tokens ?? remote.capabilities.limits.max_prompt_tokens,
-      input: remote.capabilities.limits.max_prompt_tokens,
-      output: remote.capabilities.limits.max_output_tokens,
-    },
-    capabilities: {
-      temperature: prev?.capabilities.temperature ?? true,
-      reasoning: prev?.capabilities.reasoning ?? reasoning,
-      attachment: prev?.capabilities.attachment ?? true,
-      toolcall: remote.capabilities.supports.tool_calls,
-      input: {
-        text: true,
-        audio: false,
-        image,
-        video: false,
-        pdf: false,
-      },
-      output: {
-        text: true,
-        audio: false,
-        image: false,
-        video: false,
-        pdf: false,
-      },
-      interleaved: false,
-    },
-    // existing wins
-    family: prev?.family ?? remote.capabilities.family,
-    name: prev?.name ?? remote.name,
-    cost: {
-      input: (prices?.default.input_price ?? 0) * usdPerMillion,
-      output: (prices?.default.output_price ?? 0) * usdPerMillion,
-      cache: {
-        read: (prices?.default.cache_price ?? 0) * usdPerMillion,
-        // `/models` exposes cached-input reads only; per-request billing accounts for cache writes.
-        write: 0,
-      },
-    },
-    options: prev?.options ?? {},
-    headers: prev?.headers ?? {},
-    release_date:
-      prev?.release_date ??
-      (remote.version.startsWith(`${remote.id}-`) ? remote.version.slice(remote.id.length + 1) : remote.version),
-  }
-
-  const efforts = remote.capabilities.supports.reasoning_effort
-  const variants: NonNullable<Model["variants"]> = {}
-  if (!isMsgApi && efforts?.length) {
-    efforts.forEach((effort) => {
-      variants[effort] = {
-        reasoningEffort: effort,
-        reasoningSummary: "auto",
-        include: ["reasoning.encrypted_content"],
-      }
-    })
-  } else {
-    if (efforts?.length && remote.capabilities.supports.adaptive_thinking) {
-      efforts.forEach((effort) => {
-        variants[effort] = {
-          thinking: {
-            type: "adaptive",
-            ...(model.api.id.includes("opus-4.7") ? { display: "summarized" } : {}),
-          },
-          effort,
-        }
-      })
-    } else if (remote.capabilities.supports.max_thinking_budget) {
-      const max = remote.capabilities.supports.max_thinking_budget
-      variants["max"] = {
-        thinking: {
-          type: "enabled",
-          budgetTokens: max - 1,
-        },
-      }
-      variants["high"] = {
-        thinking: {
-          type: "enabled",
-          budgetTokens: Math.floor(max / 2),
-        },
-      }
-    }
-  }
-  if (Object.keys(variants).length > 0) {
-    model.variants = variants
-  }
-
-  return model
-}
-
-function usable(item: Item): item is SelectableItem {
-  return (
-    item.policy?.state !== "disabled" &&
-    item.capabilities.limits?.max_output_tokens !== undefined &&
-    item.capabilities.limits.max_prompt_tokens !== undefined &&
-    item.capabilities.supports.tool_calls !== undefined
-  )
-}
-
-export async function get(
-  baseURL: string,
-  headers: HeadersInit = {},
-  existing: Record<string, Model> = {},
-): Promise<{ models: Record<string, Model>; pickerEnabled: Set<string> }> {
-  const data = await fetch(`${baseURL}/models`, {
-    headers,
-    signal: AbortSignal.timeout(5_000),
-  }).then(async (res) => {
-    if (!res.ok) {
-      throw new Error(`Failed to fetch models: ${res.status}`)
-    }
-    return decodeModels(await res.json())
-  })
-
-  const result = { ...existing }
-  const remote = new Map(
-    data.data.flatMap((raw) => {
-      const item = Option.getOrUndefined(decodeItem(raw))
-      return item && usable(item) ? ([[item.id, item]] as const) : []
-    }),
-  )
-
-  // prune existing models whose api.id isn't in the endpoint response
-  for (const [key, model] of Object.entries(result)) {
-    const m = remote.get(model.api.id)
-    if (!m) {
-      delete result[key]
-      continue
-    }
-    result[key] = build(key, m, baseURL, model)
-  }
-
-  // add new endpoint models not already keyed in result
-  for (const [id, m] of remote) {
-    if (id in result) continue
-    result[id] = build(id, m, baseURL)
-  }
-
-  return {
-    models: result,
-    pickerEnabled: new Set([...remote].filter(([, item]) => item.model_picker_enabled).map(([id]) => id)),
-  }
-}
-
-export * as CopilotModels from "./models"