@subrouter/opencode 0.3.0 → 0.5.0

package/dist/index.d.ts

@@ -6,8 +6,11 @@
  * 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.
+ * visible name is `subrouter.org`. Context limits follow the first live
+ * candidate. GPT candidates spoof a `gpt-*` api id so OpenCode prefers
+ * apply_patch over edit/write. Input modalities cover every usable candidate so the
+ * router can select a compatible subscription for each prompt. Tool
+ * follow-ups stay on the selected route until the session becomes idle.
  *
  * `subrouterAuthPlugin` registers the login flow, so `opencode auth login`
  * (and any harness driving opencode's auth hook, like kimaki's Discord

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -6,8 +6,11 @@
  * 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.
+ * visible name is `subrouter.org`. Context limits follow the first live
+ * candidate. GPT candidates spoof a `gpt-*` api id so OpenCode prefers
+ * apply_patch over edit/write. Input modalities cover every usable candidate so the
+ * router can select a compatible subscription for each prompt. Tool
+ * follow-ups stay on the selected route until the session becomes idle.
  *
  * `subrouterAuthPlugin` registers the login flow, so `opencode auth login`
  * (and any harness driving opencode's auth hook, like kimaki's Discord
@@ -17,39 +20,80 @@
  * NOTE: only plugin initializer functions may be exported from this module.
  * OpenCode calls every export as a plugin.
  */
-import { adapters, addAccount, DEFAULT_PRESET_NAME, isProviderId, loadModelsDevCatalog, loadPresets, modelsDevLimit, PROVIDER_DISPLAY_NAME, PROVIDER_ID, PROVIDER_IDS, resolveActiveCandidate, setSubrouterLog, } from '@subrouter/cli';
-import { addSubrouterHeaders, revealRoutedModel } from "./provider.js";
+import { adapters, addAccount, DEFAULT_PRESET_NAME, isProviderId, loadModelsDevCatalog, loadPresets, modelsDevInputModalities, modelsDevLimit, modelsDevModel, variantProviderOptions, PROVIDER_DISPLAY_NAME, PROVIDER_ID, PROVIDER_IDS, clearLiveRoute, resolveCandidates, resolvePresetModels, RouteAffinity, } from '@subrouter/cli';
+import { addSubrouterHeaders, applyPatchApiId, revealRoutedModel, shouldUseApplyPatch, } from "./provider.js";
 function providerEntryUrl() {
     const isDev = import.meta.url.endsWith('.ts');
     return new URL(isDev ? './provider.ts' : './provider.js', import.meta.url).href;
 }
-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(() => { });
-        });
-    }
+function opencodeLog(client) {
+    if (!client?.app?.log)
+        return undefined;
+    const write = client.app.log.bind(client.app);
+    return (entry) => {
+        void write({
+            body: {
+                service: 'subrouter',
+                level: entry.level,
+                message: entry.message,
+                extra: entry.extra,
+            },
+        }).catch(() => { });
+    };
+}
+export const subrouterPlugin = async ({ client, directory }) => {
+    const log = opencodeLog(client);
+    const affinity = new RouteAffinity();
+    const activeMessages = new Map();
+    const deliveredNotices = new Map();
+    const onCooldownFallback = async (notice) => {
+        if (!notice.sessionID || !notice.agent || notice.agent === 'title')
+            return;
+        const preferred = `${notice.preferred.provider}/${notice.preferred.modelId}`;
+        const active = `${notice.active.provider}/${notice.active.modelId}`;
+        const text = `Subrouter: Using ${active} because ${preferred} is rate limited.`;
+        const delivered = deliveredNotices.get(notice.sessionID);
+        if (delivered?.text === text && delivered.expiresAt > Date.now())
+            return;
+        const current = { text, expiresAt: Date.now() + notice.preferred.retryAfterMs };
+        deliveredNotices.set(notice.sessionID, current);
+        const body = {
+            noReply: true,
+            agent: notice.agent,
+            model: { providerID: PROVIDER_ID, modelID: notice.preset },
+            variant: notice.variant,
+            parts: [{ type: 'text', text, ignored: true }],
+        };
+        const result = await client.session
+            .prompt({
+            path: { id: notice.sessionID },
+            query: { directory },
+            body,
+            throwOnError: true,
+        })
+            .catch((cause) => new Error('failed to persist cooldown fallback notice', { cause }));
+        if (!(result instanceof Error))
+            return;
+        if (deliveredNotices.get(notice.sessionID) === current) {
+            deliveredNotices.delete(notice.sessionID);
+        }
+        void log?.({ level: 'warn', message: result.message });
+    };
     return {
         config: async (config) => {
             const presets = await loadPresets().catch(() => {
                 return { version: 1, presets: {} };
             });
             const names = new Set([DEFAULT_PRESET_NAME, ...Object.keys(presets.presets)]);
-            const catalog = await loadModelsDevCatalog();
-            const models = Object.fromEntries(await Promise.all([...names].map(async (name) => {
-                const candidate = await resolveActiveCandidate(name);
+            const catalog = await loadModelsDevCatalog({ log });
+            const takenApiIds = new Set();
+            const presetByApiId = {};
+            const resolved = await Promise.all([...names].map(async (name) => {
+                const presetModels = await resolvePresetModels(name);
+                const candidates = presetModels instanceof Error
+                    ? []
+                    : (await resolveCandidates({ presetModels })).candidates;
+                const candidate = candidates[0];
                 const limit = candidate
                     ? modelsDevLimit({
                         provider: candidate.provider,
@@ -57,38 +101,116 @@ export const subrouterPlugin = async ({ client }) => {
                         catalog,
                     })
                     : null;
-                return [
+                const input = new Set(['text']);
+                let attachment = false;
+                for (const current of candidates) {
+                    const model = modelsDevModel({
+                        provider: current.provider,
+                        modelId: current.modelId,
+                        catalog,
+                    });
+                    const modalities = modelsDevInputModalities({
+                        provider: current.provider,
+                        modelId: current.modelId,
+                        catalog,
+                    });
+                    if (!model || !modalities)
+                        continue;
+                    attachment ||= model.attachment && modalities.some((modality) => modality !== 'text');
+                    for (const modality of modalities)
+                        input.add(modality);
+                }
+                return { name, candidate, attachment, input, limit };
+            }));
+            const models = Object.fromEntries(resolved.map(({ name, candidate, attachment, input, limit }) => {
+                const apiId = candidate && shouldUseApplyPatch(candidate.modelId)
+                    ? applyPatchApiId({
+                        preset: name,
+                        modelId: candidate.modelId,
+                        taken: takenApiIds,
+                    })
+                    : undefined;
+                if (apiId) {
+                    takenApiIds.add(apiId);
+                    presetByApiId[apiId] = name;
+                }
+                const catalogModel = candidate
+                    ? modelsDevModel({
+                        provider: candidate.provider,
+                        modelId: candidate.modelId,
+                        catalog,
+                    })
+                    : null;
+                const reasoning = catalogModel?.reasoning ?? false;
+                const variants = candidate
+                    ? Object.fromEntries((catalogModel?.variants ?? []).map((variant) => [
+                        variant,
+                        variantProviderOptions({
+                            provider: candidate.provider,
+                            modelId: candidate.modelId,
+                            variant,
+                        }),
+                    ]))
+                    : {};
+                const model = {
                     name,
-                    {
-                        name: 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 },
+                    tool_call: true,
+                    attachment,
+                    reasoning,
+                    modalities: {
+                        input: [...input],
+                        output: ['text'],
                     },
-                ];
-            })));
+                    cost: { input: 0, output: 0, cache_read: 0, cache_write: 0 },
+                    limit: limit ?? { context: 200_000, output: 64_000 },
+                };
+                if (apiId)
+                    model.id = apiId;
+                if (Object.keys(variants).length > 0)
+                    model.variants = variants;
+                return [name, model];
+            }));
             config.provider = {
                 ...config.provider,
                 [PROVIDER_ID]: {
                     name: PROVIDER_DISPLAY_NAME,
                     npm: providerEntryUrl(),
                     models,
-                    options: {},
+                    options: { affinity, log, onCooldownFallback, presetByApiId },
                 },
             };
         },
-        'chat.headers': async (input, output) => addSubrouterHeaders(input, output),
-        // OpenCode identity uses the preset id; rewrite it to the live routed model.
+        event: async ({ event }) => {
+            if (event.type === 'session.deleted') {
+                const sessionID = event.properties.info.id;
+                const messageID = activeMessages.get(sessionID);
+                if (messageID)
+                    affinity.clear(messageID);
+                activeMessages.delete(sessionID);
+                deliveredNotices.delete(sessionID);
+                await clearLiveRoute(sessionID);
+                return;
+            }
+            if (event.type !== 'session.idle')
+                return;
+            const sessionID = event.properties.sessionID;
+            const messageID = activeMessages.get(sessionID);
+            if (messageID)
+                affinity.clear(messageID);
+            activeMessages.delete(sessionID);
+            await clearLiveRoute(sessionID);
+        },
+        'chat.headers': async (input, output) => {
+            const activeMessage = activeMessages.get(input.sessionID) ?? input.message.id;
+            const affinityKey = addSubrouterHeaders({ input, output, affinityKey: activeMessage });
+            if (affinityKey)
+                activeMessages.set(input.sessionID, affinityKey);
+        },
         'experimental.chat.system.transform': async (input, output) => {
             await revealRoutedModel({
                 providerID: input.model.providerID,
                 preset: input.model.id,
+                sessionID: input.sessionID,
                 system: output.system,
             });
         },