@asobacloud/nehanda 0.6.1 → 0.8.0

package/lib/configureProvider.mjs

@@ -0,0 +1,254 @@
+/**
+ * Goose-style provider configure wizard (#8).
+ * Single flow: provider → API key → host → keyed model discovery → persist.
+ */
+
+import {
+  discoverOpenAiCompatModels,
+  discoverOllamaModels,
+} from './modelDiscovery.mjs'
+
+/** @typedef {{ id: string, label: string, provider: string, defaultHost: string, needsKey: boolean, keySlot: string|null, discovery: 'openai'|'ollama' }} ProviderPreset */
+
+/** @type {ProviderPreset[]} */
+export const PROVIDER_PRESETS = [
+  {
+    id: 'nehanda',
+    label: 'Nehanda Cloud',
+    provider: 'nehanda',
+    defaultHost: 'https://nehanda-ml.asoba.co/v1',
+    needsKey: true,
+    keySlot: 'nehanda',
+    discovery: 'openai',
+  },
+  {
+    id: 'openrouter',
+    label: 'OpenRouter',
+    provider: 'openai_compatible',
+    defaultHost: 'https://openrouter.ai/api/v1',
+    needsKey: true,
+    keySlot: 'openai_compat',
+    discovery: 'openai',
+  },
+  {
+    id: 'openai_compatible',
+    label: 'OpenAI-compatible',
+    provider: 'openai_compatible',
+    defaultHost: 'https://api.openai.com/v1',
+    needsKey: true,
+    keySlot: 'openai_compat',
+    discovery: 'openai',
+  },
+  {
+    id: 'zhipu',
+    label: 'Zhipu (z.ai)',
+    provider: 'zhipu',
+    defaultHost: 'https://open.bigmodel.cn/api/paas/v4',
+    needsKey: true,
+    keySlot: 'zhipu',
+    discovery: 'openai',
+  },
+  {
+    id: 'ollama',
+    label: 'Ollama (local / LAN)',
+    provider: 'ollama',
+    defaultHost: 'http://localhost:11434',
+    needsKey: false,
+    keySlot: null,
+    discovery: 'ollama',
+  },
+  {
+    id: 'lm_studio',
+    label: 'LM Studio',
+    provider: 'lm_studio_local',
+    defaultHost: 'http://localhost:1234/v1',
+    needsKey: false,
+    keySlot: 'openai_compat',
+    discovery: 'openai',
+  },
+]
+
+export function normalizeOpenAiBaseUrl(host) {
+  const h = String(host || '').trim().replace(/\/+$/, '')
+  if (!h) return ''
+  return h
+}
+
+/** Ollama tags API wants host without trailing /v1. */
+export function normalizeOllamaHost(host) {
+  return String(host || '').trim().replace(/\/+$/, '').replace(/\/v1$/i, '')
+}
+
+/** Persist endpoint for agents.json — OpenAI-compat style /v1 for Ollama. */
+export function endpointForAgent(preset, host) {
+  if (preset.discovery === 'ollama') {
+    const base = normalizeOllamaHost(host)
+    return base ? `${base}/v1` : ''
+  }
+  return normalizeOpenAiBaseUrl(host)
+}
+
+/**
+ * Discover models for a preset using host + optional API key.
+ * @param {ProviderPreset} preset
+ * @param {{ host: string, apiKey?: string, timeout?: number }} opts
+ */
+export async function discoverModelsForPreset(preset, opts = {}) {
+  const timeout = opts.timeout || 5000
+  if (preset.discovery === 'ollama') {
+    const host = normalizeOllamaHost(opts.host)
+    return discoverOllamaModels(host, { timeout })
+  }
+  const host = normalizeOpenAiBaseUrl(opts.host)
+  return discoverOpenAiCompatModels(host, { apiKey: opts.apiKey || '', timeout })
+}
+
+/**
+ * Interactive configure wizard.
+ *
+ * @param {object} deps
+ * @param {(q: string) => Promise<string>} deps.ask
+ * @param {(title: string, items: object[]) => Promise<object|null>} deps.select
+ * @param {(msg: string) => void} [deps.notify]
+ * @param {(ctx: {preset, host, apiKey}) => Promise<{success, models?, error?}>} [deps.discover]
+ * @param {(args: {slot: string, key: string}) => Promise<void>} [deps.saveKey]
+ * @param {(preset: ProviderPreset) => Promise<string>} [deps.resolveExistingKey]
+ * @param {(cfg: object) => Promise<void>} [deps.persist]
+ * @param {{ presetId?: string, prefilledKey?: string }} [opts]
+ * @returns {Promise<object|null>} configured result or null if cancelled
+ */
+export async function runConfigureWizard(deps, opts = {}) {
+  const ask = deps.ask
+  const select = deps.select
+  const notify = deps.notify || (() => {})
+  const discover = deps.discover || ((ctx) => discoverModelsForPreset(ctx.preset, ctx))
+  const saveKey = deps.saveKey || (async () => {})
+  const resolveExistingKey = deps.resolveExistingKey || (async () => '')
+  const persist = deps.persist || (async () => {})
+
+  let preset
+  if (opts.presetId) {
+    preset = PROVIDER_PRESETS.find(p => p.id === opts.presetId)
+    if (!preset) throw new Error(`Unknown provider preset: ${opts.presetId}`)
+  } else {
+    const items = PROVIDER_PRESETS.map(p => ({
+      id: p.id,
+      label: p.label,
+      desc: p.defaultHost,
+      ...p,
+    }))
+    const picked = await select('Which provider?', items)
+    if (!picked) return null
+    preset = PROVIDER_PRESETS.find(p => p.id === picked.id) || picked
+  }
+
+  // ── API key ────────────────────────────────────────────────
+  let apiKey = typeof opts.prefilledKey === 'string' ? opts.prefilledKey.trim() : ''
+  let keyDirty = false
+
+  if (preset.needsKey && !apiKey) {
+    const existing = (await resolveExistingKey(preset)) || ''
+    if (existing) {
+      const choice = await select('Update API key?', [
+        { id: 'keep', label: 'Keep existing key', desc: 'Use the key already in secure storage' },
+        { id: 'replace', label: 'Replace key', desc: 'Enter a new API key' },
+      ])
+      if (!choice) return null
+      if (choice.id === 'replace') {
+        const entered = await ask(`${preset.label} API key:`)
+        if (!entered) return null
+        apiKey = entered.trim()
+        keyDirty = true
+      } else {
+        apiKey = existing
+      }
+    } else {
+      const entered = await ask(`${preset.label} API key:`)
+      if (!entered) return null
+      apiKey = entered.trim()
+      keyDirty = true
+    }
+  } else if (preset.needsKey && apiKey && opts.prefilledKey) {
+    // Key already saved by /key — do not re-save
+    keyDirty = false
+  }
+
+  // ── Host ───────────────────────────────────────────────────
+  const hostPrompt = preset.discovery === 'ollama'
+    ? `Ollama host [${preset.defaultHost}]:`
+    : `API host [${preset.defaultHost}]:`
+  const hostAnswer = await ask(hostPrompt)
+  const host = (hostAnswer && hostAnswer.trim()) || preset.defaultHost
+  if (!host) return null
+
+  const endpoint = endpointForAgent(preset, host)
+  if (!endpoint) return null
+
+  // ── Discovery ──────────────────────────────────────────────
+  notify('Fetching models from provider…')
+  let discovered = []
+  let discoveryError = null
+  try {
+    const result = await discover({
+      preset,
+      host: preset.discovery === 'ollama' ? normalizeOllamaHost(host) : normalizeOpenAiBaseUrl(host),
+      apiKey,
+    })
+    if (result?.success && Array.isArray(result.models)) {
+      discovered = result.models
+    } else {
+      discoveryError = result?.error || 'Discovery failed'
+      notify(`Discovery failed: ${discoveryError}`)
+    }
+  } catch (err) {
+    discoveryError = err.message
+    notify(`Discovery failed: ${discoveryError}`)
+  }
+
+  const modelItems = discovered.map(m => ({
+    id: m.name,
+    name: m.name,
+    label: m.name,
+    desc: 'Discovered',
+    endpoint,
+  }))
+  modelItems.push({
+    id: '__custom__',
+    name: '__custom__',
+    label: '(enter custom name…)',
+    desc: discoveryError ? 'Discovery unavailable — type a model id' : 'Type a model id not listed above',
+    endpoint,
+  })
+
+  const modelPick = await select('Select model', modelItems)
+  if (!modelPick) return null
+
+  let modelName = modelPick.name
+  if (modelPick.id === '__custom__' || modelName === '__custom__') {
+    const custom = await ask('Custom model name:')
+    if (!custom || !custom.trim()) return null
+    modelName = custom.trim()
+  }
+
+  if (keyDirty && preset.keySlot && apiKey) {
+    await saveKey({ slot: preset.keySlot, key: apiKey })
+  }
+
+  const cfg = {
+    presetId: preset.id,
+    provider: preset.provider,
+    model: modelName,
+    endpoint,
+    apiKey: preset.needsKey ? apiKey : (preset.provider === 'ollama' ? 'ollama' : apiKey),
+    model_config: {
+      provider: preset.provider,
+      model_id: modelName,
+      custom_model_name: modelName,
+      base_url: endpoint,
+      api_key: preset.provider === 'ollama' ? 'ollama' : apiKey,
+    },
+  }
+
+  await persist(cfg)
+  return cfg
+}

