@subrouter/opencode 0.3.0 → 0.4.0

package/src/opencode-e2e.test.ts

@@ -19,6 +19,8 @@ import path from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { afterAll, beforeAll, describe, expect, test } from 'vitest'
 import {
+  OPENCODE_AGENT_HEADER,
+  OPENCODE_VARIANT_HEADER,
   OPENAI_WEBSOCKET_SESSION_HEADER,
   OPENAI_WEBSOCKET_TITLE_HEADER,
   addAccount,
@@ -65,21 +67,21 @@ function summarizeSessionEvents(events: Event[]) {
 
 type MockServer = {
   url: string
-  requests: string[]
+  requests: Array<{ path: string; body: string }>
   close: () => Promise<void>
 }
 
 async function startMockServer(
   handler: (args: { path: string; body: string }, res: import('node:http').ServerResponse) => void,
 ): Promise<MockServer> {
-  const requests: string[] = []
+  const requests: MockServer['requests'] = []
   const server: Server = createServer((req, res) => {
     let body = ''
     req.on('data', (chunk) => {
       body += String(chunk)
     })
     req.on('end', () => {
-      requests.push(req.url ?? '')
+      requests.push({ path: req.url ?? '', body })
       handler({ path: req.url ?? '', body }, res)
     })
   })
@@ -110,6 +112,7 @@ function sseChunk(data: object) {
 let home: string
 let projectDir: string
 let anthropicMock: MockServer
+let modelsDevMock: MockServer
 let zenMock: MockServer
 let server: { url: string; close: () => void }
 const savedEnv: Record<string, string | undefined> = {}
@@ -170,6 +173,31 @@ beforeAll(async () => {
     res.end()
   })
 
+  modelsDevMock = await startMockServer((_request, res) => {
+    const emptyProvider = { models: {} }
+    const pdfModel = (id: string) => ({
+      id,
+      attachment: true,
+      modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+      limit: { context: 200_000, output: 64_000 },
+    })
+    res.writeHead(200, { 'content-type': 'application/json' })
+    res.end(
+      JSON.stringify({
+        anthropic: { models: { 'claude-opus-4-6': pdfModel('claude-opus-4-6') } },
+        openai: emptyProvider,
+        xai: emptyProvider,
+        'opencode-go': { models: { 'grok-4.6': pdfModel('grok-4.6') } },
+        'github-copilot': emptyProvider,
+        poe: emptyProvider,
+        'minimax-coding-plan': emptyProvider,
+        'kimi-for-coding': emptyProvider,
+        'zai-coding-plan': emptyProvider,
+        'alibaba-coding-plan': emptyProvider,
+      }),
+    )
+  })
+
   // Subrouter state: one rate-limited anthropic account + one zen key
   const subrouterHome = path.join(home, 'subrouter')
   await mkdir(subrouterHome, { recursive: true })
@@ -177,6 +205,7 @@ beforeAll(async () => {
   for (const [key, value] of Object.entries({
     SUBROUTER_HOME: subrouterHome,
     SUBROUTER_ANTHROPIC_BASE_URL: `${anthropicMock.url}/v1`,
+    SUBROUTER_MODELS_DEV_URL: modelsDevMock.url,
     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'),
@@ -208,11 +237,15 @@ beforeAll(async () => {
   const providerEntry = pathToFileURL(
     path.join(import.meta.dirname, '..', 'dist', 'provider.js'),
   ).href
+  const pluginEntry = pathToFileURL(
+    path.join(import.meta.dirname, '..', 'dist', 'index.js'),
+  ).href
 
   server = await createOpencodeServer({
     port: 0,
     timeout: 60_000,
     config: {
+      plugin: [pluginEntry],
       provider: {
         subrouter: {
           name: 'Subrouter',
@@ -221,6 +254,8 @@ beforeAll(async () => {
             default: {
               name: 'subrouter default',
               tool_call: true,
+              attachment: true,
+              modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
               cost: { input: 0, output: 0, cache_read: 0, cache_write: 0 },
               limit: { context: 200_000, output: 64_000 },
             },
@@ -234,6 +269,7 @@ beforeAll(async () => {
 afterAll(async () => {
   server?.close()
   await anthropicMock?.close()
+  await modelsDevMock?.close()
   await zenMock?.close()
   for (const [key, value] of Object.entries(savedEnv)) {
     if (value === undefined) delete process.env[key]
@@ -250,20 +286,33 @@ describe('opencode + subrouter provider', () => {
         sessionID: 'session-1',
         agent: 'build',
         model: { providerID: 'subrouter' },
+        message: {
+          agent: 'build',
+          model: { providerID: 'subrouter', modelID: 'build', variant: 'high' },
+        },
       },
       output,
     )
-    expect(output.headers).toEqual({ [OPENAI_WEBSOCKET_SESSION_HEADER]: 'session-1' })
+    expect(output.headers).toEqual({
+      [OPENAI_WEBSOCKET_SESSION_HEADER]: 'session-1',
+      [OPENCODE_AGENT_HEADER]: 'build',
+      [OPENCODE_VARIANT_HEADER]: 'high',
+    })
 
+    const titleOutput = { headers: {} }
     addSubrouterHeaders(
       {
         sessionID: 'session-2',
         agent: 'title',
         model: { providerID: 'subrouter' },
+        message: {
+          agent: 'build',
+          model: { providerID: 'subrouter', modelID: 'build', variant: 'high' },
+        },
       },
-      output,
+      titleOutput,
     )
-    expect(output.headers).toEqual({
+    expect(titleOutput.headers).toEqual({
       [OPENAI_WEBSOCKET_SESSION_HEADER]: 'session-2',
       [OPENAI_WEBSOCKET_TITLE_HEADER]: 'true',
     })
@@ -299,6 +348,110 @@ describe('opencode + subrouter provider', () => {
     expect(zenMock.requests.length).toBeGreaterThan(0)
   }, 120_000)
 
+  test('a pre-existing cooldown leaves a visible ignored route notice without another model turn', async () => {
+    const client = createOpencodeClient({ baseUrl: server.url })
+    const session = await client.session.create({
+      query: { directory: projectDir },
+      body: { title: 'subrouter route notice' },
+    })
+    expect(session.data).toBeTruthy()
+    const requestsBefore = zenMock.requests.length
+
+    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 again' }],
+      },
+    })
+    expect(
+      (result.data?.parts ?? [])
+        .filter((part) => part.type === 'text')
+        .map((part) => part.text)
+        .join('\n'),
+    ).toContain('hello from fallback')
+
+    await expect
+      .poll(async () => {
+        const messages = await client.session.messages({
+          path: { id: session.data!.id },
+          query: { directory: projectDir },
+        })
+        return (messages.data ?? []).some(({ parts }) =>
+          parts.some(
+            (part) =>
+              part.type === 'text' &&
+              part.ignored === true &&
+              part.text.includes('was rate limited. This message started with opencode-go/'),
+          ),
+        )
+      })
+      .toBe(true)
+
+    const messages = await client.session.messages({
+      path: { id: session.data!.id },
+      query: { directory: projectDir },
+    })
+    const notice = (messages.data ?? []).find(({ parts }) =>
+      parts.some((part) => part.type === 'text' && part.ignored === true),
+    )
+    expect(notice?.info).toMatchObject({
+      role: 'user',
+      agent: 'build',
+      model: { providerID: 'subrouter', modelID: 'default' },
+    })
+    expect((messages.data ?? []).filter(({ info }) => info.role === 'assistant')).toHaveLength(1)
+    expect(zenMock.requests).toHaveLength(requestsBefore + 1)
+  }, 120_000)
+
+  test('PDF file parts reach a compatible fallback through opencode', async () => {
+    const client = createOpencodeClient({ baseUrl: server.url })
+    const session = await client.session.create({
+      query: { directory: projectDir },
+      body: { title: 'subrouter PDF e2e' },
+    })
+    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: 'file',
+            filename: 'document.pdf',
+            mime: 'application/pdf',
+            url: `data:application/pdf;base64,${Buffer.from('%PDF-1.4\n%%EOF').toString('base64')}`,
+          },
+          { type: 'text', text: 'read the PDF' },
+        ],
+      },
+    })
+
+    const texts = (result.data?.parts ?? [])
+      .filter((part) => part.type === 'text')
+      .map((part) => part.text)
+      .join('\n')
+    expect(texts).toContain('hello from fallback')
+    const request = zenMock.requests.at(-1)
+    expect(request).toBeTruthy()
+    const body = JSON.parse(request!.body) as {
+      messages: Array<{ content: Array<{ type: string; file?: { filename?: string } }> }>
+    }
+    expect(body.messages.at(-1)?.content).toEqual([
+      {
+        type: 'file',
+        file: {
+          filename: 'document.pdf',
+          file_data: `data:application/pdf;base64,${Buffer.from('%PDF-1.4\n%%EOF').toString('base64')}`,
+        },
+      },
+      { type: 'text', text: 'read the PDF' },
+    ])
+  }, 120_000)
+
   test('all cooling-down accounts retry through opencode instead of dying', async () => {
     const untilMs = Date.now() + 2_000
     await markCooldown({

package/src/plugin.test.ts

@@ -1,9 +1,12 @@
+import childProcess from 'node:child_process'
 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 util from 'node:util'
 import { afterEach, beforeEach, expect, test } from 'vitest'
 import type { Config, PluginInput } from '@opencode-ai/plugin'
+import { createOpencodeClient, type Event } from '@opencode-ai/sdk'
 import {
   addAccount,
   adapters,
@@ -11,11 +14,11 @@ import {
   PROVIDER_DISPLAY_NAME,
   PROVIDER_IDS,
   savePreset,
-  setSubrouterLog,
 } 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
@@ -27,7 +30,6 @@ beforeEach(async () => {
 })
 
 afterEach(async () => {
-  setSubrouterLog(undefined)
   delete process.env.SUBROUTER_HOME
   delete process.env.SUBROUTER_OPENAI_ISSUER_URL
   delete process.env.SUBROUTER_MODELS_DEV_URL
@@ -49,7 +51,11 @@ async function startFakeModelsDev(
         string,
         {
           id: string
-          modalities?: { output?: string[] }
+          attachment?: boolean
+          reasoning?: boolean
+          temperature?: boolean
+          tool_call?: boolean
+          modalities?: { input?: string[]; output?: string[] }
           limit?: { context?: number; output?: number; input?: number }
         }
       >
@@ -126,6 +132,121 @@ function authMethod() {
   })
 }
 
+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 savePreset({ name: 'work', models: ['anthropic/claude-opus-4-6'] })
 
@@ -146,7 +267,7 @@ test('config hook registers the subrouter provider with preset models', async ()
   expect(provider.models.work.limit).toEqual({ context: 200_000, output: 64_000 })
 })
 
-test('preset model names show the first live candidate', async () => {
+test('preset model names stay stable when the routed candidate changes', async () => {
   await addAccount({
     provider: 'anthropic',
     account: {
@@ -166,7 +287,7 @@ test('preset model names show the first live candidate', async () => {
   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)')
+  expect(config.provider?.subrouter?.models?.work?.name).toBe('work')
 })
 
 test('preset model limits follow the first live candidate', async () => {
@@ -177,8 +298,8 @@ test('preset model limits follow the first live candidate', async () => {
       models: {
         [modelId]: {
           id: modelId,
-          modalities: { output: ['text'] },
-          limit: { context: 1_000_000, output: 128_000 },
+          modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+          limit: { context: 1_000_000, input: 900_000, output: 128_000 },
         },
       },
     },
@@ -203,20 +324,59 @@ test('preset model limits follow the first live candidate', async () => {
 
   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 models permit image and PDF attachments', async () => {
+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?.default).toMatchObject({
+  expect(config.provider?.subrouter?.models?.work).toMatchObject({
     attachment: true,
     modalities: {
       input: ['text', 'image', 'pdf'],
@@ -225,6 +385,75 @@ test('preset models permit image and PDF attachments', async () => {
   })
 })
 
+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>',

package/src/provider.ts

@@ -6,6 +6,8 @@
  */
 
 import {
+  OPENCODE_AGENT_HEADER,
+  OPENCODE_VARIANT_HEADER,
   OPENAI_WEBSOCKET_SESSION_HEADER,
   OPENAI_WEBSOCKET_TITLE_HEADER,
   PROVIDER_ID,
@@ -45,10 +47,24 @@ export async function revealRoutedModel({
 }
 
 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 !== 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'
 }