@subrouter/opencode 0.4.0 → 0.5.1

package/dist/index.d.ts

@@ -7,8 +7,10 @@
  * model: pick `subrouter/default` (or any preset created with
  * `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.
+ * candidate. GPT candidates spoof a `gpt-*` api id so OpenCode prefers
+ * apply_patch over edit/write. Input modalities cover every usable candidate so the
+ * router can select a compatible subscription for each prompt. Tool
+ * follow-ups stay on the selected route until the session becomes idle.
  *
  * `subrouterAuthPlugin` registers the login flow, so `opencode auth login`
  * (and any harness driving opencode's auth hook, like kimaki's Discord

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAA;AA0C9D,eAAO,MAAM,eAAe,EAAE,MAoH7B,CAAA;AAoBD,eAAO,MAAM,mBAAmB,EAAE,MA0EjC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAA;AAkD9D,eAAO,MAAM,eAAe,EAAE,MA0L7B,CAAA;AAoBD,eAAO,MAAM,mBAAmB,EAAE,MAsFjC,CAAA"}

package/dist/index.js

@@ -7,8 +7,10 @@
  * model: pick `subrouter/default` (or any preset created with
  * `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.
+ * candidate. GPT candidates spoof a `gpt-*` api id so OpenCode prefers
+ * apply_patch over edit/write. Input modalities cover every usable candidate so the
+ * router can select a compatible subscription for each prompt. Tool
+ * follow-ups stay on the selected route until the session becomes idle.
  *
  * `subrouterAuthPlugin` registers the login flow, so `opencode auth login`
  * (and any harness driving opencode's auth hook, like kimaki's Discord
@@ -18,8 +20,8 @@
  * NOTE: only plugin initializer functions may be exported from this module.
  * OpenCode calls every export as a plugin.
  */
-import { adapters, addAccount, DEFAULT_PRESET_NAME, isProviderId, loadModelsDevCatalog, loadPresets, modelsDevInputModalities, modelsDevLimit, modelsDevModel, PROVIDER_DISPLAY_NAME, PROVIDER_ID, PROVIDER_IDS, resolveCandidates, resolvePresetModels, } from '@subrouter/cli';
-import { addSubrouterHeaders, revealRoutedModel } from "./provider.js";
+import { adapters, addAccount, DEFAULT_PRESET_NAME, isProviderId, loadModelsDevCatalog, loadPresets, modelsDevInputModalities, modelsDevLimit, modelsDevModel, variantProviderOptions, PROVIDER_DISPLAY_NAME, PROVIDER_ID, PROVIDER_IDS, clearLiveRoute, resolveCandidates, resolvePresetModels, RouteAffinity, } from '@subrouter/cli';
+import { addSubrouterHeaders, applyPatchApiId, revealRoutedModel, shouldUseApplyPatch, } from "./provider.js";
 function providerEntryUrl() {
     const isDev = import.meta.url.endsWith('.ts');
     return new URL(isDev ? './provider.ts' : './provider.js', import.meta.url).href;
@@ -41,20 +43,40 @@ function opencodeLog(client) {
 }
 export const subrouterPlugin = async ({ client, directory }) => {
     const log = opencodeLog(client);
-    const pendingNotices = new Map();
-    const onCooldownFallback = (notice) => {
-        if (!client || !notice.sessionID || !notice.agent || notice.agent === 'title')
-            return;
-        if (pendingNotices.has(notice.sessionID))
+    const affinity = new RouteAffinity();
+    const activeMessages = new Map();
+    const deliveredNotices = new Map();
+    // Surface the fallback as a TUI toast, the same channel OpenCode plugins use for
+    // notifications (see kimaki's legacy anthropic/openai/xai auth plugins). A toast is
+    // not persisted into the transcript, so it never becomes a fake user/assistant
+    // message or enters model context. tui.toast.show is a global event with no session
+    // field, so append the OpenCode session id at the end: kimaki routes the toast to
+    // the matching Discord thread by that marker and strips it before display. Plain
+    // OpenCode TUI just shows the toast for the active session.
+    const onCooldownFallback = async (notice) => {
+        if (!notice.sessionID || !notice.agent || notice.agent === 'title')
             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}.`,
-        });
+        const text = `Subrouter: Using ${active} because ${preferred} is rate limited.`;
+        const delivered = deliveredNotices.get(notice.sessionID);
+        if (delivered?.text === text && delivered.expiresAt > Date.now())
+            return;
+        const current = { text, expiresAt: Date.now() + notice.preferred.retryAfterMs };
+        deliveredNotices.set(notice.sessionID, current);
+        const result = await client.tui
+            .showToast({
+            query: { directory },
+            body: { message: `${text} ${notice.sessionID}`, variant: 'info' },
+            throwOnError: true,
+        })
+            .catch((cause) => new Error('failed to show cooldown fallback toast', { cause }));
+        if (!(result instanceof Error))
+            return;
+        if (deliveredNotices.get(notice.sessionID) === current) {
+            deliveredNotices.delete(notice.sessionID);
+        }
+        void log?.({ level: 'warn', message: result.message });
     };
     return {
         config: async (config) => {
@@ -63,7 +85,9 @@ export const subrouterPlugin = async ({ client, directory }) => {
             });
             const names = new Set([DEFAULT_PRESET_NAME, ...Object.keys(presets.presets)]);
             const catalog = await loadModelsDevCatalog({ log });
-            const models = Object.fromEntries(await Promise.all([...names].map(async (name) => {
+            const takenApiIds = new Set();
+            const presetByApiId = {};
+            const resolved = await Promise.all([...names].map(async (name) => {
                 const presetModels = await resolvePresetModels(name);
                 const candidates = presetModels instanceof Error
                     ? []
@@ -95,60 +119,97 @@ export const subrouterPlugin = async ({ client, directory }) => {
                     for (const modality of modalities)
                         input.add(modality);
                 }
-                return [
+                return { name, candidate, attachment, input, limit };
+            }));
+            const models = Object.fromEntries(resolved.map(({ name, candidate, attachment, input, limit }) => {
+                const apiId = candidate && shouldUseApplyPatch(candidate.modelId)
+                    ? applyPatchApiId({
+                        preset: name,
+                        modelId: candidate.modelId,
+                        taken: takenApiIds,
+                    })
+                    : undefined;
+                if (apiId) {
+                    takenApiIds.add(apiId);
+                    presetByApiId[apiId] = name;
+                }
+                const catalogModel = candidate
+                    ? modelsDevModel({
+                        provider: candidate.provider,
+                        modelId: candidate.modelId,
+                        catalog,
+                    })
+                    : null;
+                const reasoning = catalogModel?.reasoning ?? false;
+                const variants = candidate
+                    ? Object.fromEntries((catalogModel?.variants ?? []).map((variant) => [
+                        variant,
+                        variantProviderOptions({
+                            provider: candidate.provider,
+                            modelId: candidate.modelId,
+                            variant,
+                        }),
+                    ]))
+                    : {};
+                const model = {
                     name,
-                    {
-                        name,
-                        tool_call: true,
-                        attachment,
-                        reasoning: false,
-                        modalities: {
-                            input: [...input],
-                            output: ['text'],
-                        },
-                        cost: { input: 0, output: 0, cache_read: 0, cache_write: 0 },
-                        limit: limit ?? { context: 200_000, output: 64_000 },
+                    tool_call: true,
+                    attachment,
+                    reasoning,
+                    modalities: {
+                        input: [...input],
+                        output: ['text'],
                     },
-                ];
-            })));
+                    cost: { input: 0, output: 0, cache_read: 0, cache_write: 0 },
+                    limit: limit ?? { context: 200_000, output: 64_000 },
+                };
+                if (apiId)
+                    model.id = apiId;
+                if (Object.keys(variants).length > 0)
+                    model.variants = variants;
+                return [name, model];
+            }));
             config.provider = {
                 ...config.provider,
                 [PROVIDER_ID]: {
                     name: PROVIDER_DISPLAY_NAME,
                     npm: providerEntryUrl(),
                     models,
-                    options: { log, onCooldownFallback },
+                    options: { affinity, log, onCooldownFallback, presetByApiId },
                 },
             };
         },
         event: async ({ event }) => {
-            if (event.type !== 'session.idle')
+            if (event.type === 'session.deleted') {
+                const sessionID = event.properties.info.id;
+                const messageID = activeMessages.get(sessionID);
+                if (messageID)
+                    affinity.clear(messageID);
+                activeMessages.delete(sessionID);
+                deliveredNotices.delete(sessionID);
+                await clearLiveRoute(sessionID);
                 return;
-            const pending = pendingNotices.get(event.properties.sessionID);
-            if (!pending)
+            }
+            if (event.type !== 'session.idle')
                 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', text: pending.text, ignored: true }],
-            };
-            await client.session
-                .prompt({
-                path: { id: event.properties.sessionID },
-                query: { directory },
-                body,
-            })
-                .catch(() => { });
+            const sessionID = event.properties.sessionID;
+            const messageID = activeMessages.get(sessionID);
+            if (messageID)
+                affinity.clear(messageID);
+            activeMessages.delete(sessionID);
+            await clearLiveRoute(sessionID);
+        },
+        'chat.headers': async (input, output) => {
+            const activeMessage = activeMessages.get(input.sessionID) ?? input.message.id;
+            const affinityKey = addSubrouterHeaders({ input, output, affinityKey: activeMessage });
+            if (affinityKey)
+                activeMessages.set(input.sessionID, affinityKey);
         },
-        '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,
+                sessionID: input.sessionID,
                 system: output.system,
             });
         },
@@ -171,7 +232,8 @@ function toOpencodeCredentials(account) {
         accountId: account.accountId,
     };
 }
-export const subrouterAuthPlugin = async () => {
+export const subrouterAuthPlugin = async ({ client }) => {
+    const log = opencodeLog(client);
     return {
         auth: {
             provider: PROVIDER_ID,
@@ -218,8 +280,18 @@ export const subrouterAuthPlugin = async () => {
                             throw session;
                         const finish = async (input) => {
                             const account = await session.complete(input);
-                            if (account instanceof Error)
+                            if (account instanceof Error) {
+                                // opencode's AuthOAuthResult has no failure-with-message
+                                // variant, so the real reason cannot travel back through
+                                // oauth.callback and harnesses show a generic fallback. Log it
+                                // here so the cause is diagnosable instead of lost.
+                                void log?.({
+                                    level: 'error',
+                                    message: `login failed: ${account.message}`,
+                                    extra: { provider: providerId },
+                                });
                                 return { type: 'failed' };
+                            }
                             await addAccount({ provider: providerId, account });
                             return toOpencodeCredentials(account);
                         };

package/dist/opencode-e2e.test.js

@@ -12,12 +12,12 @@
 import { createOpencodeClient } from '@opencode-ai/sdk';
 import { createOpencodeServer } from '@opencode-ai/sdk/server';
 import { createServer } 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 { OPENCODE_AGENT_HEADER, OPENCODE_VARIANT_HEADER, OPENAI_WEBSOCKET_SESSION_HEADER, OPENAI_WEBSOCKET_TITLE_HEADER, addAccount, markCooldown, } from '@subrouter/cli';
+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.js";
 function summarizeSessionEvents(events) {
     const summary = [];
@@ -90,6 +90,9 @@ let projectDir;
 let anthropicMock;
 let modelsDevMock;
 let zenMock;
+let openaiMock;
+let zenRespond;
+let defaultZenRespond;
 let server;
 const savedEnv = {};
 beforeAll(async () => {
@@ -102,7 +105,7 @@ beforeAll(async () => {
         res.end(JSON.stringify({ type: 'error', error: { type: 'rate_limit_error', message: 'rate limited' } }));
     });
     // 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' });
@@ -138,6 +141,53 @@ 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: {} };
@@ -150,7 +200,7 @@ beforeAll(async () => {
         res.writeHead(200, { 'content-type': 'application/json' });
         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,
@@ -169,6 +219,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'),
@@ -194,6 +245,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')).href;
     const pluginEntry = pathToFileURL(path.join(import.meta.dirname, '..', 'dist', 'index.js')).href;
     server = await createOpencodeServer({
@@ -220,11 +288,15 @@ 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];
@@ -237,29 +309,38 @@ describe('opencode + subrouter provider', () => {
     test('adds session affinity headers for subrouter models', async () => {
         const output = { headers: {} };
         addSubrouterHeaders({
-            sessionID: 'session-1',
-            agent: 'build',
-            model: { providerID: 'subrouter' },
-            message: {
+            input: {
+                sessionID: 'session-1',
                 agent: 'build',
-                model: { providerID: 'subrouter', modelID: 'build', variant: 'high' },
+                model: { providerID: 'subrouter' },
+                message: {
+                    id: 'message-1',
+                    agent: 'build',
+                    model: { providerID: 'subrouter', modelID: 'build', variant: 'high' },
+                },
             },
-        }, output);
+            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({
-            sessionID: 'session-2',
-            agent: 'title',
-            model: { providerID: 'subrouter' },
-            message: {
-                agent: 'build',
-                model: { providerID: 'subrouter', modelID: 'build', variant: 'high' },
+            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',
@@ -290,8 +371,18 @@ 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 () => {
+    test('a pre-existing cooldown shows one session toast without another model turn', async () => {
         const client = createOpencodeClient({ baseUrl: server.url });
+        const toasts = [];
+        const subscription = await client.event.subscribe({
+            query: { directory: projectDir },
+        });
+        void (async () => {
+            for await (const event of subscription.stream) {
+                if (event.type === 'tui.toast.show')
+                    toasts.push({ message: event.properties.message });
+            }
+        })();
         const session = await client.session.create({
             query: { directory: projectDir },
             body: { title: 'subrouter route notice' },
@@ -310,27 +401,16 @@ describe('opencode + subrouter provider', () => {
             .filter((part) => part.type === 'text')
             .map((part) => part.text)
             .join('\n')).toContain('hello from fallback');
+        // The toast is session-scoped through the trailing session-id marker and never
+        // enters the transcript, so no extra user/assistant message and no extra model turn.
         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);
+            .poll(() => toasts.filter(({ message }) => message.startsWith('Subrouter: Using ') && message.endsWith(session.data.id)).length)
+            .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(1);
         expect((messages.data ?? []).filter(({ info }) => info.role === 'assistant')).toHaveLength(1);
         expect(zenMock.requests).toHaveLength(requestsBefore + 1);
     }, 120_000);
@@ -437,4 +517,141 @@ 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 = [];
+        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);
+        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);
 });