@subrouter/opencode 0.4.0 → 0.5.0

package/src/opencode-e2e.test.ts

@@ -13,18 +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'
 
@@ -71,8 +74,13 @@ type MockServer = {
   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: MockServer['requests'] = []
   const server: Server = createServer((req, res) => {
@@ -114,6 +122,9 @@ 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> = {}
 
@@ -129,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' })
@@ -171,6 +182,54 @@ 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) => {
@@ -185,7 +244,7 @@ beforeAll(async () => {
     res.end(
       JSON.stringify({
         anthropic: { models: { 'claude-opus-4-6': pdfModel('claude-opus-4-6') } },
-        openai: emptyProvider,
+        openai: { models: { 'gpt-5.5': pdfModel('gpt-5.5') } },
         xai: emptyProvider,
         'opencode-go': { models: { 'grok-4.6': pdfModel('grok-4.6') } },
         'github-copilot': emptyProvider,
@@ -207,6 +266,7 @@ beforeAll(async () => {
     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'),
@@ -233,6 +293,23 @@ 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'),
@@ -266,11 +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
@@ -281,37 +363,40 @@ 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',
+      [ROUTE_AFFINITY_HEADER]: 'message-1',
       [OPENCODE_AGENT_HEADER]: 'build',
       [OPENCODE_VARIANT_HEADER]: 'high',
     })
 
     const titleOutput = { headers: {} }
-    addSubrouterHeaders(
-      {
+    addSubrouterHeaders({
+      input: {
         sessionID: 'session-2',
         agent: 'title',
         model: { providerID: 'subrouter' },
         message: {
+          id: 'message-1',
           agent: 'build',
           model: { providerID: 'subrouter', modelID: 'build', variant: 'high' },
         },
       },
-      titleOutput,
-    )
+      output: titleOutput,
+    })
     expect(titleOutput.headers).toEqual({
       [OPENAI_WEBSOCKET_SESSION_HEADER]: 'session-2',
       [OPENAI_WEBSOCKET_TITLE_HEADER]: 'true',
@@ -348,7 +433,7 @@ 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 () => {
+  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 },
@@ -378,29 +463,17 @@ describe('opencode + subrouter provider', () => {
           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/'),
-          ),
-        )
+        return (messages.data ?? []).filter(({ parts }) =>
+          parts.some((part) => part.type === 'text' && part.ignored === true),
+        ).length
       })
-      .toBe(true)
+      .toBe(1)
 
     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 === 'user')).toHaveLength(2)
     expect((messages.data ?? []).filter(({ info }) => info.role === 'assistant')).toHaveLength(1)
     expect(zenMock.requests).toHaveLength(requestsBefore + 1)
   }, 120_000)
@@ -520,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)
 })