@subrouter/opencode 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -1,14 +1,23 @@
 /**
- * OpenCode plugin that registers the `subrouter` provider.
+ * OpenCode plugins that expose subrouter inside opencode.
  *
- * The config hook injects a custom provider whose npm field points at this
- * package's provider module (file:// URL, so opencode never installs anything).
- * Each subrouter preset becomes a model: pick `subrouter/default` (or any
- * preset created with `subrouter preset create`) in opencode.
+ * `subrouterPlugin` registers the provider: the config hook injects a custom
+ * provider whose npm field points at this package's provider module (file://
+ * URL, so opencode never installs anything). Each subrouter preset becomes a
+ * model: pick `subrouter/default` (or any preset created with
+ * `subrouter preset create`) in opencode. Provider id stays `subrouter`; the
+ * visible name is `subrouter.org`. Model names, context limits, and
+ * `experimental.chat.system.transform` follow the first live routed candidate.
+ *
+ * `subrouterAuthPlugin` registers the login flow, so `opencode auth login`
+ * (and any harness driving opencode's auth hook, like kimaki's Discord
+ * `/login`) can add subscriptions to the pool without leaving the harness.
+ * It asks which subscription to add first, then defers to that adapter.
  *
  * NOTE: only plugin initializer functions may be exported from this module.
  * OpenCode calls every export as a plugin.
  */
 import type { Plugin } from '@opencode-ai/plugin';
 export declare const subrouterPlugin: Plugin;
+export declare const subrouterAuthPlugin: Plugin;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAQjD,eAAO,MAAM,eAAe,EAAE,MA+B7B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAuBjD,eAAO,MAAM,eAAe,EAAE,MA4E7B,CAAA;AAoBD,eAAO,MAAM,mBAAmB,EAAE,MA0EjC,CAAA"}

package/dist/index.js

@@ -1,46 +1,185 @@
 /**
- * OpenCode plugin that registers the `subrouter` provider.
+ * OpenCode plugins that expose subrouter inside opencode.
  *
- * The config hook injects a custom provider whose npm field points at this
- * package's provider module (file:// URL, so opencode never installs anything).
- * Each subrouter preset becomes a model: pick `subrouter/default` (or any
- * preset created with `subrouter preset create`) in opencode.
+ * `subrouterPlugin` registers the provider: the config hook injects a custom
+ * provider whose npm field points at this package's provider module (file://
+ * URL, so opencode never installs anything). Each subrouter preset becomes a
+ * model: pick `subrouter/default` (or any preset created with
+ * `subrouter preset create`) in opencode. Provider id stays `subrouter`; the
+ * visible name is `subrouter.org`. Model names, context limits, and
+ * `experimental.chat.system.transform` follow the first live routed candidate.
+ *
+ * `subrouterAuthPlugin` registers the login flow, so `opencode auth login`
+ * (and any harness driving opencode's auth hook, like kimaki's Discord
+ * `/login`) can add subscriptions to the pool without leaving the harness.
+ * It asks which subscription to add first, then defers to that adapter.
  *
  * NOTE: only plugin initializer functions may be exported from this module.
  * OpenCode calls every export as a plugin.
  */
-import { DEFAULT_PRESET_NAME, loadPresets } from '@subrouter/cli';
+import { adapters, addAccount, DEFAULT_PRESET_NAME, isProviderId, loadModelsDevCatalog, loadPresets, modelsDevLimit, PROVIDER_DISPLAY_NAME, PROVIDER_ID, PROVIDER_IDS, resolveActiveCandidate, setSubrouterLog, } from '@subrouter/cli';
+import { addSubrouterHeaders, revealRoutedModel } from "./provider.js";
 function providerEntryUrl() {
     const isDev = import.meta.url.endsWith('.ts');
     return new URL(isDev ? './provider.ts' : './provider.js', import.meta.url).href;
 }
