@asobacloud/nehanda 0.0.0-stage → 0.3.0

package/lib/mcp.mjs

@@ -0,0 +1,169 @@
+import { spawn } from 'node:child_process'
+import { runHooks } from './hookplane.mjs'
+
+const MCP_TIMEOUT = 120_000
+const servers = new Map()
+let _elicitationHandler = null
+
+/** Set a handler for MCP elicitation requests. Called with (serverName, params) → result. */
+export function setElicitationHandler(handler) { _elicitationHandler = handler }
+
+/** Start an MCP server from config. Returns a handle with request(). */
+export function getMcpServer(name, config) {
+  if (servers.has(name)) return servers.get(name)
+  const handle = startMcpServer(name, config)
+  servers.set(name, handle)
+  return handle
+}
+
+function startMcpServer(name, config) {
+  const cmd = config.command
+  const args = config.args || []
+  const env = { ...process.env, ...(config.env || {}) }
+
+  let child = null
+  let reqId = 1
+  let pending = new Map()
+  let buffer = ''
+  let initialized = false
+  let initPromise = null
+
+  function ensureChild() {
+    if (child && !child.killed) return
+    child = spawn(cmd, args, { env, stdio: ['pipe', 'pipe', 'pipe'] })
+    child.stdout.on('data', chunk => {
+      buffer += chunk.toString('utf8')
+      const lines = buffer.split('\n')
+      buffer = lines.pop() ?? ''
+      for (const line of lines) {
+        if (!line.trim()) continue
+        try {
+          const msg = JSON.parse(line)
+          if (msg.id != null && pending.has(msg.id)) {
+            const { resolve } = pending.get(msg.id)
+            pending.delete(msg.id)
+            resolve(msg)
+          } else if (msg.method === 'elicitation/create' && msg.id != null) {
+            // Server-initiated elicitation request
+            handleElicitation(name, msg, child).catch(() => {})
+          }
+        } catch { /* skip non-JSON */ }
+      }
+    })
+    child.on('error', () => { child = null })
+    child.on('close', () => { child = null; for (const [, p] of pending) p.resolve({ error: { code: -1, message: 'MCP server closed' } }); pending.clear() })
+  }
+
+  function sendRequest(method, params, timeoutMs = MCP_TIMEOUT) {
+    ensureChild()
+    const id = reqId++
+    const msg = JSON.stringify({ jsonrpc: '2.0', id, method, params: params || {} }) + '\n'
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pending.delete(id)
+        resolve({ error: { code: -32000, message: 'MCP request timeout' } })
+      }, timeoutMs)
+      pending.set(id, { resolve: (resp) => { clearTimeout(timer); resolve(resp) } })
+      try { child.stdin.write(msg, 'utf8') } catch (e) { clearTimeout(timer); pending.delete(id); resolve({ error: { code: -1, message: String(e) } }) }
+    })
+  }
+
+  async function initialize() {
+    if (initialized) return
+    if (initPromise) return initPromise
+    initPromise = sendRequest('initialize', {
+      protocolVersion: '2024-11-05',
+      capabilities: {},
+      clientInfo: { name: 'ona-sdlc-repl', version: '0.2.0' },
+    }).then(resp => {
+      if (!resp.error) {
+        sendRequest('notifications/initialized', {}).catch(() => {})
+        initialized = true
+      }
+    })
+    return initPromise
+  }
+
+  return {
+    name,
+    async request(method, params, timeoutMs) {
+      await initialize()
+      return sendRequest(method, params, timeoutMs)
+    },
+    close() {
+      if (child && !child.killed) { try { child.kill() } catch {} }
+      servers.delete(name)
+    },
+  }
+}
+
+export function listMcpServers(settings) {
+  const srvs = settings?.mcp_servers || {}
+  return Object.keys(srvs)
+}
+
+export async function mcpListResources(server) {
+  const resp = await server.request('resources/list', {})
+  if (resp.error) return { content: `MCP error: ${resp.error.message}`, is_error: true }
+  return { content: JSON.stringify(resp.result?.resources || [], null, 2), is_error: false }
+}
+
+export async function mcpReadResource(server, uri) {
+  const resp = await server.request('resources/read', { uri })
+  if (resp.error) return { content: `MCP error: ${resp.error.message}`, is_error: true }
+  const contents = resp.result?.contents || []
+  const text = contents.map(c => c.text || `[blob: ${c.uri}]`).join('\n')
+  return { content: text || '(empty)', is_error: false }
+}
+
+export async function mcpCallTool(server, toolName, args) {
+  const resp = await server.request('tools/call', { name: toolName, arguments: args })
+  if (resp.error) return { content: `MCP error: ${resp.error.message}`, is_error: true }
+  const result = resp.result
+  const text = Array.isArray(result?.content) ? result.content.map(c => c.text || JSON.stringify(c)).join('\n') : JSON.stringify(result)
+  return { content: text, is_error: Boolean(result?.isError) }
+}
+
+/** Handle an MCP elicitation request — fires Elicitation + ElicitationResult hooks. */
+async function handleElicitation(serverName, msg, child) {
+  const params = msg.params || {}
+  const hookRt = {
+    sessionId: '', conversationId: '', runtimeDbPath: process.env.AGENT_SDLC_DB || '',
+    cwd: process.cwd(), settings: {},
+  }
+
+  // Fire Elicitation hook
+  await runHooks(null, hookRt, 'Elicitation', {
+    mcp_server_name: serverName,
+    message: params.message || '',
+    elicitation_id: params.elicitation_id || msg.id,
+    mode: params.mode,
+    requested_schema: params.schema,
+  })
+
+  // Get user response via handler or default decline
+  let action = 'decline', content = null
+  if (_elicitationHandler) {
+    try {
+      const result = await _elicitationHandler(serverName, params)
+      action = result?.action || 'decline'
+      content = result?.content || null
+    } catch { /* decline on error */ }
+  }
+
+  // Fire ElicitationResult hook
+  await runHooks(null, hookRt, 'ElicitationResult', {
+    mcp_server_name: serverName,
+    elicitation_id: params.elicitation_id || msg.id,
+    action,
+    content,
+  })
+
+  // Send response back to server
+  const resp = JSON.stringify({ jsonrpc: '2.0', id: msg.id, result: { action, content } }) + '\n'
+  try { child.stdin.write(resp, 'utf8') } catch { /* server may have closed */ }
+}
+
+export function closeAllMcpServers() {
+  for (const [, s] of servers) s.close()
+}

