@subrouter/opencode 0.3.0 → 0.5.0

package/src/opencode-e2e.test.ts

@@ -13,16 +13,21 @@
 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, mkdir } from 'node:fs/promises'
+import { mkdtemp, rm, mkdir, writeFile } 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 { afterAll, afterEach, beforeAll, describe, expect, test } from 'vitest'
 import {
+  OPENCODE_AGENT_HEADER,
+  OPENCODE_VARIANT_HEADER,
   OPENAI_WEBSOCKET_SESSION_HEADER,
+  ROUTE_AFFINITY_HEADER,
   OPENAI_WEBSOCKET_TITLE_HEADER,
   addAccount,
+  clearCooldowns,
   markCooldown,
+  savePreset,
 } from '@subrouter/cli'
 import { addSubrouterHeaders } from './provider.ts'
 
@@ -65,21 +70,26 @@ function summarizeSessionEvents(events: Event[]) {
 
 type MockServer = {
   url: string
-  requests: string[]
+  requests: Array<{ path: string; body: string }>
   close: () => Promise<void>
 }
 
+type MockHandler = (
+  args: { path: string; body: string },
+  res: import('node:http').ServerResponse,
+) => void
+
 async function startMockServer(
-  handler: (args: { path: string; body: string }, res: import('node:http').ServerResponse) => void,
+  handler: MockHandler,
 ): 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,7 +120,11 @@ function sseChunk(data: object) {
 let home: string
 let projectDir: string
 let anthropicMock: MockServer
+let modelsDevMock: MockServer
 let zenMock: MockServer
+let openaiMock: MockServer
+let zenRespond: MockHandler
+let defaultZenRespond: MockHandler
 let server: { url: string; close: () => void }
 const savedEnv: Record<string, string | undefined> = {}
 
@@ -126,7 +140,7 @@ beforeAll(async () => {
   })
 
   // Fake opencode-go: streams a canned completion
-  zenMock = await startMockServer(({ body }, res) => {
+  defaultZenRespond = ({ body }, res) => {
     const streaming = body.includes('"stream":true')
     if (!streaming) {
       res.writeHead(200, { 'content-type': 'application/json' })
@@ -168,6 +182,79 @@ beforeAll(async () => {
     )
     res.write('data: [DONE]\n\n')
     res.end()
+  }
+  zenRespond = defaultZenRespond
+  zenMock = await startMockServer((request, response) => zenRespond(request, response))
+
+  openaiMock = await startMockServer((_request, res) => {
+    const text = 'hello from openai'
+    res.writeHead(200, { 'content-type': 'text/event-stream' })
+    for (const event of [
+      {
+        type: 'response.created',
+        response: { id: 'resp-1', created_at: 1, model: 'gpt-5.5', service_tier: null },
+      },
+      {
+        type: 'response.output_item.added',
+        output_index: 0,
+        item: { type: 'message', id: 'msg-1', role: 'assistant', status: 'in_progress', content: [] },
+      },
+      { type: 'response.content_part.added', part: { type: 'output_text', text: '' } },
+      { type: 'response.output_text.delta', item_id: 'msg-1', delta: text },
+      {
+        type: 'response.output_item.done',
+        output_index: 0,
+        item: {
+          type: 'message',
+          id: 'msg-1',
+          role: 'assistant',
+          status: 'completed',
+          content: [{ type: 'output_text', text }],
+        },
+      },
+      {
+        type: 'response.completed',
+        response: {
+          id: 'resp-1',
+          status: 'completed',
+          usage: {
+            input_tokens: 5,
+            output_tokens: 3,
+            total_tokens: 8,
+            input_tokens_details: { cached_tokens: 0 },
+          },
+        },
+      },
+    ]) {
+      res.write(sseChunk(event))
+    }
+    res.write('data: [DONE]\n\n')
+    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: { models: { 'gpt-5.5': pdfModel('gpt-5.5') } },
+        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
@@ -177,7 +264,9 @@ 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`,
+    SUBROUTER_OPENAI_BASE_URL: openaiMock.url,
     // 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'),
@@ -204,15 +293,36 @@ beforeAll(async () => {
     provider: 'opencode-go',
     account: { type: 'api', key: 'zen-key', addedAt: 1, lastUsed: 1 },
   })
+  await addAccount({
+    provider: 'openai',
+    account: {
+      type: 'oauth',
+      refresh: 'openai-refresh',
+      access: 'openai-access',
+      expires: Date.now() + 1_000_000_000,
+      email: 'o@x.com',
+      addedAt: 1,
+      lastUsed: 1,
+    },
+  })
+  await savePreset({
+    name: 'default',
+    models: ['anthropic/claude-opus-4-6', 'opencode-go/grok-4.6'],
+  })
+  await savePreset({ name: 'openai-only', models: ['openai/gpt-5.5'] })
 
   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 +331,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 },
             },
@@ -231,10 +343,16 @@ beforeAll(async () => {
   })
 }, 120_000)
 
+afterEach(() => {
+  zenRespond = defaultZenRespond
+})
+
 afterAll(async () => {
   server?.close()
   await anthropicMock?.close()
+  await modelsDevMock?.close()
   await zenMock?.close()
+  await openaiMock?.close()
   for (const [key, value] of Object.entries(savedEnv)) {
     if (value === undefined) delete process.env[key]
     else process.env[key] = value
@@ -245,25 +363,41 @@ afterAll(async () => {
 describe('opencode + subrouter provider', () => {
   test('adds session affinity headers for subrouter models', async () => {
     const output = { headers: {} }
-    addSubrouterHeaders(
-      {
+    addSubrouterHeaders({
+      input: {
         sessionID: 'session-1',
         agent: 'build',
         model: { providerID: 'subrouter' },
+        message: {
+          id: 'message-1',
+          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',
+      [ROUTE_AFFINITY_HEADER]: 'message-1',
+      [OPENCODE_AGENT_HEADER]: 'build',
+      [OPENCODE_VARIANT_HEADER]: 'high',
+    })
 
-    addSubrouterHeaders(
-      {
+    const titleOutput = { headers: {} }
+    addSubrouterHeaders({
+      input: {
         sessionID: 'session-2',
         agent: 'title',
         model: { providerID: 'subrouter' },
+        message: {
+          id: 'message-1',
+          agent: 'build',
+          model: { providerID: 'subrouter', modelID: 'build', variant: 'high' },
+        },
       },
-      output,
-    )
-    expect(output.headers).toEqual({
+      output: titleOutput,
+    })
+    expect(titleOutput.headers).toEqual({
       [OPENAI_WEBSOCKET_SESSION_HEADER]: 'session-2',
       [OPENAI_WEBSOCKET_TITLE_HEADER]: 'true',
     })
@@ -299,6 +433,98 @@ describe('opencode + subrouter provider', () => {
     expect(zenMock.requests.length).toBeGreaterThan(0)
   }, 120_000)
 
+  test('a pre-existing cooldown appends one ignored 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 ?? []).filter(({ parts }) =>
+          parts.some((part) => part.type === 'text' && part.ignored === true),
+        ).length
+      })
+      .toBe(1)
+
+    const messages = await client.session.messages({
+      path: { id: session.data!.id },
+      query: { directory: projectDir },
+    })
+    expect((messages.data ?? []).filter(({ info }) => info.role === 'user')).toHaveLength(2)
+    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({
@@ -367,4 +593,159 @@ describe('opencode + subrouter provider', () => {
       ]
     `)
   }, 120_000)
+
+  test('keeps the fallback candidate through tool follow-ups until the session is idle', async () => {
+    await clearCooldowns()
+    await markCooldown({
+      provider: 'anthropic',
+      account: {
+        type: 'oauth',
+        refresh: 'fake-refresh',
+        access: 'fake-access',
+        email: 'a@x.com',
+        addedAt: 1,
+        lastUsed: 1,
+      },
+      untilMs: Date.now() + 60_000,
+    })
+    const readable = path.join(projectDir, 'message.txt')
+    await writeFile(readable, 'tool result')
+    const fallbackBodies: string[] = []
+    let fallbackCalls = 0
+    let cooldownCleared = Promise.resolve()
+    zenRespond = ({ body }, res) => {
+      fallbackBodies.push(body)
+      fallbackCalls++
+      res.writeHead(200, { 'content-type': 'text/event-stream' })
+      if (fallbackCalls === 1) {
+        cooldownCleared = clearCooldowns()
+        res.write(
+          sseChunk({
+            id: 'tool-1',
+            object: 'chat.completion.chunk',
+            created: 1,
+            model: 'fake-model',
+            choices: [
+              {
+                index: 0,
+                delta: {
+                  role: 'assistant',
+                  tool_calls: [
+                    {
+                      index: 0,
+                      id: 'call-read',
+                      type: 'function',
+                      function: { name: 'read', arguments: JSON.stringify({ filePath: readable }) },
+                    },
+                  ],
+                },
+                finish_reason: null,
+              },
+            ],
+          }),
+        )
+        res.write(
+          sseChunk({
+            id: 'tool-1',
+            object: 'chat.completion.chunk',
+            created: 1,
+            model: 'fake-model',
+            choices: [{ index: 0, delta: {}, finish_reason: 'tool_calls' }],
+            usage: { prompt_tokens: 1, completion_tokens: 2, total_tokens: 3 },
+          }),
+        )
+        res.end('data: [DONE]\n\n')
+        return
+      }
+      res.write(
+        sseChunk({
+          id: 'text-1',
+          object: 'chat.completion.chunk',
+          created: 1,
+          model: 'fake-model',
+          choices: [{ index: 0, delta: { role: 'assistant', content: 'done' }, finish_reason: 'stop' }],
+        }),
+      )
+      res.write(
+        sseChunk({
+          id: 'text-1',
+          object: 'chat.completion.chunk',
+          created: 1,
+          model: 'fake-model',
+          choices: [{ index: 0, delta: {}, finish_reason: 'stop' }],
+          usage: { prompt_tokens: 1, completion_tokens: 2, total_tokens: 3 },
+        }),
+      )
+      res.end('data: [DONE]\n\n')
+    }
+
+    const client = createOpencodeClient({ baseUrl: server.url })
+    const session = await client.session.create({
+      query: { directory: projectDir },
+      body: { title: 'subrouter tool affinity' },
+    })
+    const anthropicBefore = anthropicMock.requests.length
+    await client.session.prompt({
+      path: { id: session.data!.id },
+      query: { directory: projectDir },
+      body: {
+        model: { providerID: 'subrouter', modelID: 'default' },
+        parts: [{ type: 'text', text: 'read the file' }],
+      },
+    })
+    expect(anthropicMock.requests).toHaveLength(anthropicBefore)
+    expect(
+      fallbackBodies
+        .slice(0, 2)
+        .map((body) => body.includes('You are powered by the model named grok-4.6')),
+    ).toEqual([true, true])
+
+    await cooldownCleared
+    await clearCooldowns()
+    await client.session.prompt({
+      path: { id: session.data!.id },
+      query: { directory: projectDir },
+      body: {
+        model: { providerID: 'subrouter', modelID: 'default' },
+        parts: [{ type: 'text', text: 'say done' }],
+      },
+    })
+    expect(anthropicMock.requests).toHaveLength(anthropicBefore + 1)
+    expect(fallbackCalls).toBeGreaterThanOrEqual(3)
+  }, 120_000)
+
+  test('openai live model advertises apply_patch and not edit or write', async () => {
+    const client = createOpencodeClient({ baseUrl: server.url })
+    const session = await client.session.create({
+      query: { directory: projectDir },
+      body: { title: 'subrouter apply_patch' },
+    })
+    expect(session.data).toBeTruthy()
+
+    const result = await client.session.prompt({
+      path: { id: session.data!.id },
+      query: { directory: projectDir },
+      body: {
+        model: { providerID: 'subrouter', modelID: 'openai-only' },
+        parts: [{ type: 'text', text: 'say hi' }],
+      },
+    })
+    const texts = (result.data?.parts ?? [])
+      .filter((part) => part.type === 'text')
+      .map((part) => part.text)
+      .join('\n')
+    expect(texts).toContain('hello from openai')
+    expect(openaiMock.requests.length).toBeGreaterThan(0)
+
+    const raw = openaiMock.requests.at(-1)!.body
+    const body = JSON.parse(raw) as {
+      tools?: Array<{ name?: string; type?: string; function?: { name?: string } }>
+    }
+    const names = (body.tools ?? []).map((tool) => tool.name ?? tool.function?.name)
+    expect(names).toContain('apply_patch')
+    expect(names).not.toContain('edit')
+    expect(names).not.toContain('write')
+    expect(raw).toContain('apply_patch')
+    expect(raw.includes('"name":"edit"') || raw.includes('"name": "edit"')).toBe(false)
+  }, 120_000)
 })