-export const subrouterPlugin = async () => {
+export const subrouterPlugin = async ({ client }) => {
+    // OpenCode loads this plugin and the provider module separately. Both import
+    // @subrouter/cli; this callback is the only log sink the router may use.
+    // Never console.log here. OpenCode prints plugin logs via client.app.log.
+    if (client?.app?.log) {
+        setSubrouterLog((entry) => {
+            void client.app
+                .log({
+                body: {
+                    service: 'subrouter',
+                    level: entry.level,
+                    message: entry.message,
+                    extra: entry.extra,
+                },
+            })
+                .catch(() => { });
+        });
+    }
     return {
         config: async (config) => {
             const presets = await loadPresets().catch(() => {
                 return { version: 1, presets: {} };
             });
             const names = new Set([DEFAULT_PRESET_NAME, ...Object.keys(presets.presets)]);
-            const models = Object.fromEntries([...names].map((name) => [
-                name,
-                {
-                    name: `subrouter ${name}`,
-                    tool_call: true,
-                    attachment: false,
-                    reasoning: false,
-                    cost: { input: 0, output: 0, cache_read: 0, cache_write: 0 },
-                    limit: { context: 200_000, output: 64_000 },
-                },
-            ]));
+            const catalog = await loadModelsDevCatalog();
+            const models = Object.fromEntries(await Promise.all([...names].map(async (name) => {
+                const candidate = await resolveActiveCandidate(name);
+                const limit = candidate
+                    ? modelsDevLimit({
+                        provider: candidate.provider,
+                        modelId: candidate.modelId,
+                        catalog,
+                    })
+                    : null;
+                return [
+                    name,
+                    {
+                        name: candidate ? `${name} (${candidate.modelId})` : name,
+                        tool_call: true,
+                        attachment: true,
+                        reasoning: false,
+                        modalities: {
+                            input: ['text', 'image', 'pdf'],
+                            output: ['text'],
+                        },
+                        cost: { input: 0, output: 0, cache_read: 0, cache_write: 0 },
+                        limit: limit ?? { context: 200_000, output: 64_000 },
+                    },
+                ];
+            })));
             config.provider = {
                 ...config.provider,
-                subrouter: {
-                    name: 'Subrouter',
+                [PROVIDER_ID]: {
+                    name: PROVIDER_DISPLAY_NAME,
                     npm: providerEntryUrl(),
                     models,
                     options: {},
                 },
             };
         },
+        '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,
+                system: output.system,
+            });
+        },
+    };
+};
+/**
+ * Map a subrouter account onto the credential shape opencode stores. The
+ * stored copy is redundant (RouterModel only ever reads ~/.subrouter), but
+ * opencode needs a success payload to close the login flow.
+ */
+function toOpencodeCredentials(account) {
+    if (account.type === 'api') {
+        return { type: 'success', key: account.key ?? '' };
+    }
+    return {
+        type: 'success',
+        refresh: account.refresh ?? '',
+        access: account.access ?? '',
+        expires: account.expires ?? 0,
+        accountId: account.accountId,
+    };
+}
+export const subrouterAuthPlugin = async () => {
+    return {
+        auth: {
+            provider: PROVIDER_ID,
+            methods: [
+                {
+                    type: 'oauth',
+                    label: 'Add a subscription',
+                    prompts: [
+                        {
+                            type: 'select',
+                            key: 'provider',
+                            message: 'Which subscription do you want to add?',
+                            options: PROVIDER_IDS.map((id) => {
+                                return { label: adapters[id].name, value: id };
+                            }),
+                        },
+                        {
+                            type: 'select',
+                            key: 'method',
+                            message: 'How do you want to log in to ChatGPT?',
+                            options: [
+                                { label: 'Browser (recommended)', value: 'browser' },
+                                { label: 'Device code', value: 'device', hint: 'May be disabled for your account' },
+                            ],
+                            when: { key: 'provider', op: 'eq', value: 'openai' },
+                        },
+                    ],
+                    authorize: async (inputs) => {
+                        const providerId = inputs?.provider;
+                        if (!providerId || !isProviderId(providerId)) {
+                            // No failure variant exists in AuthOAuthResult, so surface this
+                            // as a request error instead. Harnesses render the message.
+                            throw new Error(`Pick a subscription to add. Expected one of: ${PROVIDER_IDS.join(', ')}`);
+                        }
+                        const adapter = adapters[providerId];
+                        // Remote harnesses (a chat bot, a web UI) authorize in a browser
+                        // that is not on this machine, so a localhost callback never fires
+                        // and the user has to paste the redirect URL back instead.
+                        const session = await adapter.beginLogin({
+                            manualInput: Boolean(process.env.SUBROUTER_MANUAL_OAUTH),
+                            method: inputs?.method,
+                        });
+                        if (session instanceof Error)
+                            throw session;
+                        const finish = async (input) => {
+                            const account = await session.complete(input);
+                            if (account instanceof Error)
+                                return { type: 'failed' };
+                            await addAccount({ provider: providerId, account });
+                            return toOpencodeCredentials(account);
+                        };
+                        if (session.method === 'code') {
+                            return {
+                                url: session.url,
+                                instructions: session.instructions,
+                                method: 'code',
+                                callback: (code) => finish(code),
+                            };
+                        }
+                        return {
+                            url: session.url,
+                            instructions: session.instructions,
+                            method: 'auto',
+                            callback: () => finish(),
+                        };
+                    },
+                },
+            ],
+        },
     };
 };