package/lib/modelConfig.mjs

@@ -0,0 +1,152 @@
+/** §2.2 — wire model strings */
+const WIRE = {
+  claude_code_subscription: {
+    claude_opus_4: 'claude-opus-4-20250514',
+    claude_sonnet_4: 'claude-sonnet-4-20250514',
+    claude_3_5_haiku: 'claude-3-5-haiku-20241022',
+  },
+  openai_compatible: {
+    gpt_4o: 'gpt-4o',
+    gpt_4o_mini: 'gpt-4o-mini',
+    o3: 'o3',
+    o3_mini: 'o3-mini',
+  },
+  zhipu: {
+    glm_4_7_flash: 'glm-4.7-flash',
+  },
+  ollama: {
+    qwen2_5_14b: 'qwen2.5:14b',
+    qwen2_5_7b: 'qwen2.5:7b',
+    deepseek_coder_v2: 'deepseek-coder-v2',
+    codegemma_7b: 'codegemma:7b',
+  },
+  lm_studio_local: {
+    lm_studio_server_routed: 'lm_studio_server_routed',
+  },
+  nehanda: {
+    nehanda_rag_synthesis_27b: 'nehanda-rag-synthesis-27b',
+  },
+}
+
+/** Provider capabilities for custom model support and discovery */
+const PROVIDER_CAPABILITIES = {
+  claude_code_subscription: {
+    supportsCustomModels: false,
+    requiresHardcodedMap: true,
+    supportsDiscovery: false,
+  },
+  openai_compatible: {
+    supportsCustomModels: true,
+    requiresHardcodedMap: false,
+    supportsDiscovery: false,
+  },
+  zhipu: {
+    supportsCustomModels: false,
+    requiresHardcodedMap: true,
+    supportsDiscovery: false,
+  },
+  ollama: {
+    supportsCustomModels: true,
+    requiresHardcodedMap: false,
+    supportsDiscovery: true,
+    discoveryEndpoint: '/api/tags',
+  },
+  lm_studio_local: {
+    supportsCustomModels: true,
+    requiresHardcodedMap: false,
+    supportsDiscovery: false,
+  },
+  nehanda: {
+    supportsCustomModels: false,
+    requiresHardcodedMap: true,
+    supportsDiscovery: false,
+    omitToolChoice: true,
+  },
+}
+
+export function supportsCustomModels(provider) {
+  const capabilities = PROVIDER_CAPABILITIES[provider]
+  return capabilities ? capabilities.supportsCustomModels : false
+}
+
+export function supportsDiscovery(provider) {
+  const capabilities = PROVIDER_CAPABILITIES[provider]
+  return capabilities ? capabilities.supportsDiscovery : false
+}
+
+export function getDiscoveryEndpoint(provider) {
+  const capabilities = PROVIDER_CAPABILITIES[provider]
+  return capabilities?.discoveryEndpoint || null
+}
+
+export function omitToolChoice(provider) {
+  const capabilities = PROVIDER_CAPABILITIES[provider]
+  return capabilities ? !!capabilities.omitToolChoice : false
+}
+
+export function resolveWireModel(modelConfig) {
+  const { provider, model_id, custom_model_name } = modelConfig || {}
+  
+  if (custom_model_name && custom_model_name.trim()) {
+    return custom_model_name.trim()
+  }
+  
+  const map = WIRE[provider]
+  if (!map) throw new Error(`Unknown provider: ${provider}`)
+  const w = map[model_id]
+  if (w === undefined) throw new Error(`Invalid model_id ${model_id} for provider ${provider}`)
+
+  if (provider === 'lm_studio_local') {
+    const name = process.env.LM_STUDIO_MODEL
+    if (!name || !name.trim()) throw new Error('LM_STUDIO_MODEL not set. Export it or use /model.')
+    return name.trim()
+  }
+
+  return w
+}
+
+const DEFAULT_NEHANDA_ENDPOINT = 'https://nehanda-ml.asoba.co/v1'
+const DEFAULT_NEHANDA_MODEL = 'nehanda-rag-synthesis-27b'
+
+/**
+ * Map agents.json agent {model, endpoint} → model_config used by resolveWireModel / orchestrate.
+ * Used by nehanda-ui so /model selection actually changes the wire model on the next turn.
+ */
+export function modelConfigFromAgent(agent, { apiKey = '', defaultEndpoint = DEFAULT_NEHANDA_ENDPOINT } = {}) {
+  const model = agent?.model || DEFAULT_NEHANDA_MODEL
+  const endpoint = agent?.endpoint || defaultEndpoint
+  const isNehanda = model === DEFAULT_NEHANDA_MODEL || /nehanda-ml\.asoba\.co/.test(endpoint)
+
+  if (isNehanda) {
+    return {
+      provider: 'nehanda',
+      model_id: 'nehanda_rag_synthesis_27b',
+      custom_model_name: null,
+      base_url: endpoint,
+      api_key: apiKey,
+    }
+  }
+
+  const provider = /:11434\b/.test(endpoint) ? 'ollama' : 'openai_compatible'
+  return {
+    provider,
+    model_id: model,
+    custom_model_name: model,
+    base_url: endpoint,
+    api_key: provider === 'ollama' ? 'ollama' : apiKey,
+  }
+}
+
+export function anthropicBaseUrl() {
+  return (process.env.ANTHROPIC_BASE_URL || 'https://api.anthropic.com').replace(/\/$/, '')
+}
+
+export function allModelIds() {
+  const out = []
+  for (const [prov, map] of Object.entries(WIRE)) {
+    for (const mid of Object.keys(map)) {
+      out.push({ provider: prov, model_id: mid })
+    }
+  }
+  return out
+}

