@apinggithub/mydsh-auto-model-router 0.2.0 → 0.2.2

package/auto-adapter.mjs

@@ -1,104 +1,234 @@
-// Virtual "auto" provider adapter. Registers a provider route named `auto`
-// so the model selector shows an "Auto Router" group with one model:
-//
-//   Auto Router
-//     └─ Auto (auto routing)
-//
-// Selecting it marks the session's provider as `auto`; the router plugin then
-// takes over in `agent/request` and routes through the configured L0–L3
-// levels. Selecting any real provider/model leaves the user's choice
-// untouched (the plugin passes through).
-//
-// If a request still reaches provider `auto` (e.g. the router did not
-// intercept this particular call — a titled step, compaction, or a listener
-// ordering gap), `stream()` forwards to the router's current per-session
-// decision instead of throwing, so routing is never a hard failure.
-
-import { routesEqual } from './router.mjs'
-
-export const AUTO_PROVIDER = 'auto'
-export const AUTO_MODEL = 'auto'
-
-/** Provider route metadata shown in the selector. */
-export function autoProviderInfo(provider) {
-  return { id: provider, name: 'Auto Router' }
-}
-
-/** One advertised model: the single "Auto" choice. */
-export function autoListModels() {
-  return [{ provider: AUTO_PROVIDER, id: AUTO_MODEL, name: 'Auto' }]
-}
-
-/** Exact-model metadata for the advertised model. */
-export function autoResolveModel(provider, model) {
-  return { provider, id: model, name: model }
-}
-
-/**
- * The virtual adapter object. `stream()` forwards to the router's decision
- * when it is reachable, so the auto provider never hard-fails routing.
- */
-export const AutoAdapter = {
-  providerInfo: autoProviderInfo,
-  providerRetryPolicy() {
-    return undefined
-  },
-  listModels: async () => autoListModels(),
-  resolveModel: async (provider, model) => autoResolveModel(provider, model),
-  /**
-   * The newer adapter contract (host 0.2.x): the runtime validates a request
-   * against the model's capabilities and binds it to one concrete adapter
-   * generation through `prepareCall(provider, model, signal)`, then dispatches
-   * through the returned `stream`. The virtual `auto` provider owns no
-   * generation of its own, so it returns the metadata it already advertises and
-   * routes the stream through the same forwarding generator below.
-   *
-   * Without this, every call the router does not intercept — a title step,
-   * compaction, a listener ordering gap — died with
-   * "registration.adapter.prepareCall is not a function" on hosts past 0.1.x.
-   * (`normalizeModelInfo` requires provider === the registration id, id === the
-   * requested model, and a non-empty name; everything else is optional.)
-   */
-  async prepareCall(provider, model) {
-    return {
-      model: await AutoAdapter.resolveModel(provider, model),
-      stream: (options) => AutoAdapter.stream(options),
-    }
-  },
-  async *stream(options) {
-    const router = globalThis.__dshAutoModelRouter
-    if (router !== undefined) {
-      const sessionId = options?.sessionId ?? ''
-      const route = router.current(sessionId)
-      if (route && !routesEqual(route, { provider: AUTO_PROVIDER, model: AUTO_MODEL })) {
-        // Forward this request to the routed model through the same llm
-        // runtime; the adapter contract requires we stream chunks back.
-        const llm = globalThis.__dshLl
-        if (llm?.stream !== undefined) {
-          // ctx.llm.stream returns the AsyncIterable directly (not { stream }).
-          const stream = llm.stream({
-            ...options,
-            provider: route.provider,
-            model: route.model,
-            ...route.reasoningEffort === undefined ? {} : { reasoningEffort: route.reasoningEffort },
-          })
-          for await (const chunk of stream) yield chunk
-          return
-        }
-      }
-    }
-    throw new Error(
-      'mydsh-auto-model-router: request reached the virtual "auto" provider with no router '
-      + 'decision available. Check that the plugin is mounted.',
-    )
-  },
-}
-
-/**
- * Whether a proposed request config selects the Auto provider.
- * @param {object} proposed - { provider, model } from the agent/request waterfall.
- * @returns {boolean}
- */
-export function isAutoSelection(proposed) {
-  return proposed?.provider === AUTO_PROVIDER
-}
+// Virtual "auto" provider adapter. Registers a provider route named `auto`
+// so the model selector shows an "Auto Router" group with one model:
+//
+//   Auto Router
+//     └─ Auto (auto routing)
+//
+// Selecting it marks the session's provider as `auto`; the router plugin then
+// takes over in `agent/request` and routes through the configured L0–L3
+// levels. Selecting any real provider/model leaves the user's choice
+// untouched (the plugin passes through).
+//
+// If a request still reaches provider `auto` (e.g. the router did not
+// intercept this particular call — a titled step, compaction, or a listener
+// ordering gap), `stream()` forwards to the router's current per-session
+// decision instead of throwing, so routing is never a hard failure.
+//
+// The adapter is created per mount through `createAutoAdapter()` and closes
+// over the router and the llm service of *that* context. Earlier revisions
+// published them through `globalThis.__dshAutoModelRouter` / `__dshLl`, which
+// breaks as soon as one process hosts more than one profile (the second mount
+// overwrites the first adapter's dependencies) and leaks a plugin-private API
+// onto the global object.
+
+import { routesEqual } from './router.mjs'
+
+export const AUTO_PROVIDER = 'auto'
+export const AUTO_MODEL = 'auto'
+
+/**
+ * Reasoning efforts advertised when the routed model's own metadata cannot be
+ * read: the four values the DeepSeek catalog accepts.
+ */
+const FALLBACK_EFFORTS = Object.freeze([
+  { id: 'off', name: 'Off' },
+  { id: 'low', name: 'Low' },
+  { id: 'high', name: 'High' },
+  { id: 'max', name: 'Max' },
+])
+
+/**
+ * Context window advertised when the routed model does not report one.
+ * DeepSeek's 0.2.x catalog tops out at 1M tokens; assuming the largest window
+ * merely keeps compaction from firing early — the routed provider still
+ * rejects an oversized request and the fallback chain takes over.
+ */
+const FALLBACK_CONTEXT_WINDOW = 1_000_000
+
+/** Provider route metadata shown in the selector. */
+export function autoProviderInfo(provider) {
+  return { id: provider, name: 'Auto Router' }
+}
+
+/** One advertised model: the single "Auto" choice. */
+export function autoListModels() {
+  return [{ provider: AUTO_PROVIDER, id: AUTO_MODEL, name: 'Auto' }]
+}
+
+/** Exact-model metadata for the advertised model. */
+export function autoResolveModel(provider, model) {
+  return { provider, id: model, name: model }
+}
+
+/**
+ * The route the virtual model should borrow its capabilities from.
+ *
+ * The host asks `resolveModel("auto", "auto")` before it assembles a request,
+ * long before any session decision exists, so this picks the configured
+ * default level (falling back to the first configured one).
+ *
+ * @param {object | undefined} router
+ * @returns {{ provider: string, model: string, reasoningEffort?: string } | undefined}
+ */
+function representativeRoute(router) {
+  try {
+    const level = router?.config?.costControl?.defaultLevel
+    const route = (level === undefined ? undefined : router?.routeForLevel?.(level))
+      ?? router?.firstConfiguredRoute?.()
+    if (route === undefined || route === null) return undefined
+    if (typeof route.provider !== 'string' || route.provider === '') return undefined
+    if (typeof route.model !== 'string' || route.model === '') return undefined
+    return route
+  } catch {
+    return undefined
+  }
+}
+
+/** Read the routed model's own metadata, tolerating a host without it. */
+async function underlyingInfo(llm, route) {
+  if (route === undefined || typeof llm?.resolveModelInfo !== 'function') return undefined
+  try {
+    return await llm.resolveModelInfo(route.provider, route.model)
+  } catch {
+    return undefined
+  }
+}
+
+/** Copy the routed model's efforts, or the DeepSeek defaults. */
+function reasoningEfforts(info) {
+  const efforts = info?.reasoning?.efforts
+  if (Array.isArray(efforts) && efforts.length > 0) {
+    return efforts.map((effort) => ({
+      id: effort.id,
+      name: effort.name,
+      ...effort.description === undefined ? {} : { description: effort.description },
+    }))
+  }
+  return FALLBACK_EFFORTS.map((effort) => ({ ...effort }))
+}
+
+/**
+ * Build the virtual adapter for one plugin mount.
+ *
+ * Both dependencies are read lazily through getters so the adapter always sees
+ * the live router / llm service (they are created before the adapter, but the
+ * indirection keeps the object serializable and testable).
+ *
+ * @param {object} [resolve]
+ * @param {() => object | undefined} [resolve.router] - returns the ModelRouter.
+ * @param {() => object | undefined} [resolve.llm] - returns `ctx.llm`.
+ * @returns {object} adapter understood by `ctx.llm.registerAdapter()`
+ */
+export function createAutoAdapter(resolve = {}) {
+  const readRouter = typeof resolve.router === 'function' ? resolve.router : () => undefined
+  const readLlm = typeof resolve.llm === 'function' ? resolve.llm : () => undefined
+
+  /** @type {object} */
+  const adapter = {
+    providerInfo: autoProviderInfo,
+    providerRetryPolicy() {
+      return undefined
+    },
+    listModels: async () => autoListModels(),
+    /**
+     * Capability metadata for the virtual model.
+     *
+     * The host validates a request against the exact model *before* any
+     * provider I/O and assembles the conversation with what it learns here:
+     * without a context window it cannot budget compaction, and without
+     * reasoning efforts it treats the route as non-thinking and stops echoing
+     * the `thinking` blocks a thinking-mode provider requires on every turn.
+     * Borrowing the routed model's own metadata keeps the virtual provider
+     * indistinguishable from the model it forwards to.
+     */
+    async resolveModel(provider, model) {
+      const route = representativeRoute(readRouter())
+      const info = await underlyingInfo(readLlm(), route)
+      const efforts = reasoningEfforts(info)
+      const requested = route?.reasoningEffort
+      const wanted = efforts.some((effort) => effort.id === requested)
+        ? requested
+        : info?.reasoning?.defaultEffort
+      const defaultEffort = efforts.some((effort) => effort.id === wanted) ? wanted : efforts[0]?.id
+      const contextWindow = Number.isInteger(info?.context?.contextWindow) && info.context.contextWindow > 0
+        ? info.context.contextWindow
+        : FALLBACK_CONTEXT_WINDOW
+      return {
+        provider,
+        id: model,
+        name: 'Auto',
+        context: { contextWindow },
+        systemPromptUpdate: info?.systemPromptUpdate ?? 'in-history',
+        ...info?.defaultMaxTokens === undefined ? {} : { defaultMaxTokens: info.defaultMaxTokens },
+        ...info?.inputModalities === undefined ? {} : { inputModalities: info.inputModalities },
+        reasoning: {
+          efforts,
+          ...defaultEffort === undefined ? {} : { defaultEffort },
+        },
+      }
+    },
+    /**
+     * The 0.2.x adapter contract: the runtime validates a request against the
+     * model's capabilities and binds it to one concrete adapter generation
+     * through `prepareCall(provider, model, signal)`, then dispatches through
+     * the returned `stream`. The virtual `auto` provider owns no generation of
+     * its own, so it returns the metadata it already advertises and routes the
+     * stream through the forwarding generator below.
+     *
+     * Hosts before 0.2.x call `stream()` directly; keeping both entry points is
+     * what makes one package work on 0.1 and 0.2 alike.
+     */
+    async prepareCall(provider, model) {
+      return {
+        model: await adapter.resolveModel(provider, model),
+        stream: (options) => adapter.stream(options),
+      }
+    },
+    async *stream(options) {
+      const router = readRouter()
+      if (router !== undefined && router !== null) {
+        const sessionId = options?.sessionId ?? ''
+        const route = router.current?.(sessionId)
+        if (route && !routesEqual(route, { provider: AUTO_PROVIDER, model: AUTO_MODEL })) {
+          // Forward this request to the routed model through the same llm
+          // runtime; the adapter contract requires we stream chunks back.
+          const llm = readLlm()
+          if (typeof llm?.stream === 'function') {
+            // ctx.llm.stream returns the AsyncIterable directly (not { stream }).
+            const stream = llm.stream({
+              ...options,
+              provider: route.provider,
+              model: route.model,
+              ...route.reasoningEffort === undefined ? {} : { reasoningEffort: route.reasoningEffort },
+            })
+            for await (const chunk of stream) yield chunk
+            return
+          }
+        }
+      }
+      throw new Error(
+        'mydsh-auto-model-router: request reached the virtual "auto" provider with no router '
+        + 'decision available. Check that the plugin is mounted.',
+      )
+    },
+  }
+  return adapter
+}
+
+/**
+ * Unwired singleton kept for import compatibility with earlier revisions.
+ *
+ * It advertises the model metadata but cannot forward a stream (it has no
+ * router), so `stream()` reports the missing mount instead of silently
+ * producing an empty answer.
+ */
+export const AutoAdapter = createAutoAdapter()
+
+/**
+ * Whether a proposed request config selects the Auto provider.
+ * @param {object} proposed - { provider, model } from the agent/request waterfall.
+ * @returns {boolean}
+ */
+export function isAutoSelection(proposed) {
+  return proposed?.provider === AUTO_PROVIDER
+}

