bhg-helper 1.0.0

package/api/relay/protocol.ts

@@ -0,0 +1,393 @@
+/**
+ * Anthropic → OpenAI 兼容转换的工具函数
+ *
+ * 输入：Anthropic Messages API 格式
+ * 输出：OpenAI Chat Completions 格式
+ * 以及反向：OpenAI 响应 → Anthropic 响应
+ */
+
+export interface AnthropicMessage {
+  role: 'user' | 'assistant'
+  content: string | AnthropicContentBlock[]
+}
+
+export type AnthropicContentBlock =
+  | { type: 'text'; text: string }
+  | { type: 'image'; source: { type: 'base64'; media_type: string; data: string } }
+  | { type: 'tool_use'; id: string; name: string; input: unknown }
+  | { type: 'tool_result'; tool_use_id: string; content: string | unknown[] }
+
+export interface AnthropicRequest {
+  model: string
+  messages: AnthropicMessage[]
+  system?: string | Array<{ type: 'text'; text: string; cache_control?: unknown }>
+  max_tokens?: number
+  temperature?: number
+  top_p?: number
+  stop_sequences?: string[]
+  stream?: boolean
+  tools?: Array<{ name: string; description?: string; input_schema: unknown }>
+  tool_choice?: unknown
+  metadata?: { user_id?: string }
+}
+
+export interface OpenAIMessage {
+  role: 'system' | 'user' | 'assistant' | 'tool'
+  content?: string | null
+  name?: string
+  tool_calls?: Array<{ id: string; type: 'function'; function: { name: string; arguments: string } }>
+  tool_call_id?: string
+}
+
+export interface OpenAIRequest {
+  model: string
+  messages: OpenAIMessage[]
+  max_tokens?: number
+  temperature?: number
+  top_p?: number
+  stop?: string | string[]
+  stream?: boolean
+  tools?: Array<{
+    type: 'function'
+    function: { name: string; description?: string; parameters: unknown }
+  }>
+  tool_choice?: unknown
+  user?: string
+}
+
+// ============================================
+// Request: Anthropic → OpenAI
+// ============================================
+
+export function anthropicToOpenAI(req: AnthropicRequest): OpenAIRequest {
+  const out: OpenAIRequest = {
+    model: req.model,
+    messages: [],
+  }
+
+  // system: 顶层的 system 字段 → messages[0] role=system
+  if (req.system) {
+    const sysText = Array.isArray(req.system)
+      ? req.system.map((s) => s.text).join('\n')
+      : req.system
+    if (sysText) {
+      out.messages.push({ role: 'system', content: sysText })
+    }
+  }
+
+  // messages 转换
+  for (const m of req.messages) {
+    if (typeof m.content === 'string') {
+      out.messages.push({ role: m.role, content: m.content })
+      continue
+    }
+    // content 是 block 数组
+    if (m.role === 'user') {
+      const textParts: string[] = []
+      const toolResults: OpenAIMessage[] = []
+      for (const b of m.content) {
+        if (b.type === 'text') {
+          textParts.push(b.text)
+        } else if (b.type === 'image') {
+          // DeepSeek 当前不支持图片，跳过或转 base64（这里我们暂时跳过避免 400）
+          textParts.push(`[图片内容已省略: ${b.source.media_type}]`)
+        } else if (b.type === 'tool_result') {
+          const c = typeof b.content === 'string' ? b.content : JSON.stringify(b.content)
+          toolResults.push({ role: 'tool', tool_call_id: b.tool_use_id, content: c })
+        }
+      }
+      if (textParts.length) {
+        out.messages.push({ role: 'user', content: textParts.join('\n') })
+      }
+      for (const tr of toolResults) out.messages.push(tr)
+    } else if (m.role === 'assistant') {
+      let text = ''
+      const toolCalls: NonNullable<OpenAIMessage['tool_calls']> = []
+      for (const b of m.content) {
+        if (b.type === 'text') text += b.text
+        else if (b.type === 'tool_use') {
+          toolCalls.push({
+            id: b.id,
+            type: 'function',
+            function: { name: b.name, arguments: JSON.stringify(b.input ?? {}) },
+          })
+        }
+      }
+      const msg: OpenAIMessage = { role: 'assistant' }
+      if (text) msg.content = text
+      else msg.content = null
+      if (toolCalls.length) msg.tool_calls = toolCalls
+      out.messages.push(msg)
+    }
+  }
+
+  if (req.max_tokens !== undefined) out.max_tokens = req.max_tokens
+  if (req.temperature !== undefined) out.temperature = req.temperature
+  if (req.top_p !== undefined) out.top_p = req.top_p
+  if (req.stop_sequences?.length) out.stop = req.stop_sequences
+  if (req.stream !== undefined) out.stream = req.stream
+  if (req.tools?.length) {
+    out.tools = req.tools.map((t) => ({
+      type: 'function',
+      function: { name: t.name, description: t.description, parameters: t.input_schema },
+    }))
+  }
+  if (req.tool_choice !== undefined) out.tool_choice = req.tool_choice as never
+  if (req.metadata?.user_id) out.user = req.metadata.user_id
+
+  // DeepSeek V4 默认开启思考模式，会消耗大量 token 给 reasoning，
+  // 经常导致 content 为空。claude.exe 没传 reasoning_effort 时强制关掉
+  const openAiRequest = out as unknown as Record<string, unknown>
+  if (!('reasoning_effort' in openAiRequest) && !('thinking' in openAiRequest)) {
+    openAiRequest.thinking = { type: 'disabled' }
+  }
+
+  return out
+}
+
+// ============================================
+// Response: OpenAI → Anthropic
+// ============================================
+
+export interface AnthropicResponse {
+  id: string
+  type: 'message'
+  role: 'assistant'
+  content: AnthropicContentBlock[]
+  model: string
+  stop_reason: 'end_turn' | 'max_tokens' | 'stop_sequence' | 'tool_use' | null
+  stop_sequence: string | null
+  usage: {
+    input_tokens: number
+    output_tokens: number
+    cache_read_input_tokens?: number
+    cache_creation_input_tokens?: number
+  }
+}
+
+export function openAIToAnthropic(resp: {
+  id?: string
+  model: string
+  choices: Array<{
+    index: number
+    message: { role: string; content: string | null; tool_calls?: unknown }
+    finish_reason: string | null
+  }>
+  usage?: { prompt_tokens?: number; completion_tokens?: number; total_tokens?: number }
+}): AnthropicResponse {
+  const choice = resp.choices[0]
+  const content: AnthropicContentBlock[] = []
+  // 兼容 DeepSeek 思考模式：优先用 reasoning_content（如果 content 是空）
+  const reasoning = (choice?.message as { reasoning_content?: string })?.reasoning_content
+  const mainContent = choice?.message?.content
+  const text = mainContent || (reasoning && !mainContent ? `<think>\n${reasoning}\n</think>` : '')
+  if (text) {
+    content.push({ type: 'text', text })
+  }
+  // 工具调用支持（DeepSeek 当前不返回，但保持兼容）
+  const tc = (choice?.message as { tool_calls?: Array<{ id: string; function: { name: string; arguments: string } }> })?.tool_calls
+  if (tc?.length) {
+    for (const t of tc) {
+      let input: unknown = {}
+      try { input = JSON.parse(t.function.arguments) } catch { input = {} }
+      content.push({ type: 'tool_use', id: t.id, name: t.function.name, input })
+    }
+  }
+
+  const stopReason = mapStopReason(choice?.finish_reason ?? null, !!tc?.length)
+
+  return {
+    id: resp.id ?? `msg_${Date.now()}`,
+    type: 'message',
+    role: 'assistant',
+    content,
+    model: resp.model,
+    stop_reason: stopReason,
+    stop_sequence: null,
+    usage: {
+      input_tokens: resp.usage?.prompt_tokens ?? 0,
+      output_tokens: resp.usage?.completion_tokens ?? 0,
+    },
+  }
+}
+
+function mapStopReason(
+  fr: string | null,
+  hasTool: boolean
+): AnthropicResponse['stop_reason'] {
+  if (hasTool) return 'tool_use'
+  if (fr === 'length') return 'max_tokens'
+  if (fr === 'stop' || fr === null) return 'end_turn'
+  if (fr === 'content_filter') return 'end_turn'
+  return 'end_turn'
+}
+
+// ============================================
+// Streaming: OpenAI chunk → Anthropic SSE events
+// ============================================
+
+export interface AnthropicStreamEvent {
+  type:
+    | 'message_start'
+    | 'content_block_start'
+    | 'ping'
+    | 'content_block_delta'
+    | 'content_block_stop'
+    | 'message_delta'
+    | 'message_stop'
+    | 'error'
+  [key: string]: unknown
+}
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+function makeId(): string {
+  // 用 crypto.randomUUID 如果存在
+  if (typeof globalThis.crypto?.randomUUID === 'function') {
+    return globalThis.crypto.randomUUID()
+  }
+  // fallback
+  return 'msg_' + Math.random().toString(36).slice(2)
+}
+
+export function* openAIStreamToAnthropicEvents(
+  model: string,
+  openAIChunks: Array<{
+    id?: string
+    model?: string
+    choices?: Array<{
+      index: number
+      delta: {
+        role?: string
+        content?: string | null
+        tool_calls?: Array<{
+          index: number
+          id?: string
+          function?: { name?: string; arguments?: string }
+        }>
+      }
+      finish_reason?: string | null
+    }>
+    usage?: { prompt_tokens?: number; completion_tokens?: number }
+  }>
+): Generator<AnthropicStreamEvent> {
+  const msgId = makeId()
+  const blockIndex = 0
+  let totalOutput = 0
+  let inputTokens = 0
+  let finishReason: string | null = null
+  let hasText = false
+  let toolBlockIndex = -1
+  let toolInputBuffer = ''
+  let toolId: string | null = null
+  let toolName: string | null = null
+  const usedModel = openAIChunks[0]?.model ?? model
+
+  // message_start
+  yield {
+    type: 'message_start',
+    message: {
+      id: msgId,
+      type: 'message',
+      role: 'assistant',
+      content: [],
+      model: usedModel,
+      stop_reason: null,
+      stop_sequence: null,
+      usage: { input_tokens: 0, output_tokens: 0 },
+    },
+  }
+  yield { type: 'ping' }
+
+  // 先假定输出文本 block
+  // 这里我们采用"先开 text block，遇到 tool_call 时 close + 开 tool_use block"的策略
+  // 但 DeepSeek 暂时不会输出 tool_call，所以先开一个 text block
+
+  let textBlockOpen = false
+  function openTextBlockIfNeeded(): AnthropicStreamEvent | null {
+    if (!textBlockOpen) {
+      textBlockOpen = true
+      hasText = true
+      return { type: 'content_block_start', index: blockIndex, content_block: { type: 'text', text: '' } }
+    }
+    return null
+  }
+
+  for (const chunk of openAIChunks) {
+    const choice = chunk.choices?.[0]
+    if (!choice) continue
+    if (chunk.usage?.prompt_tokens) inputTokens = chunk.usage.prompt_tokens
+    if (chunk.usage?.completion_tokens) totalOutput = chunk.usage.completion_tokens
+
+    const delta = choice.delta
+    const reasoningDelta = (delta as { reasoning_content?: string })?.reasoning_content
+    if (delta?.content || reasoningDelta) {
+      const ev = openTextBlockIfNeeded()
+      if (ev) yield ev
+      // 思考模式时也把推理内容输出（前面打 <think> 标签以区分）
+      if (reasoningDelta && !delta?.content) {
+        yield {
+          type: 'content_block_delta',
+          index: blockIndex,
+          delta: { type: 'text_delta', text: reasoningDelta },
+        }
+      } else if (delta?.content) {
+        yield {
+          type: 'content_block_delta',
+          index: blockIndex,
+          delta: { type: 'text_delta', text: delta.content },
+        }
+      }
+    }
+    if (delta?.tool_calls?.length) {
+      // 简化处理：累计到一段再开 tool_use block
+      for (const tc of delta.tool_calls) {
+        if (textBlockOpen) {
+          yield { type: 'content_block_stop', index: blockIndex }
+          textBlockOpen = false
+        }
+        if (tc.id) toolId = tc.id
+        if (tc.function?.name) {
+          toolName = tc.function.name
+          toolBlockIndex++
+          yield {
+            type: 'content_block_start',
+            index: toolBlockIndex,
+            content_block: { type: 'tool_use', id: toolId, name: toolName, input: {} },
+          }
+        }
+        if (tc.function?.arguments) {
+          toolInputBuffer += tc.function.arguments
+          yield {
+            type: 'content_block_delta',
+            index: toolBlockIndex,
+            delta: { type: 'input_json_delta', partial_json: tc.function.arguments },
+          }
+        }
+      }
+    }
+    if (choice.finish_reason) {
+      finishReason = choice.finish_reason
+    }
+  }
+
+  if (textBlockOpen) {
+    yield { type: 'content_block_stop', index: blockIndex }
+  }
+  if (toolBlockIndex >= 0) {
+    yield { type: 'content_block_stop', index: toolBlockIndex }
+  }
+
+  const stopReason = mapStopReason(finishReason, toolBlockIndex >= 0)
+  yield {
+    type: 'message_delta',
+    delta: { stop_reason: stopReason, stop_sequence: null },
+    usage: { output_tokens: totalOutput },
+  }
+  yield {
+    type: 'message_stop',
+    usage: { input_tokens: inputTokens, output_tokens: totalOutput },
+  }
+  // keep hasText referenced (otherwise tsc will complain)
+  void hasText
+}