package/lib/modelDiscovery.mjs

@@ -0,0 +1,205 @@
+/**
+ * Model Discovery Service
+ * Queries Ollama API to discover available models
+ */
+
+/**
+ * Discover available models from an Ollama server
+ * @param {string} baseUrl - Base URL of the Ollama server (e.g., "http://localhost:11434")
+ * @param {Object} options - Discovery options
+ * @param {number} options.timeout - Request timeout in milliseconds (default: 5000)
+ * @returns {Promise<DiscoveryResult>} Discovery result with models or error
+ */
+export async function discoverOllamaModels(baseUrl, options = {}) {
+  const timeout = options.timeout || 5000
+  
+  try {
+    // Construct discovery URL - remove trailing slashes and append endpoint
+    const cleanBaseUrl = baseUrl.replace(/\/+$/, '')
+    const discoveryUrl = `${cleanBaseUrl}/api/tags`
+    
+    // Make HTTP GET request with timeout
+    const controller = new AbortController()
+    const timeoutId = setTimeout(() => controller.abort(), timeout)
+    
+    let response
+    try {
+      response = await fetch(discoveryUrl, {
+        method: 'GET',
+        signal: controller.signal,
+        headers: {
+          'Accept': 'application/json'
+        }
+      })
+    } finally {
+      clearTimeout(timeoutId)
+    }
+    
+    // Handle HTTP errors
+    if (!response.ok) {
+      const statusText = response.statusText || 'Unknown error'
+      if (response.status === 404) {
+        return {
+          success: false,
+          error: `Endpoint not found (404). The Ollama server at ${baseUrl} may not support model discovery.`
+        }
+      } else if (response.status >= 500) {
+        return {
+          success: false,
+          error: `Server error (${response.status}): ${statusText}. The Ollama server encountered an internal error.`
+        }
+      } else {
+        return {
+          success: false,
+          error: `HTTP error (${response.status}): ${statusText}`
+        }
+      }
+    }
+    
+    // Parse JSON response
+    let data
+    try {
+      data = await response.json()
+    } catch (parseError) {
+      return {
+        success: false,
+        error: `Invalid JSON response from server: ${parseError.message}`
+      }
+    }
+    
+    // Validate response structure
+    if (!data || typeof data !== 'object') {
+      return {
+        success: false,
+        error: 'Invalid response format: expected JSON object'
+      }
+    }
+    
+    if (!Array.isArray(data.models)) {
+      return {
+        success: false,
+        error: 'Invalid response format: missing or invalid "models" array'
+      }
+    }
+    
+    // Extract and validate model information
+    const models = []
+    for (const model of data.models) {
+      // Skip invalid model entries
+      if (!model || typeof model !== 'object') {
+        continue
+      }
+      
+      // Require non-empty name field
+      if (!model.name || typeof model.name !== 'string' || !model.name.trim()) {
+        continue
+      }
+      
+      // Extract model information
+      models.push({
+        name: model.name,
+        modified_at: model.modified_at || null,
+        size: typeof model.size === 'number' ? model.size : 0,
+        digest: model.digest || null,
+        details: model.details || null
+      })
+    }
+    
+    return {
+      success: true,
+      models
+    }
+    
+  } catch (error) {
+    // Handle connection errors and timeouts
+    if (error.name === 'AbortError') {
+      return {
+        success: false,
+        error: `Request timed out after ${timeout}ms. The Ollama server may be slow or unreachable.`
+      }
+    }
+    
+    // Handle network/connection errors
+    if (error.code === 'ECONNREFUSED' || error.message.includes('fetch failed')) {
+      return {
+        success: false,
+        error: `Cannot connect to Ollama server at ${baseUrl}. Make sure Ollama is running and accessible.`
+      }
+    }
+    
+    // Generic error
+    return {
+      success: false,
+      error: `Discovery failed: ${error.message}`
+    }
+  }
+}
+
+/**
+ * Format a list of models for display
+ * @param {Array} models - Array of model objects from discovery
+ * @param {Object} options - Formatting options
+ * @param {string} options.sortBy - Sort by 'date', 'name', or 'size' (default: 'date')
+ * @param {boolean} options.verbose - Include detailed information (default: false)
+ * @returns {string} Formatted model list
+ */
+export function formatModelList(models, options = {}) {
+  const sortBy = options.sortBy || 'date'
+  const verbose = options.verbose || false
+  
+  if (!models || models.length === 0) {
+    return 'No models found on the server.\n\nTo pull a model, run: ollama pull <model-name>'
+  }
+  
+  // Sort models
+  const sorted = [...models]
+  if (sortBy === 'name') {
+    sorted.sort((a, b) => a.name.localeCompare(b.name))
+  } else if (sortBy === 'size') {
+    sorted.sort((a, b) => b.size - a.size)
+  } else {
+    // Sort by modification date (newest first)
+    sorted.sort((a, b) => {
+      if (!a.modified_at) return 1
+      if (!b.modified_at) return -1
+      return new Date(b.modified_at) - new Date(a.modified_at)
+    })
+  }
+  
+  // Format output
+  const lines = []
+  lines.push('Available models:\n')
+  
+  for (const model of sorted) {
+    const size = formatBytes(model.size)
+    
+    if (verbose && model.details) {
+      const paramSize = model.details.parameter_size || 'unknown'
+      const quantization = model.details.quantization_level || 'unknown'
+      lines.push(`  ${model.name}`)
+      lines.push(`    Size: ${size}`)
+      lines.push(`    Parameters: ${paramSize}`)
+      lines.push(`    Quantization: ${quantization}`)
+    } else {
+      lines.push(`  ${model.name.padEnd(40)} ${size}`)
+    }
+  }
+  
+  lines.push('\nUsage: /model ollama/<model-name>')
+  lines.push('Example: /model ollama/llama3')
+  
+  return lines.join('\n')
+}
+
+/**
+ * Format bytes in human-readable format
+ * @param {number} bytes - Size in bytes
+ * @returns {string} Formatted size string
+ */
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 B'
+  if (bytes < 1024) return `${bytes} B`
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`
+}

package/lib/openaiCompat.mjs

@@ -0,0 +1,147 @@
+/** OpenAI Chat Completions–compatible streaming HTTP client (§2.1 lm_studio_local + openai_compatible). */
+
+/**
+ * Strip thinking traces emitted by reasoning-capable models (Nehanda, DeepSeek-R1, Qwen3).
+ * Handles:
+ *   - Tagged blocks: <think>...</think>
+ *   - Prose header: "Here's a thinking process: ..."
+ *   - Numbered planning list that ends before the actual answer (```code or plain prose)
+ */
+function stripThinkingTraces(text) {
+  // Tagged blocks
+  text = text.replace(/<think>[\s\S]*?<\/think>/g, '')
+  text = text.replace(/<think>[\s\S]*/g, '')
+
+  // Prose thinking header
+  text = text.replace(/^Here's a thinking process:[\s\S]*?(?=\n\n(?!\n)|\n(?=[A-Z0-9`#]))/m, '')
+
+  // Numbered planning lists: lines starting with "1." or "1.  **" that precede a code block
+  // or a clean paragraph. We detect: text starts with a numbered step AND contains a code fence.
+  const hasCodeFence = text.includes('```')
+  const startsWithStep = /^\s*1\.\s/.test(text)
+  if (startsWithStep && hasCodeFence) {
+    // Keep only from the first code block onward
+    const fenceIdx = text.indexOf('```')
+    text = text.slice(fenceIdx)
+  }
+
+  return text.trim()
+}
+
+export async function streamOpenAIChatCompletion({ baseUrl, apiKey, model, messages, tools, io, maxTokens = 8192, bufferOutput = true, num_ctx: numCtx, omitToolChoice: skipToolChoice = false, useStream = true }) {
+  const url = `${String(baseUrl).replace(/\/$/, '')}/chat/completions`
+  const body = { model, messages, stream: useStream, max_tokens: maxTokens }
+  // Suppress tool_choice:"auto" for providers that do not support it (e.g. Nehanda
+  // vLLM without --enable-auto-tool-choice). When omitToolChoice is true we still
+  // send the tools schema so the model can call them — we just omit the directive.
+  if (tools?.length) { body.tools = tools; if (!skipToolChoice) body.tool_choice = 'auto' }
+  if (numCtx) body.num_ctx = numCtx
+
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
+    body: JSON.stringify(body),
+  })
+
+  if (!res.ok) {
+    const t = await res.text()
+    throw new Error(`OpenAI-compat ${res.status}: ${t.slice(0, 2000)}`)
+  }
+  if (!res.body) throw new Error('OpenAI-compat: empty response body')
+
+  // Non-streaming path: Lambda/proxy returns a single JSON completion object.
+  // Used for providers like Nehanda whose Lambda Function URL buffers the full
+  // response rather than forwarding SSE chunks.
+  if (!useStream) {
+    const text = await res.text()
+    let json
+    try { json = JSON.parse(text) } catch { throw new Error(`OpenAI-compat: non-JSON response: ${text.slice(0, 500)}`) }
+    const content = json.choices?.[0]?.message?.content || ''
+    const strippedText = stripThinkingTraces(content)
+    if (!bufferOutput && strippedText) { if (io.spinner) io.spinner.stop(); io.write(strippedText) }
+    const assistantBlocks = []
+    if (strippedText) assistantBlocks.push({ type: 'text', text: strippedText })
+    return {
+      assistantBlocks,
+      finishReason: json.choices?.[0]?.finish_reason || 'stop',
+      bufferedText: bufferOutput ? strippedText : null,
+      usage: json.usage || null,
+    }
+  }
+
+  const reader = res.body.getReader()
+  const decoder = new TextDecoder()
+  let buffer = '', fullText = '', finishReason = null, firstToken = true, usage = null
+  const toolAcc = new Map()
+
+  while (true) {
+    const { done, value } = await reader.read()
+    if (done) break
+    buffer += decoder.decode(value, { stream: true })
+    const parts = buffer.split('\n')
+    buffer = parts.pop() ?? ''
+
+    for (const line of parts) {
+      const trimmed = line.trim()
+      if (!trimmed.startsWith('data:')) continue
+      const data = trimmed.slice(5).trim()
+      if (data === '[DONE]') continue
+      let json
+      try { json = JSON.parse(data) } catch { continue }
+      const choice = json.choices?.[0]
+      const delta = choice?.delta
+      if (delta?.content) {
+        if (firstToken) {
+          firstToken = false
+          // Only stop spinner and write newline when streaming directly to output.
+          // When buffering, the caller owns the spinner — don't touch it here.
+          if (!bufferOutput) { if (io.spinner) io.spinner.stop(); io.write('\n') }
+        }
+        fullText += delta.content
+        if (!bufferOutput) {
+          io.write(delta.content)
+        }
+      }
+      if (delta?.tool_calls) {
+        if (firstToken) {
+          firstToken = false
+          // Tool calls are always handled by the caller — don't stop spinner here.
+        }
+        for (const tc of delta.tool_calls) {
+          const idx = tc.index ?? 0
+          if (!toolAcc.has(idx)) toolAcc.set(idx, { id: '', name: '', arguments: '' })
+          const acc = toolAcc.get(idx)
+          if (tc.id) acc.id = tc.id
+          if (tc.function?.name) acc.name = tc.function.name
+          if (tc.function?.arguments != null) acc.arguments += String(tc.function.arguments)
+        }
+      }
+      if (choice?.finish_reason) finishReason = choice.finish_reason
+      if (json.usage) usage = json.usage
+    }
+  }
+
+  const toolCalls = [...toolAcc.keys()].sort((a, b) => a - b).map(idx => {
+    const acc = toolAcc.get(idx)
+    if (!acc.name) return null
+    let input = {}
+    try { input = acc.arguments.trim() ? JSON.parse(acc.arguments) : {} } catch { input = { _parseError: true, _raw: acc.arguments.slice(0, 500) } }
+    return { id: acc.id || `call_${idx}_${Date.now()}`, name: acc.name, input }
+  }).filter(Boolean)
+
+  // Strip thinking traces before returning — applies to buffered and non-buffered paths.
+  // Non-buffered (live streaming) will have printed raw tokens already; the stripped
+  // version is used for the transcript and any downstream processing.
+  const strippedText = stripThinkingTraces(fullText)
+
+  const assistantBlocks = []
+  if (strippedText) assistantBlocks.push({ type: 'text', text: strippedText })
+  for (const tc of toolCalls) assistantBlocks.push({ type: 'tool_use', id: tc.id, name: tc.name, input: tc.input })
+
+  return {
+    assistantBlocks,
+    finishReason: finishReason || (toolCalls.length > 0 ? 'tool_calls' : 'stop'),
+    bufferedText: bufferOutput ? strippedText : null,
+    usage,
+  }
+}