package/dist/opencode-e2e.test.d.ts

@@ -2,7 +2,7 @@
  * End-to-end test: a real opencode server drives the subrouter provider.
  *
  * No real API requests. Fake HTTP servers play the provider endpoints:
- * anthropic always answers 429 (rate limited), the opencode zen mock streams
+ * anthropic always answers 429 (rate limited), the opencode-go mock streams
  * a canned completion. The test prompts opencode with model subrouter/default
  * and asserts the reply came from the fallback provider, proving the cycling
  * works through the whole opencode -> provider -> router pipeline.

package/dist/opencode-e2e.test.js

@@ -2,7 +2,7 @@
  * End-to-end test: a real opencode server drives the subrouter provider.
  *
  * No real API requests. Fake HTTP servers play the provider endpoints:
- * anthropic always answers 429 (rate limited), the opencode zen mock streams
+ * anthropic always answers 429 (rate limited), the opencode-go mock streams
  * a canned completion. The test prompts opencode with model subrouter/default
  * and asserts the reply came from the fallback provider, proving the cycling
  * works through the whole opencode -> provider -> router pipeline.
@@ -12,11 +12,44 @@
 import { createOpencodeClient } from '@opencode-ai/sdk';
 import { createOpencodeServer } from '@opencode-ai/sdk/server';
 import { createServer } from 'node:http';
