@subrouter/opencode 0.2.0 → 0.4.0

package/dist/plugin.test.js

@@ -1,19 +1,27 @@
+import childProcess from 'node:child_process';
 import { createServer } from 'node:http';
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+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 { loadAccounts, PROVIDER_IDS } from '@subrouter/cli';
+import { createOpencodeClient } from '@opencode-ai/sdk';
+import { addAccount, adapters, loadAccounts, PROVIDER_DISPLAY_NAME, PROVIDER_IDS, savePreset, } from '@subrouter/cli';
 import { subrouterAuthPlugin, subrouterPlugin } from "./index.js";
+import { revealRoutedModel, rewritePoweredByModelLine } from "./provider.js";
+const execFile = util.promisify(childProcess.execFile);
 let home;
 const openServers = [];
+const pluginInput = {};
 beforeEach(async () => {
     home = await mkdtemp(path.join(tmpdir(), 'subrouter-plugin-'));
     process.env.SUBROUTER_HOME = home;
+    process.env.SUBROUTER_MODELS_DEV_URL = await startFakeModelsDev();
 });
 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)) {
         await new Promise((resolve) => {
             server.close(() => {
@@ -23,6 +31,33 @@ afterEach(async () => {
     }
     await rm(home, { recursive: true, force: true });
 });
+async function startFakeModelsDev(providers = {}) {
+    const payload = {
+        anthropic: { models: {} },
+        openai: { models: {} },
+        xai: { models: {} },
+        'opencode-go': { models: {} },
+        'github-copilot': { models: {} },
+        poe: { models: {} },
+        'minimax-coding-plan': { models: {} },
+        'kimi-for-coding': { models: {} },
+        'zai-coding-plan': { models: {} },
+        'alibaba-coding-plan': { models: {} },
+        ...providers,
+    };
+    const server = createServer((_req, res) => {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(payload));
+    });
+    await new Promise((resolve) => {
+        server.listen(0, '127.0.0.1', resolve);
+    });
+    const address = server.address();
+    if (typeof address === 'string' || !address)
+        throw new Error('failed to bind fake models.dev');
+    openServers.push(server);
+    return `http://127.0.0.1:${address.port}`;
+}
 /** Minimal stand-in for the OpenAI Codex device endpoints. */
 async function startFakeOpenAIIssuer() {
     const server = createServer((req, res) => {
@@ -58,24 +93,356 @@ async function startFakeOpenAIIssuer() {
     return `http://127.0.0.1:${address.port}`;
 }
 function authMethod() {
-    return subrouterAuthPlugin({}).then((hooks) => {
+    return subrouterAuthPlugin(pluginInput).then((hooks) => {
         const method = hooks.auth?.methods[0];
         if (!method || method.type !== 'oauth')
             throw new Error('expected an oauth method');
         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 creates only a persisted ignored notice after idle', 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');
+    await onCooldownFallback({
+        sessionID: 'session-1',
+        agent: 'build',
+        variant: 'high',
+        preset: 'work',
+        preferred: { provider: 'xai', modelId: 'grok-4.6', retryAfterMs: 252_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 = {
+        type: 'session.idle',
+        properties: { sessionID: 'session-1' },
+    };
+    await hooks.event?.({ event });
+    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: xai/grok-4.6 was rate limited. This message started with openai/gpt-5.6-sol.',
+                        ignored: true,
+                    },
+                ],
+            },
+        },
+    ]);
+});
 test('config hook registers the subrouter provider with preset models', async () => {
-    await writeFile(path.join(home, 'presets.json'), JSON.stringify({ version: 1, presets: { work: ['anthropic/claude-opus-4-6'] } }));
-    const hooks = await subrouterPlugin({});
+    await savePreset({ name: 'work', models: ['anthropic/claude-opus-4-6'] });
+    const hooks = await subrouterPlugin(pluginInput);
     const config = {};
     await hooks.config?.(config);
     const provider = config.provider?.subrouter;
     expect(provider).toBeTruthy();
+    expect(provider.name).toBe(PROVIDER_DISPLAY_NAME);
     expect(provider.npm.startsWith('file://')).toBe(true);
     expect(provider.npm.endsWith('provider.ts') || provider.npm.endsWith('provider.js')).toBe(true);
     expect(Object.keys(provider.models).sort()).toEqual(['default', 'work']);
+    expect(provider.models.default.name).toBe('default');
+    expect(provider.models.work.name).toBe('work');
     expect(provider.models.default.cost).toEqual({ input: 0, output: 0, cache_read: 0, cache_write: 0 });
+    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 stay stable when the routed candidate changes', 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 savePreset({ name: 'work', models: ['anthropic/claude-opus-4-6'] });
+    const hooks = await subrouterPlugin(pluginInput);
+    const config = {};
+    await hooks.config?.(config);
+    expect(config.provider?.subrouter?.name).toBe(PROVIDER_DISPLAY_NAME);
+    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];
+    if (!modelId)
+        throw new Error('anthropic adapter has no default model');
+    process.env.SUBROUTER_MODELS_DEV_URL = await startFakeModelsDev({
+        anthropic: {
+            models: {
+                [modelId]: {
+                    id: modelId,
+                    modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+                    limit: { context: 1_000_000, input: 900_000, output: 128_000 },
+                },
+            },
+        },
+    });
+    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 savePreset({ name: 'work', models: [`anthropic/${modelId}`] });
+    const hooks = await subrouterPlugin(pluginInput);
+    const config = {};
+    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,
+        input: 900_000,
+        output: 128_000,
+    });
+});
+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'],
+            output: ['text'],
+        },
+    });
+});
+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('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>',
+    ];
+    rewritePoweredByModelLine({
+        system,
+        candidate: { provider: 'anthropic', modelId: 'claude-opus-4-6' },
+    });
+    expect(system[0]).toContain('You are powered by the model named claude-opus-4-6.');
+    expect(system[0]).toContain('The exact model ID is anthropic/claude-opus-4-6');
+    expect(system[0]).not.toContain('subrouter/build');
+});
+test('system transform rewrites the powered-by line to the live candidate', 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,
+        },
+    });
+    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>',
+    ];
+    await revealRoutedModel({ providerID: 'subrouter', preset: 'default', system });
+    const modelId = adapters.anthropic.defaultModels[0];
+    expect(system[0]).toContain(`You are powered by the model named ${modelId}.`);
+    expect(system[0]).toContain(`The exact model ID is anthropic/${modelId}`);
+    expect(system[0]).not.toContain('subrouter/build');
+});
+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];
+    await revealRoutedModel({ providerID: 'anthropic', preset: 'claude-opus-4-6', system });
+    expect(system[0]).toBe(original);
 });
 test('auth hook asks which subscription to add before authorizing', async () => {
     const { provider, method } = await authMethod();
@@ -112,22 +479,22 @@ test('authorize dispatches to the chosen adapter and the callback pools the acco
         { type: 'oauth', email: 'pool@example.com', accountId: 'acct-9' },
     ]);
 });