package/api/relay/server.ts

@@ -0,0 +1,283 @@
+/**
+ * 中转服务 HTTP 进程
+ *
+ * 监听 localhost:<port>，对外提供 Anthropic Messages API 兼容端点。
+ * 收到请求后翻译成 OpenAI Chat Completions，转发给 DeepSeek，再把响应
+ * （含流式 SSE）翻译回 Anthropic 事件后返回。
+ */
+import http, { type IncomingMessage, type ServerResponse } from 'node:http'
+import { AnthropicRequest, anthropicToOpenAI, openAIToAnthropic, openAIStreamToAnthropicEvents } from './protocol.js'
+import { log } from '../lib/logger.js'
+import { loadRelayConfig, type RelayConfig } from './config.js'
+
+let currentServer: http.Server | null = null
+let currentConfig: RelayConfig | null = null
+
+export function isRelayRunning(): boolean {
+  return currentServer?.listening ?? false
+}
+
+export function getRelayInfo(): { port: number; running: boolean; baseUrl: string; modelMap: Record<string, string>; deepseekApiKey: string } | null {
+  if (!currentConfig) return null
+  return {
+    port: currentConfig.port,
+    running: isRelayRunning(),
+    baseUrl: currentConfig.deepseekBaseUrl,
+    modelMap: currentConfig.modelMap,
+    deepseekApiKey: currentConfig.deepseekApiKey ? maskKey(currentConfig.deepseekApiKey) : '',
+  }
+}
+
+function maskKey(k: string): string {
+  if (k.length <= 8) return '••••'
+  return k.slice(0, 4) + '••••' + k.slice(-4)
+}
+
+export async function startRelay(): Promise<RelayConfig> {
+  if (currentServer?.listening) {
+    log('WARN', 'relay', 'already running')
+    return currentConfig!
+  }
+  const cfg = await loadRelayConfig()
+  currentConfig = cfg
+  currentServer = http.createServer(handler)
+  await new Promise<void>((resolve, reject) => {
+    const onErr = (e: Error) => reject(e)
+    currentServer!.once('error', onErr)
+    currentServer!.listen(cfg.port, '127.0.0.1', () => {
+      currentServer!.off('error', onErr)
+      log('OK', 'relay', `listening on http://127.0.0.1:${cfg.port} (upstream: ${cfg.deepseekBaseUrl})`)
+      resolve()
+    })
+  })
+  return cfg
+}
+
+export async function stopRelay(): Promise<void> {
+  if (!currentServer) return
+  await new Promise<void>((resolve) => currentServer!.close(() => resolve()))
+  currentServer = null
+  log('OK', 'relay', 'stopped')
+}
+
+export async function restartRelay(): Promise<RelayConfig> {
+  if (currentServer) await stopRelay()
+  return startRelay()
+}
+
+async function readBody(req: IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = []
+    req.on('data', (c) => chunks.push(c))
+    req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')))
+    req.on('error', reject)
+  })
+}
+
+function sendJson(res: ServerResponse, status: number, body: unknown): void {
+  const text = JSON.stringify(body, null, 2)
+  res.statusCode = status
+  res.setHeader('Content-Type', 'application/json')
+  res.setHeader('Content-Length', Buffer.byteLength(text))
+  res.end(text)
+}
+
+function sendAnthropicError(res: ServerResponse, status: number, type: string, message: string): void {
+  sendJson(res, status, { type: 'error', error: { type, message } })
+}
+
+async function handler(req: IncomingMessage, res: ServerResponse): Promise<void> {
+  const rawUrl = req.url ?? '/'
+  const [path] = rawUrl.split('?')   // 把 ?beta=true 这种 query 剥掉
+  const method = req.method ?? 'GET'
+  // CORS
+  res.setHeader('Access-Control-Allow-Origin', '*')
+  res.setHeader('Access-Control-Allow-Headers', '*')
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
+  if (method === 'OPTIONS') {
+    res.statusCode = 204
+    res.end()
+    return
+  }
+
+  log('INFO', 'relay', `${method} ${rawUrl} from ${req.socket.remoteAddress}`)
+
+  if (method === 'GET' && path === '/health') {
+    sendJson(res, 200, { ok: true, data: { running: true, port: currentConfig?.port } })
+    return
+  }
+
+  if (method === 'GET' && path === '/v1/models') {
+    // Claude Code 用 Anthropic SDK 解析这个端点。
+    // Anthropic 格式：{ data: [{ id, display_name, type: "model", created_at }] }
+    // 为了兼容可能的旧 client，也补一份 OpenAI 字段（id/object/owned_by/created）。
+    const cfg = currentConfig!
+    const base = Date.now()
+    const data = Object.keys(cfg.modelMap).map((id, i) => {
+      const target = cfg.modelMap[id]
+      // 把 -cc / [1m] 之类剥掉，从真实名得到一个友好的 display_name
+      const display = id
+        .replace(/\[.*?\]$/, '')
+        .replace(/-cc$/, '')
+        .replace(/-v4-/, ' V4 ')
+      return {
+        // Anthropic
+        id,
+        display_name: display,
+        type: 'model',
+        created_at: new Date(base - i).toISOString(),
+        // OpenAI 兼容（部分 SDK 也会读）
+        object: 'model',
+        owned_by: cfg.spoofProvider,
+        created: Math.floor((base - i) / 1000),
+        // 调试用：真实转发的目标
+        target_model: target,
+      }
+    })
+    sendJson(res, 200, { data, object: 'list' })
+    return
+  }
+
+  if (method === 'POST' && path === '/v1/messages') {
+    return handleMessages(req, res)
+  }
+
+  // 兜底：404
+  sendAnthropicError(res, 404, 'not_found_error', `unknown route: ${method} ${rawUrl}`)
+}
+
+async function handleMessages(req: IncomingMessage, res: ServerResponse): Promise<void> {
+  const cfg = currentConfig!
+  if (!cfg.deepseekApiKey) {
+    sendAnthropicError(res, 500, 'configuration_error', 'deepseekApiKey not configured')
+    return
+  }
+
+  let body: AnthropicRequest
+  try {
+    const raw = await readBody(req)
+    body = JSON.parse(raw) as AnthropicRequest
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    sendAnthropicError(res, 400, 'invalid_request_error', `bad json: ${msg}`)
+    return
+  }
+
+  // 先按原名查；查不到就剥掉 [1m] / [200k] 这类上下文后缀再查一次
+  const requested = body.model
+  const stripped = requested.replace(/\[.*?\]$/, '')
+  const mappedModel = cfg.modelMap[requested] ?? cfg.modelMap[stripped] ?? stripped
+  const openaiBody = anthropicToOpenAI({ ...body, model: mappedModel })
+
+  if (cfg.verbose) {
+    const msgPreview = openaiBody.messages
+      .map((m) => (typeof m.content === 'string' ? m.content.slice(0, 80) : '[non-text]'))
+      .join(' | ')
+    log(
+      'INFO',
+      'relay',
+      `→ deepseek model=${mappedModel} stream=${!!openaiBody.stream} messages=${openaiBody.messages.length} preview="${msgPreview.slice(0, 120)}"`
+    )
+  }
+
+  // 调用 DeepSeek
+  const upstreamUrl = `${cfg.deepseekBaseUrl.replace(/\/$/, '')}/v1/chat/completions`
+  let upstreamRes: Response
+  try {
+    upstreamRes = await fetch(upstreamUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${cfg.deepseekApiKey}`,
+        Accept: openaiBody.stream ? 'text/event-stream' : 'application/json',
+      },
+      body: JSON.stringify(openaiBody),
+    })
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    log('ERR', 'relay', `upstream fetch failed: ${msg}`)
+    sendAnthropicError(res, 502, 'upstream_error', `DeepSeek unreachable: ${msg}`)
+    return
+  }
+
+  if (!upstreamRes.ok) {
+    const errText = await upstreamRes.text().catch(() => '')
+    log('ERR', 'relay', `deepseek ${upstreamRes.status}: ${errText.slice(0, 200)}`)
+    sendJson(res, upstreamRes.status, { type: 'error', error: { type: 'upstream_error', message: errText } })
+    return
+  }
+
+  if (openaiBody.stream) {
+    await streamUpstreamToAnthropic(upstreamRes, res, mappedModel)
+  } else {
+    const json = (await upstreamRes.json()) as Parameters<typeof openAIToAnthropic>[0]
+    const anth = openAIToAnthropic(json)
+    res.statusCode = 200
+    res.setHeader('Content-Type', 'application/json')
+    res.end(JSON.stringify(anth))
+    log('OK', 'relay', `← ${anth.usage.input_tokens}+${anth.usage.output_tokens} tokens (model=${anth.model})`)
+  }
+}
+
+async function streamUpstreamToAnthropic(
+  upstream: Response,
+  res: ServerResponse,
+  model: string
+): Promise<void> {
+  res.statusCode = 200
+  res.setHeader('Content-Type', 'text/event-stream; charset=utf-8')
+  res.setHeader('Cache-Control', 'no-cache')
+  res.setHeader('Connection', 'keep-alive')
+  res.setHeader('X-Accel-Buffering', 'no')
+
+  const reader = upstream.body?.getReader()
+  if (!reader) {
+    sendAnthropicError(res, 500, 'upstream_error', 'no body from deepseek')
+    return
+  }
+
+  const decoder = new TextDecoder('utf-8')
+  let buffer = ''
+  const chunks: Array<Parameters<typeof openAIStreamToAnthropicEvents>[1][number]> = []
+  let outTokens = 0
+
+  try {
+    while (true) {
+      const { value, done } = await reader.read()
+      if (done) break
+      buffer += decoder.decode(value, { stream: true })
+      let nlIdx: number
+      while ((nlIdx = buffer.indexOf('\n')) >= 0) {
+        const line = buffer.slice(0, nlIdx).replace(/\r$/, '')
+        buffer = buffer.slice(nlIdx + 1)
+        const trimmed = line.trim()
+        if (!trimmed.startsWith('data:')) continue
+        const data = trimmed.slice(5).trim()
+        if (data === '[DONE]') continue
+        try {
+          const chunk = JSON.parse(data)
+          chunks.push(chunk)
+        } catch {
+          // 忽略
+        }
+      }
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    log('ERR', 'relay', `stream read error: ${msg}`)
+    try { res.end() } catch { /* */ }
+    return
+  }
+
+  // 把累计的 chunks 转成 Anthropic 事件
+  for (const ev of openAIStreamToAnthropicEvents(model, chunks)) {
+    if (ev.type === 'message_delta') {
+      const u = (ev as { usage?: { output_tokens?: number } }).usage
+      if (u?.output_tokens) outTokens = u.output_tokens
+    }
+    res.write(`event: ${ev.type}\n`)
+    res.write(`data: ${JSON.stringify(ev)}\n\n`)
+  }
+  res.end()
+  log('OK', 'relay', `← stream done (out~${outTokens} tokens)`)
+}