@goodandready/dsh-subscriptions 0.6.39 → 0.6.40

package/lib/adapter-manager.js

@@ -63,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

package/lib/adapter.js

@@ -132,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)
@@ -206,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
                 }
@@ -237,7 +249,10 @@ 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 */ }

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

@@ -44,7 +44,7 @@ export function cooldownBlocks(acc, family) {
 export function pickAccount(accounts, nowMs, opts) {
   const list = Array.isArray(accounts) ? accounts : []
   const now = Number(nowMs) || 0
-  const thrRaw = opts && opts.switchAtRemaining != null ? Number(opts.switchAtRemaining) : 0.01
+  const thrRaw = opts && opts.switchAtRemaining != null ? Number(opts.switchAtRemaining) : 0
   const thr = Number.isFinite(thrRaw) ? thrRaw : 0
   const isVipRequest = Boolean(opts && opts.vip)
   const targetTag = opts && opts.tag
@@ -115,8 +115,7 @@ 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 isHardExhausted = (acc.quota && acc.quota.remaining != null && Number(acc.quota.remaining) <= 0 && acc.quota.resetAt && Number(acc.quota.resetAt) > now) ||
-                            (acc.usagePercent != null && Number(acc.usagePercent) >= 100 && (!acc.quota || !acc.quota.resetAt || Number(acc.quota.resetAt) > now))
+    const isHardExhausted = (acc.usagePercent != null && Number(acc.usagePercent) >= 100 && (!acc.quota || !acc.quota.resetAt || Number(acc.quota.resetAt) > now))
 
     if (isCooldown || inQuarantine || isHardExhausted) {
       continue

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.39",
+  "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",