dsh-cline-pass 0.1.1 → 0.2.1

package/README.en.md

@@ -68,7 +68,7 @@ To override defaults, add a `cline-pass` section to your profile's `$DSH_HOME/pr
         apiKeyEnv: CLINE_PASS_BACKUP_KEY
 ```
 
-Common settings include `baseURL`, `knownModels`, `models`, `perModel`, `exposeCatalog`, and `historyLimit`. The default gateway is `https://api.cline.bot/api/v1`.
+Common settings include `baseURL`, `knownModels`, `models`, `perModel`, `exposeCatalog`, and `historyLimit`. The default gateway is `https://api.cline.bot/api/v1`. `maxConcurrentRequests` caps how many streams each account keeps open to the gateway at once (default 16); further requests wait for a free slot, and `0` lifts the cap.
 
 ## Upstream channels
 

package/README.md

@@ -68,7 +68,7 @@ cline_pass_accounts action=mode mode=roundrobin
         apiKeyEnv: CLINE_PASS_BACKUP_KEY
 ```
 
-常用设置包括 `baseURL`、`knownModels`、`models`、`perModel`、`exposeCatalog` 和 `historyLimit`。默认网关地址为 `https://api.cline.bot/api/v1`。
+常用设置包括 `baseURL`、`knownModels`、`models`、`perModel`、`exposeCatalog` 和 `historyLimit`。默认网关地址为 `https://api.cline.bot/api/v1`。`maxConcurrentRequests` 限制每个账号同时发往网关的流数，默认 16，超出的请求排队等待空位，设为 `0` 表示不限。
 
 ## 上游渠道
 

package/lib/adapter.js

@@ -30,12 +30,23 @@ import {
   errorText,
   injectPrefs,
   parseRouting,
+  pinAdherence,
+  pinWarnings,
   unwrapEnvelope,
 } from './protocol.js'
 import { parseServerSentEvents } from './engine.js'
 
 /** Default maximum idle interval while a stream read is outstanding. */
 export const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 300000
+/**
+ * Default number of streams one account keeps open to the gateway at once.
+ *
+ * Twice dsh 0.1.7's default `maxActiveSubagents` (8): a main agent with a full
+ * set of subagents, plus a title or compaction call, never queues, while a
+ * runaway fan-out still cannot open an unbounded number of upstream streams
+ * (CWE-770). `0` lifts the cap.
+ */
+export const DEFAULT_MAX_CONCURRENT_REQUESTS = 16
 /**
  * Conservative context capacity for a model the catalog does not describe.
  * Shipped models carry their published window, so this only bounds the
@@ -56,6 +67,84 @@ export const DEFAULT_MAX_TOKENS = 32000
  * cap. These match the values the shipped adapters use.
  */
 export const DEFAULT_REQUEST_IMAGE_POLICY = { maxPixels: 4194304, maxBytes: 1048576 }
