@subrouter/opencode 0.3.0 → 0.5.0

package/dist/plugin.test.js

@@ -1,11 +1,15 @@
+import childProcess from 'node:child_process';
 import { createServer } from 'node:http';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
+import util from 'node:util';
 import { afterEach, beforeEach, expect, test } from 'vitest';
-import { addAccount, adapters, loadAccounts, PROVIDER_DISPLAY_NAME, PROVIDER_IDS, savePreset, setSubrouterLog, } from '@subrouter/cli';
+import { createOpencodeClient } from '@opencode-ai/sdk';
+import { addAccount, adapters, loadAccounts, PROVIDER_DISPLAY_NAME, PROVIDER_IDS, savePreset, setLiveRoute, } from '@subrouter/cli';
 import { subrouterAuthPlugin, subrouterPlugin } from "./index.js";
-import { revealRoutedModel, rewritePoweredByModelLine } from "./provider.js";
+import { appendApplyPatchConstraint, applyPatchApiId, applyPatchConstraint, revealRoutedModel, rewritePoweredByModelLine, shouldUseApplyPatch, } from "./provider.js";
+const execFile = util.promisify(childProcess.execFile);
 let home;
 const openServers = [];
 const pluginInput = {};
@@ -15,8 +19,6 @@ beforeEach(async () => {
     process.env.SUBROUTER_MODELS_DEV_URL = await startFakeModelsDev();
 });
 afterEach(async () => {
-    setSubrouterLog(undefined);
-    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)) {
@@ -97,6 +99,110 @@ function authMethod() {
         return { provider: hooks.auth.provider, method };
     });
 }
