@subrouter/opencode 0.2.0 → 0.4.0

package/src/index.ts

@@ -5,7 +5,10 @@
  * provider whose npm field points at this package's provider module (file://
  * URL, so opencode never installs anything). Each subrouter preset becomes a
  * model: pick `subrouter/default` (or any preset created with
- * `subrouter preset create`) in opencode.
+ * `subrouter preset create`) in opencode. Provider id stays `subrouter`; the
+ * visible name is `subrouter.org`. Context limits follow the first live
+ * candidate. Input modalities cover every usable candidate so the
+ * router can select a compatible subscription for each prompt.
  *
  * `subrouterAuthPlugin` registers the login flow, so `opencode auth login`
  * (and any harness driving opencode's auth hook, like kimaki's Discord
@@ -16,54 +19,163 @@
  * OpenCode calls every export as a plugin.
  */
 
-import type { Plugin } from '@opencode-ai/plugin'
+import type { Plugin, PluginInput } from '@opencode-ai/plugin'
 import {
   adapters,
   addAccount,
   DEFAULT_PRESET_NAME,
   isProviderId,
+  loadModelsDevCatalog,
   loadPresets,
+  modelsDevInputModalities,
+  modelsDevLimit,
+  modelsDevModel,
+  PROVIDER_DISPLAY_NAME,
+  PROVIDER_ID,
   PROVIDER_IDS,
+  resolveCandidates,
+  resolvePresetModels,
+  type CooldownFallbackNotice,
   type StoredAccount,
+  type SubrouterLog,
 } from '@subrouter/cli'
-import { addSubrouterHeaders } from './provider.ts'
+import { addSubrouterHeaders, revealRoutedModel } from './provider.ts'
 
 function providerEntryUrl() {
   const isDev = import.meta.url.endsWith('.ts')
   return new URL(isDev ? './provider.ts' : './provider.js', import.meta.url).href
 }
 
-export const subrouterPlugin: Plugin = async () => {
+function opencodeLog(client: PluginInput['client'] | undefined): SubrouterLog | undefined {
+  if (!client?.app?.log) return undefined
+  const write = client.app.log.bind(client.app)
+  return (entry) => {
+    void write({
+      body: {
+        service: 'subrouter',
+        level: entry.level,
+        message: entry.message,
+        extra: entry.extra,
+      },
+    }).catch(() => {})
+  }
+}
+
+export const subrouterPlugin: Plugin = async ({ client, directory }) => {
+  const log = opencodeLog(client)
+  const pendingNotices = new Map<
+    string,
+    { agent: string; variant?: string; preset: string; text: string }
+  >()
+  const onCooldownFallback = (notice: CooldownFallbackNotice) => {
+    if (!client || !notice.sessionID || !notice.agent || notice.agent === 'title') return
+    if (pendingNotices.has(notice.sessionID)) return
+    const preferred = `${notice.preferred.provider}/${notice.preferred.modelId}`
+    const active = `${notice.active.provider}/${notice.active.modelId}`
+    pendingNotices.set(notice.sessionID, {
+      agent: notice.agent,
+      variant: notice.variant,
+      preset: notice.preset,
+      text: `Subrouter: ${preferred} was rate limited. This message started with ${active}.`,
+    })
+  }
   return {
     config: async (config) => {
       const presets = await loadPresets().catch(() => {
         return { version: 1 as const, presets: {} }
       })
       const names = new Set([DEFAULT_PRESET_NAME, ...Object.keys(presets.presets)])
+      const catalog = await loadModelsDevCatalog({ log })
       const models = Object.fromEntries(
-        [...names].map((name) => [
-          name,
-          {
-            name: `subrouter ${name}`,
-            tool_call: true,
-            attachment: false,
-            reasoning: false,
-            cost: { input: 0, output: 0, cache_read: 0, cache_write: 0 },
-            limit: { context: 200_000, output: 64_000 },
-          },
-        ]),
+        await Promise.all(
+          [...names].map(async (name) => {
+            const presetModels = await resolvePresetModels(name)
+            const candidates =
+              presetModels instanceof Error
+                ? []
+                : (await resolveCandidates({ presetModels })).candidates
+            const candidate = candidates[0]
+            const limit = candidate
+              ? modelsDevLimit({
+                  provider: candidate.provider,
+                  modelId: candidate.modelId,
+                  catalog,
+                })
+              : null
+            const input = new Set<'text' | 'audio' | 'image' | 'video' | 'pdf'>(['text'])
+            let attachment = false
+            for (const current of candidates) {
+              const model = modelsDevModel({
+                provider: current.provider,
+                modelId: current.modelId,
+                catalog,
+              })
+              const modalities = modelsDevInputModalities({
+                provider: current.provider,
+                modelId: current.modelId,
+                catalog,
+              })
+              if (!model || !modalities) continue
+              attachment ||= model.attachment && modalities.some((modality) => modality !== 'text')
+              for (const modality of modalities) input.add(modality)
+            }
+            return [
+              name,
+              {
+                name,
+                tool_call: true,
+                attachment,
+                reasoning: false,
+                modalities: {
+                  input: [...input],
+                  output: ['text'] satisfies Array<'text'>,
+                },
+                cost: { input: 0, output: 0, cache_read: 0, cache_write: 0 },
+                limit: limit ?? { context: 200_000, output: 64_000 },
+              },
+            ]
+          }),
+        ),
       )
       config.provider = {
         ...config.provider,
-        subrouter: {
-          name: 'Subrouter',
+        [PROVIDER_ID]: {
+          name: PROVIDER_DISPLAY_NAME,
           npm: providerEntryUrl(),
           models,
-          options: {},
+          options: { log, onCooldownFallback },
         },
       }
     },
+    event: async ({ event }) => {
+      if (event.type !== 'session.idle') return
+      const pending = pendingNotices.get(event.properties.sessionID)
+      if (!pending) return
+      pendingNotices.delete(event.properties.sessionID)
+      const body = {
+        noReply: true,
+        agent: pending.agent,
+        model: { providerID: PROVIDER_ID, modelID: pending.preset },
+        variant: pending.variant,
+        parts: [{ type: 'text' as const, text: pending.text, ignored: true }],
+      }
+      await client.session
+        .prompt({
+          path: { id: event.properties.sessionID },
+          query: { directory },
+          body,
+        })
+        .catch(() => {})
+    },
     'chat.headers': async (input, output) => addSubrouterHeaders(input, output),
+    // OpenCode identity uses the preset id; rewrite it to the live routed model.
+    'experimental.chat.system.transform': async (input, output) => {
+      await revealRoutedModel({
+        providerID: input.model.providerID,
+        preset: input.model.id,
+        system: output.system,
+      })
+    },
   }
 }
 
@@ -88,7 +200,7 @@ function toOpencodeCredentials(account: StoredAccount) {
 export const subrouterAuthPlugin: Plugin = async () => {
   return {
     auth: {
-      provider: 'subrouter',
+      provider: PROVIDER_ID,
       methods: [
         {
           type: 'oauth',

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,37 +10,78 @@
  * 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 {
+  OPENCODE_AGENT_HEADER,
+  OPENCODE_VARIANT_HEADER,
   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
-  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)
     })
   })
@@ -71,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> = {}
@@ -86,7 +128,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) {
@@ -131,40 +173,40 @@ 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 })
-  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_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'),
     XDG_DATA_HOME: path.join(home, 'xdg-data'),
@@ -175,14 +217,35 @@ 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
+  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',
@@ -191,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 },
             },
@@ -204,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]
@@ -220,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',
     })
@@ -268,4 +347,177 @@ describe('opencode + subrouter provider', () => {
     expect(anthropicMock.requests.length).toBeGreaterThan(0)
     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({
+      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)
 })