@subrouter/opencode 0.2.0 → 0.4.0

package/src/plugin.test.ts

@@ -1,23 +1,38 @@
+import childProcess from 'node:child_process'
 import { createServer, type Server } from 'node:http'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { mkdtemp, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import path from 'node:path'
+import util from 'node:util'
 import { afterEach, beforeEach, expect, test } from 'vitest'
-import type { PluginInput } from '@opencode-ai/plugin'
-import { loadAccounts, PROVIDER_IDS } from '@subrouter/cli'
+import type { Config, PluginInput } from '@opencode-ai/plugin'
+import { createOpencodeClient, type Event } from '@opencode-ai/sdk'
+import {
+  addAccount,
+  adapters,
+  loadAccounts,
+  PROVIDER_DISPLAY_NAME,
+  PROVIDER_IDS,
+  savePreset,
+} from '@subrouter/cli'
 import { subrouterAuthPlugin, subrouterPlugin } from './index.ts'
+import { revealRoutedModel, rewritePoweredByModelLine } from './provider.ts'
 
+const execFile = util.promisify(childProcess.execFile)
 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 () => {
   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(() => {
@@ -28,6 +43,51 @@ afterEach(async () => {
   await rm(home, { recursive: true, force: true })
 })
 
+async function startFakeModelsDev(
+  providers: Record<
+    string,
+    {
+      models: Record<
+        string,
+        {
+          id: string
+          attachment?: boolean
+          reasoning?: boolean
+          temperature?: boolean
+          tool_call?: boolean
+          modalities?: { input?: string[]; 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) => {
@@ -65,29 +125,379 @@ async function startFakeOpenAIIssuer() {
 }
 
 function authMethod() {
-  return subrouterAuthPlugin({} as PluginInput).then((hooks) => {
+  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('plugin load and config do not write stdout or stderr', async () => {
+  const script = "import('./src/index.ts').then(async ({ subrouterPlugin }) => { const hooks = await subrouterPlugin({}); await hooks.config?.({}) })"
+  const result = await execFile(process.execPath, ['--no-warnings', '--import', 'tsx', '--eval', script], {
+    cwd: process.cwd(),
+    env: process.env,
+  })
+  expect(result).toEqual({ stdout: '', stderr: '' })
+})
+
+test('provider log callback forwards only to client.app.log', async () => {
+  const received = Promise.withResolvers<object>()
+  const server = createServer((req, res) => {
+    const chunks: Buffer[] = []
+    req.on('data', (chunk: Buffer) => {
+      chunks.push(chunk)
+    })
+    req.on('end', () => {
+      received.resolve(JSON.parse(Buffer.concat(chunks).toString('utf8')) as object)
+      res.writeHead(200, { 'Content-Type': 'application/json' })
+      res.end('{}')
+    })
+  })
+  await new Promise<void>((resolve) => {
+    server.listen(0, '127.0.0.1', resolve)
+  })
+  openServers.push(server)
+  const address = server.address()
+  if (typeof address === 'string' || !address) throw new Error('failed to bind log server')
+  const client = createOpencodeClient({ baseUrl: `http://127.0.0.1:${address.port}` })
+  const hooks = await subrouterPlugin({ ...pluginInput, client })
+  const config: Config = {}
+  await hooks.config?.(config)
+  const log = config.provider?.subrouter?.options?.log
+  expect(log).toBeTypeOf('function')
+  if (typeof log !== 'function') throw new Error('expected provider log callback')
+  await log({
+    level: 'warn',
+    message: 'failover openai/gpt-5.5',
+    extra: { provider: 'openai', modelId: 'gpt-5.5' },
+  })
+  expect(await received.promise).toEqual({
+    service: 'subrouter',
+    level: 'warn',
+    message: 'failover openai/gpt-5.5',
+    extra: { provider: 'openai', modelId: 'gpt-5.5' },
+  })
+})
+
+test('cooldown fallback creates only a persisted ignored notice after idle', async () => {
+  const requests: Array<{ path: string; body: any }> = []
+  const server = createServer((req, res) => {
+    const chunks: Buffer[] = []
+    req.on('data', (chunk: Buffer) => chunks.push(chunk))
+    req.on('end', () => {
+      requests.push({
+        path: req.url ?? '',
+        body: JSON.parse(Buffer.concat(chunks).toString('utf8')),
+      })
+      res.writeHead(200, { 'Content-Type': 'application/json' })
+      res.end('{}')
+    })
+  })
+  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve))
+  openServers.push(server)
+  const address = server.address()
+  if (typeof address === 'string' || !address) throw new Error('failed to bind notification server')
+  const client = createOpencodeClient({ baseUrl: `http://127.0.0.1:${address.port}` })
+  const hooks = await subrouterPlugin({ ...pluginInput, client, directory: '/tmp/project' })
+  const config: Config = {}
+  await hooks.config?.(config)
+  const onCooldownFallback = config.provider?.subrouter?.options?.onCooldownFallback
+  expect(onCooldownFallback).toBeTypeOf('function')
+  if (typeof onCooldownFallback !== 'function') throw new Error('expected cooldown callback')
+
+  await onCooldownFallback({
+    sessionID: 'session-1',
+    agent: 'build',
+    variant: 'high',
+    preset: 'work',
+    preferred: { provider: 'xai', modelId: 'grok-4.6', retryAfterMs: 252_000 },
+    active: { provider: 'openai', modelId: 'gpt-5.6-sol' },
+  })
+  await onCooldownFallback({
+    sessionID: 'session-1',
+    agent: 'compaction',
+    preset: 'work',
+    preferred: { provider: 'xai', modelId: 'grok-4.6', retryAfterMs: 251_000 },
+    active: { provider: 'anthropic', modelId: 'claude-sonnet-5' },
+  })
+  const event: Event = {
+    type: 'session.idle',
+    properties: { sessionID: 'session-1' },
+  }
+  await hooks.event?.({ event })
+
+  expect(requests).toEqual([
+    {
+      path: '/session/session-1/message?directory=%2Ftmp%2Fproject',
+      body: {
+        noReply: true,
+        agent: 'build',
+        model: { providerID: 'subrouter', modelID: 'work' },
+        variant: 'high',
+        parts: [
+          {
+            type: 'text',
+            text: 'Subrouter: xai/grok-4.6 was rate limited. This message started with openai/gpt-5.6-sol.',
+            ignored: true,
+          },
+        ],
+      },
+    },
+  ])
+})
+
 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 stay stable when the routed candidate changes', 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')
+})
+
+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: { input: ['text', 'image', 'pdf'], output: ['text'] },
+          limit: { context: 1_000_000, input: 900_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,
+    input: 900_000,
+    output: 128_000,
+  })
+  expect(config.provider?.subrouter?.models?.default?.limit).toEqual({
+    context: 1_000_000,
+    input: 900_000,
+    output: 128_000,
+  })
+})
+
+test('preset model input modalities are the union of usable candidates', async () => {
+  process.env.SUBROUTER_MODELS_DEV_URL = await startFakeModelsDev({
+    openai: {
+      models: {
+        'gpt-pdf': {
+          id: 'gpt-pdf',
+          attachment: true,
+          modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+        },
+      },
+    },
+    'kimi-for-coding': {
+      models: {
+        'kimi-image': {
+          id: 'kimi-image',
+          attachment: true,
+          modalities: { input: ['text', 'image'], output: ['text'] },
+        },
+      },
+    },
+  })
+  await addAccount({
+    provider: 'openai',
+    account: {
+      type: 'oauth',
+      access: 'access-1',
+      refresh: 'refresh-1',
+      expires: Date.now() + 60_000,
+      addedAt: 1,
+      lastUsed: 1,
+    },
+  })
+  await addAccount({
+    provider: 'kimi',
+    account: { type: 'api', key: 'kimi-key', addedAt: 1, lastUsed: 1 },
+  })
+  await savePreset({ name: 'work', models: ['openai/gpt-pdf', 'kimi/kimi-image'] })
+
+  const hooks = await subrouterPlugin(pluginInput)
+  const config: Config = {}
+  await hooks.config?.(config)
+
+  expect(config.provider?.subrouter?.models?.work).toMatchObject({
+    attachment: true,
+    modalities: {
+      input: ['text', 'image', 'pdf'],
+      output: ['text'],
+    },
+  })
+})
+
+test('xAI presets do not advertise inline PDF support that its SDK cannot encode', async () => {
+  process.env.SUBROUTER_MODELS_DEV_URL = await startFakeModelsDev({
+    xai: {
+      models: {
+        'grok-pdf': {
+          id: 'grok-pdf',
+          attachment: true,
+          modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+        },
+      },
+    },
+  })
+  await addAccount({
+    provider: 'xai',
+    account: {
+      type: 'oauth',
+      access: 'access-1',
+      refresh: 'refresh-1',
+      expires: Date.now() + 60_000,
+      addedAt: 1,
+      lastUsed: 1,
+    },
+  })
+  await savePreset({ name: 'work', models: ['xai/grok-pdf'] })
+
+  const hooks = await subrouterPlugin(pluginInput)
+  const config: Config = {}
+  await hooks.config?.(config)
+
+  expect(config.provider?.subrouter?.models?.work).toMatchObject({
+    attachment: true,
+    modalities: {
+      input: ['text', 'image'],
+      output: ['text'],
+    },
+  })
+})
+
+test('Anthropic-compatible coding plans do not advertise video input', async () => {
+  process.env.SUBROUTER_MODELS_DEV_URL = await startFakeModelsDev({
+    'kimi-for-coding': {
+      models: {
+        'kimi-video': {
+          id: 'kimi-video',
+          attachment: true,
+          modalities: { input: ['text', 'image', 'video'], output: ['text'] },
+        },
+      },
+    },
+  })
+  await addAccount({
+    provider: 'kimi',
+    account: { type: 'api', key: 'kimi-key', addedAt: 1, lastUsed: 1 },
+  })
+  await savePreset({ name: 'work', models: ['kimi/kimi-video'] })
+
+  const hooks = await subrouterPlugin(pluginInput)
+  const config: Config = {}
+  await hooks.config?.(config)
+
+  expect(config.provider?.subrouter?.models?.work).toMatchObject({
+    attachment: true,
+    modalities: {
+      input: ['text', 'image'],
+      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 () => {
@@ -132,26 +542,26 @@ test('authorize dispatches to the chosen adapter and the callback pools the acco
   ])
 })
 
-test('opencode zen asks for a pasted key and stores it as an api account', async () => {
+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' })
+  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('zen-key-1')).toMatchObject({ type: 'success', key: 'zen-key-1' })
+  expect(await result.callback('go-key-1')).toMatchObject({ type: 'success', key: 'go-key-1' })
 
   const accounts = await loadAccounts()
-  expect(accounts.providers.opencode?.accounts).toMatchObject([{ type: 'api', key: 'zen-key-1' }])
+  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' })
+  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).toBeUndefined()
+  expect(accounts.providers['opencode-go']).toBeUndefined()
 })

package/src/provider.ts

@@ -2,20 +2,69 @@
  * 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 {
+  OPENCODE_AGENT_HEADER,
+  OPENCODE_VARIANT_HEADER,
   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 } },
+  input: {
+    sessionID: string
+    agent: string
+    model: { providerID: string }
+    message: {
+      agent: string
+      model: { providerID: string; modelID: string; variant?: string }
+    }
+  },
   output: { headers: Record<string, string> },
 ) {
-  if (input.model.providerID !== 'subrouter') return
+  if (input.model.providerID !== PROVIDER_ID) return
   output.headers[OPENAI_WEBSOCKET_SESSION_HEADER] = input.sessionID
+  if (input.agent === input.message.agent) {
+    output.headers[OPENCODE_AGENT_HEADER] = input.message.agent
+    if (input.message.model.variant) {
+      output.headers[OPENCODE_VARIANT_HEADER] = input.message.model.variant
+    }
+  }
   if (input.agent === 'title') output.headers[OPENAI_WEBSOCKET_TITLE_HEADER] = 'true'
 }