-import { mkdtemp, rm, writeFile, mkdir } from 'node:fs/promises';
+import { mkdtemp, rm, mkdir } 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 { OPENAI_WEBSOCKET_SESSION_HEADER, OPENAI_WEBSOCKET_TITLE_HEADER, addAccount, markCooldown, } from '@subrouter/cli';
+import { addSubrouterHeaders } from "./provider.js";
+function summarizeSessionEvents(events) {
+    const summary = [];
+    for (const event of events) {
+        if (event.type === 'session.status') {
+            const status = event.properties.status;
+            summary.push({
+                type: event.type,
+                status: status.type,
+                message: status.type === 'retry' ? status.message : undefined,
+            });
+            continue;
+        }
+        if (event.type === 'session.error') {
+            const error = event.properties.error;
+            if (!error)
+                continue;
+            const message = typeof error.data.message === 'string' ? error.data.message : undefined;
+            summary.push({
+                type: event.type,
+                name: error.name,
+                message,
+                statusCode: error.name === 'APIError' ? error.data.statusCode : undefined,
+                isRetryable: error.name === 'APIError' ? error.data.isRetryable : undefined,
+            });
+            continue;
+        }
+        if (event.type === 'session.idle')
+            summary.push({ type: event.type });
+    }
+    return summary;
+}
 async function startMockServer(handler) {
     const requests = [];
     const server = createServer((req, res) => {
@@ -67,7 +100,7 @@ beforeAll(async () => {
         res.writeHead(429, { 'content-type': 'application/json' });
         res.end(JSON.stringify({ type: 'error', error: { type: 'rate_limit_error', message: 'rate limited' } }));
     });
-    // Fake opencode zen: streams a canned completion
+    // Fake opencode-go: streams a canned completion
     zenMock = await startMockServer(({ body }, res) => {
         const streaming = body.includes('"stream":true');
         if (!streaming) {
@@ -108,33 +141,10 @@ beforeAll(async () => {
     // Subrouter state: one rate-limited anthropic account + one zen key
     const subrouterHome = path.join(home, 'subrouter');
     await mkdir(subrouterHome, { recursive: true });
-    await writeFile(path.join(subrouterHome, 'accounts.json'), JSON.stringify({
-        version: 1,
-        providers: {
-            anthropic: {
-                activeIndex: 0,
-                accounts: [
-                    {
-                        type: 'oauth',
-                        refresh: 'fake-refresh',
-                        access: 'fake-access',
-                        expires: Date.now() + 1_000_000_000,
-                        email: 'a@x.com',
-                        addedAt: 1,
-                        lastUsed: 1,
-                    },
-                ],
-            },
-            opencode: {
-                activeIndex: 0,
-                accounts: [{ type: 'api', key: 'zen-key', addedAt: 1, lastUsed: 1 }],
-            },
-        },
-    }));
     for (const [key, value] of Object.entries({
         SUBROUTER_HOME: subrouterHome,
         SUBROUTER_ANTHROPIC_BASE_URL: `${anthropicMock.url}/v1`,
-        SUBROUTER_OPENCODE_BASE_URL: `${zenMock.url}/v1`,
+        SUBROUTER_OPENCODE_GO_BASE_URL: `${zenMock.url}/v1`,
         // 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'),
@@ -144,6 +154,22 @@ beforeAll(async () => {
         savedEnv[key] = process.env[key];
         process.env[key] = value;
     }
+    await addAccount({
+        provider: 'anthropic',
+        account: {
+            type: 'oauth',
+            refresh: 'fake-refresh',
+            access: 'fake-access',
+            expires: Date.now() + 1_000_000_000,
+            email: 'a@x.com',
+            addedAt: 1,
+            lastUsed: 1,
+        },
+    });
+    await addAccount({
+        provider: 'opencode-go',
+        account: { type: 'api', key: 'zen-key', addedAt: 1, lastUsed: 1 },
+    });
     const providerEntry = pathToFileURL(path.join(import.meta.dirname, '..', 'dist', 'provider.js')).href;
     server = await createOpencodeServer({
         port: 0,
@@ -179,6 +205,24 @@ afterAll(async () => {
     await rm(home, { recursive: true, force: true });
 });
 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' },
+        }, output);
+        expect(output.headers).toEqual({ [OPENAI_WEBSOCKET_SESSION_HEADER]: 'session-1' });
+        addSubrouterHeaders({
+            sessionID: 'session-2',
+            agent: 'title',
+            model: { providerID: 'subrouter' },
+        }, output);
+        expect(output.headers).toEqual({
+            [OPENAI_WEBSOCKET_SESSION_HEADER]: 'session-2',
+            [OPENAI_WEBSOCKET_TITLE_HEADER]: 'true',
+        });
+    });
     test('rate-limited provider is cycled to the fallback through opencode', async () => {
         const client = createOpencodeClient({ baseUrl: server.url });
         const session = await client.session.create({
@@ -204,4 +248,65 @@ describe('opencode + subrouter provider', () => {
         expect(anthropicMock.requests.length).toBeGreaterThan(0);
         expect(zenMock.requests.length).toBeGreaterThan(0);
     }, 120_000);
+    test('all cooling-down accounts retry through opencode instead of dying', async () => {
+        const untilMs = Date.now() + 2_000;
+        await markCooldown({
+            provider: 'anthropic',
+            account: { type: 'oauth', refresh: 'fake-refresh', access: 'fake-access', email: 'a@x.com', addedAt: 1, lastUsed: 1 },
+            untilMs,
+        });
+        await markCooldown({
+            provider: 'opencode-go',
+            account: { type: 'api', key: 'zen-key', addedAt: 1, lastUsed: 1 },
+            untilMs,
+        });
+        const client = createOpencodeClient({ baseUrl: server.url });
+        const events = [];
+        const subscription = await client.event.subscribe({
+            query: { directory: projectDir },
+        });
+        void (async () => {
+            for await (const event of subscription.stream) {
+                events.push(event);
+            }
+        })();
+        const session = await client.session.create({
+            query: { directory: projectDir },
+            body: { title: 'subrouter cooldown retry' },
+        });
+        expect(session.data).toBeTruthy();
+        const result = await client.session.prompt({
+            path: { id: session.data.id },
+            query: { directory: projectDir },
+            body: {
+                model: { providerID: 'subrouter', modelID: 'default' },
+                parts: [{ type: 'text', text: 'say hi' }],
+            },
+        });
+        const parts = result.data?.parts ?? [];
+        const texts = parts
+            .filter((part) => part.type === 'text')
+            .map((part) => part.text)
+            .join('\n');
+        expect(texts).toContain('hello from fallback');
+        const summary = summarizeSessionEvents(events);
+        expect(summary.some((event) => event.status === 'retry')).toBe(true);
+        expect(summary.some((event) => event.name === 'UnknownError')).toBe(false);
+        expect(summary.map((event) => {
+            if (event.status === 'retry') {
+                return { status: 'retry', coolingDown: event.message?.includes('cooling down') };
+            }
+            return event.status ?? event.type;
+        })).toMatchInlineSnapshot(`
+      [
+        "busy",
+        "busy",
+        {
+          "coolingDown": true,
+          "status": "retry",
+        },
+        "busy",
+      ]
+    `);
+    }, 120_000);
 });