+/**
+ * Lead-in text for the user message that carries images recovered from tool
+ * results, matching the wording the shipped DeepSeek adapter uses.
+ */
+const TOOL_RESULT_IMAGE_TEXT = 'Attached image(s) from tool result:'
+
+/**
+ * Compute aspect-preserving integer dimensions within a total-pixel budget.
+ *
+ * Local copy of the harness's own projection: it is pure geometry, and this
+ * adapter must not add a hard dependency on `@deepseek-ai/dsh-attachment` for
+ * one helper. Mirrors `requestImageDimensions`, including the inward rounding
+ * and the "never enlarge a small image" rule.
+ *
+ * @param width - positive source width.
+ * @param height - positive source height.
+ * @param maxPixels - positive width-times-height cap.
+ * @returns projected dimensions.
+ */
+export function projectImageDimensions(width, height, maxPixels) {
+  const safeWidth = Number.isSafeInteger(width) && width > 0 ? width : 1
+  const safeHeight = Number.isSafeInteger(height) && height > 0 ? height : 1
+  const safeBudget = Number.isSafeInteger(maxPixels) && maxPixels > 0 ? maxPixels : DEFAULT_REQUEST_IMAGE_POLICY.maxPixels
+  const scale = Math.min(1, Math.sqrt(safeBudget / (safeWidth * safeHeight)))
+  if (scale === 1) return { width: safeWidth, height: safeHeight }
+  if (safeWidth >= safeHeight) {
+    let projectedWidth = Math.max(1, Math.floor(safeWidth * scale))
+    let projectedHeight = Math.max(1, Math.round((projectedWidth * safeHeight) / safeWidth))
+    while (projectedWidth * projectedHeight > safeBudget && projectedWidth > 1) {
+      projectedWidth -= 1
+      projectedHeight = Math.max(1, Math.round((projectedWidth * safeHeight) / safeWidth))
+    }
+    return { width: projectedWidth, height: projectedHeight }
+  }
+  let projectedHeight = Math.max(1, Math.floor(safeHeight * scale))
+  let projectedWidth = Math.max(1, Math.round((projectedHeight * safeWidth) / safeHeight))
+  while (projectedWidth * projectedHeight > safeBudget && projectedHeight > 1) {
+    projectedHeight -= 1
+    projectedWidth = Math.max(1, Math.round((projectedHeight * safeWidth) / safeHeight))
+  }
+  return { width: projectedWidth, height: projectedHeight }
+}
+
+/**
+ * Build the target object one attachment must be materialized at.
+ *
+ * The harness changed this contract between releases and the two shapes are
+ * mutually exclusive, not additive:
+ *
+ * - 0.1.2 - 0.1.5 validate `{maxPixels, maxBytes}` and project the dimensions
+ *   themselves;
+ * - 0.1.6+ validate `{width, height, maxBytes}` and take the dimensions as
+ *   given.
+ *
+ * A caller that sends only one shape fails on the other host — the newer one
+ * rejects a missing `width` with `Image request width must be a positive
+ * integer.`, which surfaces to the user as a failed turn on every image. Each
+ * validator reads only the fields it knows and ignores the rest, so one target
+ * carrying both the projected dimensions and the pixel budget satisfies either
+ * host. The dimensions are projected here with the same geometry the older
+ * host would have applied, so the rendered result is identical on both.
+ *
+ * @param ref - the durable attachment reference, which carries its own size.
+ * @param policy - the configured pixel and byte budget.
+ * @returns the request target for `readImageRequest`.
+ * @throws {LlmError} UNSUPPORTED_CONTENT when the reference carries no usable size.
+ */
+export function requestImageTarget(ref, policy) {
+  const maxPixels = policy?.maxPixels ?? DEFAULT_REQUEST_IMAGE_POLICY.maxPixels
+  const maxBytes = policy?.maxBytes ?? DEFAULT_REQUEST_IMAGE_POLICY.maxBytes
+  const width = ref?.width
+  const height = ref?.height
+  if (!Number.isSafeInteger(width) || width <= 0 || !Number.isSafeInteger(height) || height <= 0) {
+    throw new LlmError('The Cline Pass adapter received an image reference without usable dimensions.', 'UNSUPPORTED_CONTENT')
+  }
+  const projected = projectImageDimensions(width, height, maxPixels)
+  return { width: projected.width, height: projected.height, maxPixels, maxBytes }
+}
 
 const STREAM_IDLE_TIMEOUT_CODE = 'CLINE_PASS_STREAM_IDLE_TIMEOUT'
 
@@ -107,7 +196,7 @@ export async function prepareRequestImages(messages, attachments, policy, signal
     throw new LlmError('The Cline Pass adapter needs the durable attachment service to send image input.', 'UNSUPPORTED_CONTENT')
   }
   const ordered = [...refs.values()]
-  const prepared = await Promise.all(ordered.map((ref) => attachments.readImageRequest(ref, policy, signal)))
+  const prepared = await Promise.all(ordered.map((ref) => attachments.readImageRequest(ref, requestImageTarget(ref, policy), signal)))
   const versions = new Map()
   for (const [index, ref] of ordered.entries()) versions.set(ref.attachmentId, prepared[index])
   return versions
@@ -135,21 +224,55 @@ function serializeAssistant(message) {
   }
 }
 
