@subrouter/opencode 0.4.0 → 0.5.0

package/src/plugin.test.ts

@@ -6,7 +6,7 @@ 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 { createOpencodeClient } from '@opencode-ai/sdk'
 import {
   addAccount,
   adapters,
@@ -14,9 +14,17 @@ import {
   PROVIDER_DISPLAY_NAME,
   PROVIDER_IDS,
   savePreset,
+  setLiveRoute,
 } from '@subrouter/cli'
 import { subrouterAuthPlugin, subrouterPlugin } from './index.ts'
-import { revealRoutedModel, rewritePoweredByModelLine } from './provider.ts'
+import {
+  appendApplyPatchConstraint,
+  applyPatchApiId,
+  applyPatchConstraint,
+  revealRoutedModel,
+  rewritePoweredByModelLine,
+  shouldUseApplyPatch,
+} from './provider.ts'
 
 const execFile = util.promisify(childProcess.execFile)
 let home: string
@@ -30,7 +38,6 @@ beforeEach(async () => {
 })
 
 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)) {
@@ -56,12 +63,13 @@ async function startFakeModelsDev(
           temperature?: boolean
           tool_call?: boolean
           modalities?: { input?: string[]; output?: string[] }
-          limit?: { context?: number; output?: number; input?: number }
-        }
-      >
-    }
-  > = {},
-) {
+           limit?: { context?: number; output?: number; input?: number }
+           reasoning_options?: Array<{ type: string; values?: Array<string | null> }>
+         }
+       >
+     }
+   > = {},
+ ) {
   const payload = {
     anthropic: { models: {} },
     openai: { models: {} },
@@ -180,8 +188,8 @@ test('provider log callback forwards only to client.app.log', async () => {
   })
 })
 
