@stonerzju/opencode 1.2.16-offline.1

package/src/provider/auth.ts

@@ -0,0 +1,147 @@
+import { Instance } from "@/project/instance"
+import { Plugin } from "../plugin"
+import { map, filter, pipe, fromEntries, mapValues } from "remeda"
+import z from "zod"
+import { fn } from "@/util/fn"
+import type { AuthOuathResult, Hooks } from "@opencode-ai/plugin"
+import { NamedError } from "@opencode-ai/util/error"
+import { Auth } from "@/auth"
+
+export namespace ProviderAuth {
+  const state = Instance.state(async () => {
+    const methods = pipe(
+      await Plugin.list(),
+      filter((x) => x.auth?.provider !== undefined),
+      map((x) => [x.auth!.provider, x.auth!] as const),
+      fromEntries(),
+    )
+    return { methods, pending: {} as Record<string, AuthOuathResult> }
+  })
+
+  export const Method = z
+    .object({
+      type: z.union([z.literal("oauth"), z.literal("api")]),
+      label: z.string(),
+    })
+    .meta({
+      ref: "ProviderAuthMethod",
+    })
+  export type Method = z.infer<typeof Method>
+
+  export async function methods() {
+    const s = await state().then((x) => x.methods)
+    return mapValues(s, (x) =>
+      x.methods.map(
+        (y): Method => ({
+          type: y.type,
+          label: y.label,
+        }),
+      ),
+    )
+  }
+
+  export const Authorization = z
+    .object({
+      url: z.string(),
+      method: z.union([z.literal("auto"), z.literal("code")]),
+      instructions: z.string(),
+    })
+    .meta({
+      ref: "ProviderAuthAuthorization",
+    })
+  export type Authorization = z.infer<typeof Authorization>
+
+  export const authorize = fn(
+    z.object({
+      providerID: z.string(),
+      method: z.number(),
+    }),
+    async (input): Promise<Authorization | undefined> => {
+      const auth = await state().then((s) => s.methods[input.providerID])
+      const method = auth.methods[input.method]
+      if (method.type === "oauth") {
+        const result = await method.authorize()
+        await state().then((s) => (s.pending[input.providerID] = result))
+        return {
+          url: result.url,
+          method: result.method,
+          instructions: result.instructions,
+        }
+      }
+    },
+  )
+
+  export const callback = fn(
+    z.object({
+      providerID: z.string(),
+      method: z.number(),
+      code: z.string().optional(),
+    }),
+    async (input) => {
+      const match = await state().then((s) => s.pending[input.providerID])
+      if (!match) throw new OauthMissing({ providerID: input.providerID })
+      let result
+
+      if (match.method === "code") {
+        if (!input.code) throw new OauthCodeMissing({ providerID: input.providerID })
+        result = await match.callback(input.code)
+      }
+
+      if (match.method === "auto") {
+        result = await match.callback()
+      }
+
+      if (result?.type === "success") {
+        if ("key" in result) {
+          await Auth.set(input.providerID, {
+            type: "api",
+            key: result.key,
+          })
+        }
+        if ("refresh" in result) {
+          const info: Auth.Info = {
+            type: "oauth",
+            access: result.access,
+            refresh: result.refresh,
+            expires: result.expires,
+          }
+          if (result.accountId) {
+            info.accountId = result.accountId
+          }
+          await Auth.set(input.providerID, info)
+        }
+        return
+      }
+
+      throw new OauthCallbackFailed({})
+    },
+  )
+
+  export const api = fn(
+    z.object({
+      providerID: z.string(),
+      key: z.string(),
+    }),
+    async (input) => {
+      await Auth.set(input.providerID, {
+        type: "api",
+        key: input.key,
+      })
+    },
+  )
+
+  export const OauthMissing = NamedError.create(
+    "ProviderAuthOauthMissing",
+    z.object({
+      providerID: z.string(),
+    }),
+  )
+  export const OauthCodeMissing = NamedError.create(
+    "ProviderAuthOauthCodeMissing",
+    z.object({
+      providerID: z.string(),
+    }),
+  )
+
+  export const OauthCallbackFailed = NamedError.create("ProviderAuthOauthCallbackFailed", z.object({}))
+}

package/src/provider/error.ts