package/compat.mjs

@@ -0,0 +1,199 @@
+// Host-compatibility layer.
+//
+// DSH's boot is all-or-nothing: a bundle whose patch throws takes the whole
+// host down with it. That makes every direct host-API call in `apply()` a
+// compatibility risk — a future DSH that renames or drops one of them would
+// not merely lose the router, it would stop the user's Harness from starting.
+//
+// This module probes the APIs the plugin needs once per mount, classifies the
+// host line against the range this revision was exercised on, and provides
+// small helpers that degrade to a logged no-op instead of throwing. Nothing
+// here imports the host, so it stays unit-testable without cordis.
+
+import { createRequire } from 'node:module'
+
+/** Host lines this revision has actually been run against. */
+export const TESTED_HOST_RANGE = '>=0.1.0-0 <0.4.0'
+/** Host lines the plugin will still attempt to run on (its peer ceiling). */
+export const SUPPORTED_HOST_RANGE = '>=0.1.0-0 <1.0.0'
+
+const NOOP = () => {}
+
+/**
+ * Read an optional service without tripping cordis's inject fence.
+ *
+ * cordis throws on `ctx.someService` when that service is not declared in the
+ * plugin's `inject` list ("cannot get property ... without inject"), so an
+ * optional dependency must always go through `ctx.get()` and still be guarded
+ * for hosts that expose no reflection at all.
+ *
+ * @param {object} ctx
+ * @param {string} name
+ * @returns {any}
+ */
+export function readService(ctx, name) {
+  try {
+    return ctx?.get?.(name)
+  } catch {
+    return undefined
+  }
+}
+
+/** Property read that tolerates cordis's inject fence and exotic hosts. */
+function readProperty(ctx, name) {
+  try {
+    return ctx?.[name]
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Snapshot the host surface the plugin depends on.
+ *
+ * Every entry is a plain boolean so it can be serialized into the status
+ * endpoint and used by tests without a live host.
+ *
+ * @param {object} ctx - the cordis context handed to `apply()`.
+ * @returns {{
+ *   llm: boolean, registerAdapter: boolean, listModels: boolean,
+ *   stream: boolean, scopedInject: boolean, webServer: boolean,
+ *   tokenMeter: boolean, provide: boolean,
+ * }}
+ */
+export function probeHost(ctx) {
+  const llm = readProperty(ctx, 'llm') ?? readService(ctx, 'llm')
+  const webServer = readService(ctx, 'webServer')
+  const tokenMeter = readService(ctx, 'tokenMeter')
+  return {
+    llm: Boolean(llm),
+    registerAdapter: typeof llm?.registerAdapter === 'function',
+    listModels: typeof llm?.listModels === 'function',
+    stream: typeof llm?.stream === 'function',
+    scopedInject: typeof readProperty(ctx, 'inject') === 'function',
+    webServer: typeof webServer?.register === 'function',
+    tokenMeter: Boolean(tokenMeter),
+    provide: typeof readProperty(ctx, 'provide') === 'function',
+  }
+}
+
+/**
+ * Register an HTTP route on a webserver-like service, tolerating a renamed
+ * registration method.
+ *
+ * `register(route)` is the 0.1–0.3 shape; `route(route)` is accepted as a
+ * forward-compatible alias. When neither exists the call is a no-op: the
+ * settings page will show its "no report yet" state, which is strictly better
+ * than refusing to mount.
+ *
+ * @param {object} scope - a context exposing `webServer` (and usually `effect`).
+ * @param {{ kind: string, path: string, handler: Function }} route
+ * @returns {() => void} disposer
+ */
+export function registerRoute(scope, route) {
+  const server = scope?.webServer
+  if (server === undefined || server === null) return NOOP
+  for (const method of ['register', 'route', 'addRoute']) {
+    if (typeof server[method] !== 'function') continue
+    try {
+      const dispose = server[method](route)
+      return typeof dispose === 'function' ? dispose : NOOP
+    } catch (error) {
+      // A duplicate path throws in the current host. That is a composition
+      // problem worth failing soft on, not a reason to abort the mount.
+      scope?.logger?.warn?.(
+        `[mydsh-auto-model-router] could not claim ${route.path} via webServer.${method}: ${error?.message ?? error}`,
+      )
+      return NOOP
+    }
+  }
+  return NOOP
+}
+
+/** Per-context dedupe for warnings that would otherwise repeat per session. */
+const warned = new WeakMap()
+
+/**
+ * Log a warning at most once per context and key.
+ *
+ * @param {object} ctx - cordis context (used for the logger and the dedupe key).
+ * @param {string} key - stable identifier for the message.
+ * @param {string} message - human-readable text (the plugin prefix is added).
+ */
+export function warnOnce(ctx, key, message) {
+  try {
+    if (ctx !== null && typeof ctx === 'object') {
+      let keys = warned.get(ctx)
+      if (keys === undefined) {
+        keys = new Set()
+        warned.set(ctx, keys)
+      }
+      if (keys.has(key)) return
+      keys.add(key)
+    }
+    ctx?.logger?.warn?.(`[mydsh-auto-model-router] ${message}`)
+  } catch {
+    // Logging must never be the thing that breaks a mount.
+  }
+}
+
+/**
+ * Version of the running `@deepseek-ai/dsh` package, when it is resolvable.
+ *
+ * DSH installs the runtime resolution that lets a profile plugin import the
+ * packages carried by the installation, so this usually works inside the host
+ * and throws (quietly) everywhere else — which is exactly what a best-effort
+ * probe wants.
+ *
+ * @returns {string | undefined}
+ */
+function installVersion() {
+  try {
+    const require = createRequire(import.meta.url)
+    const manifest = require('@deepseek-ai/dsh/package.json')
+    if (typeof manifest?.version === 'string' && manifest.version !== '') return manifest.version
+  } catch {
+    // Not launched by the harness, or the package does not export its manifest.
+  }
+  return undefined
+}
+
+/**
+ * Best-effort host version, read from the places a host may expose it.
+ *
+ * @param {object} ctx - cordis context.
+ * @param {Record<string, string | undefined>} [env] - defaults to `process.env`.
+ * @returns {string | undefined}
+ */
+export function readHostVersion(ctx, env = globalThis.process?.env) {
+  const app = readService(ctx, 'app')
+  const candidates = [
+    app?.version,
+    readProperty(ctx, 'cmdlineArgs')?.version,
+    readService(ctx, 'cmdlineArgs')?.version,
+    env?.DSH_VERSION,
+    env?.npm_package_version,
+    installVersion(),
+  ]
+  for (const candidate of candidates) {
+    if (typeof candidate === 'string' && candidate.trim() !== '') return candidate.trim()
+  }
+  return undefined
+}
+
+/**
+ * Classify a host version against the range this revision was tested on.
+ *
+ * @param {string | undefined} version
+ * @returns {'tested' | 'untested' | 'unknown'}
+ */
+export function classifyHostVersion(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)/.exec(version ?? '')
+  if (match === null) return 'unknown'
+  const major = Number(match[1])
+  const minor = Number(match[2])
+  // DSH is pre-1.0: every 0.x minor may break. 0.1–0.3 are the exercised
+  // lines; 0.4+ and 1.x+ are allowed to mount but reported as untested.
+  if (major === 0 && minor <= 3) return 'tested'
+  return 'untested'
+}

package/config.mjs

@@ -22,7 +22,7 @@
 //   fallbackChain:  [route, ...]  (model-level, appended with the default)
 //   maxRetries:     per-route retry budget on request-error
 
-export const PLUGIN_VERSION = '0.1.0'
+export const PLUGIN_VERSION = '0.2.2'
 
 export const LEVEL_IDS = Object.freeze(['L0', 'L1', 'L2', 'L3'])
 export const COST_MODES = Object.freeze(['cost-first', 'quality-first', 'balanced'])
@@ -150,6 +150,9 @@ export function resolveConfig(input = {}) {
   // Nothing declares a window → the guard is inert (no behaviour change).
   cfg.contextGuard.enabled = cfg.contextGuard.enabled
     && LEVEL_IDS.some((id) => Number.isFinite(cfg.levels[id]?.contextWindow))
+  // Exposed to the status endpoint and the browser settings page so a bug
+  // report always names the build that produced it.
+  cfg.pluginVersion = PLUGIN_VERSION
   return cfg
 }