-test('opencode zen asks for a pasted key and stores it as an api account', async () => {
+test('opencode go asks for a pasted key and stores it as an api account', async () => {
     const { method } = await authMethod();
-    const result = await method.authorize({ provider: 'opencode' });
+    const result = await method.authorize({ provider: 'opencode-go' });
     expect(result.method).toBe('code');
     if (result.method !== 'code')
         throw new Error('expected a pasted-key flow');
-    expect(await result.callback('zen-key-1')).toMatchObject({ type: 'success', key: 'zen-key-1' });
+    expect(await result.callback('go-key-1')).toMatchObject({ type: 'success', key: 'go-key-1' });
     const accounts = await loadAccounts();
-    expect(accounts.providers.opencode?.accounts).toMatchObject([{ type: 'api', key: 'zen-key-1' }]);
+    expect(accounts.providers['opencode-go']?.accounts).toMatchObject([{ type: 'api', key: 'go-key-1' }]);
 });
 test('a failed login reports failure instead of pooling a broken account', async () => {
     const { method } = await authMethod();
-    const result = await method.authorize({ provider: 'opencode' });
+    const result = await method.authorize({ provider: 'opencode-go' });
     if (result.method !== 'code')
         throw new Error('expected a pasted-key flow');
     expect(await result.callback('   ')).toEqual({ type: 'failed' });
     const accounts = await loadAccounts();
-    expect(accounts.providers.opencode).toBeUndefined();
+    expect(accounts.providers['opencode-go']).toBeUndefined();
 });

package/dist/provider.d.ts

@@ -2,14 +2,35 @@
  * 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.
  */
 export { createSubrouter } from '@subrouter/cli';
+export declare function rewritePoweredByModelLine({ system, candidate, }: {
+    system: string[];
+    candidate: {
+        provider: string;
+        modelId: string;
+    };
+}): void;
+export declare function revealRoutedModel({ providerID, preset, system, }: {
+    providerID: string;
+    preset: string;
+    system: string[];
+}): Promise<void>;
 export declare function addSubrouterHeaders(input: {
     sessionID: string;
     agent: string;
     model: {
         providerID: string;
     };
+    message: {
+        agent: string;
+        model: {
+            providerID: string;
+            modelID: string;
+            variant?: string;
+        };
+    };
 }, output: {
     headers: Record<string, string>;
 }): void;

package/dist/provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAEhD,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;;;;;GAKG;AAWH,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;IACL,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,CAAA;IAC7B,OAAO,EAAE;QACP,KAAK,EAAE,MAAM,CAAA;QACb,KAAK,EAAE;YAAE,UAAU,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAC;YAAC,OAAO,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KACjE,CAAA;CACF,EACD,MAAM,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,QAW5C"}

package/dist/provider.js

@@ -2,13 +2,35 @@
  * 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.
  */
-import { OPENAI_WEBSOCKET_SESSION_HEADER, OPENAI_WEBSOCKET_TITLE_HEADER, } from '@subrouter/cli';
+import { OPENCODE_AGENT_HEADER, OPENCODE_VARIANT_HEADER, OPENAI_WEBSOCKET_SESSION_HEADER, OPENAI_WEBSOCKET_TITLE_HEADER, PROVIDER_ID, resolveActiveCandidate, } from '@subrouter/cli';
 export { createSubrouter } from '@subrouter/cli';
+const POWERED_BY_MODEL = /You are powered by the model named [^\n]+/;
+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, }) {
+    if (providerID !== PROVIDER_ID)
+        return;
+    const candidate = await resolveActiveCandidate(preset);
+    if (!candidate)
+        return;
+    rewritePoweredByModelLine({ system, candidate });
+}
 export function addSubrouterHeaders(input, output) {
-    if (input.model.providerID !== 'subrouter')
+    if (input.model.providerID !== PROVIDER_ID)
         return;
     output.headers[OPENAI_WEBSOCKET_SESSION_HEADER] = input.sessionID;
+    if (input.agent === input.message.agent) {
+        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';
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@subrouter/opencode",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "type": "module",
   "description": "OpenCode plugin that registers the subrouter provider: cycle through your personal AI subscriptions when one hits rate limits.",
   "main": "./dist/index.js",
@@ -44,7 +44,7 @@
   },
   "dependencies": {
     "errore": "^0.14.1",
-    "@subrouter/cli": "^0.2.0"
+    "@subrouter/cli": "^0.5.0"
   },
   "devDependencies": {
     "@opencode-ai/plugin": "^1.18.23",