@subrouter/opencode 0.3.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@subrouter/opencode",
-  "version": "0.3.0",
+  "version": "0.5.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.4.0"
+    "@subrouter/cli": "^0.6.0"
   },
   "devDependencies": {
     "@opencode-ai/plugin": "^1.18.23",

package/src/index.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
@@ -18,7 +21,7 @@
  * OpenCode calls every export as a plugin.
  */
 
-import type { Plugin } from '@opencode-ai/plugin'
+import type { Plugin, PluginInput } from '@opencode-ai/plugin'
 import {
   adapters,
   addAccount,
@@ -26,38 +29,82 @@ import {
   isProviderId,
   loadModelsDevCatalog,
   loadPresets,
+  modelsDevInputModalities,
   modelsDevLimit,
+  modelsDevModel,
+  variantProviderOptions,
   PROVIDER_DISPLAY_NAME,
   PROVIDER_ID,
   PROVIDER_IDS,
-  resolveActiveCandidate,
-  setSubrouterLog,
+  clearLiveRoute,
+  resolveCandidates,
+  resolvePresetModels,
+  RouteAffinity,
+  type CooldownFallbackNotice,
   type StoredAccount,
+  type SubrouterLog,
 } from '@subrouter/cli'
-import { addSubrouterHeaders, revealRoutedModel } from './provider.ts'
+import {
+  addSubrouterHeaders,
+  applyPatchApiId,
+  revealRoutedModel,
+  shouldUseApplyPatch,
+} 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 ({ 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: PluginInput['client'] | undefined): SubrouterLog | undefined {
+  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: Plugin = async ({ client, directory }) => {
+  const log = opencodeLog(client)
+  const affinity = new RouteAffinity()
+  const activeMessages = new Map<string, string>()
+  const deliveredNotices = new Map<string, { text: string; expiresAt: number }>()
+  const onCooldownFallback = async (notice: CooldownFallbackNotice) => {
+    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' as const, 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) => {
@@ -65,37 +112,110 @@ export const subrouterPlugin: Plugin = async ({ client }) => {
         return { version: 1 as const, presets: {} }
       })
       const names = new Set([DEFAULT_PRESET_NAME, ...Object.keys(presets.presets)])
-      const catalog = await loadModelsDevCatalog()
+      const catalog = await loadModelsDevCatalog({ log })
+      const takenApiIds = new Set<string>()
+      const presetByApiId: Record<string, string> = {}
+      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,
+                modelId: candidate.modelId,
+                catalog,
+              })
+            : null
+          const input = new Set<'text' | 'audio' | 'image' | 'video' | 'pdf'>(['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(
-        await Promise.all(
-          [...names].map(async (name) => {
-            const candidate = await resolveActiveCandidate(name)
-            const limit = candidate
-              ? modelsDevLimit({
-                  provider: candidate.provider,
+        resolved.map(({ name, candidate, attachment, input, limit }) => {
+          const apiId =
+            candidate && shouldUseApplyPatch(candidate.modelId)
+              ? applyPatchApiId({
+                  preset: name,
                   modelId: candidate.modelId,
-                  catalog,
+                  taken: takenApiIds,
                 })
-              : 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 },
-              },
-            ]
-          }),
-        ),
+              : 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: string
+            id?: string
+            tool_call: true
+            attachment: boolean
+            reasoning: boolean
+            variants?: Record<
+              string,
+              { thinking?: { type: string }; effort?: string; reasoningEffort?: string; reasoningSummary?: string }
+            >
+            modalities: {
+              input: Array<'text' | 'audio' | 'image' | 'video' | 'pdf'>
+              output: Array<'text'>
+            }
+            cost: { input: number; output: number; cache_read: number; cache_write: number }
+            limit: { context: number; input?: number; output: number }
+          } = {
+            name,
+            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,
@@ -103,16 +223,37 @@ export const subrouterPlugin: Plugin = async ({ client }) => {
           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,
       })
     },