@subrouter/opencode 0.1.0 → 0.3.0

package/src/opencode-e2e.test.ts

@@ -2,7 +2,7 @@
  * End-to-end test: a real opencode server drives the subrouter provider.
  *
  * No real API requests. Fake HTTP servers play the provider endpoints:
- * anthropic always answers 429 (rate limited), the opencode zen mock streams
+ * anthropic always answers 429 (rate limited), the opencode-go mock streams
  * a canned completion. The test prompts opencode with model subrouter/default
  * and asserts the reply came from the fallback provider, proving the cycling
  * works through the whole opencode -> provider -> router pipeline.
@@ -10,14 +10,58 @@
  * Requires built dist (pnpm build) because opencode loads dist/provider.js.
  */
 
-import { createOpencodeClient } from '@opencode-ai/sdk'
+import { createOpencodeClient, type Event } from '@opencode-ai/sdk'
 import { createOpencodeServer } from '@opencode-ai/sdk/server'
 import { createServer, type Server } from 'node:http'
-import { mkdtemp, rm, writeFile, mkdir } from 'node:fs/promises'
+import { mkdtemp, rm, mkdir } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import path from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { afterAll, beforeAll, describe, expect, test } from 'vitest'
+import {
+  OPENAI_WEBSOCKET_SESSION_HEADER,
+  OPENAI_WEBSOCKET_TITLE_HEADER,
+  addAccount,
+  markCooldown,
+} from '@subrouter/cli'
+import { addSubrouterHeaders } from './provider.ts'
+
+function summarizeSessionEvents(events: Event[]) {
+  const summary: Array<{
+    type: string
+    status?: string
+    message?: string
+    name?: string
+    statusCode?: number
+    isRetryable?: boolean
+  }> = []
+  for (const event of events) {
+    if (event.type === 'session.status') {
+      const status = event.properties.status
+      summary.push({
+        type: event.type,
+        status: status.type,
+        message: status.type === 'retry' ? status.message : undefined,
+      })
+      continue
+    }
+    if (event.type === 'session.error') {
+      const error = event.properties.error
+      if (!error) continue
+      const message = typeof error.data.message === 'string' ? error.data.message : undefined
+      summary.push({
+        type: event.type,
+        name: error.name,
+        message,
+        statusCode: error.name === 'APIError' ? error.data.statusCode : undefined,
+        isRetryable: error.name === 'APIError' ? error.data.isRetryable : undefined,
+      })
+      continue
+    }
+    if (event.type === 'session.idle') summary.push({ type: event.type })
+  }
+  return summary
+}
 
 type MockServer = {
   url: string
@@ -59,7 +103,7 @@ async function startMockServer(
   }
 }
 
