@subrouter/opencode 0.4.0 → 0.5.1

package/src/index.ts

@@ -7,8 +7,10 @@
  * model: pick `subrouter/default` (or any preset created with
  * `subrouter preset create`) in opencode. Provider id stays `subrouter`; the
  * visible name is `subrouter.org`. Context limits follow the first live
- * candidate. Input modalities cover every usable candidate so the
- * router can select a compatible subscription for each prompt.
+ * 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
@@ -30,16 +32,24 @@ import {
   modelsDevInputModalities,
   modelsDevLimit,
   modelsDevModel,
+  variantProviderOptions,
   PROVIDER_DISPLAY_NAME,
   PROVIDER_ID,
   PROVIDER_IDS,
+  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')
@@ -63,21 +73,37 @@ function opencodeLog(client: PluginInput['client'] | undefined): SubrouterLog |
 
 export const subrouterPlugin: Plugin = async ({ client, directory }) => {
   const log = opencodeLog(client)
-  const pendingNotices = new Map<
-    string,
-    { agent: string; variant?: string; preset: string; text: string }
-  >()
-  const onCooldownFallback = (notice: CooldownFallbackNotice) => {
-    if (!client || !notice.sessionID || !notice.agent || notice.agent === 'title') return
-    if (pendingNotices.has(notice.sessionID)) return
+  const affinity = new RouteAffinity()
+  const activeMessages = new Map<string, string>()
+  const deliveredNotices = new Map<string, { text: string; expiresAt: number }>()
+  // Surface the fallback as a TUI toast, the same channel OpenCode plugins use for
+  // notifications (see kimaki's legacy anthropic/openai/xai auth plugins). A toast is
+  // not persisted into the transcript, so it never becomes a fake user/assistant
+  // message or enters model context. tui.toast.show is a global event with no session
+  // field, so append the OpenCode session id at the end: kimaki routes the toast to
+  // the matching Discord thread by that marker and strips it before display. Plain
+  // OpenCode TUI just shows the toast for the active session.
+  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}`
-    pendingNotices.set(notice.sessionID, {
-      agent: notice.agent,
-      variant: notice.variant,
-      preset: notice.preset,
-      text: `Subrouter: ${preferred} was rate limited. This message started with ${active}.`,
-    })
+    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 result = await client.tui
+      .showToast({
+        query: { directory },
+        body: { message: `${text} ${notice.sessionID}`, variant: 'info' },
+        throwOnError: true,
+      })
+      .catch((cause) => new Error('failed to show cooldown fallback toast', { 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) => {
@@ -86,56 +112,109 @@ export const subrouterPlugin: Plugin = async ({ client, directory }) => {
       })
       const names = new Set([DEFAULT_PRESET_NAME, ...Object.keys(presets.presets)])
       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 presetModels = await resolvePresetModels(name)
-            const candidates =
-              presetModels instanceof Error
-                ? []
-                : (await resolveCandidates({ presetModels })).candidates
-            const candidate = candidates[0]
-            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
-            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,
+              : undefined
+          if (apiId) {
+            takenApiIds.add(apiId)
+            presetByApiId[apiId] = name
+          }
+          const catalogModel = candidate
+            ? modelsDevModel({
+                provider: candidate.provider,
+                modelId: candidate.modelId,
                 catalog,
               })
-              if (!model || !modalities) continue
-              attachment ||= model.attachment && modalities.some((modality) => modality !== 'text')
-              for (const modality of modalities) input.add(modality)
+            : 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'>
             }
-            return [
-              name,
-              {
-                name,
-                tool_call: true,
-                attachment,
-                reasoning: false,
-                modalities: {
-                  input: [...input],
-                  output: ['text'] satisfies Array<'text'>,
-                },
-                cost: { input: 0, output: 0, cache_read: 0, cache_write: 0 },
-                limit: limit ?? { context: 200_000, output: 64_000 },
-              },
-            ]
-          }),
-        ),
+            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,
@@ -143,36 +222,37 @@ export const subrouterPlugin: Plugin = async ({ client, directory }) => {
           name: PROVIDER_DISPLAY_NAME,
           npm: providerEntryUrl(),
           models,
-          options: { log, onCooldownFallback },
+          options: { affinity, log, onCooldownFallback, presetByApiId },
         },
       }
     },
     event: async ({ event }) => {
-      if (event.type !== 'session.idle') return
-      const pending = pendingNotices.get(event.properties.sessionID)
-      if (!pending) return
-      pendingNotices.delete(event.properties.sessionID)
-      const body = {
-        noReply: true,
-        agent: pending.agent,
-        model: { providerID: PROVIDER_ID, modelID: pending.preset },
-        variant: pending.variant,
-        parts: [{ type: 'text' as const, text: pending.text, ignored: true }],
+      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
       }
-      await client.session
-        .prompt({
-          path: { id: event.properties.sessionID },
-          query: { directory },
-          body,
-        })
-        .catch(() => {})
+      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)
     },
-    '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,
+        sessionID: input.sessionID,
         system: output.system,
       })
     },
@@ -197,7 +277,8 @@ function toOpencodeCredentials(account: StoredAccount) {
   }
 }
 
-export const subrouterAuthPlugin: Plugin = async () => {
+export const subrouterAuthPlugin: Plugin = async ({ client }) => {
+  const log = opencodeLog(client)
   return {
     auth: {
       provider: PROVIDER_ID,
@@ -247,7 +328,18 @@ export const subrouterAuthPlugin: Plugin = async () => {
 
             const finish = async (input?: string) => {
               const account = await session.complete(input)
-              if (account instanceof Error) return { type: 'failed' as const }
+              if (account instanceof Error) {
+                // opencode's AuthOAuthResult has no failure-with-message
+                // variant, so the real reason cannot travel back through
+                // oauth.callback and harnesses show a generic fallback. Log it
+                // here so the cause is diagnosable instead of lost.
+                void log?.({
+                  level: 'error',
+                  message: `login failed: ${account.message}`,
+                  extra: { provider: providerId },
+                })
+                return { type: 'failed' as const }
+              }
               await addAccount({ provider: providerId, account })
               return toOpencodeCredentials(account)
             }