+test('plugin load and config do not write stdout or stderr', async () => {
+    const script = "import('./src/index.ts').then(async ({ subrouterPlugin }) => { const hooks = await subrouterPlugin({}); await hooks.config?.({}) })";
+    const result = await execFile(process.execPath, ['--no-warnings', '--import', 'tsx', '--eval', script], {
+        cwd: process.cwd(),
+        env: process.env,
+    });
+    expect(result).toEqual({ stdout: '', stderr: '' });
+});
+test('provider log callback forwards only to client.app.log', async () => {
+    const received = Promise.withResolvers();
+    const server = createServer((req, res) => {
+        const chunks = [];
+        req.on('data', (chunk) => {
+            chunks.push(chunk);
+        });
+        req.on('end', () => {
+            received.resolve(JSON.parse(Buffer.concat(chunks).toString('utf8')));
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end('{}');
+        });
+    });
+    await new Promise((resolve) => {
+        server.listen(0, '127.0.0.1', resolve);
+    });
+    openServers.push(server);
+    const address = server.address();
+    if (typeof address === 'string' || !address)
+        throw new Error('failed to bind log server');
+    const client = createOpencodeClient({ baseUrl: `http://127.0.0.1:${address.port}` });
+    const hooks = await subrouterPlugin({ ...pluginInput, client });
+    const config = {};
+    await hooks.config?.(config);
+    const log = config.provider?.subrouter?.options?.log;
+    expect(log).toBeTypeOf('function');
+    if (typeof log !== 'function')
+        throw new Error('expected provider log callback');
+    await log({
+        level: 'warn',
+        message: 'failover openai/gpt-5.5',
+        extra: { provider: 'openai', modelId: 'gpt-5.5' },
+    });
+    expect(await received.promise).toEqual({
+        service: 'subrouter',
+        level: 'warn',
+        message: 'failover openai/gpt-5.5',
+        extra: { provider: 'openai', modelId: 'gpt-5.5' },
+    });
+});
+test('cooldown fallback persists one ignored notice during the active run', async () => {
+    const requests = [];
+    const server = createServer((req, res) => {
+        const chunks = [];
+        req.on('data', (chunk) => chunks.push(chunk));
+        req.on('end', () => {
+            requests.push({
+                path: req.url ?? '',
+                body: JSON.parse(Buffer.concat(chunks).toString('utf8')),
+            });
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end('{}');
+        });
+    });
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+    openServers.push(server);
+    const address = server.address();
+    if (typeof address === 'string' || !address)
+        throw new Error('failed to bind notification server');
+    const client = createOpencodeClient({ baseUrl: `http://127.0.0.1:${address.port}` });
+    const hooks = await subrouterPlugin({ ...pluginInput, client, directory: '/tmp/project' });
+    const config = {};
+    await hooks.config?.(config);
+    const onCooldownFallback = config.provider?.subrouter?.options?.onCooldownFallback;
+    expect(onCooldownFallback).toBeTypeOf('function');
+    if (typeof onCooldownFallback !== 'function')
+        throw new Error('expected cooldown callback');
+    const notice = {
+        sessionID: 'session-1',
+        agent: 'build',
+        variant: 'high',
+        preset: 'work',
+        preferred: { provider: 'xai', modelId: 'grok-4.6', retryAfterMs: 250_000 },
+        active: { provider: 'openai', modelId: 'gpt-5.6-sol' },
+    };
+    await onCooldownFallback(notice);
+    await onCooldownFallback(notice);
+    expect(requests).toEqual([
+        {
+            path: '/session/session-1/message?directory=%2Ftmp%2Fproject',
+            body: {
+                noReply: true,
+                agent: 'build',
+                model: { providerID: 'subrouter', modelID: 'work' },
+                variant: 'high',
+                parts: [
+                    {
+                        type: 'text',
+                        text: 'Subrouter: Using openai/gpt-5.6-sol because xai/grok-4.6 is rate limited.',
+                        ignored: true,
+                    },
+                ],
+            },
+        },
+    ]);
+});
 test('config hook registers the subrouter provider with preset models', async () => {
     await savePreset({ name: 'work', models: ['anthropic/claude-opus-4-6'] });
     const hooks = await subrouterPlugin(pluginInput);
@@ -114,7 +220,7 @@ test('config hook registers the subrouter provider with preset models', async ()
     expect(provider.models.default.limit).toEqual({ context: 200_000, output: 64_000 });
     expect(provider.models.work.limit).toEqual({ context: 200_000, output: 64_000 });
 });
-test('preset model names show the first live candidate', async () => {
+test('preset model names stay stable when the routed candidate changes', async () => {
     await addAccount({
         provider: 'anthropic',
         account: {
@@ -132,7 +238,7 @@ test('preset model names show the first live candidate', async () => {
     const config = {};
     await hooks.config?.(config);
     expect(config.provider?.subrouter?.name).toBe(PROVIDER_DISPLAY_NAME);
-    expect(config.provider?.subrouter?.models?.work?.name).toBe('work (claude-opus-4-6)');
+    expect(config.provider?.subrouter?.models?.work?.name).toBe('work');
 });
 test('preset model limits follow the first live candidate', async () => {
     const modelId = adapters.anthropic.defaultModels[0];
@@ -143,8 +249,8 @@ test('preset model limits follow the first live candidate', async () => {
             models: {
                 [modelId]: {
                     id: modelId,
-                    modalities: { output: ['text'] },
-                    limit: { context: 1_000_000, output: 128_000 },
+                    modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+                    limit: { context: 1_000_000, input: 900_000, output: 128_000 },
                 },
             },
         },
@@ -167,18 +273,126 @@ test('preset model limits follow the first live candidate', async () => {
     await hooks.config?.(config);
     expect(config.provider?.subrouter?.models?.work?.limit).toEqual({
         context: 1_000_000,
+        input: 900_000,
         output: 128_000,
     });
-    expect(config.provider?.subrouter?.models?.default?.limit).toEqual({
-        context: 1_000_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 = {};
+    await hooks.config?.(config);
+    expect(config.provider?.subrouter?.models?.work?.reasoning).toBe(true);
 });
-test('preset models permit image and PDF attachments', async () => {
+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 = {};
     await hooks.config?.(config);
-    expect(config.provider?.subrouter?.models?.default).toMatchObject({
+    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' },
+        },
+    });
+});
+test('preset model input modalities are the union of usable candidates', async () => {
+    process.env.SUBROUTER_MODELS_DEV_URL = await startFakeModelsDev({
+        openai: {
+            models: {
+                'gpt-pdf': {
+                    id: 'gpt-pdf',
+                    attachment: true,
+                    modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+                },
+            },
+        },
+        'kimi-for-coding': {
+            models: {
+                'kimi-image': {
+                    id: 'kimi-image',
+                    attachment: true,
+                    modalities: { input: ['text', 'image'], output: ['text'] },
+                },
+            },
+        },
+    });
+    await addAccount({
+        provider: 'openai',
+        account: {
+            type: 'oauth',
+            access: 'access-1',
+            refresh: 'refresh-1',
+            expires: Date.now() + 60_000,
+            addedAt: 1,
+            lastUsed: 1,
+        },
+    });
+    await addAccount({
+        provider: 'kimi',
+        account: { type: 'api', key: 'kimi-key', addedAt: 1, lastUsed: 1 },
+    });
+    await savePreset({ name: 'work', models: ['openai/gpt-pdf', 'kimi/kimi-image'] });
+    const hooks = await subrouterPlugin(pluginInput);
+    const config = {};
+    await hooks.config?.(config);
+    expect(config.provider?.subrouter?.models?.work).toMatchObject({
         attachment: true,
         modalities: {
             input: ['text', 'image', 'pdf'],
@@ -186,6 +400,143 @@ test('preset models permit image and PDF attachments', async () => {
         },
     });
 });
+test('xAI presets do not advertise inline PDF support that its SDK cannot encode', async () => {
+    process.env.SUBROUTER_MODELS_DEV_URL = await startFakeModelsDev({
+        xai: {
+            models: {
+                'grok-pdf': {
+                    id: 'grok-pdf',
+                    attachment: true,
+                    modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+                },
+            },
+        },
+    });
+    await addAccount({
+        provider: 'xai',
+        account: {
+            type: 'oauth',
+            access: 'access-1',
+            refresh: 'refresh-1',
+            expires: Date.now() + 60_000,
+            addedAt: 1,
+            lastUsed: 1,
+        },
+    });
+    await savePreset({ name: 'work', models: ['xai/grok-pdf'] });
+    const hooks = await subrouterPlugin(pluginInput);
+    const config = {};
+    await hooks.config?.(config);
+    expect(config.provider?.subrouter?.models?.work).toMatchObject({
+        attachment: true,
+        modalities: {
+            input: ['text', 'image'],
+            output: ['text'],
+        },
+    });
+});
+test('Anthropic-compatible coding plans do not advertise video input', async () => {
+    process.env.SUBROUTER_MODELS_DEV_URL = await startFakeModelsDev({
+        'kimi-for-coding': {
+            models: {
+                'kimi-video': {
+                    id: 'kimi-video',
+                    attachment: true,
+                    modalities: { input: ['text', 'image', 'video'], output: ['text'] },
+                },
+            },
+        },
+    });
+    await addAccount({
+        provider: 'kimi',
+        account: { type: 'api', key: 'kimi-key', addedAt: 1, lastUsed: 1 },
+    });
+    await savePreset({ name: 'work', models: ['kimi/kimi-video'] });
+    const hooks = await subrouterPlugin(pluginInput);
+    const config = {};
+    await hooks.config?.(config);
+    expect(config.provider?.subrouter?.models?.work).toMatchObject({
+        attachment: true,
+        modalities: {
+            input: ['text', 'image'],
+            output: ['text'],
+        },
+    });
+});
+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();
+    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 = {};
+    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>',
@@ -220,6 +571,78 @@ test('system transform rewrites the powered-by line to the live candidate', asyn
     expect(system[0]).toContain(`The exact model ID is anthropic/${modelId}`);
     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';
     const system = [original];

package/dist/provider.d.ts

@@ -1,10 +1,23 @@
 /**
  * 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.
  */
 export { createSubrouter } from '@subrouter/cli';
+export declare function shouldUseApplyPatch(modelId: string): boolean;
+export declare function applyPatchApiId({ preset, modelId, taken, }: {
+    preset: string;
+    modelId: string;
+    taken: Set<string>;
+}): string;
+export declare function applyPatchConstraint(modelId: string): "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." | "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 declare function appendApplyPatchConstraint({ system, modelId, }: {
+    system: string[];
+    modelId: string;
+}): void;
 export declare function rewritePoweredByModelLine({ system, candidate, }: {
     system: string[];
     candidate: {
@@ -12,18 +25,32 @@ export declare function rewritePoweredByModelLine({ system, candidate, }: {
         modelId: string;
     };
 }): void;
-export declare function revealRoutedModel({ providerID, preset, system, }: {
+export declare function revealRoutedModel({ providerID, preset, sessionID, system, }: {
     providerID: string;
     preset: string;
+    sessionID?: string;
     system: string[];
 }): Promise<void>;
-export declare function addSubrouterHeaders(input: {
-    sessionID: string;
-    agent: string;
-    model: {
-        providerID: string;
+export declare function addSubrouterHeaders({ input, output, affinityKey, }: {
+    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>;
-}): void;
+    output: {
+        headers: Record<string, string>;
+    };
+    affinityKey?: string;
+}): string | null;
 //# sourceMappingURL=provider.d.ts.map

package/dist/provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAIhD,wBAAgB,yBAAyB,CAAC,EACxC,MAAM,EACN,SAAS,GACV,EAAE;IACD,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,SAAS,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;CACjD,QAKA;AAED,wBAAsB,iBAAiB,CAAC,EACtC,UAAU,EACV,MAAM,EACN,MAAM,GACP,EAAE;IACD,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,EAAE,CAAA;CACjB,iBAKA;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,EAC1E,MAAM,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,QAK5C"}
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAYH,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAKhD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,WAElD;AAED,wBAAgB,eAAe,CAAC,EAC9B,MAAM,EACN,OAAO,EACP,KAAK,GACN,EAAE;IACD,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CACnB,UAGA;AAQD,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,+iBAGnD;AAED,wBAAgB,0BAA0B,CAAC,EACzC,MAAM,EACN,OAAO,GACR,EAAE;IACD,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;CAChB,QAKA;AAED,wBAAgB,yBAAyB,CAAC,EACxC,MAAM,EACN,SAAS,GACV,EAAE;IACD,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,SAAS,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;CACjD,QAKA;AAED,wBAAsB,iBAAiB,CAAC,EACtC,UAAU,EACV,MAAM,EACN,SAAS,EACT,MAAM,GACP,EAAE;IACD,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,MAAM,EAAE,CAAA;CACjB,iBAMA;AAED,wBAAgB,mBAAmB,CAAC,EAClC,KAAK,EACL,MAAM,EACN,WAA8B,GAC/B,EAAE;IACD,KAAK,EAAE;QACL,SAAS,EAAE,MAAM,CAAA;QACjB,KAAK,EAAE,MAAM,CAAA;QACb,KAAK,EAAE;YAAE,UAAU,EAAE,MAAM,CAAA;SAAE,CAAA;QAC7B,OAAO,EAAE;YACP,EAAE,EAAE,MAAM,CAAA;YACV,KAAK,EAAE,MAAM,CAAA;YACb,KAAK,EAAE;gBAAE,UAAU,EAAE,MAAM,CAAC;gBAAC,OAAO,EAAE,MAAM,CAAC;gBAAC,OAAO,CAAC,EAAE,MAAM,CAAA;aAAE,CAAA;SACjE,CAAA;KACF,CAAA;IACD,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAA;IAC3C,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,iBAYA"}

package/dist/provider.js

@@ -1,30 +1,65 @@
 /**
  * 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 { OPENAI_WEBSOCKET_SESSION_HEADER, OPENAI_WEBSOCKET_TITLE_HEADER, PROVIDER_ID, resolveActiveCandidate, } from '@subrouter/cli';
+import { OPENCODE_AGENT_HEADER, OPENCODE_VARIANT_HEADER, OPENAI_WEBSOCKET_SESSION_HEADER, OPENAI_WEBSOCKET_TITLE_HEADER, PROVIDER_ID, 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) {
+    return modelId.includes('gpt-') && !modelId.includes('oss') && !modelId.includes('gpt-4');
+}
+export function applyPatchApiId({ preset, modelId, taken, }) {
+    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) {
+    if (modelId.includes('codex'))
+        return APPLY_PATCH_CODEX;
+    return APPLY_PATCH_GPT;
+}
+export function appendApplyPatchConstraint({ system, modelId, }) {
+    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, }) {
     const line = `You are powered by the model named ${candidate.modelId}. The exact model ID is ${candidate.provider}/${candidate.modelId}`;
     for (let i = 0; i < system.length; i++) {
         system[i] = system[i].replace(POWERED_BY_MODEL, line);
     }
 }
-export async function revealRoutedModel({ providerID, preset, system, }) {
+export async function revealRoutedModel({ providerID, preset, sessionID, system, }) {
     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(input, output) {
+export function addSubrouterHeaders({ input, output, affinityKey = input.message.id, }) {
     if (input.model.providerID !== PROVIDER_ID)
-        return;
+        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;
 }