@subrouter/opencode 0.1.0 → 0.3.0

package/dist/plugin.test.js

@@ -1,26 +1,282 @@
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { createServer } from 'node:http';
+import { mkdtemp, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { afterEach, beforeEach, expect, test } from 'vitest';
-import { subrouterPlugin } from "./index.js";
+import { addAccount, adapters, loadAccounts, PROVIDER_DISPLAY_NAME, PROVIDER_IDS, savePreset, setSubrouterLog, } from '@subrouter/cli';
+import { subrouterAuthPlugin, subrouterPlugin } from "./index.js";
+import { revealRoutedModel, rewritePoweredByModelLine } from "./provider.js";
 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 () => {
+    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)) {
+        await new Promise((resolve) => {
+            server.close(() => {
+                resolve();
+            });
+        });
+    }
     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) => {
+        const url = new URL(req.url || '', 'http://localhost');
+        const send = (body) => {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(body));
+        };
+        if (url.pathname === '/api/accounts/deviceauth/usercode') {
+            return send({ device_auth_id: 'dev-1', user_code: 'ABCD-9876', interval: '0' });
+        }
+        if (url.pathname === '/api/accounts/deviceauth/token') {
+            return send({ authorization_code: 'auth-code', code_verifier: 'verifier' });
+        }
+        if (url.pathname === '/oauth/token') {
+            const claims = Buffer.from(JSON.stringify({ email: 'pool@example.com', chatgpt_account_id: 'acct-9' })).toString('base64url');
+            return send({
+                access_token: 'access-9',
+                refresh_token: 'refresh-9',
+                expires_in: 3600,
+                id_token: `header.${claims}.signature`,
+            });
+        }
+        res.writeHead(404).end('{}');
+    });
+    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 issuer');
+    openServers.push(server);
+    return `http://127.0.0.1:${address.port}`;
+}
+function authMethod() {
+    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('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 show the first 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,
+        },
+    });
+    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 (claude-opus-4-6)');
+});
+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: { output: ['text'] },
+                    limit: { context: 1_000_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,
+        output: 128_000,
+    });
+    expect(config.provider?.subrouter?.models?.default?.limit).toEqual({
+        context: 1_000_000,
+        output: 128_000,
+    });
+});
+test('preset models permit image and PDF attachments', async () => {
+    const hooks = await subrouterPlugin(pluginInput);
+    const config = {};
+    await hooks.config?.(config);
+    expect(config.provider?.subrouter?.models?.default).toMatchObject({
+        attachment: true,
+        modalities: {
+            input: ['text', 'image', 'pdf'],
+            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();
+    expect(provider).toBe('subrouter');
+    const prompt = method.prompts?.[0];
+    expect(prompt?.type).toBe('select');
+    expect(prompt?.key).toBe('provider');
+    expect(prompt?.type === 'select' && prompt.options.map((o) => o.value)).toEqual([...PROVIDER_IDS]);
+    const methodPrompt = method.prompts?.[1];
+    expect(methodPrompt?.type).toBe('select');
+    expect(methodPrompt?.key).toBe('method');
+    expect(methodPrompt?.type === 'select' && methodPrompt.options.map((o) => o.value)).toEqual([
+        'browser',
+        'device',
+    ]);
+});
+test('authorize rejects a missing or unknown subscription', async () => {
+    const { method } = await authMethod();
+    await expect(method.authorize({})).rejects.toThrow(/Pick a subscription/);
+    await expect(method.authorize({ provider: 'nope' })).rejects.toThrow(/Pick a subscription/);
+});
+test('authorize dispatches to the chosen adapter and the callback pools the account', async () => {
+    process.env.SUBROUTER_OPENAI_ISSUER_URL = await startFakeOpenAIIssuer();
+    const { method } = await authMethod();
+    const result = await method.authorize({ provider: 'openai', method: 'device' });
+    expect(result.method).toBe('auto');
+    expect(result.instructions).toMatch(/code:\s*ABCD-9876/);
+    if (result.method !== 'auto')
+        throw new Error('expected the device flow');
+    const credentials = await result.callback();
+    expect(credentials).toMatchObject({ type: 'success', access: 'access-9', refresh: 'refresh-9' });
+    const accounts = await loadAccounts();
+    expect(accounts.providers.openai?.accounts).toMatchObject([
+        { type: 'oauth', email: 'pool@example.com', accountId: 'acct-9' },
+    ]);
+});
+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-go' });
+    expect(result.method).toBe('code');
+    if (result.method !== 'code')
+        throw new Error('expected a pasted-key flow');
+    expect(await result.callback('go-key-1')).toMatchObject({ type: 'success', key: 'go-key-1' });
+    const accounts = await loadAccounts();
+    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-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-go']).toBeUndefined();
 });

package/dist/provider.d.ts

@@ -2,6 +2,28 @@
  * 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;
+    };
+}, output: {
+    headers: Record<string, string>;
+}): void;
 //# 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;;;;GAIG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA"}
+{"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"}

package/dist/provider.js

@@ -2,5 +2,29 @@
  * 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, 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 !== PROVIDER_ID)
+        return;
+    output.headers[OPENAI_WEBSOCKET_SESSION_HEADER] = input.sessionID;
+    if (input.agent === 'title')
+        output.headers[OPENAI_WEBSOCKET_TITLE_HEADER] = 'true';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@subrouter/opencode",
-  "version": "0.1.0",
+  "version": "0.3.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.1.0"
+    "@subrouter/cli": "^0.4.0"
   },
   "devDependencies": {
     "@opencode-ai/plugin": "^1.18.23",

package/src/index.ts

@@ -1,52 +1,214 @@
 /**
- * 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'
-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,
+  type StoredAccount,
+} from '@subrouter/cli'
+import { addSubrouterHeaders, revealRoutedModel } from './provider.ts'
 
 function providerEntryUrl() {
   const isDev = import.meta.url.endsWith('.ts')
   return new URL(isDev ? './provider.ts' : './provider.js', import.meta.url).href
 }
 
-export const subrouterPlugin: Plugin = async () => {
+export const subrouterPlugin: Plugin = 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 as const, presets: {} }
       })
       const names = new Set([DEFAULT_PRESET_NAME, ...Object.keys(presets.presets)])
+      const catalog = await loadModelsDevCatalog()
       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 },
-          },
-        ]),
+        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'] satisfies Array<
+                    'text' | 'image' | 'pdf'
+                  >,
+                  output: ['text'] satisfies Array<'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: StoredAccount) {
+  if (account.type === 'api') {
+    return { type: 'success' as const, key: account.key ?? '' }
+  }
+  return {
+    type: 'success' as const,
+    refresh: account.refresh ?? '',
+    access: account.access ?? '',
+    expires: account.expires ?? 0,
+    accountId: account.accountId,
+  }
+}
+
+export const subrouterAuthPlugin: Plugin = 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?: string) => {
+              const account = await session.complete(input)
+              if (account instanceof Error) return { type: 'failed' as const }
+              await addAccount({ provider: providerId, account })
+              return toOpencodeCredentials(account)
+            }
+
+            if (session.method === 'code') {
+              return {
+                url: session.url,
+                instructions: session.instructions,
+                method: 'code' as const,
+                callback: (code) => finish(code),
+              }
+            }
+            return {
+              url: session.url,
+              instructions: session.instructions,
+              method: 'auto' as const,
+              callback: () => finish(),
+            }
+          },
+        },
+      ],
+    },
   }
 }