@toddzheng024/dscode-desktop 0.0.0-stage → 0.7.34

package/plugins/memory/store.mjs

@@ -0,0 +1,93 @@
+import { DatabaseSync } from 'node:sqlite';
+import { mkdirSync, writeFileSync, renameSync, rmSync, chmodSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { digest, redact } from './content.mjs';
+
+export class MemoryStore {
+  constructor(root) {
+    this.root = root;
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    this.db = new DatabaseSync(join(root, 'state.sqlite'));
+    chmodSync(join(root, 'state.sqlite'), 0o600);
+    this.db.exec(`PRAGMA busy_timeout=3000; PRAGMA journal_mode=WAL;
+      CREATE TABLE IF NOT EXISTS kv (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS leases (key TEXT PRIMARY KEY, owner TEXT NOT NULL, expires INTEGER NOT NULL);
+      CREATE TABLE IF NOT EXISTS sessions (id TEXT PRIMARY KEY, enabled INTEGER NOT NULL DEFAULT 1);
+      CREATE TABLE IF NOT EXISTS jobs (id TEXT PRIMARY KEY, revision TEXT NOT NULL, retry INTEGER NOT NULL DEFAULT 0, failures INTEGER NOT NULL DEFAULT 0);
+      CREATE TABLE IF NOT EXISTS memories (id TEXT PRIMARY KEY, revision TEXT NOT NULL, cwd TEXT NOT NULL, value TEXT NOT NULL, generated INTEGER NOT NULL, used INTEGER NOT NULL, uses INTEGER NOT NULL DEFAULT 0);
+      CREATE TABLE IF NOT EXISTS notes (id TEXT PRIMARY KEY, text TEXT NOT NULL, created INTEGER NOT NULL);`);
+  }
+  get(key, fallback = null) { const row = this.db.prepare('SELECT value FROM kv WHERE key=?').get(key); return row ? JSON.parse(row.value) : fallback; }
+  set(key, value) { this.db.prepare('INSERT OR REPLACE INTO kv VALUES (?,?)').run(key, JSON.stringify(value)); }
+  acquire(key, owner, ttl, now = Date.now()) {
+    return this.db.prepare(`INSERT INTO leases VALUES (?,?,?) ON CONFLICT(key) DO UPDATE SET owner=excluded.owner,expires=excluded.expires WHERE leases.expires < ? OR leases.owner=excluded.owner`).run(key, owner, now + ttl, now).changes > 0;
+  }
+  owns(key, owner) { return !!this.db.prepare('SELECT 1 FROM leases WHERE key=? AND owner=? AND expires>=?').get(key, owner, Date.now()); }
+  release(key, owner) { this.db.prepare('DELETE FROM leases WHERE key=? AND owner=?').run(key, owner); }
+  cancelPipeline() { this.db.prepare('DELETE FROM leases WHERE key=?').run('pipeline'); }
+  active(id) { return !!this.db.prepare('SELECT 1 FROM leases WHERE key=? AND expires>=?').get(`session:${id}`, Date.now()); }
+  enabled(id) { return this.db.prepare('SELECT enabled FROM sessions WHERE id=?').get(id)?.enabled !== 0; }
+  enable(id, enabled) { this.db.prepare('INSERT OR REPLACE INTO sessions VALUES (?,?)').run(id, +enabled); }
+  pending(id, revision) { const job = this.db.prepare('SELECT * FROM jobs WHERE id=?').get(id); return !job || job.revision !== revision || job.retry > 0 && job.retry < Date.now(); }
+  failed(id, revision) {
+    const count = (this.db.prepare('SELECT failures FROM jobs WHERE id=?').get(id)?.failures ?? 0) + 1;
+    this.db.prepare('INSERT OR REPLACE INTO jobs VALUES (?,?,?,?)').run(id, revision, Date.now() + Math.min(86400000, 60000 * 2 ** Math.min(count, 10)), count);
+  }
+  save(id, revision, cwd, value) {
+    this.db.exec('BEGIN IMMEDIATE');
+    try {
+      this.db.prepare('INSERT OR REPLACE INTO jobs VALUES (?,?,0,0)').run(id, revision);
+      if (value.raw_memory.trim()) this.db.prepare(`INSERT INTO memories VALUES (?,?,?,?,?,?,0) ON CONFLICT(id) DO UPDATE SET revision=excluded.revision,cwd=excluded.cwd,value=excluded.value,generated=excluded.generated`).run(id, revision, cwd, JSON.stringify(value), Date.now(), Date.now());
+      else this.db.prepare('DELETE FROM memories WHERE id=?').run(id);
+      this.db.exec('COMMIT');
+    } catch (error) { this.db.exec('ROLLBACK'); throw error; }
+  }
+  candidates(days, limit) {
+    return this.db.prepare(`SELECT m.* FROM memories m LEFT JOIN sessions s ON s.id=m.id WHERE COALESCE(s.enabled,1)=1 AND MAX(m.used,m.generated)>=? ORDER BY m.uses DESC,MAX(m.used,m.generated) DESC LIMIT ?`).all(Date.now() - days * 86400000, limit).map(row => ({ ...row, value: JSON.parse(row.value) }));
+  }
+  prune(days) { this.db.prepare('DELETE FROM memories WHERE MAX(used,generated)<?').run(Date.now() - days * 86400000); }
+  recordCall(call) {
+    const stats = this.get('usage', { calls: 0, inputTokens: 0, outputTokens: 0, unknownUsage: 0 });
+    stats.calls++; stats.inputTokens += call.usage?.inputTokens ?? 0; stats.outputTokens += call.usage?.outputTokens ?? 0;
+    if (!call.usage) stats.unknownUsage++;
+    this.set('usage', { ...stats, last: call });
+  }
+  touch(ids) { for (const id of ids) this.db.prepare('UPDATE memories SET used=?,uses=uses+1 WHERE id=?').run(Date.now(), id); }
+  note(text) { const id = `note:${randomUUID()}`; this.db.prepare('INSERT INTO notes VALUES (?,?,?)').run(id, redact(text.slice(0, 4000)), Date.now()); return id; }
+  notes() { return this.db.prepare('SELECT * FROM notes ORDER BY created DESC LIMIT 32').all(); }
+  publish(snapshot, fingerprint) {
+    this.db.exec('BEGIN IMMEDIATE');
+    try { this.set('snapshot', snapshot); this.set('fingerprint', fingerprint); this.db.exec('COMMIT'); }
+    catch (error) { this.db.exec('ROLLBACK'); throw error; }
+    this.materialize(snapshot);
+  }
+  materialize(snapshot = this.get('snapshot')) {
+    if (!snapshot) return;
+    const write = (path, text) => {
+      const tmp = `${path}.${randomUUID()}.tmp`;
+      writeFileSync(tmp, text, { mode: 0o600 }); renameSync(tmp, path);
+    };
+    const cite = ids => ids.map(id => `source: ${id}`).join(', ');
+    write(join(this.root, 'memory_summary.md'), snapshot.summary + '\n');
+    write(join(this.root, 'MEMORY.md'), snapshot.entries.map(e => `## ${e.title}\n\n${e.body}\n\n${cite(e.sources)}`).join('\n\n') + '\n');
+    write(join(this.root, 'raw_memories.md'), snapshot.candidates.map(c => `## ${c.id}\nWorkspace: ${c.cwd}\n\n${c.value.raw_memory}`).join('\n\n'));
+    // These two directories contain generated files only. The DB snapshot is
+    // authoritative; interrupted materialization is repaired on the next run.
+    for (const dir of ['rollout_summaries', 'skills']) { rmSync(join(this.root, dir), { recursive: true, force: true }); mkdirSync(join(this.root, dir), { mode: 0o700 }); }
+    for (const c of snapshot.candidates) write(join(this.root, 'rollout_summaries', digest(c.id) + '.md'), `Session: ${c.id}\nWorkspace: ${c.cwd}\nMessage sequences: ${c.value.evidence.join(', ')}\n\n${c.value.rollout_summary}\n`);
+    for (const skill of snapshot.skills) {
+      const dir = join(this.root, 'skills', digest(skill.title).slice(0, 16)); mkdirSync(dir, { mode: 0o700 });
+      write(join(dir, 'SKILL.md'), `# ${skill.title}\n\n${skill.body}\n\n${cite(skill.sources)}\n`);
+    }
+  }
+  clear() {
+    this.db.exec('BEGIN IMMEDIATE');
+    try {
+      this.db.exec("DELETE FROM memories; DELETE FROM notes; DELETE FROM jobs; DELETE FROM kv WHERE key NOT IN ('use','generate'); DELETE FROM leases WHERE key='pipeline';");
+      this.set('clearedAt', Date.now()); this.db.exec('COMMIT');
+    } catch (error) { this.db.exec('ROLLBACK'); throw error; }
+    for (const file of ['MEMORY.md', 'memory_summary.md', 'raw_memories.md', 'rollout_summaries', 'skills']) rmSync(join(this.root, file), { recursive: true, force: true });
+  }
+  close() { this.db.close(); }
+}

package/plugins/message-source/kind.mjs

@@ -0,0 +1,20 @@
+/**
+ * Producer identity of one message source.
+ *
+ * DSH 0.1.7 retired the shared `plugin` kind: every producer now declares its own
+ * `kind`, and DSCODE's plugins name themselves the same way. Durable history carries two
+ * older shapes — the raw `{ kind: 'plugin', plugin: '<producer>' }` of a session written
+ * before the upgrade, and the `plugin:<producer>` kind the session format's v3-to-v4
+ * migration writes for a producer it does not know — so every reader of history resolves
+ * all three through this one function.
+ *
+ * @param source - a message source from any release.
+ * @returns the producing subsystem's name, or `''` when the source names none.
+ */
+export function producerKind(source) {
+  if (source === null || typeof source !== 'object') return '';
+  const { kind, plugin } = source;
+  if (kind === 'plugin') return typeof plugin === 'string' ? plugin : '';
+  if (typeof kind !== 'string') return '';
+  return kind.startsWith('plugin:') ? kind.slice('plugin:'.length) : kind;
+}

package/plugins/opencode-go/adapter.mjs

@@ -0,0 +1,96 @@
+import { LlmError, ReasoningEffortId, attributionHeaders } from '@deepseek-ai/dsh-llm';
+import { OpenRouterAdapter } from '../openrouter/adapter.mjs';
+import { effortInfo } from '../openrouter/wire.mjs';
+import { DEFAULT_CONTEXT_WINDOW, GO_MODELS, OTHER_PROTOCOL_MODELS, goModel } from './models.mjs';
+import { LABEL, PROVIDER, REPLAY_KIND, explainError, modelReasoning, requestBody } from './wire.mjs';
+
+export { PROVIDER };
+/** Output cap materialized when a caller names none. */
+export const DEFAULT_OUTPUT_CAP = 131072;
+const APP_URL = 'https://github.com/qiz029/dscode';
+
+function modelInfo(provider, id, entry) {
+  return { provider, id, name: entry?.name ?? id, inputModalities: entry?.inputModalities?.length ? [...entry.inputModalities] : ['text'] };
+}
+
+/**
+ * OpenCode Go chat completions as a harness adapter. The request loop, image handling and
+ * stream translation are OpenRouter's; this route supplies its own catalog, body, headers
+ * and the account login's endpoint. Go asks each client to name itself in the user agent and to send one stable
+ * `x-opencode-session` per conversation.
+ */
+export class OpenCodeGoAdapter extends OpenRouterAdapter {
+  /**
+   * @param config - `options()` connection facts, `resolveAccount()` (request auth from the account
+   *   login; throws when signed out), `version`, optional `resolveAttachments()`,
+   *   `resolveImageAccess(attachments, ref)` and `fetch`.
+   */
+  constructor(config) {
+    super({ ensureModels: async () => {}, ...config });
+  }
+
+  get label() {
+    return LABEL;
+  }
+
+  providerInfo(provider) {
+    return { id: provider, name: this.config.displayName ?? LABEL };
+  }
+
+  async listModels(provider) {
+    return [...GO_MODELS].map(([id, entry]) => modelInfo(provider, id, entry));
+  }
+
+  async resolveModel(provider, model) {
+    const entry = goModel(model);
+    const reasoning = modelReasoning(entry);
+    return {
+      ...modelInfo(provider, model, entry),
+      context: { contextWindow: entry?.contextWindow ?? DEFAULT_CONTEXT_WINDOW },
+      defaultMaxTokens: DEFAULT_OUTPUT_CAP,
+      ...(reasoning ? { reasoning: {
+        efforts: reasoning.levels.map(id => ({ ...effortInfo(id), id: ReasoningEffortId(id) })),
+        defaultEffort: ReasoningEffortId(reasoning.defaultEffort),
+      } } : {}),
+    };
+  }
+
+  async modelEntry(model) {
+    const protocol = OTHER_PROTOCOL_MODELS.get(model);
+    if (protocol !== undefined) {
+      throw new LlmError(`${LABEL} serves "${model}" over its ${protocol} endpoint, which DSCODE does not support yet; pick a model from /model`, 'INVALID_REQUEST');
+    }
+    return goModel(model);
+  }
+
+  requestBody(options, context) {
+    return requestBody(options, context);
+  }
+
+  /** The OpenCode account login: the endpoint it names, its token and its organisation header. */
+  async resolveAuth() {
+    return this.config.resolveAccount();
+  }
+
+  requestHeaders(options) {
+    return {
+      ...attributionHeaders({ product: 'dscode', version: this.config.version ?? '0.0.0', url: APP_URL }),
+      ...(options.sessionId !== undefined ? { 'x-opencode-session': String(options.sessionId).slice(0, 256) } : {}),
+    };
+  }
+
+  translateOptions(options) {
+    return { model: options.model, kind: REPLAY_KIND, label: LABEL };
+  }
+
+  async *stream(options) {
+    try {
+      yield* super.stream(options);
+    } catch (error) {
+      const explained = error instanceof LlmError ? explainError(error.message) : undefined;
+      if (explained === undefined || explained === error.message) throw error;
+      const status = error.failure?.status;
+      throw new LlmError(explained, error.code, { cause: error, ...(status === undefined ? {} : { status }) });
+    }
+  }
+}

package/plugins/opencode-go/command.mjs

@@ -0,0 +1,128 @@
+import { t } from '../i18n/messages.mjs';
+import { openBrowser } from '../account/index.mjs';
+import { completeGrant, grantSummary, pollDeviceToken, startDeviceLogin } from './oauth.mjs';
+
+// `/opencode`: sign in to OpenCode Go with an OpenCode account. A command settles with one
+// result and cannot print while it waits, and the device flow needs the code in front of the
+// user before approval, so `login` answers at once with the code and URL and keeps polling
+// in the background; `/opencode` reports how it ended.
+
+const ok = text => ({ kind: 'success', text });
+const fail = text => ({ kind: 'error', text });
+const who = summary => [summary.email, summary.orgName].filter(Boolean).join(' · ') || 'OpenCode account';
+
+/**
+ * The login state machine behind the command, kept apart so a test can drive it with fakes.
+ * @param deps - `store` (`write`, `remove`), `grant()` for the stored grant, optional `onSignedIn()`,
+ *   `fetch`, `open(url)`, `sleep(ms)`, `now()` and `log(message)`.
+ */
+export class OpenCodeLogin {
+  constructor(deps) {
+    this.deps = deps;
+    this.attempt = undefined;
+    this.outcome = undefined;
+  }
+
+  now() {
+    return this.deps.now?.() ?? Date.now();
+  }
+
+  /** Status lines: the stored login, an attempt in flight, the last outcome. */
+  async status(locale) {
+    const lines = [];
+    if (this.attempt !== undefined) lines.push(t(locale, 'opencode.pending', { code: this.attempt.device.userCode }), this.attempt.device.url);
+    else if (this.outcome !== undefined) lines.push(this.outcome);
+    const grant = await this.deps.grant();
+    if (grant !== undefined) {
+      const summary = grantSummary(grant, this.now());
+      lines.push(t(locale, 'opencode.signedIn', { who: who(summary), days: summary.expiresInDays }));
+    } else if (this.attempt === undefined) lines.push(t(locale, 'opencode.signedOut'));
+    return lines;
+  }
+
+  /** Start a login, or show the one already waiting. */
+  async login(locale) {
+    if (this.attempt !== undefined) return { ok: true, lines: await this.status(locale) };
+    let device;
+    try {
+      device = await startDeviceLogin({ ...(this.deps.fetch ? { fetch: this.deps.fetch } : {}), now: this.now() });
+    } catch (error) {
+      return { ok: false, lines: [t(locale, 'opencode.startFailed', { reason: error.message })] };
+    }
+    const controller = new AbortController();
+    const attempt = { device, controller };
+    this.attempt = attempt;
+    this.outcome = undefined;
+    attempt.done = this.follow(attempt, locale);
+    const opened = await (this.deps.open ?? openBrowser)(device.url);
+    return {
+      ok: true,
+      lines: [
+        t(locale, 'opencode.started', { code: device.userCode, minutes: Math.max(1, Math.round((device.expiresAt - this.now()) / 60000)) }),
+        t(locale, opened ? 'opencode.browserOpened' : 'opencode.browserManual'),
+        device.url,
+      ],
+    };
+  }
+
+  /** Poll to the end, store the grant on approval, and record how it ended. */
+  async follow(attempt, locale) {
+    const options = { ...(this.deps.fetch ? { fetch: this.deps.fetch } : {}), signal: attempt.controller.signal, ...(this.deps.sleep ? { sleep: this.deps.sleep } : {}), now: () => this.now() };
+    try {
+      const token = await pollDeviceToken(attempt.device, options);
+      const grant = await completeGrant(token, { ...(this.deps.fetch ? { fetch: this.deps.fetch } : {}), now: this.now() });
+      await this.deps.store.write(JSON.stringify(grant));
+      this.outcome = t(locale, 'opencode.succeeded', { who: who(grantSummary(grant, this.now())) });
+      this.deps.log?.('signed in');
+      this.deps.onSignedIn?.();
+    } catch (error) {
+      this.outcome = attempt.controller.signal.aborted ? t(locale, 'opencode.cancelled') : t(locale, 'opencode.failed', { reason: error.message });
+      this.deps.log?.(`sign-in did not complete: ${error.message}`);
+    } finally {
+      if (this.attempt === attempt) this.attempt = undefined;
+    }
+  }
+
+  cancel(locale) {
+    const attempt = this.attempt;
+    if (attempt === undefined) return t(locale, 'opencode.nothingToCancel');
+    attempt.controller.abort(new Error('cancelled'));
+    this.attempt = undefined;
+    this.outcome = t(locale, 'opencode.cancelled');
+    return this.outcome;
+  }
+
+  async logout(locale) {
+    this.attempt?.controller.abort(new Error('signed out'));
+    this.attempt = undefined;
+    this.outcome = undefined;
+    await this.deps.store.remove();
+    return t(locale, 'opencode.loggedOut');
+  }
+
+  dispose() {
+    this.attempt?.controller.abort(new Error('disposed'));
+    this.attempt = undefined;
+  }
+}
+
+/** The `/opencode` command descriptor over one login machine. */
+export function openCodeCommand(login, language) {
+  return {
+    name: 'opencode',
+    description: 'Sign in to OpenCode Go with an OpenCode account, or read the login (/opencode [login|cancel|logout])',
+    input: { hint: '[login|cancel|logout]' },
+    handler: async ({ rawInput }) => {
+      const locale = language();
+      const argument = String(rawInput ?? '').trim().toLowerCase();
+      if (argument === '' || argument === 'status') return ok((await login.status(locale)).join('\n'));
+      if (argument === 'login' || argument === 'signin' || argument === 'sign-in') {
+        const result = await login.login(locale);
+        return (result.ok ? ok : fail)(result.lines.join('\n'));
+      }
+      if (argument === 'cancel') return ok(login.cancel(locale));
+      if (argument === 'logout' || argument === 'signout' || argument === 'sign-out') return ok(await login.logout(locale));
+      return fail(t(locale, 'opencode.usage'));
+    },
+  };
+}

package/plugins/opencode-go/index.mjs

@@ -0,0 +1,121 @@
+import { resolveDshHome } from '@deepseek-ai/dsh-home-paths';
+import z from '@deepseek-ai/schemastery';
+import { LlmError, RetryPolicySchema, resolveImageAttachmentAccess, resolveRetryPolicy } from '@deepseek-ai/dsh-llm';
+import { credentialRef } from '@deepseek-ai/dsh-credentials';
+import { deepEqualJson } from '@deepseek-ai/dsh-util-values';
+import { plainConfig } from '../cordis-config/plain.mjs';
+import { OpenCodeGoAdapter, PROVIDER } from './adapter.mjs';
+import { dscodeVersion } from './version.mjs';
+import { GRANT_REF, GrantSession } from './oauth.mjs';
+import { OpenCodeLogin, openCodeCommand } from './command.mjs';
+import { GO_USAGE_TTL_MS, clearGoUsage, currentGoUsage } from './usage.mjs';
+import { readLanguage } from '../i18n/messages.mjs';
+
+// The `opencode-go` route: the OpenCode Go subscription's chat-completions models through
+// DSCODE's OpenRouter request loop, authorised only by an OpenCode account login
+// (`/opencode login`, see oauth.mjs). The login names the account's own inference endpoint,
+// which also answers the subscription's usage for the status line (usage.mjs).
+export const name = 'dscode-opencode-go';
+export const inject = ['llm'];
+const NS = 'llm-opencode-go';
+/** Where requests go before a login names the account's endpoint; used only in messages. */
+const DEFAULT_BASE_URL = 'https://opencode.ai/inference/go/openai/v1';
+
+// The route's credential reference is the login itself: `/provider` reads its status from
+// here, and the credential store describes it as read-only so no key form is ever offered.
+// Each `.volatile()` field arrives as a reference the Settings form and a profile edit both
+// write, so every read below sees the current value.
+export const Config = z.object({
+  providerName: z.union(['opencode-go', 'dscode-opencode-go']).default('opencode-go'),
+  apiKeyEnv: z.string().role('credential-ref').default(GRANT_REF).volatile(),
+  streamIdleTimeoutMs: z.number().min(1).default(300000).volatile(),
+  maxRequestImageBytes: z.number().step(1).min(1).default(20 * 1024 * 1024).volatile(),
+  retryPolicy: RetryPolicySchema.volatile(),
+});
+
+/** Validated connection facts from one config snapshot. */
+export function resolveOptions(config = {}) {
+  const streamIdleTimeoutMs = config.streamIdleTimeoutMs ?? 300000;
+  if (!Number.isFinite(streamIdleTimeoutMs) || streamIdleTimeoutMs <= 0) throw new Error(`${name}: streamIdleTimeoutMs must be a positive number`);
+  return {
+    apiKeyEnv: credentialRef(config.apiKeyEnv || GRANT_REF),
+    baseURL: DEFAULT_BASE_URL,
+    streamIdleTimeoutMs,
+    maxRequestImageBytes: config.maxRequestImageBytes ?? 20 * 1024 * 1024,
+    retryPolicy: resolveRetryPolicy(config.retryPolicy, `${name}: retryPolicy`),
+  };
+}
+
+export function apply(ctx, config = {}) {
+  const provider = config.providerName ?? PROVIDER;
+  const displayName = provider === 'dscode-opencode-go' ? 'DSCODE OpenCode Go' : 'OpenCode Go';
+  // `/opencode` owns the login, so Settings must not generate a form for this entry.
+  ctx.inject(['settings'], settingsCtx => {
+    settingsCtx.effect(() => settingsCtx.settings.configure({ auto: false }, ctx.fiber));
+  });
+  let lastGood;
+  const options = () => {
+    try {
+      lastGood = resolveOptions(plainConfig(config));
+      return lastGood;
+    } catch (error) {
+      if (lastGood === undefined) throw error;
+      ctx.logger.error(`${name}: keeping the last good configuration after an invalid edit`);
+      ctx.logger.error(error);
+      return lastGood;
+    }
+  };
+  options();
+  const home = resolveDshHome();
+  // The login lives in the shared credential store beside the provider keys.
+  const grants = {
+    read: async () => (await ctx.get('credentials')?.resolve(GRANT_REF))?.value || undefined,
+    write: value => ctx.get('credentials').set(GRANT_REF, value),
+    remove: async () => {
+      await ctx.get('credentials')?.unset(GRANT_REF);
+      clearGoUsage(home);
+    },
+  };
+  const session = new GrantSession(grants);
+  const signedIn = async () => {
+    const auth = await session.auth();
+    if (auth !== undefined) return auth;
+    throw new LlmError(`${name}: not signed in to OpenCode Go; run /opencode login`, 'MISSING_CREDENTIAL');
+  };
+  const adapter = new OpenCodeGoAdapter({
+    displayName,
+    options,
+    version: dscodeVersion(),
+    resolveAccount: signedIn,
+    resolveAttachments: () => ctx.get('attachments'),
+    resolveImageAccess: (attachments, ref) => resolveImageAttachmentAccess(attachments, hostPath => ctx.get('fs')?.processPathFromHostPath(hostPath), ref),
+  });
+  // Keep the subscription's usage fresh for the status line while signed in.
+  const refreshUsage = () => currentGoUsage({ home, resolveAuth: () => session.auth() });
+  const login = new OpenCodeLogin({
+    store: grants,
+    grant: () => session.current(),
+    onSignedIn: () => { void refreshUsage().catch(() => {}); },
+    log: message => ctx.logger.info(`${name}: ${message}`),
+  });
+  ctx.provide('dscodeOpenCodeLogin', login);
+  ctx.effect(() => () => login.dispose());
+  ctx.inject(['commands'], commandsCtx => {
+    commandsCtx.commands.register(openCodeCommand(login, () => readLanguage()));
+  });
+  ctx.llm.registerConfigurableProviders([{ provider, displayName, settingsNs: ctx.fiber.entry?.options.id ?? NS, settingsPath: [] }]);
+  const registration = ctx.llm.registerAdapter([provider], adapter);
+  // The retry policy is captured at registration: re-register when an edit changes it.
+  let registeredPolicy = options().retryPolicy;
+  ctx.on('loader/volatile-update', () => {
+    let policy;
+    try { policy = options().retryPolicy; } catch (error) { ctx.logger.warn(error); return; }
+    if (deepEqualJson(policy, registeredPolicy)) return;
+    registration.replace([provider]);
+    registeredPolicy = policy;
+  });
+  void refreshUsage().catch(() => {});
+  const timer = setInterval(() => { void refreshUsage().catch(() => {}); }, GO_USAGE_TTL_MS);
+  timer.unref?.();
+  ctx.effect(() => () => clearInterval(timer));
+}

package/plugins/opencode-go/models.mjs

@@ -0,0 +1,58 @@
+// The OpenCode Go catalog DSCODE serves. Go's `/models` listing names ids only, with no
+// context size, modalities or reasoning controls, and Go passes request fields through to
+// each upstream, so every fact below was probed against the live gateway (2026-09): which
+// `reasoning_effort` values each model accepts, whether it can switch thinking off, and
+// whether it accepts image input (a text-only model answers an image with HTTP 404).
+// Context windows follow each lab's published figure. DeepSeek needs the workspace's
+// Global region, so its rows follow DeepSeek's own API rather than a probe.
+
+/** Context assumed for a model the catalog does not size. */
+export const DEFAULT_CONTEXT_WINDOW = 262144;
+
+// Reasoning shapes: the harness efforts a model offers. `off` sends `none`; Ultra rides `max`.
+const SWITCHABLE = Object.freeze(['off', 'low', 'high', 'max', 'ultra']);
+const MANDATORY = Object.freeze(['low', 'high', 'max', 'ultra']);
+const NO_MAX = Object.freeze(['off', 'low', 'high']);
+const DEEPSEEK = Object.freeze(['high', 'max', 'ultra']);
+
+const model = (id, name, contextWindow, efforts, image = false) => [id, Object.freeze({ name, contextWindow, efforts, inputModalities: image ? ['text', 'image'] : ['text'] })];
+
+/** Chat-completions models in picker order. */
+export const GO_MODELS = new Map([
+  model('deepseek-v4-pro', 'DeepSeek V4 Pro', 1048576, DEEPSEEK),
+  model('deepseek-v4-flash', 'DeepSeek V4 Flash', 1048576, DEEPSEEK),
+  model('deepseek-v4.1-flash', 'DeepSeek V4.1 Flash', 1048576, DEEPSEEK, true),
+  model('deepseek-v4-flash-vision-exp', 'DeepSeek V4 Flash Vision Exp', 1048576, DEEPSEEK, true),
+  // GLM is thinking-only: `none` is refused.
+  model('glm-5.3', 'GLM-5.3', 1048576, MANDATORY),
+  model('glm-5.3-flash', 'GLM-5.3-Flash', 1048576, MANDATORY, true),
+  model('glm-5.2', 'GLM-5.2', 1048576, MANDATORY),
+  model('glm-5.1', 'GLM-5.1', 204800, MANDATORY),
+  model('kimi-k3', 'Kimi K3', 1048576, SWITCHABLE, true),
+  model('kimi-k2.7-code', 'Kimi K2.7 Code', 262144, MANDATORY, true),
+  model('kimi-k2.6', 'Kimi K2.6', 262144, SWITCHABLE, true),
+  // MiMo V2.6 refuses `max`.
+  model('mimo-v2.6-pro', 'MiMo-V2.6-Pro', 1048576, NO_MAX, true),
+  model('mimo-v2.6-flash', 'MiMo-V2.6-Flash', 1048576, NO_MAX, true),
+  model('mimo-v2.5-pro', 'MiMo-V2.5-Pro', 1048576, SWITCHABLE),
+  model('mimo-v2.5', 'MiMo-V2.5', 1048576, SWITCHABLE, true),
+  // LongCat accepts `none` but keeps thinking, so it offers no Off.
+  model('longcat-2.0', 'LongCat-2.0', 1048576, MANDATORY),
+  model('hy4-preview', 'Hy4 preview', 1048576, SWITCHABLE),
+  model('hy3', 'Hy3', 262144, SWITCHABLE),
+  model('space-bunny-free', 'Space Bunny Free', DEFAULT_CONTEXT_WINDOW, MANDATORY, true),
+]);
+
+/**
+ * Go models served over another protocol (Anthropic messages or OpenAI responses), which
+ * this route does not speak yet; asking for one fails before any request.
+ */
+export const OTHER_PROTOCOL_MODELS = Object.freeze(new Map([
+  ...['grok-4.7', 'grok-4.6', 'gpt-6-luna', 'gpt-5.6-luna', 'muse-spark-1.3-contributor', 'muse-spark-1.2-contributor'].map(id => [id, 'responses']),
+  ...['minimax-m3', 'minimax-m2.7', 'minimax-m2.5', 'qwen3.8-max', 'qwen3.8-flash', 'qwen3.7-max', 'qwen3.7-plus', 'qwen3.6-plus'].map(id => [id, 'messages']),
+]));
+
+/** One model's catalog entry, or undefined for an id the catalog does not describe. */
+export function goModel(id) {
+  return GO_MODELS.get(id);
+}