@goodandready/dsh-subscriptions 0.6.38 → 0.6.40

package/lib/accounts.js

@@ -1,3 +1,4 @@
+import { needsWarmupProbe, enterProbing, resolveWarmupSuccess, resolveWarmupFailure, STATUS_QUARANTINE, STATUS_PROBING } from "./quarantine.js"
 import { fetchWithTimeout } from "./http.js"
 import { credentialRef } from '@deepseek-ai/dsh-credentials'
 import { oauthRef, isProvider } from './refs.js'
@@ -348,19 +349,51 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
       quarantines.delete(ref)
       if (health.has(ref)) health.set(ref, null)
     },
-    rememberQuarantine(ref, reason, until) {
+    rememberQuarantine(ref, reason, until, attempts = 1) {
       if (!ref) return
-      quarantines.set(ref, { reason: reason || 'RATE_LIMIT', until: Number(until) || (Date.now() + 3600000) })
+      quarantines.set(ref, {
+        reason: reason || 'RATE_LIMIT',
+        until: Number(until) || (Date.now() + 3600000),
+        attempts: Number(attempts) || 1,
+        status: STATUS_QUARANTINE,
+      })
     },
-    getQuarantine(ref) {
+    getQuarantine(ref, now = Date.now()) {
       const q = quarantines.get(ref)
       if (!q) return null
-      if (Number(q.until) <= Date.now()) {
+      if (Number(q.until) <= now) {
+        if (q.status === STATUS_PROBING) return q
         quarantines.delete(ref)
         return null
       }
       return q
     },
+    async probeWarmup(ref, probeFn) {
+      const q = quarantines.get(ref)
+      if (!q) return { success: true }
+      const acc = { quarantineReason: q.reason, quarantineUntil: q.until, quarantineAttempts: q.attempts || 1, status: q.status }
+      if (!needsWarmupProbe(acc)) {
+        return { success: false, reason: 'NOT_EXPIRED' }
+      }
+      quarantines.set(ref, enterProbing(acc))
+      try {
+        if (typeof probeFn === 'function') {
+          await probeFn(ref)
+        }
+        resolveWarmupSuccess(acc)
+        quarantines.delete(ref)
+        return { success: true }
+      } catch (err) {
+        const updated = resolveWarmupFailure(acc, err?.message || q.reason)
+        quarantines.set(ref, {
+          reason: updated.quarantineReason,
+          until: updated.quarantineUntil,
+          attempts: updated.quarantineAttempts,
+          status: updated.status,
+        })
+        return { success: false, account: updated, error: err }
+      }
+    },
     releaseQuarantine(ref) {
       quarantines.delete(ref)
     },

package/lib/adapter-manager.js

@@ -21,6 +21,7 @@ export function createAdapterManager({
 }) {
   let handle
   let adapterDisposed = false
+  let retryTimer
   let registeredByUs = new Set()
 
   function disposeAdapterHandle(h) {
@@ -48,6 +49,11 @@ export function createAdapterManager({
     saveBlob: (ref, blob) => store.saveBlob(ref, blob),
     alertThresholds: () => live().alertThresholds,
     webhookUrl: () => live().webhookUrl,
+    rememberRequest: (ref) => store.rememberRequest(ref),
+    recordSuccess: (ref) => store.recordSuccess(ref),
+    recordSwitch: (ref) => store.recordSwitch(ref),
+    recordExhaust: (ref) => store.recordExhaust(ref),
+    recordBroken: (ref) => store.recordBroken(ref),
     recordHistory,
     fetchImpl: fetch,
     fetchForRef,
@@ -57,7 +63,8 @@ export function createAdapterManager({
     const cfg = live()
     if (!cfg.cascadingFallback) throw err
     const logged = await store.loggedInProviders()
-    const available = Object.keys(logged || {}).filter((p) => logged[p] && p !== provider)
+    const loggedList = Array.isArray(logged) ? logged : Object.keys(logged || {}).filter((p) => logged[p])
+    const available = loggedList.filter((p) => p !== provider)
     visited.add(provider)
     const nextVendor = resolveFallbackVendor(provider, available, cfg.cascadingChain, visited)
     if (!nextVendor) throw err
@@ -83,6 +90,7 @@ export function createAdapterManager({
   async function syncAdapter() {
     if (adapterDisposed) return
     const desired = await store.loggedInProviders()
+    if (adapterDisposed) return
     const globalProviders = ctx.llm && typeof ctx.llm.listProviders === 'function'
       ? ctx.llm.listProviders().map((p) => p.id)
       : []
@@ -95,6 +103,7 @@ export function createAdapterManager({
       logger.info(`[dsh-subscriptions] syncAdapter skipping already-bound providers: ${skipped.join(', ')}`)
     }
 
+    if (adapterDisposed) return
     if (!handle && claimable.length) {
       handle = ctx.llm.registerAdapter(claimable, adapter)
       registeredByUs = new Set(claimable)
@@ -239,7 +248,6 @@ export function createAdapterManager({
       })
 
       let retries = 0
-      let retryTimer
       const scheduleRetry = () => {
         if (adapterDisposed || retries >= 30) return
         retryTimer = setTimeout(retrySync, 1000)
@@ -303,5 +311,15 @@ export function createAdapterManager({
     refreshModels,
     cascadeFallbackStream,
     registerAdapterLifecycle,
+    dispose: () => {
+      adapterDisposed = true
+      adapter.dispose()
+      if (retryTimer) clearTimeout(retryTimer)
+      if (handle) {
+        disposeAdapterHandle(handle)
+        handle = undefined
+        registeredByUs.clear()
+      }
+    },
   }
 }

package/lib/adapter.js

@@ -32,6 +32,11 @@ export class SubscriptionAdapter extends LlmAdapter {
   constructor(deps) {
     super()
     this.deps = deps
+    this.disposed = false
+  }
+
+  dispose() {
+    this.disposed = true
   }
 
   providerInfo(provider) {
@@ -127,6 +132,9 @@ export class SubscriptionAdapter extends LlmAdapter {
           const t0 = Date.now()
           let firstChunkTime = null
           let outputTokens = 0
+          let inputTokens = 0
+          let cacheReadTokens = 0
+          let cacheWriteTokens = 0
           let approxChars = 0
           const blob = await deps.ensureFresh(provider, await deps.loadBlob(account.ref), account.ref)
           const vendor = getVendor(provider)
@@ -201,6 +209,15 @@ export class SubscriptionAdapter extends LlmAdapter {
                   if (u && typeof u.outputTokens === 'number' && u.outputTokens > 0) {
                     outputTokens = u.outputTokens
                   }
+                  if (u && typeof u.inputTokens === 'number') {
+                    inputTokens = u.inputTokens
+                  }
+                  if (u && typeof u.cacheReadTokens === 'number') {
+                    cacheReadTokens = u.cacheReadTokens
+                  }
+                  if (u && typeof u.cacheWriteTokens === 'number') {
+                    cacheWriteTokens = u.cacheWriteTokens
+                  }
                 } else if (chunk.type === 'text-delta' && typeof chunk.text === 'string') {
                   approxChars += chunk.text.length
                 }
@@ -232,12 +249,20 @@ export class SubscriptionAdapter extends LlmAdapter {
                   ms: totalMs,
                   ttftMs,
                   tps,
+                  inputTokens: inputTokens || undefined,
                   outputTokens: outputTokens || undefined,
+                  cacheReadTokens: cacheReadTokens || undefined,
+                  cacheWriteTokens: cacheWriteTokens || undefined,
                   kind: 'stream',
                 })
               } catch { /* ignore quota capture failure */ }
             }
           } catch (err) {
+            if (err && (err.code === 'QUOTA' || err.code === 'QUOTA_EXCEEDED' || err.status === 429)) {
+              if (typeof deps.recordExhaust === 'function') deps.recordExhaust(account.ref)
+            } else if (err && (err.status === 401 || err.status === 403 || err.code === 'TOKEN_REVOKED' || err.code === 'BROKEN')) {
+              if (typeof deps.recordBroken === 'function') deps.recordBroken(account.ref)
+            }
             if (err && err.code === 'VALIDATION_REQUIRED' && err.validationUrl) {
               await deps.saveBlob(account.ref, {
                 ...blob,
@@ -275,7 +300,7 @@ export class SubscriptionAdapter extends LlmAdapter {
       }
       // #91: when the whole pool is exhausted and nothing has been streamed
       // yet, continue seamlessly on local Ollama instead of failing the chat.
-      if (!yieldedAny && typeof deps.ollamaFallback === 'function') {
+      if (!yieldedAny && !options.signal?.aborted && typeof deps.ollamaFallback === 'function') {
         yield* deps.ollamaFallback({ options, provider, err })
         return
       }

package/lib/cascade.js

@@ -9,6 +9,16 @@ export const DEFAULT_CASCADE_CHAINS = {
   copilot: ['cursor', 'codex'],
   cursor: ['copilot', 'claude'],
   antigravity: ['copilot', 'claude'],
+  kimi: ['qwen', 'glm', 'spark'],
+  glm: ['kimi', 'qwen', 'spark'],
+  qwen: ['kimi', 'glm', 'spark'],
+  spark: ['qwen', 'kimi', 'glm'],
+  jetbrains: ['copilot', 'cursor'],
+  perplexity: ['copilot', 'cursor'],
+  replit: ['copilot', 'cursor'],
+  cody: ['copilot', 'cursor'],
+  kiro: ['copilot', 'cursor'],
+  ernie: ['qwen', 'glm'],
 }
 
 /**

package/lib/images.js

@@ -205,25 +205,48 @@ export function toOpenAiImage(norm) {
 }
 
 export function toAnthropicImage(norm) {
-  if (!norm.base64) return null
-  return {
-    type: 'image',
-    source: {
-      type: 'base64',
-      media_type: norm.mimeType || 'image/jpeg',
-      data: norm.base64,
-    },
+  if (!norm) return null
+  if (norm.base64) {
+    return {
+      type: 'image',
+      source: {
+        type: 'base64',
+        media_type: norm.mimeType || 'image/jpeg',
+        data: norm.base64,
+      },
+    }
   }
+  if (norm.url) {
+    return {
+      type: 'image',
+      source: {
+        type: 'url',
+        url: norm.url,
+      },
+    }
+  }
+  return null
 }
 
 export function toGeminiImage(norm) {
-  if (!norm.base64) return null
-  return {
-    inlineData: {
-      mimeType: norm.mimeType || 'image/jpeg',
-      data: norm.base64,
-    },
+  if (!norm) return null
+  if (norm.base64) {
+    return {
+      inlineData: {
+        mimeType: norm.mimeType || 'image/jpeg',
+        data: norm.base64,
+      },
+    }
   }
+  if (norm.url) {
+    return {
+      fileData: {
+        mimeType: norm.mimeType || 'image/jpeg',
+        fileUri: norm.url,
+      },
+    }
+  }
+  return null
 }
 
 export function toCodexImage(norm) {

package/lib/index.js

@@ -22,6 +22,7 @@ import { HistoryStore, resolveHistoryDir } from './history.js'
 import { createDiagnosticsReport } from './diagnostics.js'
 import { createAccountsView } from './accounts-view.js'
 import { createAdapterManager } from './adapter-manager.js'
+import { pickAccount } from './rotate.js'
 
 export { observeForecast, estimateForecast } from './forecast.js'
 export { formatRelativeReset } from './relative-time.js'
@@ -328,7 +329,8 @@ export function apply(ctx, rawConfig) {
   ctx.effect(() => ctx.provide('subscriptionImages', {
     async available() {
       const logged = await store.loggedInProviders()
-      return ['codex', 'grok'].filter((name) => logged && logged[name])
+      const loggedList = Array.isArray(logged) ? logged : Object.keys(logged || {}).filter((name) => logged[name])
+      return ['codex', 'grok'].filter((name) => loggedList.includes(name))
     },
     sizes: IMAGE_SIZES,
     async generate(request) {
@@ -337,18 +339,20 @@ export function apply(ctx, rawConfig) {
         throw new Error(`unknown subscription provider: ${provider}`)
       }
       const accounts = await store.listAccounts(provider)
-      const slot = (accounts || []).find((row) => row && row.ref)
+      const eligible = pickAccount(accounts || [], Date.now(), { family: provider === 'codex' ? 'gpt' : 'grok' })
+      const slot = eligible || (accounts || []).find((row) => row && row.ref && row.hasToken)
       if (!slot) throw new Error(`not logged in to ${provider}: sign in in the Subscriptions section`)
       const raw = await store.resolveRaw(slot.ref)
       if (!raw) throw new Error(`not logged in to ${provider}: sign in in the Subscriptions section`)
       const session = await store.ensureFresh(provider, parseBlob(raw), slot.ref)
+      const fetchFn = (typeof fetchForRef === 'function' && fetchForRef(slot.ref)) || fetch
       return generateOnce({
         provider,
         prompt: request.prompt,
         size: request.size,
         quality: request.quality,
         session,
-        fetchImpl: fetch,
+        fetchImpl: fetchFn,
         signal: request.signal,
       })
     },

package/lib/responses-stream.js

@@ -170,6 +170,6 @@ export async function* streamResponses(body) {
     if (translator.terminated) return
   }
   if (!translator.terminated) {
-    yield { type: 'finish', reason: { kind: 'stop' } }
+    yield { type: 'finish', reason: { kind: 'error', failure: { code: 'INCOMPLETE', message: 'stream terminated before response.completed' } } }
   }
 }

package/lib/rotate.js

@@ -1,3 +1,4 @@
+import { computePacingRisk, calculateBurnRatePerHour } from "./forecast.js"
 import { isQuarantined } from './quarantine.js'
 import { getPinnedAccountRef, pinSession } from './session-pin.js'
 
@@ -92,11 +93,20 @@ export function pickAccount(accounts, nowMs, opts) {
   // Tier 1: Quota unknown (null) & healthy
   // Tier 2: Cooldown, quarantine or exhausted
   const tiers = [[], [], []]
-  const fallback = []
 
   for (const acc of list) {
     if (!acc || !acc.hasToken) continue
 
+    if (!opts || opts.autoPacing !== false) {
+      if (acc.pacingRisk === undefined) {
+        const rem = acc.quota?.remainingPercent ?? (acc.usagePercent != null ? (100 - Number(acc.usagePercent)) : null)
+        const pace = acc.pacePerHour || (Array.isArray(acc.samples) ? calculateBurnRatePerHour(acc.samples, now) : 0)
+        const resetAt = acc.quota?.resetAt || 0
+        const riskInfo = computePacingRisk(rem, pace, resetAt, now)
+        acc.pacingRisk = riskInfo.pacingRisk
+      }
+    }
+
     // VIP Slot Reservation (#175)
     if (acc.vipOnly && !isVipRequest) continue
 
@@ -105,11 +115,15 @@ export function pickAccount(accounts, nowMs, opts) {
 
     const isCooldown = acc.cooldownUntil && Number(acc.cooldownUntil) > now && cooldownBlocks(acc, opts && opts.family)
     const inQuarantine = isQuarantined(acc, now)
-    const exhausted = isQuotaExhausted(acc) || isUsageExhausted(acc)
+    const isHardExhausted = (acc.usagePercent != null && Number(acc.usagePercent) >= 100 && (!acc.quota || !acc.quota.resetAt || Number(acc.quota.resetAt) > now))
+
+    if (isCooldown || inQuarantine || isHardExhausted) {
+      continue
+    }
 
-    if (isCooldown || inQuarantine || exhausted) {
+    const softExhausted = isQuotaExhausted(acc) || isUsageExhausted(acc)
+    if (softExhausted) {
       tiers[2].push(acc)
-      fallback.push(acc)
       continue
     }
 
@@ -140,7 +154,7 @@ export function pickAccount(accounts, nowMs, opts) {
         if (aWeight !== bWeight) return bWeight - aWeight
 
         // 3. Health Score
-        return (b.healthScore || 100) - (a.healthScore || 100)
+        return (b.healthScore ?? 100) - (a.healthScore ?? 100)
       })
 
       const chosen = tier[0]
@@ -151,7 +165,6 @@ export function pickAccount(accounts, nowMs, opts) {
     }
   }
 
-  if (fallback.length) return fallback[0]
   return null
 }
 

package/lib/routes/proxy.js

@@ -53,7 +53,7 @@ export function registerProxyRoutes(ctx, state) {
       const url = new URL(req.url || '/', 'http://localhost')
       const parts = url.pathname.replace(/^\/dsh-subscriptions\/proxy\//, '').split('/').filter(Boolean)
       const provider = parts[0]
-      const restPath = '/' + parts.slice(1).join('/')
+      const restPath = '/' + parts.slice(1).join('/') + (url.search || '')
       if (!isProvider(provider)) {
         writeJson(res, 404, { ok: false, error: { code: 'provider', message: 'unknown provider' } })
         return

package/lib/sse.js

@@ -2,7 +2,10 @@ export async function* iterateSse(body, { idleTimeoutMs = 60000, signal } = {})
   const reader = body && typeof body.getReader === 'function' ? body.getReader() : null
   const decoder = new TextDecoder()
   let buffer = ''
+  let terminated = false
+
   async function* fromText(chunk) {
+    if (terminated) return
     buffer += chunk
     let sep
     while ((sep = buffer.search(/\r?\n\r?\n/)) >= 0) {
@@ -10,12 +13,16 @@ export async function* iterateSse(body, { idleTimeoutMs = 60000, signal } = {})
       buffer = buffer.slice(sep).replace(/^\r?\n\r?\n/, '')
       const dataLines = []
       for (const line of raw.split(/\r?\n/)) {
-        if (line.startsWith(":")) continue // SSE comments / keep-alive pings
+        if (line.startsWith(':')) continue // SSE comments / keep-alive pings
         if (line.startsWith('data:')) dataLines.push(line.slice(5).trimStart())
       }
       if (!dataLines.length) continue
       const data = dataLines.join('\n')
-      if (data === '[DONE]') return
+      if (data === '[DONE]') {
+        terminated = true
+        yield '[DONE]'
+        return
+      }
       yield data
     }
   }
@@ -36,7 +43,7 @@ export async function* iterateSse(body, { idleTimeoutMs = 60000, signal } = {})
         reject(err)
       }, idleTimeoutMs)
     })
-    
+
     let abortPromise
     let abortHandler
     if (signal) {
@@ -64,12 +71,15 @@ export async function* iterateSse(body, { idleTimeoutMs = 60000, signal } = {})
 
   if (reader) {
     try {
-      while (true) {
+      while (!terminated) {
         const { done, value } = await readWithTimeout(reader)
         if (done) break
         yield* fromText(decoder.decode(value, { stream: true }))
+        if (terminated) break
+      }
+      if (!terminated) {
+        yield* fromText(decoder.decode())
       }
-      yield* fromText(decoder.decode())
     } finally {
       if (typeof reader.cancel === 'function') await reader.cancel().catch(() => {})
     }
@@ -77,11 +87,19 @@ export async function* iterateSse(body, { idleTimeoutMs = 60000, signal } = {})
   }
   if (body && typeof body[Symbol.asyncIterator] === 'function') {
     for await (const chunk of body) {
-      if (signal && signal.aborted) break
+      if (signal && signal.aborted) {
+        const err = new Error('stream aborted by client')
+        err.name = 'AbortError'
+        throw err
+      }
+      if (terminated) break
       const text = typeof chunk === 'string' ? chunk : decoder.decode(chunk, { stream: true })
       yield* fromText(text)
+      if (terminated) break
+    }
+    if (!terminated) {
+      yield* fromText(decoder.decode())
     }
-    yield* fromText(decoder.decode())
     return
   }
   const text = typeof body === 'string' ? body : await new Response(body).text()

package/lib/tools-normalizer.js

@@ -1,40 +1,44 @@
 export function sanitizeToolName(name) {
-  if (typeof name !== 'string' || !name.trim()) return 'tool_fn'
-  const sanitized = name.trim().replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64)
-  return sanitized || 'tool_fn'
+  if (typeof name !== "string" || !name.trim()) return "tool_fn"
+  const sanitized = name.trim().replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64)
+  return sanitized || "tool_fn"
 }
 
 export function sanitizeDescription(desc) {
-  if (typeof desc === 'string') return desc.trim()
-  if (desc == null) return ''
+  if (typeof desc === "string") return desc.trim()
+  if (desc == null) return ""
   return String(desc).trim()
 }
 
 export function normalizeJsonSchema(schema, depth = 0) {
-  if (depth > 12) return { type: 'string' }
-  if (!schema || typeof schema !== 'object') {
-    return { type: 'object' }
+  if (depth > 12) return { type: "string" }
+  if (!schema || typeof schema !== "object") {
+    return { type: "object" }
   }
   if (Array.isArray(schema)) {
-    return normalizeJsonSchema(schema[0] || { type: 'object' }, depth + 1)
+    return normalizeJsonSchema(schema[0] || { type: "object" }, depth + 1)
   }
 
   const out = {}
 
+  if (schema.title) out.title = String(schema.title)
+
   let type = schema.type
   let nullable = false
   if (Array.isArray(type)) {
-    nullable = type.includes('null')
-    type = type.find((t) => t && t !== 'null') || 'string'
+    nullable = type.includes("null")
+    type = type.find((t) => t && t !== "null") || "string"
   }
-  if (typeof type === 'string') {
+  if (typeof type === "string") {
     out.type = type.toLowerCase()
   } else if (schema.properties) {
-    out.type = 'object'
+    out.type = "object"
   } else if (schema.items) {
-    out.type = 'array'
+    out.type = "array"
+  } else if (schema.anyOf || schema.oneOf || schema.allOf) {
+    // Schema combinator without explicit type
   } else {
-    out.type = depth === 0 ? 'object' : 'string'
+    out.type = depth === 0 ? "object" : "string"
   }
 
   if (nullable) {
@@ -45,51 +49,74 @@ export function normalizeJsonSchema(schema, depth = 0) {
     out.description = String(schema.description)
   }
 
-  if (out.type === 'object') {
-    if (schema.properties && typeof schema.properties === 'object' && !Array.isArray(schema.properties)) {
+  if (schema.default !== undefined) {
+    out.default = schema.default
+  }
+
+  if (out.type === "object" || (!out.type && (schema.properties || schema.required || schema.additionalProperties !== undefined))) {
+    if (schema.properties && typeof schema.properties === "object" && !Array.isArray(schema.properties)) {
       out.properties = {}
       for (const [key, val] of Object.entries(schema.properties)) {
-        if (typeof key === 'string' && key) {
+        if (typeof key === "string" && key) {
           out.properties[key] = normalizeJsonSchema(val, depth + 1)
         }
       }
     }
 
     if (Array.isArray(schema.required)) {
-      const propKeys = new Set(Object.keys(out.properties))
+      const propKeys = out.properties ? new Set(Object.keys(out.properties)) : null
       const reqs = schema.required
-        .filter((k) => typeof k === 'string' && k.length > 0)
-        .filter((k) => propKeys.size === 0 || propKeys.has(k))
+        .filter((k) => typeof k === "string" && k.length > 0)
+        .filter((k) => !propKeys || propKeys.size === 0 || propKeys.has(k))
       if (reqs.length > 0) {
         out.required = [...new Set(reqs)]
       }
     }
 
-    if (typeof schema.additionalProperties === 'boolean') {
+    if (typeof schema.additionalProperties === "boolean") {
       out.additionalProperties = schema.additionalProperties
+    } else if (typeof schema.additionalProperties === "object" && schema.additionalProperties !== null) {
+      out.additionalProperties = normalizeJsonSchema(schema.additionalProperties, depth + 1)
     }
-  } else if (out.type === 'array') {
+  } else if (out.type === "array" || (!out.type && schema.items)) {
     if (schema.items) {
       out.items = normalizeJsonSchema(
         Array.isArray(schema.items) ? schema.items[0] : schema.items,
         depth + 1,
       )
     } else {
-      out.items = { type: 'string' }
+      out.items = { type: "string" }
     }
   }
 
+  if (Array.isArray(schema.anyOf)) {
+    out.anyOf = schema.anyOf.map((s) => normalizeJsonSchema(s, depth + 1))
+  }
+  if (Array.isArray(schema.oneOf)) {
+    out.oneOf = schema.oneOf.map((s) => normalizeJsonSchema(s, depth + 1))
+  }
+  if (Array.isArray(schema.allOf)) {
+    out.allOf = schema.allOf.map((s) => normalizeJsonSchema(s, depth + 1))
+  }
+
   if (Array.isArray(schema.enum) && schema.enum.length > 0) {
     const cleaned = [...new Set(
       schema.enum
-        .map((item) => (item != null ? String(item).trim() : ''))
-        .filter((item) => item.length > 0),
+        .filter((v) => v !== undefined && v !== null)
+        .map((v) => (typeof v === "string" ? v.trim() : v))
+        .filter((v) => (typeof v === "string" ? v.length > 0 : true))
     )]
     if (cleaned.length > 0) {
       out.enum = cleaned
     }
   }
 
+  if (typeof schema.pattern === "string") out.pattern = schema.pattern
+  if (typeof schema.minimum === "number") out.minimum = schema.minimum
+  if (typeof schema.maximum === "number") out.maximum = schema.maximum
+  if (typeof schema.minLength === "number") out.minLength = schema.minLength
+  if (typeof schema.maxLength === "number") out.maxLength = schema.maxLength
+
   return out
 }
 
@@ -98,7 +125,7 @@ export function normalizeTools(tools) {
   const validTools = []
 
   for (const tool of tools) {
-    if (!tool || typeof tool !== 'object') continue
+    if (!tool || typeof tool !== "object") continue
     const rawName = tool.name || (tool.function && tool.function.name)
     if (!rawName) continue
 

package/lib/wire.js

@@ -162,7 +162,12 @@ export async function* openaiChatStream(body) {
   let textBlock = null
   const tools = new Map()
   let finish = { kind: 'stop' }
+  let sawTerminal = false
   for await (const data of iterateSse(body)) {
+    if (data === '[DONE]') {
+      sawTerminal = true
+      break
+    }
     const json = jsonSse(data)
     if (!json) continue
     const choice = (json.choices && json.choices[0]) || {}
@@ -196,9 +201,19 @@ export async function* openaiChatStream(body) {
       }
     }
     if (json.usage) yield { type: 'usage', usage: json.usage }
-    if (choice.finish_reason === 'length') finish = { kind: 'length' }
-    else if (choice.finish_reason === 'tool_calls') finish = { kind: 'tool' }
+    if (choice.finish_reason) {
+      sawTerminal = true
+      if (choice.finish_reason === 'length') finish = { kind: 'max-tokens' }
+      else if (choice.finish_reason === 'tool_calls' || choice.finish_reason === 'function_call') finish = { kind: 'tool-calls' }
+      else if (choice.finish_reason === 'content_filter') finish = { kind: 'error', failure: { code: 'CONTENT_FILTER', message: 'content filter triggered' } }
+      else if (choice.finish_reason === 'stop') finish = { kind: 'stop' }
+    }
+  }
+  if (!sawTerminal && (textBlock !== null || tools.size > 0)) {
+    yield { type: 'finish', reason: { kind: 'error', failure: { code: 'INCOMPLETE', message: 'stream terminated unexpectedly before finish_reason or terminal marker' } } }
+    return
   }
+  if (finish.kind === 'stop' && tools.size > 0) finish = { kind: 'tool-calls' }
   yield { type: 'finish', reason: finish }
 }
 
@@ -208,10 +223,20 @@ export async function* anthropicStream(body) {
   let index = 0
   let textIndex = 0
   const toolCallIds = new Map()
+  let finish = { kind: 'stop' }
+  let sawTerminal = false
+  let usageState = null
+  let yieldedUsage = false
   for await (const data of iterateSse(body)) {
+    if (data === '[DONE]') {
+      sawTerminal = true
+      break
+    }
     const json = jsonSse(data)
     if (!json) continue
-    if (json.type === 'content_block_start') {
+    if (json.type === 'message_start' && json.message && json.message.usage) {
+      usageState = { ...(usageState || {}), ...json.message.usage }
+    } else if (json.type === 'content_block_start') {
       const block = json.content_block || {}
       if (block.type === 'text') {
         textIndex = json.index ?? index++
@@ -243,17 +268,54 @@ export async function* anthropicStream(body) {
           argumentsDelta: delta.partial_json,
         }
       }
-    } else if (json.type === 'message_delta' && json.usage) {
-      yield {
-        type: 'usage',
-        usage: {
-          input: Number(json.usage.input_tokens ?? json.usage.input ?? 0) || 0,
-          output: Number(json.usage.output_tokens ?? json.usage.output ?? 0) || 0,
-        },
+    } else if (json.type === 'message_delta') {
+      sawTerminal = true
+      if (json.delta && json.delta.stop_reason) {
+        const sr = json.delta.stop_reason
+        if (sr === 'tool_use') finish = { kind: 'tool-calls' }
+        else if (sr === 'max_tokens') finish = { kind: 'max-tokens' }
+        else finish = { kind: 'stop' }
+      }
+      if (json.usage) {
+        usageState = { ...(usageState || {}), ...json.usage }
+      }
+      if (usageState) {
+        const norm = toTokenUsage(usageState)
+        yieldedUsage = true
+        yield {
+          type: 'usage',
+          usage: {
+            ...usageState,
+            ...(norm || {}),
+            input: norm ? norm.inputTokens : (Number(usageState.input_tokens ?? usageState.input ?? 0) || 0),
+            output: norm ? norm.outputTokens : (Number(usageState.output_tokens ?? usageState.output ?? 0) || 0),
+          },
+        }
       }
+    } else if (json.type === 'error') {
+      sawTerminal = true
+      const err = json.error || {}
+      finish = { kind: 'error', failure: { code: String(err.type || 'ANTHROPIC_ERROR'), message: String(err.message || 'anthropic error') } }
+    }
+  }
+  if (usageState && !yieldedUsage) {
+    const norm = toTokenUsage(usageState)
+    yield {
+      type: 'usage',
+      usage: {
+        ...usageState,
+        ...(norm || {}),
+        input: norm ? norm.inputTokens : (Number(usageState.input_tokens ?? usageState.input ?? 0) || 0),
+        output: norm ? norm.outputTokens : (Number(usageState.output_tokens ?? usageState.output ?? 0) || 0),
+      },
     }
   }
-  yield { type: 'finish', reason: { kind: 'stop' } }
+  if (!sawTerminal && (index > 0 || textIndex > 0 || toolCallIds.size > 0)) {
+    yield { type: 'finish', reason: { kind: 'error', failure: { code: 'INCOMPLETE', message: 'stream terminated before message_delta' } } }
+    return
+  }
+  if (finish.kind === 'stop' && toolCallIds.size > 0) finish = { kind: 'tool-calls' }
+  yield { type: 'finish', reason: finish }
 }
 
 export async function* googleStream(body) {
@@ -261,11 +323,27 @@ export async function* googleStream(body) {
   let started = false
   let callCount = 0
   const functionCallIndexes = new Map()
+  let finish = { kind: 'stop' }
+  let sawTerminal = false
   for await (const data of iterateSse(body)) {
+    if (data === '[DONE]') {
+      sawTerminal = true
+      break
+    }
     const json = jsonSse(data)
     const wrapped = json && json.response ? json.response : json
     if (!wrapped) continue
     const cand = wrapped.candidates && wrapped.candidates[0]
+    if (cand && cand.finishReason) {
+      sawTerminal = true
+      const fr = cand.finishReason
+      if (fr === 'MAX_TOKENS') finish = { kind: 'max-tokens' }
+      else if (fr === 'SAFETY' || fr === 'RECITATION' || fr === 'BLOCKLIST' || fr === 'PROHIBITED_CONTENT' || fr === 'SPII') {
+        finish = { kind: 'error', failure: { code: fr, message: cand.finishMessage || fr } }
+      } else if (fr === 'STOP') {
+        finish = { kind: 'stop' }
+      }
+    }
     const parts = cand && cand.content && Array.isArray(cand.content.parts) ? cand.content.parts : []
     for (const part of parts) {
       if (part.text) {
@@ -299,16 +377,27 @@ export async function* googleStream(body) {
       }
     }
     if (wrapped.usageMetadata) {
+      const u = wrapped.usageMetadata
+      const norm = toTokenUsage(u)
       yield {
         type: 'usage',
         usage: {
-          input: Number(wrapped.usageMetadata.promptTokenCount ?? 0) || 0,
-          output: Number(wrapped.usageMetadata.candidatesTokenCount ?? 0) || 0,
+          ...u,
+          ...(norm || {}),
+          input: norm ? norm.inputTokens : (Number(u.promptTokenCount ?? 0) || 0),
+          output: norm ? norm.outputTokens : (Number(u.candidatesTokenCount ?? 0) || 0),
         },
       }
     }
   }
-  yield { type: 'finish', reason: { kind: 'stop' } }
+  if (!sawTerminal && (started || callCount > 0)) {
+    yield { type: 'finish', reason: { kind: 'error', failure: { code: 'INCOMPLETE', message: 'stream terminated before finishReason' } } }
+    return
+  }
+  if (finish.kind === 'stop' && (functionCallIndexes.size > 0 || callCount > 0)) {
+    finish = { kind: 'tool-calls' }
+  }
+  yield { type: 'finish', reason: finish }
 }
 
 export async function formTokenRequest(url, params, fetchImpl, headers, { timeoutMs = 25000 } = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-subscriptions",
-  "version": "0.6.38",
+  "version": "0.6.40",
   "description": "Use ChatGPT Codex, Claude, Grok, Antigravity, Kimi, GLM, Cursor, Kiro, Copilot, Qwen, ERNIE, Spark, JetBrains, Perplexity, Replit, and Cody subscriptions as DeepSeek Harness LLM providers via OAuth.",
   "license": "MIT",
   "type": "module",