alchemylab-opencode 1.0.7 → 1.0.9

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

@@ -1,361 +0,0 @@
-import type { Hooks, PluginInput } from "@opencode-ai/plugin"
-import type { Model } from "@opencode-ai/sdk/v2"
-import { Installation } from "@/installation"
-import { iife } from "@/util/iife"
-import { Log } from "../../util/log"
-import { setTimeout as sleep } from "node:timers/promises"
-import { CopilotModels } from "./models"
-
-const log = Log.create({ service: "plugin.copilot" })
-
-const CLIENT_ID = "Ov23li8tweQw6odWQebz"
-// 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"
-}
-
-function fix(model: Model): Model {
-  return {
-    ...model,
-    api: {
-      ...model.api,
-      npm: "@ai-sdk/github-copilot",
-    },
-  }
-}
-
-export async function CopilotAuthPlugin(input: PluginInput): Promise<Hooks> {
-  const sdk = input.client
-  return {
-    provider: {
-      id: "github-copilot",
-      async models(provider, ctx) {
-        if (ctx.auth?.type !== "oauth") {
-          return Object.fromEntries(Object.entries(provider.models).map(([id, model]) => [id, fix(model)]))
-        }
-
-        return CopilotModels.get(
-          base(ctx.auth.enterpriseUrl),
-          {
-            Authorization: `Bearer ${ctx.auth.refresh}`,
-            "User-Agent": `opencode/${Installation.VERSION}`,
-          },
-          provider.models,
-        ).catch((error) => {
-          log.error("failed to fetch copilot models", { error })
-          return Object.fromEntries(Object.entries(provider.models).map(([id, model]) => [id, fix(model)]))
-        })
-      },
-    },
-    auth: {
-      provider: "github-copilot",
-      async loader(getAuth) {
-        const info = await getAuth()
-        if (!info || info.type !== "oauth") return {}
-
-        const baseURL = base(info.enterpriseUrl)
-
-        return {
-          baseURL,
-          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 : request.toString()
-            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",
-                  }
-                }
-
-                // 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",
-                  }
-                }
-
-                // 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),
-                  }
-                }
-              } 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/${Installation.VERSION}`,
-              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/${Installation.VERSION}`,
-              },
-              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/${Installation.VERSION}`,
-                    },
-                    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
-      }
-    },
-    "chat.headers": async (incoming, output) => {
-      if (!incoming.model.providerID.includes("github-copilot")) return
-
-      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")) {
-        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/packages/opencode/src/plugin/github-copilot/models.ts

@@ -1,144 +0,0 @@
-import { z } from "zod"
-import type { Model } from "@opencode-ai/sdk/v2"
-
-export namespace CopilotModels {
-  export const schema = z.object({
-    data: z.array(
-      z.object({
-        model_picker_enabled: z.boolean(),
-        id: z.string(),
-        name: z.string(),
-        // every version looks like: `{model.id}-YYYY-MM-DD`
-        version: z.string(),
-        supported_endpoints: z.array(z.string()).optional(),
-        capabilities: z.object({
-          family: z.string(),
-          limits: z.object({
-            max_context_window_tokens: z.number(),
-            max_output_tokens: z.number(),
-            max_prompt_tokens: z.number(),
-            vision: z
-              .object({
-                max_prompt_image_size: z.number(),
-                max_prompt_images: z.number(),
-                supported_media_types: z.array(z.string()),
-              })
-              .optional(),
-          }),
-          supports: z.object({
-            adaptive_thinking: z.boolean().optional(),
-            max_thinking_budget: z.number().optional(),
-            min_thinking_budget: z.number().optional(),
-            reasoning_effort: z.array(z.string()).optional(),
-            streaming: z.boolean(),
-            structured_outputs: z.boolean().optional(),
-            tool_calls: z.boolean(),
-            vision: z.boolean().optional(),
-          }),
-        }),
-      }),
-    ),
-  })
-
-  type Item = z.infer<typeof schema>["data"][number]
-
-  function build(key: string, remote: Item, 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/"))
-
-    return {
-      id: key,
-      providerID: "github-copilot",
-      api: {
-        id: remote.id,
-        url,
-        npm: "@ai-sdk/github-copilot",
-      },
-      // API response wins
-      status: "active",
-      limit: {
-        context: remote.capabilities.limits.max_context_window_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: 0,
-        output: 0,
-        cache: { read: 0, 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),
-      variants: prev?.variants ?? {},
-    }
-  }
-
-  export async function get(
-    baseURL: string,
-    headers: HeadersInit = {},
-    existing: Record<string, Model> = {},
-  ): Promise<Record<string, Model>> {
-    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 schema.parse(await res.json())
-    })
-
-    const result = { ...existing }
-    const remote = new Map(data.data.filter((m) => m.model_picker_enabled).map((m) => [m.id, m] 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 result
-  }
-}