-function sseChunk(data: unknown) {
+function sseChunk(data: object) {
   return `data: ${JSON.stringify(data)}\n\n`
 }
 
@@ -81,7 +125,7 @@ beforeAll(async () => {
     res.end(JSON.stringify({ type: 'error', error: { type: 'rate_limit_error', message: 'rate limited' } }))
   })
 
-  // Fake opencode zen: streams a canned completion
+  // Fake opencode-go: streams a canned completion
   zenMock = await startMockServer(({ body }, res) => {
     const streaming = body.includes('"stream":true')
     if (!streaming) {
@@ -129,37 +173,11 @@ beforeAll(async () => {
   // Subrouter state: one rate-limited anthropic account + one zen key
   const subrouterHome = path.join(home, 'subrouter')
   await mkdir(subrouterHome, { recursive: true })
-  await writeFile(
-    path.join(subrouterHome, 'accounts.json'),
-    JSON.stringify({
-      version: 1,
-      providers: {
-        anthropic: {
-          activeIndex: 0,
-          accounts: [
-            {
-              type: 'oauth',
-              refresh: 'fake-refresh',
-              access: 'fake-access',
-              expires: Date.now() + 1_000_000_000,
-              email: 'a@x.com',
-              addedAt: 1,
-              lastUsed: 1,
-            },
-          ],
-        },
-        opencode: {
-          activeIndex: 0,
-          accounts: [{ type: 'api', key: 'zen-key', addedAt: 1, lastUsed: 1 }],
-        },
-      },
-    }),
-  )
 
   for (const [key, value] of Object.entries({
     SUBROUTER_HOME: subrouterHome,
     SUBROUTER_ANTHROPIC_BASE_URL: `${anthropicMock.url}/v1`,
-    SUBROUTER_OPENCODE_BASE_URL: `${zenMock.url}/v1`,
+    SUBROUTER_OPENCODE_GO_BASE_URL: `${zenMock.url}/v1`,
     // Isolate opencode from the user's real global config and auth
     XDG_CONFIG_HOME: path.join(home, 'xdg-config'),
     XDG_DATA_HOME: path.join(home, 'xdg-data'),
@@ -170,6 +188,23 @@ beforeAll(async () => {
     process.env[key] = value
   }
 
+  await addAccount({
+    provider: 'anthropic',
+    account: {
+      type: 'oauth',
+      refresh: 'fake-refresh',
+      access: 'fake-access',
+      expires: Date.now() + 1_000_000_000,
+      email: 'a@x.com',
+      addedAt: 1,
+      lastUsed: 1,
+    },
+  })
+  await addAccount({
+    provider: 'opencode-go',
+    account: { type: 'api', key: 'zen-key', addedAt: 1, lastUsed: 1 },
+  })
+
   const providerEntry = pathToFileURL(
     path.join(import.meta.dirname, '..', 'dist', 'provider.js'),
   ).href
@@ -208,6 +243,32 @@ afterAll(async () => {
 })
 
 describe('opencode + subrouter provider', () => {
+  test('adds session affinity headers for subrouter models', async () => {
+    const output = { headers: {} }
+    addSubrouterHeaders(
+      {
+        sessionID: 'session-1',
+        agent: 'build',
+        model: { providerID: 'subrouter' },
+      },
+      output,
+    )
+    expect(output.headers).toEqual({ [OPENAI_WEBSOCKET_SESSION_HEADER]: 'session-1' })
+
+    addSubrouterHeaders(
+      {
+        sessionID: 'session-2',
+        agent: 'title',
+        model: { providerID: 'subrouter' },
+      },
+      output,
+    )
+    expect(output.headers).toEqual({
+      [OPENAI_WEBSOCKET_SESSION_HEADER]: 'session-2',
+      [OPENAI_WEBSOCKET_TITLE_HEADER]: 'true',
+    })
+  })
+
   test('rate-limited provider is cycled to the fallback through opencode', async () => {
     const client = createOpencodeClient({ baseUrl: server.url })
 
@@ -229,7 +290,7 @@ describe('opencode + subrouter provider', () => {
     const parts = result.data?.parts ?? []
     const texts = parts
       .filter((part) => part.type === 'text')
-      .map((part) => (part as { text: string }).text)
+      .map((part) => part.text)
       .join('\n')
     expect(texts).toContain('hello from fallback')
 
@@ -237,4 +298,73 @@ describe('opencode + subrouter provider', () => {
     expect(anthropicMock.requests.length).toBeGreaterThan(0)
     expect(zenMock.requests.length).toBeGreaterThan(0)
   }, 120_000)
+
+  test('all cooling-down accounts retry through opencode instead of dying', async () => {
+    const untilMs = Date.now() + 2_000
+    await markCooldown({
+      provider: 'anthropic',
+      account: { type: 'oauth', refresh: 'fake-refresh', access: 'fake-access', email: 'a@x.com', addedAt: 1, lastUsed: 1 },
+      untilMs,
+    })
+    await markCooldown({
+      provider: 'opencode-go',
+      account: { type: 'api', key: 'zen-key', addedAt: 1, lastUsed: 1 },
+      untilMs,
+    })
+
+    const client = createOpencodeClient({ baseUrl: server.url })
+    const events: Event[] = []
+    const subscription = await client.event.subscribe({
+      query: { directory: projectDir },
+    })
+    void (async () => {
+      for await (const event of subscription.stream) {
+        events.push(event)
+      }
+    })()
+
+    const session = await client.session.create({
+      query: { directory: projectDir },
+      body: { title: 'subrouter cooldown retry' },
+    })
+    expect(session.data).toBeTruthy()
+
+    const result = await client.session.prompt({
+      path: { id: session.data!.id },
+      query: { directory: projectDir },
+      body: {
+        model: { providerID: 'subrouter', modelID: 'default' },
+        parts: [{ type: 'text', text: 'say hi' }],
+      },
+    })
+
+    const parts = result.data?.parts ?? []
+    const texts = parts
+      .filter((part) => part.type === 'text')
+      .map((part) => part.text)
+      .join('\n')
+    expect(texts).toContain('hello from fallback')
+
+    const summary = summarizeSessionEvents(events)
+    expect(summary.some((event) => event.status === 'retry')).toBe(true)
+    expect(summary.some((event) => event.name === 'UnknownError')).toBe(false)
+    expect(
+      summary.map((event) => {
+        if (event.status === 'retry') {
+          return { status: 'retry', coolingDown: event.message?.includes('cooling down') }
+        }
+        return event.status ?? event.type
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "busy",
+        "busy",
+        {
+          "coolingDown": true,
+          "status": "retry",
+        },
+        "busy",
+      ]
+    `)
+  }, 120_000)
 })

package/src/plugin.test.ts

@@ -1,36 +1,338 @@
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { createServer, type Server } from 'node:http'
+import { mkdtemp, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import path from 'node:path'
 import { afterEach, beforeEach, expect, test } from 'vitest'
-import type { PluginInput } from '@opencode-ai/plugin'
-import { subrouterPlugin } from './index.ts'
+import type { Config, PluginInput } from '@opencode-ai/plugin'
+import {
+  addAccount,
+  adapters,
+  loadAccounts,
+  PROVIDER_DISPLAY_NAME,
+  PROVIDER_IDS,
+  savePreset,
+  setSubrouterLog,
+} from '@subrouter/cli'
+import { subrouterAuthPlugin, subrouterPlugin } from './index.ts'
+import { revealRoutedModel, rewritePoweredByModelLine } from './provider.ts'
 
 let home: string
+const openServers: Server[] = []
+const pluginInput = {} as PluginInput
 
 beforeEach(async () => {
   home = await mkdtemp(path.join(tmpdir(), 'subrouter-plugin-'))
   process.env.SUBROUTER_HOME = home
+  process.env.SUBROUTER_MODELS_DEV_URL = await startFakeModelsDev()
 })
 
 afterEach(async () => {
+  setSubrouterLog(undefined)
   delete process.env.SUBROUTER_HOME
+  delete process.env.SUBROUTER_OPENAI_ISSUER_URL
+  delete process.env.SUBROUTER_MODELS_DEV_URL
+  for (const server of openServers.splice(0)) {
+    await new Promise<void>((resolve) => {
+      server.close(() => {
+        resolve()
+      })
+    })
+  }
   await rm(home, { recursive: true, force: true })
 })
 
+async function startFakeModelsDev(
+  providers: Record<
+    string,
+    {
+      models: Record<
+        string,
+        {
+          id: string
+          modalities?: { output?: string[] }
+          limit?: { context?: number; output?: number; input?: number }
+        }
+      >
+    }
+  > = {},
+) {
+  const payload = {
+    anthropic: { models: {} },
+    openai: { models: {} },
+    xai: { models: {} },
+    'opencode-go': { models: {} },
+    'github-copilot': { models: {} },
+    poe: { models: {} },
+    'minimax-coding-plan': { models: {} },
+    'kimi-for-coding': { models: {} },
+    'zai-coding-plan': { models: {} },
+    'alibaba-coding-plan': { models: {} },
+    ...providers,
+  }
+  const server = createServer((_req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' })
+    res.end(JSON.stringify(payload))
+  })
+  await new Promise<void>((resolve) => {
+    server.listen(0, '127.0.0.1', resolve)
+  })
+  const address = server.address()
+  if (typeof address === 'string' || !address) throw new Error('failed to bind fake models.dev')
+  openServers.push(server)
+  return `http://127.0.0.1:${address.port}`
+}
+
+/** Minimal stand-in for the OpenAI Codex device endpoints. */
+async function startFakeOpenAIIssuer() {
+  const server = createServer((req, res) => {
+    const url = new URL(req.url || '', 'http://localhost')
+    const send = (body: unknown) => {
+      res.writeHead(200, { 'Content-Type': 'application/json' })
+      res.end(JSON.stringify(body))
+    }
+    if (url.pathname === '/api/accounts/deviceauth/usercode') {
+      return send({ device_auth_id: 'dev-1', user_code: 'ABCD-9876', interval: '0' })
+    }
+    if (url.pathname === '/api/accounts/deviceauth/token') {
+      return send({ authorization_code: 'auth-code', code_verifier: 'verifier' })
+    }
+    if (url.pathname === '/oauth/token') {
+      const claims = Buffer.from(
+        JSON.stringify({ email: 'pool@example.com', chatgpt_account_id: 'acct-9' }),
+      ).toString('base64url')
+      return send({
+        access_token: 'access-9',
+        refresh_token: 'refresh-9',
+        expires_in: 3600,
+        id_token: `header.${claims}.signature`,
+      })
+    }
+    res.writeHead(404).end('{}')
+  })
+  await new Promise<void>((resolve) => {
+    server.listen(0, '127.0.0.1', resolve)
+  })
+  const address = server.address()
+  if (typeof address === 'string' || !address) throw new Error('failed to bind fake issuer')
+  openServers.push(server)
+  return `http://127.0.0.1:${address.port}`
+}
+
+function authMethod() {
+  return subrouterAuthPlugin(pluginInput).then((hooks) => {
+    const method = hooks.auth?.methods[0]
+    if (!method || method.type !== 'oauth') throw new Error('expected an oauth method')
+    return { provider: hooks.auth!.provider, method }
+  })
+}
+
 test('config hook registers the subrouter provider with preset models', async () => {
-  await writeFile(
-    path.join(home, 'presets.json'),
-    JSON.stringify({ version: 1, presets: { work: ['anthropic/claude-opus-4-6'] } }),
-  )
+  await savePreset({ name: 'work', models: ['anthropic/claude-opus-4-6'] })
 
-  const hooks = await subrouterPlugin({} as PluginInput)
+  const hooks = await subrouterPlugin(pluginInput)
   const config: Record<string, any> = {}
   await hooks.config?.(config as any)
 
   const provider = config.provider?.subrouter
   expect(provider).toBeTruthy()
+  expect(provider.name).toBe(PROVIDER_DISPLAY_NAME)
   expect(provider.npm.startsWith('file://')).toBe(true)
   expect(provider.npm.endsWith('provider.ts') || provider.npm.endsWith('provider.js')).toBe(true)
   expect(Object.keys(provider.models).sort()).toEqual(['default', 'work'])
+  expect(provider.models.default.name).toBe('default')
+  expect(provider.models.work.name).toBe('work')
   expect(provider.models.default.cost).toEqual({ input: 0, output: 0, cache_read: 0, cache_write: 0 })
+  expect(provider.models.default.limit).toEqual({ context: 200_000, output: 64_000 })
+  expect(provider.models.work.limit).toEqual({ context: 200_000, output: 64_000 })
+})
+
+test('preset model names show the first live candidate', async () => {
+  await addAccount({
+    provider: 'anthropic',
+    account: {
+      type: 'oauth',
+      refresh: 'refresh-1',
+      access: 'access-1',
+      expires: Date.now() + 60_000,
+      email: 'a@x.com',
+      addedAt: 1,
+      lastUsed: 1,
+    },
+  })
+  await savePreset({ name: 'work', models: ['anthropic/claude-opus-4-6'] })
+
+  const hooks = await subrouterPlugin(pluginInput)
+  const config: Config = {}
+  await hooks.config?.(config)
+
+  expect(config.provider?.subrouter?.name).toBe(PROVIDER_DISPLAY_NAME)
+  expect(config.provider?.subrouter?.models?.work?.name).toBe('work (claude-opus-4-6)')
+})
+
+test('preset model limits follow the first live candidate', async () => {
+  const modelId = adapters.anthropic.defaultModels[0]
+  if (!modelId) throw new Error('anthropic adapter has no default model')
+  process.env.SUBROUTER_MODELS_DEV_URL = await startFakeModelsDev({
+    anthropic: {
+      models: {
+        [modelId]: {
+          id: modelId,
+          modalities: { output: ['text'] },
+          limit: { context: 1_000_000, output: 128_000 },
+        },
+      },
+    },
+  })
+  await addAccount({
+    provider: 'anthropic',
+    account: {
+      type: 'oauth',
+      refresh: 'refresh-1',
+      access: 'access-1',
+      expires: Date.now() + 60_000,
+      email: 'a@x.com',
+      addedAt: 1,
+      lastUsed: 1,
+    },
+  })
+  await savePreset({ name: 'work', models: [`anthropic/${modelId}`] })
+
+  const hooks = await subrouterPlugin(pluginInput)
+  const config: Config = {}
+  await hooks.config?.(config)
+
+  expect(config.provider?.subrouter?.models?.work?.limit).toEqual({
+    context: 1_000_000,
+    output: 128_000,
+  })
+  expect(config.provider?.subrouter?.models?.default?.limit).toEqual({
+    context: 1_000_000,
+    output: 128_000,
+  })
+})
+
+test('preset models permit image and PDF attachments', async () => {
+  const hooks = await subrouterPlugin(pluginInput)
+  const config: Config = {}
+  await hooks.config?.(config)
+
+  expect(config.provider?.subrouter?.models?.default).toMatchObject({
+    attachment: true,
+    modalities: {
+      input: ['text', 'image', 'pdf'],
+      output: ['text'],
+    },
+  })
+})
+
+test('rewrites the OpenCode powered-by line to the routed candidate', () => {
+  const system = [
+    'You are powered by the model named build. The exact model ID is subrouter/build\n<env>\n  Working directory: /tmp\n</env>',
+  ]
+  rewritePoweredByModelLine({
+    system,
+    candidate: { provider: 'anthropic', modelId: 'claude-opus-4-6' },
+  })
+  expect(system[0]).toContain('You are powered by the model named claude-opus-4-6.')
+  expect(system[0]).toContain('The exact model ID is anthropic/claude-opus-4-6')
+  expect(system[0]).not.toContain('subrouter/build')
+})
+
+test('system transform rewrites the powered-by line to the live candidate', async () => {
+  await addAccount({
+    provider: 'anthropic',
+    account: {
+      type: 'oauth',
+      refresh: 'refresh-1',
+      access: 'access-1',
+      expires: Date.now() + 60_000,
+      email: 'a@x.com',
+      addedAt: 1,
+      lastUsed: 1,
+    },
+  })
+
+  const system = [
+    'You are powered by the model named build. The exact model ID is subrouter/build\n<env>\n  Working directory: /tmp\n</env>',
+  ]
+  await revealRoutedModel({ providerID: 'subrouter', preset: 'default', system })
+
+  const modelId = adapters.anthropic.defaultModels[0]
+  expect(system[0]).toContain(`You are powered by the model named ${modelId}.`)
+  expect(system[0]).toContain(`The exact model ID is anthropic/${modelId}`)
+  expect(system[0]).not.toContain('subrouter/build')
+})
+
+test('system transform leaves other providers unchanged', async () => {
+  const original =
+    'You are powered by the model named claude-opus-4-6. The exact model ID is anthropic/claude-opus-4-6'
+  const system = [original]
+  await revealRoutedModel({ providerID: 'anthropic', preset: 'claude-opus-4-6', system })
+  expect(system[0]).toBe(original)
+})
+
+test('auth hook asks which subscription to add before authorizing', async () => {
+  const { provider, method } = await authMethod()
+
+  expect(provider).toBe('subrouter')
+  const prompt = method.prompts?.[0]
+  expect(prompt?.type).toBe('select')
+  expect(prompt?.key).toBe('provider')
+  expect(prompt?.type === 'select' && prompt.options.map((o) => o.value)).toEqual([...PROVIDER_IDS])
+  const methodPrompt = method.prompts?.[1]
+  expect(methodPrompt?.type).toBe('select')
+  expect(methodPrompt?.key).toBe('method')
+  expect(methodPrompt?.type === 'select' && methodPrompt.options.map((o) => o.value)).toEqual([
+    'browser',
+    'device',
+  ])
+})
+
+test('authorize rejects a missing or unknown subscription', async () => {
+  const { method } = await authMethod()
+
+  await expect(method.authorize({})).rejects.toThrow(/Pick a subscription/)
+  await expect(method.authorize({ provider: 'nope' })).rejects.toThrow(/Pick a subscription/)
+})
+
+test('authorize dispatches to the chosen adapter and the callback pools the account', async () => {
+  process.env.SUBROUTER_OPENAI_ISSUER_URL = await startFakeOpenAIIssuer()
+  const { method } = await authMethod()
+
+  const result = await method.authorize({ provider: 'openai', method: 'device' })
+  expect(result.method).toBe('auto')
+  expect(result.instructions).toMatch(/code:\s*ABCD-9876/)
+
+  if (result.method !== 'auto') throw new Error('expected the device flow')
+  const credentials = await result.callback()
+
+  expect(credentials).toMatchObject({ type: 'success', access: 'access-9', refresh: 'refresh-9' })
+  const accounts = await loadAccounts()
+  expect(accounts.providers.openai?.accounts).toMatchObject([
+    { type: 'oauth', email: 'pool@example.com', accountId: 'acct-9' },
+  ])
+})
+
+test('opencode go asks for a pasted key and stores it as an api account', async () => {
+  const { method } = await authMethod()
+
+  const result = await method.authorize({ provider: 'opencode-go' })
+  expect(result.method).toBe('code')
+
+  if (result.method !== 'code') throw new Error('expected a pasted-key flow')
+  expect(await result.callback('go-key-1')).toMatchObject({ type: 'success', key: 'go-key-1' })
+
+  const accounts = await loadAccounts()
+  expect(accounts.providers['opencode-go']?.accounts).toMatchObject([{ type: 'api', key: 'go-key-1' }])
+})
+
+test('a failed login reports failure instead of pooling a broken account', async () => {
+  const { method } = await authMethod()
+
+  const result = await method.authorize({ provider: 'opencode-go' })
+  if (result.method !== 'code') throw new Error('expected a pasted-key flow')
+
+  expect(await result.callback('   ')).toEqual({ type: 'failed' })
+  const accounts = await loadAccounts()
+  expect(accounts.providers['opencode-go']).toBeUndefined()
 })

package/src/provider.ts

@@ -2,6 +2,53 @@
  * Provider entry loaded by opencode via `provider.subrouter.npm` (file:// URL).
  * OpenCode imports this module, calls the first export starting with `create`,
  * then `sdk.languageModel(modelId)` where modelId is a subrouter preset name.
+ * Also rewrites OpenCode's powered-by identity to the live routed model.
  */
 
+import {
+  OPENAI_WEBSOCKET_SESSION_HEADER,
+  OPENAI_WEBSOCKET_TITLE_HEADER,
+  PROVIDER_ID,
+  resolveActiveCandidate,
+} from '@subrouter/cli'
+
 export { createSubrouter } from '@subrouter/cli'
+
+const POWERED_BY_MODEL = /You are powered by the model named [^\n]+/
+
+export function rewritePoweredByModelLine({
+  system,
+  candidate,
+}: {
+  system: string[]
+  candidate: { provider: string; modelId: string }
+}) {
+  const line = `You are powered by the model named ${candidate.modelId}. The exact model ID is ${candidate.provider}/${candidate.modelId}`
+  for (let i = 0; i < system.length; i++) {
+    system[i] = system[i]!.replace(POWERED_BY_MODEL, line)
+  }
+}
+
+export async function revealRoutedModel({
+  providerID,
+  preset,
+  system,
+}: {
+  providerID: string
+  preset: string
+  system: string[]
+}) {
+  if (providerID !== PROVIDER_ID) return
+  const candidate = await resolveActiveCandidate(preset)
+  if (!candidate) return
+  rewritePoweredByModelLine({ system, candidate })
+}
+
+export function addSubrouterHeaders(
+  input: { sessionID: string; agent: string; model: { providerID: string } },
+  output: { headers: Record<string, string> },
+) {
+  if (input.model.providerID !== PROVIDER_ID) return
+  output.headers[OPENAI_WEBSOCKET_SESSION_HEADER] = input.sessionID
+  if (input.agent === 'title') output.headers[OPENAI_WEBSOCKET_TITLE_HEADER] = 'true'
+}