@@ -0,0 +1,189 @@
+import { APICallError } from "ai"
+import { STATUS_CODES } from "http"
+import { iife } from "@/util/iife"
+
+export namespace ProviderError {
+  // Adapted from overflow detection patterns in:
+  // https://github.com/badlogic/pi-mono/blob/main/packages/ai/src/utils/overflow.ts
+  const OVERFLOW_PATTERNS = [
+    /prompt is too long/i, // Anthropic
+    /input is too long for requested model/i, // Amazon Bedrock
+    /exceeds the context window/i, // OpenAI (Completions + Responses API message text)
+    /input token count.*exceeds the maximum/i, // Google (Gemini)
+    /maximum prompt length is \d+/i, // xAI (Grok)
+    /reduce the length of the messages/i, // Groq
+    /maximum context length is \d+ tokens/i, // OpenRouter, DeepSeek
+    /exceeds the limit of \d+/i, // GitHub Copilot
+    /exceeds the available context size/i, // llama.cpp server
+    /greater than the context length/i, // LM Studio
+    /context window exceeds limit/i, // MiniMax
+    /exceeded model token limit/i, // Kimi For Coding, Moonshot
+    /context[_ ]length[_ ]exceeded/i, // Generic fallback
+  ]
+
+  function isOpenAiErrorRetryable(e: APICallError) {
+    const status = e.statusCode
+    if (!status) return e.isRetryable
+    // openai sometimes returns 404 for models that are actually available
+    return status === 404 || e.isRetryable
+  }
+
+  // Providers not reliably handled in this function:
+  // - z.ai: can accept overflow silently (needs token-count/context-window checks)
+  function isOverflow(message: string) {
+    if (OVERFLOW_PATTERNS.some((p) => p.test(message))) return true
+
+    // Providers/status patterns handled outside of regex list:
+    // - Cerebras: often returns "400 (no body)" / "413 (no body)"
+    // - Mistral: often returns "400 (no body)" / "413 (no body)"
+    return /^4(00|13)\s*(status code)?\s*\(no body\)/i.test(message)
+  }
+
+  function error(providerID: string, error: APICallError) {
+    if (providerID.includes("github-copilot") && error.statusCode === 403) {
+      return "Please reauthenticate with the copilot provider to ensure your credentials work properly with OpenCode."
+    }
+
+    return error.message
+  }
+
+  function message(providerID: string, e: APICallError) {
+    return iife(() => {
+      const msg = e.message
+      if (msg === "") {
+        if (e.responseBody) return e.responseBody
+        if (e.statusCode) {
+          const err = STATUS_CODES[e.statusCode]
+          if (err) return err
+        }
+        return "Unknown error"
+      }
+
+      const transformed = error(providerID, e)
+      if (transformed !== msg) {
+        return transformed
+      }
+      if (!e.responseBody || (e.statusCode && msg !== STATUS_CODES[e.statusCode])) {
+        return msg
+      }
+
+      try {
+        const body = JSON.parse(e.responseBody)
+        // try to extract common error message fields
+        const errMsg = body.message || body.error || body.error?.message
+        if (errMsg && typeof errMsg === "string") {
+          return `${msg}: ${errMsg}`
+        }
+      } catch {}
+
+      return `${msg}: ${e.responseBody}`
+    }).trim()
+  }
+
+  function json(input: unknown) {
+    if (typeof input === "string") {
+      try {
+        const result = JSON.parse(input)
+        if (result && typeof result === "object") return result
+        return undefined
+      } catch {
+        return undefined
+      }
+    }
+    if (typeof input === "object" && input !== null) {
+      return input
+    }
+    return undefined
+  }
+
+  export type ParsedStreamError =
+    | {
+        type: "context_overflow"
+        message: string
+        responseBody: string
+      }
+    | {
+        type: "api_error"
+        message: string
+        isRetryable: false
+        responseBody: string
+      }
+
+  export function parseStreamError(input: unknown): ParsedStreamError | undefined {
+    const body = json(input)
+    if (!body) return
+
+    const responseBody = JSON.stringify(body)
+    if (body.type !== "error") return
+
+    switch (body?.error?.code) {
+      case "context_length_exceeded":
+        return {
+          type: "context_overflow",
+          message: "Input exceeds context window of this model",
+          responseBody,
+        }
+      case "insufficient_quota":
+        return {
+          type: "api_error",
+          message: "Quota exceeded. Check your plan and billing details.",
+          isRetryable: false,
+          responseBody,
+        }
+      case "usage_not_included":
+        return {
+          type: "api_error",
+          message: "To use Codex with your ChatGPT plan, upgrade to Plus: https://chatgpt.com/explore/plus.",
+          isRetryable: false,
+          responseBody,
+        }
+      case "invalid_prompt":
+        return {
+          type: "api_error",
+          message: typeof body?.error?.message === "string" ? body?.error?.message : "Invalid prompt.",
+          isRetryable: false,
+          responseBody,
+        }
+    }
+  }
+
+  export type ParsedAPICallError =
+    | {
+        type: "context_overflow"
+        message: string
+        responseBody?: string
+      }
+    | {
+        type: "api_error"
+        message: string
+        statusCode?: number
+        isRetryable: boolean
+        responseHeaders?: Record<string, string>
+        responseBody?: string
+        metadata?: Record<string, string>
+      }
+
+  export function parseAPICallError(input: { providerID: string; error: APICallError }): ParsedAPICallError {
+    const m = message(input.providerID, input.error)
+    if (isOverflow(m)) {
+      return {
+        type: "context_overflow",
+        message: m,
+        responseBody: input.error.responseBody,
+      }
+    }
+
+    const metadata = input.error.url ? { url: input.error.url } : undefined
+    return {
+      type: "api_error",
+      message: m,
+      statusCode: input.error.statusCode,
+      isRetryable: input.providerID.startsWith("openai")
+        ? isOpenAiErrorRetryable(input.error)
+        : input.error.isRetryable,
+      responseHeaders: input.error.responseHeaders,
+      responseBody: input.error.responseBody,
+      metadata,
+    }
+  }
+}