+/**
+ * Resolve one image block into its OpenAI wire part.
+ *
+ * @throws {LlmError} UNSUPPORTED_CONTENT when its request bytes were not prepared.
+ */
+function imagePart(block, images) {
+  const version = images?.get(block.attachment?.attachmentId)
+  if (version === undefined) {
+    throw new LlmError('The Cline Pass adapter received an image it could not resolve into request bytes.', 'UNSUPPORTED_CONTENT')
+  }
+  return { type: 'image_url', image_url: { url: `data:${version.mediaType};base64,${toBase64(version.data)}` } }
+}
+
+/** Recursively collect image parts from blocks, including nested tool results. */
+function collectImageParts(blocks, images, target = []) {
+  for (const block of blocks ?? []) {
+    if (block.type === 'image') target.push(imagePart(block, images))
+    else if (block.type === 'tool-result') collectImageParts(block.content, images, target)
+  }
+  return target
+}
+
 /**
  * Convert the harness conversation to wire messages.
  *
  * Tool results become standalone `{ role: 'tool' }` messages. A user message
  * carrying an image switches to the OpenAI content-part array; a text-only one
  * keeps the plain-string form.
+ *
+ * An image nested in a tool result (read_image, a screenshot tool) has no
+ * OpenAI `tool` wire spelling, so it rides a following user message instead —
+ * the same shape the shipped adapters use.
  */
 function serializeMessages(messages, images) {
   const wire = []
+  let pendingToolImages = []
+  const flushToolImages = () => {
+    if (pendingToolImages.length === 0) return
+    wire.push({ role: 'user', content: [{ type: 'text', text: TOOL_RESULT_IMAGE_TEXT }, ...pendingToolImages] })
+    pendingToolImages = []
+  }
   for (const message of messages) {
     if (message.role === 'system') {
+      flushToolImages()
       wire.push({ role: 'system', content: flattenText(message.content) })
       continue
     }
     if (message.role === 'assistant') {
+      flushToolImages()
       wire.push(serializeAssistant(message))
       continue
     }
@@ -157,26 +280,24 @@ function serializeMessages(messages, images) {
     const parts = []
     for (const block of message.content ?? []) {
       if (block.type === 'text' && block.text.length > 0) parts.push({ type: 'text', text: block.text })
-      else if (block.type === 'image') {
-        const version = images?.get(block.attachment?.attachmentId)
-        if (version === undefined) {
-          throw new LlmError('The Cline Pass adapter received an image it could not resolve into request bytes.', 'UNSUPPORTED_CONTENT')
-        }
-        parts.push({ type: 'image_url', image_url: { url: `data:${version.mediaType};base64,${toBase64(version.data)}` } })
-      }
+      else if (block.type === 'image') parts.push(imagePart(block, images))
     }
     const hasImage = parts.some((part) => part.type === 'image_url')
     const text = parts.filter((part) => part.type === 'text').map((part) => part.text).join('')
-    if (hasImage) wire.push({ role: 'user', content: parts })
-    else if (text.length > 0 || toolResults.length === 0) wire.push({ role: 'user', content: text })
+    if (hasImage || text.length > 0 || toolResults.length === 0) {
+      flushToolImages()
+      wire.push({ role: 'user', content: hasImage ? parts : text })
+    }
     for (const result of toolResults) {
       wire.push({
         role: 'tool',
         tool_call_id: result.toolCallId,
         content: flattenText(result.content) || '(no output)',
       })
+      collectImageParts(result.content, images, pendingToolImages)
     }
   }
+  flushToolImages()
   return wire
 }
 
@@ -303,6 +424,31 @@ export function streamErrorCode(message, status) {
   return 'UPSTREAM'
 }
 
+/**
+ * Note the moment the first byte of a response body arrives.
+ *
+ * A pass-through stream: it reports once, on the first chunk, and forwards every
+ * chunk unchanged. A keep-alive comment or an early frame reaches this before it
+ * reaches the SSE parser, so the recorded moment is the gateway's first sign of
+ * life rather than the caller's first content.
+ *
+ * @param body - the response body stream.
+ * @param onFirst - called once, when the first chunk is seen.
+ * @returns a stream equivalent to `body`.
+ */
+function tapFirstByte(body, onFirst) {
+  let seen = false
+  return body.pipeThrough(new TransformStream({
+    transform(chunk, controller) {
+      if (!seen) {
+        seen = true
+        onFirst()
+      }
+      controller.enqueue(chunk)
+    },
+  }))
+}
+
 /**
  * Translate decoded SSE payloads into harness stream chunks.
  *
@@ -421,6 +567,81 @@ async function* tapRouting(payloads, observed) {
   }
 }
 
+//#region upstream concurrency
+
+/**
+ * Per-account slots for streams open to the gateway.
+ *
+ * A slot is held for a whole attempt — from before `fetch` until the response
+ * body is closed — because the stream, not the wait for headers, is what keeps
+ * a socket and the account's concurrency busy. Accounts are counted apart, so a
+ * stalled account cannot hold up requests routed to a healthy one; absorbing
+ * exactly that is what the pool is for.
+ *
+ * Waiters are served first in, first out, and a freed slot is handed to the
+ * next waiter and counted in the same step, so a request arriving in between
+ * cannot take it as well. A waiter whose signal aborts leaves the queue at
+ * once; a held slot is also freed when its signal aborts, so a consumer that
+ * stops reading without closing the stream does not keep it.
+ *
+ * @returns `{ acquire(key, limit, signal) }`, resolving to a release function
+ *   that is safe to call more than once. A `limit` below 1 means no limit.
+ */
+export function createUpstreamSlots() {
+  const pools = new Map()
+  const admit = (pool) => {
+    while (pool.waiting.length > 0 && pool.active < pool.limit) {
+      pool.active += 1
+      pool.waiting.shift()()
+    }
+  }
+  const hold = (pool, signal) => {
+    let held = true
+    const release = () => {
+      if (!held) return
+      held = false
+      signal?.removeEventListener('abort', release)
+      pool.active -= 1
+      admit(pool)
+    }
+    signal?.addEventListener('abort', release, { once: true })
+    return release
+  }
+  return {
+    async acquire(key, limit, signal) {
+      signal?.throwIfAborted()
+      let pool = pools.get(key)
+      if (pool === undefined) {
+        pool = { active: 0, limit: Infinity, waiting: [] }
+        pools.set(key, pool)
+      }
+      // Read on every call, so a changed setting reaches the next request; a
+      // raised limit admits the queue before this caller joins it.
+      pool.limit = Number.isFinite(limit) && limit >= 1 ? Math.floor(limit) : Infinity
+      admit(pool)
+      if (pool.waiting.length === 0 && pool.active < pool.limit) {
+        pool.active += 1
+        return hold(pool, signal)
+      }
+      return await new Promise((resolve, reject) => {
+        const grant = () => {
+          signal?.removeEventListener('abort', abandon)
+          resolve(hold(pool, signal))
+        }
+        const abandon = () => {
+          const at = pool.waiting.indexOf(grant)
+          if (at !== -1) pool.waiting.splice(at, 1)
+          reject(signal.reason)
+        }
+        pool.waiting.push(grant)
+        signal?.addEventListener('abort', abandon, { once: true })
+      })
+    },
+  }
+}
+
+//#endregion
+
 /**
  * The Cline Pass adapter. One instance serves the plugin's provider route(s);
  * the harness model id IS the gateway's wire model id.
@@ -429,6 +650,7 @@ export class ClinePassAdapter extends LlmAdapter {
   constructor(config) {
     super()
     this.config = config
+    this.upstreamSlots = createUpstreamSlots()
   }
 
   providerInfo(provider) {
@@ -444,11 +666,15 @@ export class ClinePassAdapter extends LlmAdapter {
     const configured = connection.models.find((entry) => entry.id === model)
     const discovered = this.config.discoveredContext?.(model)
     const override = configured ?? { id: model }
+    // What the last official scan published about this model. Without it a model
+    // newer than this release resolves to the `text` fallback and the harness
+    // refuses every image for it, silently.
+    const published = this.config.publishedModel?.(model) ?? {}
     const resolved = resolveModelMetadata(provider, model, override, {
       contextWindow: discovered ?? connection.defaultContextWindow,
       maxTokens: connection.maxTokens,
       reasoning: connection.reasoningModels !== false,
-    })
+    }, published)
     // A probe that saw this model's real endpoints overrides the published
     // window: it is measured, not documented.
     return Promise.resolve(discovered === undefined
@@ -494,12 +720,51 @@ export class ClinePassAdapter extends LlmAdapter {
     const trace = []
     let delivered = false
     let lastError = null
+    /**
+     * When the caller saw its first chunk, in ms from the request's own start.
+     *
+     * Measured from `startedAt` rather than from the serving attempt so it can be
+     * read next to `ms`, which is also request-scoped: a failover attempt's dead
+     * time is part of what the user actually waited through. Zero means no chunk
+     * ever arrived, which is a fact worth keeping rather than a missing value.
+     */
+    let firstChunkMs = 0
+    /**
+     * When the gateway's first byte arrived, in ms from the request's own start.
+     *
+     * `ttft` answers "when did the caller see something"; this answers "when did
+     * the gateway start talking at all". The pair separates two very different
+     * stalls: a gateway that accepted the request and then sent nothing (both
+     * late) from one that keeps the socket warm while the model thinks — a
+     * keep-alive comment or an early frame produces bytes without producing a
+     * chunk, and only having both tells those apart.
+     */
+    let firstByteMs = 0
+    /**
+     * Accounts this request has already been refused by.
+     *
+     * The pool is offered as one account with a combined quota, so a refusal that
+     * is about the ACCOUNT — a spent window, a revoked key — moves to the next
+     * one instead of ending the request. `resolveAccount` answers `undefined` once
+     * nothing is left, which is when the real error is raised below.
+     */
+    const refused = new Set()
     for (const attempt of attempts) {
-      const account = await this.config.resolveAccount()
+      const account = await this.config.resolveAccount({ exclude: [...refused] })
+      if (account === undefined) break
       const body = injectPrefs(buildRequestBody(options, connection, images), meta, attempt)
-      const attemptStarted = Date.now()
       const consumer = new AbortController()
       const upstream = options.signal === undefined ? consumer.signal : AbortSignal.any([options.signal, consumer.signal])
+      // The account's slot is taken before the attempt's clock starts: the wait
+      // is local, and counting it would teach the channel a latency it never had.
+      let release
+      try {
+        release = await this.upstreamSlots.acquire(account.name, connection.maxConcurrentRequests ?? DEFAULT_MAX_CONCURRENT_REQUESTS, upstream)
+      } catch (error) {
+        if (options.signal?.aborted) throw new LlmError('Cline Pass request aborted by caller', 'ABORTED', { cause: error })
+        throw error
+      }
+      const attemptStarted = Date.now()
       const watchdog = idleWatchdog(upstream, connection.streamIdleTimeoutMs, STREAM_IDLE_TIMEOUT_CODE)
       try {
         let response
@@ -534,9 +799,22 @@ export class ClinePassAdapter extends LlmAdapter {
           trace.push({ upstream: attempt.upstream ?? '(auto)', status: response.status, ms, note: detail.slice(0, 160) })
           this.config.learnUpstream(options.model, attempt.upstream, classifyUpstreamError(detail), detail, ms)
           lastError = new LlmError(`${detail || `HTTP ${response.status}`} [model=${options.model}]`, streamErrorCode(detail, response.status), { status: response.status })
-          // A rejected pin or a busy upstream is worth another candidate; an
-          // auth failure is not, so it is raised immediately.
-          if (lastError.code === 'AUTH' || lastError.code === QUOTA_EXCEEDED_CODE) throw lastError
+          // A rejected pin or a busy upstream is worth another candidate. An
+          // account-level refusal is worth another ACCOUNT: that is the whole
+          // point of a pool, and with one account the next attempt simply finds
+          // nothing left and this error is raised unchanged.
+          if (lastError.code === 'AUTH' || lastError.code === QUOTA_EXCEEDED_CODE) {
+            refused.add(account.name)
+            this.config.record(options.model, {
+              provider: null,
+              attempts: trace.map((row) => row.upstream),
+              ms: Date.now() - startedAt,
+              stream: true,
+              error: firstLine(lastError.message, 200),
+              code: lastError.code,
+              account: account.name,
+            })
+          }
           continue
         }
         if (response.body === null || response.body === undefined) {
@@ -545,11 +823,28 @@ export class ClinePassAdapter extends LlmAdapter {
         }
         let yielded = false
         const observed = { provider: null, canonical: null, pipeline: null }
-        const iterator = translate(tapRouting(parseServerSentEvents(response.body), observed))[Symbol.asyncIterator]()
+        // `body` in this scope is the request payload, so the response stream
+        // gets its own name.
+        const responseBody = tapFirstByte(response.body, () => {
+          if (firstByteMs === 0) firstByteMs = Date.now() - startedAt
+        })
+        const iterator = translate(tapRouting(parseServerSentEvents(responseBody), observed))[Symbol.asyncIterator]()
+        /**
+         * The usage frame, captured as it passes through.
+         *
+         * The gateway sends it in the last frames, after the content, so a record
+         * written when the stream ends has it — but only if the chunk was read on
+         * its way to the caller. `reasoningTokens` in particular is the number
+         * that explains a large time-to-first-chunk: it is thinking the caller
+         * cannot see, because this gateway does not stream it.
+         */
+        let usage = null
         try {
           for (;;) {
             const next = await watchdog.next(iterator)
             if (next.done === true) break
+            if (next.value?.type === 'usage') usage = next.value.usage
+            if (firstChunkMs === 0) firstChunkMs = Date.now() - startedAt
             yielded = true
             yield next.value
           }
@@ -562,21 +857,41 @@ export class ClinePassAdapter extends LlmAdapter {
           const ms = Date.now() - attemptStarted
           trace.push({ upstream: attempt.upstream ?? '(auto)', status: 200, ms, note: note.slice(0, 160) })
           this.config.learnUpstream(options.model, attempt.upstream, classifyUpstreamError(note), note, ms)
-          // Content already reached the caller: this is the answer's failure,
-          // not a reason to silently ask another channel. A missing account is
-          // fatal for the same reason — every candidate would fail the same way.
-          if (yielded || error?.code === 'AUTH' || error?.code === QUOTA_EXCEEDED_CODE) {
+          // Content already reached the caller: this is the answer's failure, and
+          // no retry can un-deliver it. Before any content, an account-level
+          // refusal (a spent window, a revoked key) moves to the next account —
+          // the pool exists to absorb exactly that.
+          const code = error instanceof LlmError ? error.code : 'TRANSPORT'
+          if (yielded) {
             this.config.record(options.model, {
               provider: observed.provider,
               canonical: observed.canonical,
               attempts: trace.map((row) => row.upstream),
               ms: Date.now() - startedAt,
+              ttfb: firstByteMs,
+              ttft: firstChunkMs,
               stream: true,
               error: note.slice(0, 200),
+              code,
               account: account.name,
             })
             throw error instanceof LlmError ? error : new LlmError(note, 'TRANSPORT', { cause: error })
           }
+          if (code === 'AUTH' || code === QUOTA_EXCEEDED_CODE) {
+            refused.add(account.name)
+            this.config.record(options.model, {
+              provider: observed.provider,
+              canonical: observed.canonical,
+              attempts: trace.map((row) => row.upstream),
+              ms: Date.now() - startedAt,
+              ttfb: firstByteMs,
+              ttft: firstChunkMs,
+              stream: true,
+              error: note.slice(0, 200),
+              code,
+              account: account.name,
+            })
+          }
           lastError = error instanceof LlmError ? error : new LlmError(note, 'TRANSPORT', { cause: error })
           continue
         } finally {
@@ -588,19 +903,47 @@ export class ClinePassAdapter extends LlmAdapter {
           }
         }
         delivered = true
-        trace.push({ upstream: attempt.upstream ?? '(auto)', status: 200, ms: Date.now() - attemptStarted, note: 'ok' })
+        // Which channel answered is read back from the stream, because a 200
+        // only proves someone answered. The router drops an unusable `only`
+        // without complaining, so "we asked for baseten" and "baseten served it"
+        // are different facts and only the second one is evidence.
+        const adherence = pinAdherence(attempt, { finalProvider: observed.provider })
+        const warnings = pinWarnings(attempt, meta)
+        trace.push({
+          upstream: attempt.upstream ?? '(auto)',
+          status: 200,
+          ms: Date.now() - attemptStarted,
+          note: adherence === 'not-adopted' || adherence === 'violated'
+            ? `pin not adopted: served by ${observed.provider ?? '(unknown)'}`
+            : 'ok',
+        })
         this.config.record(options.model, {
           provider: observed.provider ?? (attempt.upstream ?? null),
           canonical: observed.canonical,
           attempts: trace.map((row) => row.upstream),
           ms: Date.now() - startedAt,
+          ttfb: firstByteMs,
+          ttft: firstChunkMs,
           stream: true,
           error: null,
           account: account.name,
+          adherence,
+          warnings,
+          // What the request cost in tokens, and how much of that the model spent
+          // thinking invisibly — the two numbers that explain a large `ttft`.
+          usage,
+          effort: options.reasoningEffort ?? '',
         })
-        if (attempt.upstream !== null) this.config.learnUpstream(options.model, attempt.upstream, 'ok', '', Date.now() - attemptStarted)
+        // Only a pin the router actually honored proves the channel works.
+        // Marking it usable no matter who answered is how a false "available"
+        // reached the verdict map the exclusion allow-list is built from — the
+        // map then vouched for the very channels it was meant to exclude.
+        if (attempt.upstream !== null && adherence === 'adopted') this.config.learnUpstream(options.model, attempt.upstream, 'ok', '', Date.now() - attemptStarted)
         return
       } finally {
+        // Held until the attempt ends, response body included, so the slot
+        // bounds open streams rather than requests waiting for headers.
+        release()
         watchdog[Symbol.dispose]()
       }
     }
@@ -610,6 +953,8 @@ export class ClinePassAdapter extends LlmAdapter {
         provider: null,
         attempts: trace.map((row) => row.upstream),
         ms: Date.now() - startedAt,
+        ttfb: firstByteMs,
+        ttft: firstChunkMs,
         stream: true,
         error: message.slice(0, 200),
         account: null,

package/lib/catalog.js

@@ -168,17 +168,25 @@ const SEAM_MODALITIES = new Set(['text', 'image'])
 /**
  * Resolve the metadata seam fields for one model.
  *
- * Precedence per field: the configured override, then the published catalog,
- * then the route-wide fallback.
+ * Precedence per field: the configured override, then the shipped catalog, then
+ * what the last official scan published, then the route-wide fallback.
  *
+ * The live scan sits below the shipped table rather than above it because the
+ * shipped entry is curated: models.dev reports `audio`/`video`/`pdf`, and the
+ * underscore-free spelling of a display name, neither of which the seam or the
+ * provider's own label wants. It exists to cover what the table cannot know —
+ * a model published after this release — so a multimodal model is never adopted
+ * as text-only just because it is new.
+ *
+ * @param discovered - metadata for this model from the last catalog scan.
  * @returns a descriptor the seam's `normalizeModelInfo` accepts.
  */
-export function resolveModelMetadata(provider, model, override, fallback) {
-  const published = catalogEntry(model) ?? {}
+export function resolveModelMetadata(provider, model, override, fallback, discovered = {}) {
+  const published = { ...(discovered ?? {}), ...(catalogEntry(model) ?? {}) }
   const name = pick(override?.name, published.name, model)
   const contextWindow = pick(override?.contextWindow, published.contextWindow, fallback.contextWindow)
   const maxTokens = pick(override?.maxTokens, published.maxTokens, fallback.maxTokens)
-  const modality = pick(override?.input, published.input, undefined)
+  const modality = pick(override?.input, published.input ?? published.inputModalities, undefined)
   const reasoning = override?.reasoning ?? published.reasoning ?? fallback.reasoning
   const offered = (modality ?? ['text']).filter((entry) => SEAM_MODALITIES.has(entry))
   return {