-test('cooldown fallback creates only a persisted ignored notice after idle', async () => {
-  const requests: Array<{ path: string; body: any }> = []
+test('cooldown fallback persists one ignored notice during the active run', async () => {
+  const requests: Array<{ path: string; body: Record<string, unknown> }> = []
   const server = createServer((req, res) => {
     const chunks: Buffer[] = []
     req.on('data', (chunk: Buffer) => chunks.push(chunk))
@@ -205,27 +213,17 @@ test('cooldown fallback creates only a persisted ignored notice after idle', asy
   const onCooldownFallback = config.provider?.subrouter?.options?.onCooldownFallback
   expect(onCooldownFallback).toBeTypeOf('function')
   if (typeof onCooldownFallback !== 'function') throw new Error('expected cooldown callback')
-
-  await onCooldownFallback({
+  const notice = {
     sessionID: 'session-1',
     agent: 'build',
     variant: 'high',
     preset: 'work',
-    preferred: { provider: 'xai', modelId: 'grok-4.6', retryAfterMs: 252_000 },
+    preferred: { provider: 'xai', modelId: 'grok-4.6', retryAfterMs: 250_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 })
+  } as const
+
+  await onCooldownFallback(notice)
+  await onCooldownFallback(notice)
 
   expect(requests).toEqual([
     {
@@ -238,7 +236,7 @@ test('cooldown fallback creates only a persisted ignored notice after idle', asy
         parts: [
           {
             type: 'text',
-            text: 'Subrouter: xai/grok-4.6 was rate limited. This message started with openai/gpt-5.6-sol.',
+            text: 'Subrouter: Using openai/gpt-5.6-sol because xai/grok-4.6 is rate limited.',
             ignored: true,
           },
         ],
@@ -327,10 +325,84 @@ test('preset model limits follow the first live candidate', async () => {
     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 reasoning follows the first live candidate', async () => {
+  const modelId = adapters.openai.defaultModels[0]
+  if (!modelId) throw new Error('openai adapter has no default model')
+  process.env.SUBROUTER_MODELS_DEV_URL = await startFakeModelsDev({
+    openai: {
+      models: {
+        [modelId]: {
+          id: modelId,
+          reasoning: true,
+          modalities: { input: ['text'], output: ['text'] },
+          limit: { context: 200_000, output: 64_000 },
+        },
+      },
+    },
+  })
+  await addAccount({
+    provider: 'openai',
+    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: [`openai/${modelId}`] })
+
+  const hooks = await subrouterPlugin(pluginInput)
+  const config: Config = {}
+  await hooks.config?.(config)
+
+  expect(config.provider?.subrouter?.models?.work?.reasoning).toBe(true)
+})
+
+test('preset variants follow the first live candidate', async () => {
+  const modelId = adapters.openai.defaultModels[0]
+  if (!modelId) throw new Error('openai adapter has no default model')
+  process.env.SUBROUTER_MODELS_DEV_URL = await startFakeModelsDev({
+    openai: {
+      models: {
+        [modelId]: {
+          id: modelId,
+          reasoning: true,
+          modalities: { input: ['text'], output: ['text'] },
+          reasoning_options: [{ type: 'effort', values: ['none', 'low', 'medium', 'high'] }],
+        },
+      },
+    },
+  })
+  await addAccount({
+    provider: 'openai',
+    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: [`openai/${modelId}#high`] })
+
+  const hooks = await subrouterPlugin(pluginInput)
+  const config: Config = {}
+  await hooks.config?.(config)
+
+  expect(config.provider?.subrouter?.models?.work).toMatchObject({
+    variants: {
+      none: { reasoningEffort: 'none', reasoningSummary: 'auto' },
+      low: { reasoningEffort: 'low', reasoningSummary: 'auto' },
+      medium: { reasoningEffort: 'medium', reasoningSummary: 'auto' },
+      high: { reasoningEffort: 'high', reasoningSummary: 'auto' },
+    },
   })
 })
 
@@ -454,6 +526,87 @@ test('Anthropic-compatible coding plans do not advertise video input', async ()
   })
 })
 
+test('OpenCode apply_patch matcher follows gpt- and skips gpt-4 and gpt-oss', () => {
+  expect(shouldUseApplyPatch('gpt-5.5')).toBe(true)
+  expect(shouldUseApplyPatch('gpt-5.4')).toBe(true)
+  expect(shouldUseApplyPatch('gpt-5.3-codex')).toBe(true)
+  expect(shouldUseApplyPatch('gpt-4.1')).toBe(false)
+  expect(shouldUseApplyPatch('gpt-oss-120b')).toBe(false)
+  expect(shouldUseApplyPatch('claude-opus-4-6')).toBe(false)
+})
+
+test('apply_patch api ids stay unique across presets that share a model', () => {
+  const taken = new Set<string>()
+  const first = applyPatchApiId({ preset: 'codex-a', modelId: 'gpt-5.5', taken })
+  taken.add(first)
+  const second = applyPatchApiId({ preset: 'codex-b', modelId: 'gpt-5.5', taken })
+  expect(first).toBe('gpt-5.5')
+  expect(second).toBe('gpt-5.5:codex-b')
+  expect(shouldUseApplyPatch(second)).toBe(true)
+})
+
+test('appendApplyPatchConstraint adds the OpenCode GPT line once', () => {
+  const system = ['You are powered by the model named gpt-5.5.']
+  appendApplyPatchConstraint({ system, modelId: 'gpt-5.5' })
+  appendApplyPatchConstraint({ system, modelId: 'gpt-5.5' })
+  expect(system).toEqual(['You are powered by the model named gpt-5.5.', applyPatchConstraint('gpt-5.5')])
+})
+
+test('appendApplyPatchConstraint skips non-GPT models', () => {
+  const system = ['You are powered by the model named claude-opus-4-6.']
+  appendApplyPatchConstraint({ system, modelId: 'claude-opus-4-6' })
+  expect(system).toEqual(['You are powered by the model named claude-opus-4-6.'])
+})
+
+test('openai live candidate spoofs a gpt api id so OpenCode prefers apply_patch', 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 addAccount({
+    provider: 'openai',
+    account: {
+      type: 'oauth',
+      refresh: 'refresh-o',
+      access: 'access-o',
+      expires: Date.now() + 60_000,
+      email: 'o@x.com',
+      addedAt: 1,
+      lastUsed: 1,
+    },
+  })
+  await savePreset({ name: 'default', models: ['anthropic/claude-opus-4-6'] })
+  await savePreset({ name: 'openai-only', models: ['openai/gpt-5.5'] })
+  await savePreset({ name: 'codex-b', models: ['openai/gpt-5.5'] })
+
+  const hooks = await subrouterPlugin(pluginInput)
+  const config: Config = {}
+  await hooks.config?.(config)
+
+  expect(config.provider?.subrouter?.models?.work).toBeUndefined()
+  expect(config.provider?.subrouter?.models?.['openai-only']).toMatchObject({
+    name: 'openai-only',
+    id: 'gpt-5.5',
+  })
+  expect(config.provider?.subrouter?.models?.['codex-b']).toMatchObject({
+    name: 'codex-b',
+    id: 'gpt-5.5:codex-b',
+  })
+  expect(config.provider?.subrouter?.models?.default?.id).toBeUndefined()
+  expect(config.provider?.subrouter?.options?.presetByApiId).toEqual({
+    'gpt-5.5': 'openai-only',
+    'gpt-5.5:codex-b': 'codex-b',
+  })
+})
+
 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>',
@@ -492,6 +645,84 @@ test('system transform rewrites the powered-by line to the live candidate', asyn
   expect(system[0]).not.toContain('subrouter/build')
 })
 
+test('system transform uses the in-flight session route, not the first free preset model', 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 addAccount({
+    provider: 'opencode-go',
+    account: { type: 'api', key: 'zen-key', addedAt: 1, lastUsed: 1 },
+  })
+  await savePreset({
+    name: 'default',
+    models: ['anthropic/claude-fake', 'opencode-go/fake-model'],
+  })
+  await setLiveRoute({
+    sessionID: 'ses_1',
+    preset: 'default',
+    provider: 'opencode-go',
+    modelId: 'fake-model',
+  })
+
+  const system = [
+    'You are powered by the model named default. The exact model ID is subrouter/default',
+  ]
+  await revealRoutedModel({
+    providerID: 'subrouter',
+    preset: 'default',
+    sessionID: 'ses_1',
+    system,
+  })
+
+  expect(system[0]).toContain('You are powered by the model named fake-model.')
+  expect(system[0]).toContain('The exact model ID is opencode-go/fake-model')
+  expect(system[0]).not.toContain('claude-fake')
+})
+
+test('system transform appends the apply_patch constraint for a live GPT route', async () => {
+  await addAccount({
+    provider: 'openai',
+    account: {
+      type: 'oauth',
+      refresh: 'refresh-o',
+      access: 'access-o',
+      expires: Date.now() + 60_000,
+      email: 'o@x.com',
+      addedAt: 1,
+      lastUsed: 1,
+    },
+  })
+  await savePreset({ name: 'openai-only', models: ['openai/gpt-5.5'] })
+  await setLiveRoute({
+    sessionID: 'ses_gpt',
+    preset: 'openai-only',
+    provider: 'openai',
+    modelId: 'gpt-5.5',
+  })
+
+  const system = [
+    'You are powered by the model named openai-only. The exact model ID is subrouter/openai-only',
+  ]
+  await revealRoutedModel({
+    providerID: 'subrouter',
+    preset: 'openai-only',
+    sessionID: 'ses_gpt',
+    system,
+  })
+
+  expect(system[0]).toContain('You are powered by the model named gpt-5.5.')
+  expect(system).toContain(applyPatchConstraint('gpt-5.5'))
+})
+
 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'

package/src/provider.ts

@@ -1,8 +1,10 @@
 /**
  * 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.
+ * then `sdk.languageModel(modelId)`. For GPT presets that id is a spoofed
+ * `gpt-*` api id so OpenCode prefers apply_patch; createSubrouter maps it
+ * back to the preset. Also rewrites OpenCode's powered-by identity to the
+ * live routed model and appends the GPT apply_patch constraint when needed.
  */
 
 import {
@@ -11,13 +13,56 @@ import {
   OPENAI_WEBSOCKET_SESSION_HEADER,
   OPENAI_WEBSOCKET_TITLE_HEADER,
   PROVIDER_ID,
-  resolveActiveCandidate,
+  resolveLiveModel,
+  ROUTE_AFFINITY_HEADER,
 } from '@subrouter/cli'
 
 export { createSubrouter } from '@subrouter/cli'
 
 const POWERED_BY_MODEL = /You are powered by the model named [^\n]+/
 
+// OpenCode v1 registry.ts and v2 patch.ts: GPT (not gpt-4 / gpt-oss) uses apply_patch.
+export function shouldUseApplyPatch(modelId: string) {
+  return modelId.includes('gpt-') && !modelId.includes('oss') && !modelId.includes('gpt-4')
+}
+
+export function applyPatchApiId({
+  preset,
+  modelId,
+  taken,
+}: {
+  preset: string
+  modelId: string
+  taken: Set<string>
+}) {
+  if (!taken.has(modelId)) return modelId
+  return `${modelId}:${preset}`
+}
+
+const APPLY_PATCH_GPT =
+  'Always use apply_patch for manual code edits. Do not use cat or any other commands when creating or editing files. Formatting commands or bulk edits don\'t need to be done with apply_patch.'
+
+const APPLY_PATCH_CODEX =
+  'Try to use apply_patch for single file edits, but it is fine to explore other options to make the edit if it does not work well. Do not use apply_patch for changes that are auto-generated (i.e. generating package.json or running a lint or format command like gofmt) or when scripting is more efficient (such as search and replacing a string across a codebase).'
+
+export function applyPatchConstraint(modelId: string) {
+  if (modelId.includes('codex')) return APPLY_PATCH_CODEX
+  return APPLY_PATCH_GPT
+}
+
+export function appendApplyPatchConstraint({
+  system,
+  modelId,
+}: {
+  system: string[]
+  modelId: string
+}) {
+  if (!shouldUseApplyPatch(modelId)) return
+  const constraint = applyPatchConstraint(modelId)
+  if (system.some((line) => line.includes('use apply_patch'))) return
+  system.push(constraint)
+}
+
 export function rewritePoweredByModelLine({
   system,
   candidate,
@@ -34,37 +79,48 @@ export function rewritePoweredByModelLine({
 export async function revealRoutedModel({
   providerID,
   preset,
+  sessionID,
   system,
 }: {
   providerID: string
   preset: string
+  sessionID?: string
   system: string[]
 }) {
   if (providerID !== PROVIDER_ID) return
-  const candidate = await resolveActiveCandidate(preset)
+  const candidate = await resolveLiveModel({ preset, sessionID })
   if (!candidate) return
   rewritePoweredByModelLine({ system, candidate })
+  appendApplyPatchConstraint({ system, modelId: candidate.modelId })
 }
 
-export function addSubrouterHeaders(
+export function addSubrouterHeaders({
+  input,
+  output,
+  affinityKey = input.message.id,
+}: {
   input: {
     sessionID: string
     agent: string
     model: { providerID: string }
     message: {
+      id: string
       agent: string
       model: { providerID: string; modelID: string; variant?: string }
     }
-  },
-  output: { headers: Record<string, string> },
-) {
-  if (input.model.providerID !== PROVIDER_ID) return
+  }
+  output: { headers: Record<string, string> }
+  affinityKey?: string
+}) {
+  if (input.model.providerID !== PROVIDER_ID) return null
   output.headers[OPENAI_WEBSOCKET_SESSION_HEADER] = input.sessionID
   if (input.agent === input.message.agent) {
+    output.headers[ROUTE_AFFINITY_HEADER] = affinityKey
     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'
+  return output.headers[ROUTE_AFFINITY_HEADER] ?? null
 }