package/src/provider/models.ts

@@ -0,0 +1,146 @@
+import { Global } from "../global"
+import { Log } from "../util/log"
+import path from "path"
+import z from "zod"
+import { Installation } from "../installation"
+import { Flag } from "../flag/flag"
+import { lazy } from "@/util/lazy"
+import { Filesystem } from "../util/filesystem"
+
+// Try to import bundled snapshot (generated at build time)
+// Falls back to undefined in dev mode when snapshot doesn't exist
+/* @ts-ignore */
+
+export namespace ModelsDev {
+  const log = Log.create({ service: "models.dev" })
+  const filepath = path.join(Global.Path.cache, "models.json")
+
+  export const Model = z.object({
+    id: z.string(),
+    name: z.string(),
+    family: z.string().optional(),
+    release_date: z.string(),
+    attachment: z.boolean(),
+    reasoning: z.boolean(),
+    temperature: z.boolean(),
+    tool_call: z.boolean(),
+    interleaved: z
+      .union([
+        z.literal(true),
+        z
+          .object({
+            field: z.enum(["reasoning_content", "reasoning_details"]),
+          })
+          .strict(),
+      ])
+      .optional(),
+    cost: z
+      .object({
+        input: z.number(),
+        output: z.number(),
+        cache_read: z.number().optional(),
+        cache_write: z.number().optional(),
+        context_over_200k: z
+          .object({
+            input: z.number(),
+            output: z.number(),
+            cache_read: z.number().optional(),
+            cache_write: z.number().optional(),
+          })
+          .optional(),
+      })
+      .optional(),
+    limit: z.object({
+      context: z.number(),
+      input: z.number().optional(),
+      output: z.number(),
+    }),
+    modalities: z
+      .object({
+        input: z.array(z.enum(["text", "audio", "image", "video", "pdf"])),
+        output: z.array(z.enum(["text", "audio", "image", "video", "pdf"])),
+      })
+      .optional(),
+    experimental: z.boolean().optional(),
+    status: z.enum(["alpha", "beta", "deprecated"]).optional(),
+    options: z.record(z.string(), z.any()),
+    headers: z.record(z.string(), z.string()).optional(),
+    provider: z.object({ npm: z.string().optional(), api: z.string().optional() }).optional(),
+    variants: z.record(z.string(), z.record(z.string(), z.any())).optional(),
+  })
+  export type Model = z.infer<typeof Model>
+
+  export const Provider = z.object({
+    api: z.string().optional(),
+    name: z.string(),
+    env: z.array(z.string()),
+    id: z.string(),
+    npm: z.string().optional(),
+    models: z.record(z.string(), Model),
+  })
+
+  export type Provider = z.infer<typeof Provider>
+
+  function url() {
+    return Flag.OPENCODE_MODELS_URL || "https://models.dev"
+  }
+
+  export const Data = lazy(async () => {
+    const result = await Filesystem.readJson(Flag.OPENCODE_MODELS_PATH ?? filepath).catch(() => {})
+    if (result) return result
+    // @ts-ignore
+    const snapshot = await import("./models-snapshot")
+      .then((m) => m.snapshot as Record<string, unknown>)
+      .catch(() => undefined)
+    if (snapshot) return snapshot
+    if (Flag.OPENCODE_DISABLE_MODELS_FETCH) return {}
+    
+    // Offline mode: skip network fetch, return empty or cached data
+    if (process.env.OPENCODE_OFFLINE_MODE === "true") {
+      log.debug("offline mode: skipping models.dev fetch")
+      return {}
+    }
+    
+    const json = await fetch(`${url()}/api.json`).then((x) => x.text())
+    return JSON.parse(json)
+  })
+
+  export async function get() {
+    const result = await Data()
+    return result as Record<string, Provider>
+  }
+
+  export async function refresh() {
+    // Offline mode: skip network refresh
+    if (process.env.OPENCODE_OFFLINE_MODE === "true") {
+      log.debug("offline mode: skipping models.dev refresh")
+      return
+    }
+    
+    const result = await fetch(`${url()}/api.json`, {
+      headers: {
+        "User-Agent": Installation.USER_AGENT,
+      },
+      signal: AbortSignal.timeout(10 * 1000),
+    }).catch((e) => {
+      log.error("Failed to fetch models.dev", {
+        error: e,
+      })
+    })
+    if (result && result.ok) {
+      await Filesystem.write(filepath, await result.text())
+      ModelsDev.Data.reset()
+    }
+  }
+}
+
+// Disable auto-refresh in offline mode
+if (!Flag.OPENCODE_DISABLE_MODELS_FETCH && !process.argv.includes("--get-yargs-completions") && process.env.OPENCODE_OFFLINE_MODE !== "true") {
+  ModelsDev.refresh()
+  setInterval(
+    async () => {
+      await ModelsDev.refresh()
+    },
+    60 * 1000 * 60,
+  ).unref()
+}