package/lib/modelConfig.mjs

@@ -38,12 +38,14 @@ const PROVIDER_CAPABILITIES = {
   openai_compatible: {
     supportsCustomModels: true,
     requiresHardcodedMap: false,
-    supportsDiscovery: false,
+    supportsDiscovery: true,
+    discoveryEndpoint: '/models',
   },
   zhipu: {
-    supportsCustomModels: false,
-    requiresHardcodedMap: true,
-    supportsDiscovery: false,
+    supportsCustomModels: true,
+    requiresHardcodedMap: false,
+    supportsDiscovery: true,
+    discoveryEndpoint: '/models',
   },
   ollama: {
     supportsCustomModels: true,
@@ -54,12 +56,14 @@ const PROVIDER_CAPABILITIES = {
   lm_studio_local: {
     supportsCustomModels: true,
     requiresHardcodedMap: false,
-    supportsDiscovery: false,
+    supportsDiscovery: true,
+    discoveryEndpoint: '/models',
   },
   nehanda: {
-    supportsCustomModels: false,
-    requiresHardcodedMap: true,
-    supportsDiscovery: false,
+    supportsCustomModels: true,
+    requiresHardcodedMap: false,
+    supportsDiscovery: true,
+    discoveryEndpoint: '/models',
     omitToolChoice: true,
   },
 }
@@ -118,16 +122,22 @@ export function modelConfigFromAgent(agent, { apiKey = '', defaultEndpoint = DEF
   const isNehanda = model === DEFAULT_NEHANDA_MODEL || /nehanda-ml\.asoba\.co/.test(endpoint)
 
   if (isNehanda) {
+    const isDefault = model === DEFAULT_NEHANDA_MODEL
     return {
       provider: 'nehanda',
       model_id: 'nehanda_rag_synthesis_27b',
-      custom_model_name: null,
+      // Discovered / non-default names ride as custom_model_name (#8)
+      custom_model_name: isDefault ? null : model,
       base_url: endpoint,
       api_key: apiKey,
     }
   }
 
-  const provider = /:11434\b/.test(endpoint) ? 'ollama' : 'openai_compatible'
+  let provider = 'openai_compatible'
+  if (/:11434\b/.test(endpoint)) provider = 'ollama'
+  else if (/bigmodel\.cn|\.z\.ai\b/.test(endpoint)) provider = 'zhipu'
+  else if (/:1234\b|:8000\b/.test(endpoint)) provider = 'lm_studio_local'
+
   return {
     provider,
     model_id: model,

package/lib/modelDiscovery.mjs

@@ -1,6 +1,6 @@
 /**
  * Model Discovery Service
- * Queries Ollama API to discover available models
+ * Queries Ollama (/api/tags) and OpenAI-compatible (/v1/models) endpoints.
  */
 
 import http from 'node:http'
@@ -232,6 +232,130 @@ export async function discoverOllamaModels(baseUrl, options = {}) {
   }
 }
 
+/**
+ * Normalize an OpenAI-compatible base URL so `{base}/models` resolves correctly.
+ * Accepts either `https://host/v1` or `https://host`.
+ */
+export function normalizeOpenAiCompatBase(baseUrl) {
+  if (!baseUrl || typeof baseUrl !== 'string') return ''
+  // Do not force /v1 — Zhipu and similar hosts use paths like /api/paas/v4.
+  return baseUrl.trim().replace(/\/+$/, '')
+}
+
+/**
+ * Strip trailing /v1 so Ollama `/api/tags` is hit on the root host.
+ */
+export function normalizeOllamaBase(baseUrl) {
+  if (!baseUrl || typeof baseUrl !== 'string') return ''
+  return baseUrl.trim().replace(/\/+$/, '').replace(/\/v1$/i, '')
+}
+
+function isEmbeddingModelId(id) {
+  return /embedding|whisper|tts|dall-e|moderation/i.test(id)
+}
+
+/**
+ * Discover models from an OpenAI-compatible `/v1/models` endpoint (keyed).
+ * @param {string} baseUrl - e.g. https://openrouter.ai/api/v1
+ * @param {Object} options
+ * @param {string} [options.apiKey] - Bearer token (optional for local servers)
+ * @param {number} [options.timeout=5000]
+ * @returns {Promise<{success:boolean, models?:Array<{name:string}>, error?:string}>}
+ */
+export async function discoverOpenAiCompatModels(baseUrl, options = {}) {
+  const timeout = options.timeout || 5000
+  const apiKey = typeof options.apiKey === 'string' ? options.apiKey.trim() : ''
+  const cleanBase = normalizeOpenAiCompatBase(baseUrl)
+  if (!cleanBase) {
+    return { success: false, error: 'Base URL is required for model discovery.' }
+  }
+  const discoveryUrl = `${cleanBase}/models`
+
+  try {
+    const controller = new AbortController()
+    const timeoutId = setTimeout(() => controller.abort(), timeout)
+    let response
+    try {
+      const headers = { Accept: 'application/json' }
+      if (apiKey) headers.Authorization = `Bearer ${apiKey}`
+      response = await fetch(discoveryUrl, { method: 'GET', signal: controller.signal, headers })
+    } finally {
+      clearTimeout(timeoutId)
+    }
+
+    if (!response.ok) {
+      const statusText = response.statusText || 'Unknown error'
+      if (response.status === 401 || response.status === 403) {
+        return {
+          success: false,
+          error: `Authentication failed (${response.status}): ${statusText}. Check the API key.`,
+        }
+      }
+      return {
+        success: false,
+        error: `HTTP error (${response.status}): ${statusText}`,
+      }
+    }
+
+    let data
+    try {
+      data = await response.json()
+    } catch (parseError) {
+      return { success: false, error: `Invalid JSON response from server: ${parseError.message}` }
+    }
+
+    const rows = Array.isArray(data?.data) ? data.data
+      : Array.isArray(data?.models) ? data.models
+      : null
+    if (!rows) {
+      return { success: false, error: 'Invalid response format: expected OpenAI-style { data: [...] }' }
+    }
+
+    const models = []
+    const seen = new Set()
+    for (const row of rows) {
+      const id = typeof row?.id === 'string' ? row.id.trim()
+        : typeof row?.name === 'string' ? row.name.trim()
+        : ''
+      if (!id || isEmbeddingModelId(id) || seen.has(id)) continue
+      seen.add(id)
+      models.push({ name: id })
+    }
+
+    return { success: true, models }
+  } catch (error) {
+    if (error.name === 'AbortError') {
+      return {
+        success: false,
+        error: `Request timed out after ${timeout}ms. The server may be slow or unreachable.`,
+      }
+    }
+    if (error.code === 'ECONNREFUSED' || (error.message && error.message.includes('fetch failed'))) {
+      return {
+        success: false,
+        error: `Cannot connect to ${cleanBase}. Check the host and network.`,
+      }
+    }
+    return { success: false, error: `Discovery failed: ${error.message}` }
+  }
+}
+
+/**
+ * Route discovery by provider id (used by bin/agent.mjs `/models`).
+ * @param {string} provider
+ * @param {{ baseUrl: string, apiKey?: string, timeout?: number }} opts
+ */
+export async function discoverModelsForProvider(provider, opts = {}) {
+  const timeout = opts.timeout || 5000
+  if (provider === 'ollama') {
+    return discoverOllamaModels(normalizeOllamaBase(opts.baseUrl), { timeout })
+  }
+  return discoverOpenAiCompatModels(opts.baseUrl, {
+    apiKey: opts.apiKey || '',
+    timeout,
+  })
+}
+
 /**
  * Format a list of models for display
  * @param {Array} models - Array of model objects from discovery

package/lib/openaiCompat.mjs

@@ -28,7 +28,16 @@ function stripThinkingTraces(text) {
   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 }) {
+/** True for DOM AbortError and Anthropic SDK APIUserAbortError. */
+export function isAbortError(e) {
+  if (!e) return false
+  if (e.name === 'AbortError' || e.name === 'APIUserAbortError') return true
+  if (e.constructor?.name === 'APIUserAbortError') return true
+  const msg = String(e.message || '')
+  return msg === 'Request was aborted.' || /operation was aborted/i.test(msg)
+}
+
+export async function streamOpenAIChatCompletion({ baseUrl, apiKey, model, messages, tools, io, maxTokens = 8192, bufferOutput = true, num_ctx: numCtx, omitToolChoice: skipToolChoice = false, useStream = true, signal } = {}) {
   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
@@ -41,6 +50,7 @@ export async function streamOpenAIChatCompletion({ baseUrl, apiKey, model, messa
     method: 'POST',
     headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
     body: JSON.stringify(body),
+    signal,
   })
 
   if (!res.ok) {

package/lib/orchestrate.mjs

@@ -8,7 +8,7 @@ import { runHooks } from './hookplane.mjs'
 import { appendEntry, transcriptToAnthropicMessages, transcriptToOpenAIMessages, makeUserPayload, makeAssistantPayload, makeToolResultPayload, applyEpistemicFilter } from './transcript.mjs'
 import { evaluatePermission } from './permissions.mjs'
 import { executeBuiltinTool, anthropicToolDefinitions, openAICompatToolDefinitions, LOCAL_CORE_TOOLS, EXPLORE_ONLY_TOOLS, dynamicTools, getMcpToolDefinitions } from './tools.mjs'
-import { streamOpenAIChatCompletion } from './openaiCompat.mjs'
+import { streamOpenAIChatCompletion, isAbortError } from './openaiCompat.mjs'
 import { withTransaction } from './store.mjs'
 import { getPhase, setPhase, canTransition } from './workflow.mjs'
 import { buildJevSystem2Messages } from './compact.mjs'
@@ -425,6 +425,16 @@ function classifyError(e) {
   return 'unknown'
 }
 
+/** Re-throw user aborts so Esc is not swallowed as a soft model failure (issue #7). */
+function rethrowIfAborted(e) {
+  if (!isAbortError(e)) return
+  if (e.name === 'AbortError') throw e
+  const err = new Error('abort')
+  err.name = 'AbortError'
+  err.cause = e
+  throw err
+}
+
 async function askHuman(io, q) {
   if (!process.stdin.isTTY) return true
   if (io?.ask) return (await io.ask(q)).trim().toLowerCase().startsWith('y')
@@ -637,13 +647,14 @@ If this file is not relevant to the task, say "Not relevant" and nothing else.`
         model: rt._model,
         max_tokens: 512,
         messages: [{ role: 'user', content: prompt }],
-      })
+      }, { signal: rt.signal })
       const summary = sanitizeModelText(response.content?.[0]?.text || '')
       trackTokens(rt.sessionId, response.usage?.input_tokens, response.usage?.output_tokens)
       if (summary && !/^not relevant/i.test(summary)) {
         summaries.push({ path, header, summary })
       }
-    } catch {
+    } catch (e) {
+      rethrowIfAborted(e)
       summaries.push({ path, header, summary: '(summarization failed — see header)' })
     }
     if (io.spinner) io.spinner.stop()
@@ -681,13 +692,15 @@ If this file is not relevant to the task, say "Not relevant" and nothing else.`
         bufferOutput: true,
         maxTokens: 512,
         numCtx: rt.settings?.model_config?.num_ctx,
+        signal: rt.signal,
       })
       const summary = sanitizeModelText(out.bufferedText || '')
       if (out.usage) trackTokens(rt.sessionId, out.usage.prompt_tokens, out.usage.completion_tokens)
       if (summary && !/^not relevant/i.test(summary)) {
         summaries.push({ path, header, summary })
       }
-    } catch {
+    } catch (e) {
+      rethrowIfAborted(e)
       summaries.push({ path, header, summary: '(summarization failed — see header)' })
     }
     if (io.spinner) io.spinner.stop()
@@ -829,7 +842,10 @@ async function runAnthropicSummaryTurn(db, rt, io, hookRt, client, summaryPrompt
 
   let bufferedText = ''
   try {
-    const stream = await client.messages.stream({ model: rt._model, max_tokens: 1024, system, messages, tools: [] })
+    const stream = await client.messages.stream(
+      { model: rt._model, max_tokens: 1024, system, messages, tools: [] },
+      { signal: rt.signal },
+    )
     for await (const ev of stream) {
       if (ev.type === 'content_block_delta' && ev.delta?.type === 'text_delta' && ev.delta.text) {
         bufferedText += ev.delta.text
@@ -839,6 +855,7 @@ async function runAnthropicSummaryTurn(db, rt, io, hookRt, client, summaryPrompt
     trackTokens(rt.sessionId, final.usage?.input_tokens, final.usage?.output_tokens)
     appendEntry(db, rt.sessionId, 'assistant', makeAssistantPayload(mapAnthropicContent(final.content || [])))
   } catch (e) {
+    rethrowIfAborted(e)
     if (io.spinner) io.spinner.stop()
     return null
   }
@@ -857,11 +874,12 @@ async function runOpenAICompatSummaryTurn(db, rt, io, hookRt, provider, baseUrl,
 
   let result = null
   try {
-    const out = await streamOpenAIChatCompletion({ baseUrl, apiKey, model: rt._model, messages, tools: [], io, bufferOutput: true, numCtx: rt.settings?.model_config?.num_ctx })
+    const out = await streamOpenAIChatCompletion({ baseUrl, apiKey, model: rt._model, messages, tools: [], io, bufferOutput: true, numCtx: rt.settings?.model_config?.num_ctx, signal: rt.signal })
     if (out.usage) trackTokens(rt.sessionId, out.usage.prompt_tokens, out.usage.completion_tokens)
     appendEntry(db, rt.sessionId, 'assistant', makeAssistantPayload(out.assistantBlocks))
     result = sanitizeModelText(out.bufferedText)
-  } catch {
+  } catch (e) {
+    rethrowIfAborted(e)
   }
   if (io.spinner) io.spinner.stop()
   return result
@@ -878,7 +896,10 @@ async function runAnthropicPhase(db, rt, io, hookRt, client, tools, phase) {
 
     let assistantBlocks = [], stopReason = null, bufferedText = ''
     try {
-      const stream = await client.messages.stream({ model: rt._model, max_tokens: 8192, system, messages, tools: filteredTools })
+      const stream = await client.messages.stream(
+        { model: rt._model, max_tokens: 8192, system, messages, tools: filteredTools },
+        { signal: rt.signal },
+      )
       for await (const ev of stream) {
         if (ev.type === 'content_block_delta' && ev.delta?.type === 'text_delta' && ev.delta.text) {
           bufferedText += ev.delta.text
@@ -893,6 +914,7 @@ async function runAnthropicPhase(db, rt, io, hookRt, client, tools, phase) {
       assistantBlocks = mapAnthropicContent(final.content || [])
       trackTokens(rt.sessionId, final.usage?.input_tokens, final.usage?.output_tokens)
     } catch (e) {
+      rethrowIfAborted(e)
       if (io.spinner) io.spinner.stop()
       await runHooks(db, hookRt, 'StopFailure', { error: classifyError(e), error_details: e.message })
       io.println(`\n[model error] ${e.message}`)
@@ -942,7 +964,7 @@ async function runOpenAICompatPhase(db, rt, io, hookRt, provider, baseUrl, apiKe
       // on top of the prompt-injected instructions, producing malformed hybrid output
       // like {"Glob", "arguments": {...}} instead of {"name": "Glob", "arguments": {...}}.
       const toolsForRequest = xmlInstructions ? [] : filteredTools
-      const out = await streamOpenAIChatCompletion({ baseUrl, apiKey, model: rt._model, messages, tools: toolsForRequest, io, bufferOutput: true, numCtx: rt.settings?.model_config?.num_ctx, omitToolChoice: omitToolChoice(provider), useStream: !omitToolChoice(provider) })
+      const out = await streamOpenAIChatCompletion({ baseUrl, apiKey, model: rt._model, messages, tools: toolsForRequest, io, bufferOutput: true, numCtx: rt.settings?.model_config?.num_ctx, omitToolChoice: omitToolChoice(provider), useStream: !omitToolChoice(provider), signal: rt.signal })
       assistantBlocks = out.assistantBlocks
       bufferedText = out.bufferedText
       finishReason = out.finishReason
@@ -962,6 +984,7 @@ async function runOpenAICompatPhase(db, rt, io, hookRt, provider, baseUrl, apiKe
 
       if (out.usage) trackTokens(rt.sessionId, out.usage.prompt_tokens, out.usage.completion_tokens)
     } catch (e) {
+      rethrowIfAborted(e)
       if (e.message?.includes('does not support tools') && activeTools.length > 0) {
         if (io.spinner) io.spinner.stop()
         io.println('\n[info] Model switching to manual tool injection...')