mohdel 0.90.0

package/js/session/_tracing.js

@@ -0,0 +1,58 @@
+/**
+ * OTel span helpers for the session process.
+ *
+ * Re-exports the traceparent parser, span lifecycle, and
+ * `gen_ai.*` attribute helpers from `src/lib/tracing.js` so adapter
+ * code has one canonical import path. `ensureOtelInitialized()`
+ * lazily wires `@opentelemetry/sdk-node` when
+ * `OTEL_EXPORTER_OTLP_ENDPOINT` is set — without it, the no-op
+ * tracer is fine: span IDs still come from the parsed traceparent
+ * (via `remoteParentFromTraceparent` + fresh spanId), so log lines
+ * still carry valid correlation even without an exporter.
+ *
+ * @module session/tracing
+ */
+
+export {
+  startSpan,
+  endSpanOk,
+  endSpanError,
+  parseTraceparent,
+  remoteParentFromTraceparent
+} from '../../src/lib/tracing.js'
+
+let otelInitialized = false
+
+/**
+ * Lazy OTel SDK setup. Safe to call multiple times — idempotent and
+ * no-op when the host app has already registered a tracer provider
+ * or when the env doesn't request one.
+ */
+export async function ensureOtelInitialized () {
+  if (otelInitialized) return
+  const endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT
+  if (!endpoint) {
+    otelInitialized = true
+    return
+  }
+
+  try {
+    const [{ NodeSDK }, { OTLPTraceExporter }] = await Promise.all([
+      import('@opentelemetry/sdk-node'),
+      import('@opentelemetry/exporter-trace-otlp-grpc')
+    ])
+    const sdk = new NodeSDK({
+      traceExporter: new OTLPTraceExporter({ url: endpoint }),
+      serviceName: process.env.OTEL_SERVICE_NAME || 'mohdel-session'
+    })
+    sdk.start()
+    otelInitialized = true
+  } catch (e) {
+    // Leave the flag false so a retry is possible. The current caller
+    // (bin.js::main) runs this once, so "retry" in practice means a
+    // process restart — but the semantics should match the flag name.
+    process.stderr.write(
+      `${JSON.stringify({ level: 'warn', time: Date.now(), msg: '[mohdel:tracing] OTel SDK init failed', err: { message: e.message } })}\n`
+    )
+  }
+}

package/js/session/adapters/_cancelled.js

@@ -0,0 +1,44 @@
+/**
+ * Shared `cancelledDone` helper for adapters that need to synthesize
+ * a terminal `done` event on `signal.aborted` mid-stream.
+ *
+ * Three adapters (openai, anthropic, gemini) had byte-identical
+ * copies of this before F58; consolidated here. `_chat_completions.js`
+ * and `run.js` have their own cancel paths — don't migrate them
+ * here unless you're certain the shape matches (thinkingTokens,
+ * cost, tool_calls semantics can all differ).
+ *
+ * @module session/adapters/_cancelled
+ */
+
+import { STATUS_INCOMPLETE, WARNING_CANCELLED } from '#core/status.js'
+import { costFor } from './_pricing.js'
+
+/**
+ * @param {string} start       hrtime-bigint-as-string at call entry
+ * @param {string | null} first  first-token hrtime, or null if never streamed
+ * @param {import('#core/envelope.js').CallEnvelope} envelope
+ * @param {string} output
+ * @param {number} inputTokens
+ * @param {number} outputTokens
+ * @returns {import('#core/events.js').DoneEvent}
+ */
+export function cancelledDone (start, first, envelope, output, inputTokens, outputTokens) {
+  const end = String(process.hrtime.bigint())
+  return {
+    type: 'done',
+    result: {
+      status: STATUS_INCOMPLETE,
+      output: output || null,
+      inputTokens,
+      outputTokens,
+      thinkingTokens: 0,
+      cost: costFor(
+        `${envelope.provider}/${envelope.model}`,
+        { inputTokens, outputTokens, thinkingTokens: 0 }
+      ),
+      timestamps: { start, first: first ?? end, end },
+      warning: WARNING_CANCELLED
+    }
+  }
+}

package/js/session/adapters/_catalog.js

@@ -0,0 +1,58 @@
+/**
+ * Curated catalog reader. Single source of truth for per-model
+ * metadata used by adapters: pricing, thinking effort levels,
+ * output token limits, etc. Lives in `~/.config/mohdel/curated.json`;
+ * each entry keyed by `<provider>/<model>` carries the model spec.
+ *
+ * Adapters and `_pricing.js` both consume this — no parallel cache,
+ * no parallel file read.
+ *
+ * @module session/adapters/_catalog
+ */
+
+import envPaths from 'env-paths'
+
+import { createLazyJsonFileCache } from './_lazy_json_cache.js'
+
+// `{ suffix: null }` mirrors `src/lib/common.js::CONFIG_DIR` so the
+// session subprocess reads the same `~/.config/mohdel/curated.json`
+// the `mo` CLI writes. Without the override, env-paths appends
+// `-nodejs` and the cache silently loads empty.
+const cache = createLazyJsonFileCache(() => `${envPaths('mohdel', { suffix: null }).config}/curated.json`)
+
+/**
+ * @param {string} path
+ * @returns {Record<string, any>}
+ */
+export function loadCatalog (path) {
+  return cache.loadSync(path)
+}
+
+/**
+ * Eager async initialization from the default curated path. Called from
+ * `bin.js::main` before `drive()` so the first `getSpec` doesn't stall
+ * the event loop on a sync read mid-call. Idempotent; respects a
+ * prior `setCatalog` (tests).
+ */
+export async function initCatalogFromDefault () {
+  await cache.initAsync()
+}
+
+/**
+ * Replace the active catalog. Test injection point and the extension
+ * seam for deployments that source spec from somewhere other than
+ * curated.json.
+ *
+ * @param {Record<string, any>} table
+ */
+export function setCatalog (table) {
+  cache.set(table)
+}
+
+/**
+ * @param {string} model  Fully-qualified `<provider>/<model>` key.
+ * @returns {any | undefined}
+ */
+export function getSpec (model) {
+  return cache.get(model)
+}

package/js/session/adapters/_chat_completions.js

@@ -0,0 +1,439 @@
+/**
+ * Shared chat.completions core — handles both streaming and
+ * non-streaming variants.
+ *
+ * Used by all providers that speak the classic OpenAI Chat
+ * Completions shape (Groq, Cerebras, DeepSeek, Mistral, OpenRouter,
+ * Fireworks). Each provider supplies an SDK client factory plus a
+ * small config block (tool-choice flavor, identifier field name,
+ * DSML fallback, reasoning field mapping, arg mutation hook); this
+ * module owns the request/response shape.
+ *
+ * Non-streaming mode emits a single synthetic `delta` for the
+ * visible message content followed by a terminal `done`. Streaming
+ * mode emits real per-chunk deltas.
+ *
+ * @module session/adapters/_chat_completions
+ */
+
+import { getSpec } from './_catalog.js'
+import { classifyProviderError } from './_errors.js'
+import { costFor } from './_pricing.js'
+import {
+  STATUS_COMPLETED,
+  STATUS_INCOMPLETE,
+  STATUS_TOOL_USE,
+  WARNING_INSUFFICIENT_OUTPUT_BUDGET
+} from '#core/status.js'
+import {
+  toCerebrasTools,
+  fromCerebrasToolCalls,
+  toToolChoice
+} from './_tools.js'
+
+// DSML parse regexes. These run against untrusted model output, so
+// worst-case match time MUST stay linear in input length (no ReDoS).
+// Rules to preserve that:
+//   - Lazy quantifiers (`*?`) only with bounded character classes
+//     (`[\s\S]`, `[^"]`, `[^<]`) and followed by a literal/anchor.
+//   - No nested alternations (e.g. `(a|b)*?`) inside a quantifier —
+//     that's what flips `*?` to exponential worst-case.
+//   - No backreferences.
+// If you add a new pattern here, benchmark it against a 1 MiB
+// adversarial input before merging.
+const DSML_RE = /<\uFF5CDSML\uFF5Cfunction_calls>/
+const DSML_BLOCK_RE = /<\uFF5CDSML\uFF5Cfunction_calls>[\s\S]*?<\/\uFF5CDSML\uFF5Cfunction_calls>/g
+const DSML_INVOKE_RE = /<\uFF5CDSML\uFF5Cinvoke\s+name="([^"]+)">([\s\S]*?)<\/\uFF5CDSML\uFF5Cinvoke>/g
+const DSML_PARAM_RE = /<\uFF5CDSML\uFF5Cparameter\s+name="([^"]+)"(?:\s+string="([^"]*)")?>([^<]*)<\/\uFF5CDSML\uFF5Cparameter>/g
+
+/**
+ * @typedef {object} ChatCompletionsConfig
+ * @property {string} provider
+ *   Registry key. Also used as tool-choice flavor unless
+ *   `toolChoiceFlavor` is set.
+ * @property {'openai'|'mistral'|'cerebras'} [toolChoiceFlavor]
+ * @property {'user'|'safety_identifier'} [identifierField]
+ *   Defaults to 'user'.
+ * @property {'reasoning_effort'|'cerebras_zai'} [reasoningField]
+ *   How to wire outputEffort into the request. `reasoning_effort`
+ *   sets `args.reasoning_effort = effort`. `cerebras_zai` flips
+ *   `args.disable_reasoning = false` instead (zai-family only).
+ * @property {boolean} [parseDsml]
+ *   Extract DeepSeek DSML function-call blocks from message content
+ *   when native `tool_calls` is absent.
+ * @property {boolean} [stream]
+ *   Use chat.completions streaming. Emits real delta events per SSE
+ *   chunk; usage reported on the final chunk via
+ *   `stream_options.include_usage`.
+ * @property {(envelope: any, args: any) => void} [mutateArgs]
+ *   Last-mile hook to splice provider-specific fields into the
+ *   request (e.g. OpenRouter routing prefs).
+ */
+
+/**
+ * @param {import('#core/envelope.js').CallEnvelope} envelope
+ * @param {any} client
+ * @param {ChatCompletionsConfig} config
+ * @param {{signal?: AbortSignal, log?: any, span?: any}} [deps]
+ * @returns {AsyncGenerator<import('#core/events.js').Event>}
+ */
+export async function * runChatCompletions (envelope, client, config, deps = {}) {
+  const spec = getSpec(`${envelope.provider}/${envelope.model}`) || {}
+  const start = String(process.hrtime.bigint())
+
+  const args = buildRequest(envelope, spec, config)
+  if (config.mutateArgs) config.mutateArgs(envelope, args)
+
+  if (config.stream) {
+    yield * runStreaming(envelope, client, args, config, start, deps)
+    return
+  }
+
+  let response
+  try {
+    response = await client.chat.completions.create(args, { signal: deps.signal })
+  } catch (e) {
+    deps.log?.warn({ err: e }, `[mohdel:${config.provider}] request failed`)
+    yield { type: 'error', error: classifyProviderError(e) }
+    return
+  }
+
+  const first = String(process.hrtime.bigint())
+  const choice = Array.isArray(response?.choices) ? response.choices[0] : null
+  const message = choice?.message || {}
+  const usage = response?.usage || {}
+  const finishReason = choice?.finish_reason
+
+  let content = message.content || ''
+  let toolCalls = message.tool_calls
+
+  if (config.parseDsml && content && (!toolCalls || !toolCalls.length)) {
+    const dsml = parseDsmlToolCalls(content)
+    if (dsml) {
+      toolCalls = dsml
+      content = stripDsml(content)
+    }
+  }
+
+  if (content) {
+    yield { type: 'delta', delta: { type: 'message', delta: content } }
+  }
+
+  yield finalize({
+    envelope, content, toolCalls, usage, finishReason, start, first
+  })
+}
+
+/**
+ * @param {import('#core/envelope.js').CallEnvelope} envelope
+ * @param {any} client
+ * @param {any} args
+ * @param {ChatCompletionsConfig} config
+ * @param {string} start
+ * @param {{signal?: AbortSignal}} deps
+ */
+async function * runStreaming (envelope, client, args, config, start, deps) {
+  args.stream = true
+  args.stream_options = { include_usage: true }
+
+  // F53: accumulate via array + join to avoid per-delta V8 cons-string
+  // churn on long streams.
+  const contentParts = []
+  let first = null
+  let finishReason = null
+  let usage = {}
+  const toolCallAccum = {}
+  // Cross-reference: tc.id observed on the opener → slot index. Lets
+  // us correlate continuation chunks that carry only `id` (some
+  // OpenAI-compat providers omit `index` after the opener) back to
+  // their original slot. Without this, chunks defaulting to
+  // `index ?? 0` silently merge multiple calls into slot 0.
+  const idToIndex = {}
+
+  let stream
+  try {
+    stream = await client.chat.completions.create(args, { signal: deps.signal })
+  } catch (e) {
+    deps.log?.warn({ err: e }, `[mohdel:${config.provider}] request failed`)
+    yield { type: 'error', error: classifyProviderError(e) }
+    return
+  }
+
+  try {
+    for await (const chunk of stream) {
+      const choice = chunk.choices?.[0]
+      if (choice?.delta?.content) {
+        if (first === null) first = String(process.hrtime.bigint())
+        contentParts.push(choice.delta.content)
+        yield { type: 'delta', delta: { type: 'message', delta: choice.delta.content } }
+      }
+      if (choice?.delta?.tool_calls) {
+        for (const tc of choice.delta.tool_calls) {
+          // Resolve which slot this chunk belongs to:
+          //   1. explicit `tc.index` always wins (normal case);
+          //   2. missing `tc.index` but a `tc.id` we've seen before
+          //      → use the cross-ref we recorded on the opener;
+          //   3. new `tc.id` with no index → allocate next slot;
+          //   4. neither id nor index → can't correlate; drop + warn.
+          let idx = tc.index
+          if (idx == null && tc.id != null && idToIndex[tc.id] != null) {
+            idx = idToIndex[tc.id]
+          }
+          if (idx == null && tc.id != null) {
+            idx = Object.keys(toolCallAccum).length
+          }
+          if (idx == null) {
+            deps.log?.warn(
+              { tc },
+              `[mohdel:${config.provider}] tool_call chunk with no id or index; skipped`
+            )
+            continue
+          }
+          const slot = toolCallAccum[idx] || (toolCallAccum[idx] = { id: '', name: '', arguments: '' })
+          if (tc.id) {
+            slot.id = tc.id
+            idToIndex[tc.id] = idx
+          }
+          if (tc.function?.name) slot.name += tc.function.name
+          if (tc.function?.arguments) {
+            slot.arguments += tc.function.arguments
+            if (first === null) first = String(process.hrtime.bigint())
+            yield {
+              type: 'delta',
+              delta: { type: 'function_call', delta: tc.function.arguments }
+            }
+          }
+        }
+      }
+      if (choice?.finish_reason) finishReason = choice.finish_reason
+      if (chunk.usage) usage = chunk.usage
+    }
+  } catch (e) {
+    deps.log?.warn({ err: e }, `[mohdel:${config.provider}] stream failed`)
+    yield { type: 'error', error: classifyProviderError(e) }
+    return
+  }
+
+  const collectedToolCalls = Object.values(toolCallAccum).map(tc => ({
+    id: tc.id,
+    function: { name: tc.name, arguments: tc.arguments }
+  }))
+
+  yield finalize({
+    envelope,
+    content: contentParts.join(''),
+    toolCalls: collectedToolCalls.length ? collectedToolCalls : null,
+    usage,
+    finishReason,
+    start,
+    first
+  })
+}
+
+/**
+ * @param {{
+ *   envelope: any,
+ *   content: string,
+ *   toolCalls: any[] | null,
+ *   usage: any,
+ *   finishReason: string | null,
+ *   start: string,
+ *   first: string | null
+ * }} p
+ * @returns {import('#core/events.js').DoneEvent}
+ */
+function finalize ({ envelope, content, toolCalls, usage, finishReason, start, first }) {
+  const end = String(process.hrtime.bigint())
+  const inputTokens = usage.prompt_tokens || 0
+  const totalOutputTokens = usage.completion_tokens || 0
+  const thinkingTokens = usage.completion_tokens_details?.reasoning_tokens || 0
+  const visibleOutputTokens = Math.max(0, totalOutputTokens - thinkingTokens)
+
+  const truncated = finishReason === 'length'
+  let status = truncated ? STATUS_INCOMPLETE : STATUS_COMPLETED
+  if (toolCalls && toolCalls.length > 0) status = STATUS_TOOL_USE
+
+  /** @type {import('#core/events.js').DoneEvent} */
+  const done = {
+    type: 'done',
+    result: {
+      status,
+      output: content || null,
+      inputTokens,
+      outputTokens: visibleOutputTokens,
+      thinkingTokens,
+      cost: costFor(
+        `${envelope.provider}/${envelope.model}`,
+        { inputTokens, outputTokens: visibleOutputTokens, thinkingTokens }
+      ),
+      timestamps: { start, first: first ?? end, end }
+    }
+  }
+  if (truncated) done.result.warning = WARNING_INSUFFICIENT_OUTPUT_BUDGET
+  if (toolCalls && toolCalls.length > 0) {
+    done.result.toolCalls = fromCerebrasToolCalls(toolCalls)
+  }
+  return done
+}
+
+/**
+ * @param {import('#core/envelope.js').CallEnvelope} envelope
+ * @param {any} spec
+ * @param {ChatCompletionsConfig} config
+ */
+function buildRequest (envelope, spec, config) {
+  /** @type {Record<string, any>} */
+  const args = {
+    model: envelope.model,
+    temperature: 0,
+    messages: toChatMessages(envelope.prompt)
+  }
+
+  if (envelope.outputBudget !== undefined) {
+    args.max_tokens = envelope.outputBudget
+  }
+
+  if (envelope.images?.length) {
+    injectImages(args, envelope.images)
+  }
+
+  if (envelope.tools?.length) {
+    args.tools = toCerebrasTools(envelope.tools)
+    if (envelope.toolChoice) {
+      args.tool_choice = toToolChoice(config.toolChoiceFlavor || 'openai', envelope.toolChoice)
+    }
+    if (envelope.parallelToolCalls === false) {
+      args.parallel_tool_calls = false
+    }
+  }
+
+  if (envelope.outputType === 'json') {
+    args.response_format = { type: 'json_object' }
+  }
+
+  if (spec.thinkingEffortLevels) {
+    const effort = envelope.outputEffort ?? spec.defaultThinkingEffort ?? 'low'
+    if (effort && effort !== 'none') {
+      const headroom = spec.thinkingEffortLevels[effort]
+      if (args.max_tokens && typeof headroom === 'number') {
+        args.max_tokens += headroom
+      }
+      delete args.temperature
+      if (config.reasoningField === 'cerebras_zai' && /zai/i.test(envelope.model)) {
+        args.disable_reasoning = false
+      } else {
+        args.reasoning_effort = effort
+      }
+    }
+  }
+
+  if (envelope.identifier) {
+    args[config.identifierField || 'user'] = envelope.identifier
+  }
+
+  return args
+}
+
+/**
+ * @param {string | import('#core/envelope.js').Message[]} prompt
+ * @returns {Array<any>}
+ */
+function toChatMessages (prompt) {
+  if (typeof prompt === 'string') return [{ role: 'user', content: prompt }]
+  return prompt.map(m => {
+    if (m.role === 'tool') {
+      return {
+        role: 'tool',
+        tool_call_id: m.toolCallId,
+        content: flattenText(m.content)
+      }
+    }
+    if (m.role === 'assistant' && m.toolCalls?.length) {
+      // Chat Completions assistant turn: optional `content` + the
+      // `tool_calls` array. `arguments` must be a JSON string on
+      // the wire.
+      return {
+        role: 'assistant',
+        content: flattenText(m.content) || '',
+        tool_calls: m.toolCalls.map(tc => ({
+          id: tc.id,
+          type: 'function',
+          function: {
+            name: tc.name,
+            arguments: stringifyToolArgs(tc.arguments)
+          }
+        }))
+      }
+    }
+    return { role: m.role, content: flattenText(m.content) }
+  })
+}
+
+/** @param {unknown} args */
+function stringifyToolArgs (args) {
+  if (typeof args === 'string' && args) return args
+  try { return JSON.stringify(args ?? {}) } catch { return '{}' }
+}
+
+/** @param {string | import('#core/envelope.js').MessagePart[]} content */
+function flattenText (content) {
+  if (typeof content === 'string') return content
+  if (!Array.isArray(content)) return ''
+  return content.filter(p => p.type === 'text' && p.text).map(p => p.text).join('\n')
+}
+
+/**
+ * @param {any} args
+ * @param {import('#core/envelope.js').MediaRef[]} images
+ */
+function injectImages (args, images) {
+  const blocks = images
+    .filter(i => i?.fileUri && i?.mimeType)
+    .map(i => ({
+      type: 'image_url',
+      image_url: { url: i.fileUri, detail: 'high' }
+    }))
+  if (!blocks.length) return
+
+  // Append to the last user message; fallback to creating one.
+  for (let i = args.messages.length - 1; i >= 0; i--) {
+    const m = args.messages[i]
+    if (m.role !== 'user') continue
+    if (typeof m.content === 'string') {
+      m.content = [{ type: 'text', text: m.content }, ...blocks]
+    } else if (Array.isArray(m.content)) {
+      m.content = [...m.content, ...blocks]
+    }
+    return
+  }
+  args.messages.push({ role: 'user', content: blocks })
+}
+
+/** @param {string} text */
+function parseDsmlToolCalls (text) {
+  if (!text || !DSML_RE.test(text)) return null
+  const calls = []
+  let m
+  while ((m = DSML_INVOKE_RE.exec(text)) !== null) {
+    const args = {}
+    let p
+    while ((p = DSML_PARAM_RE.exec(m[2])) !== null) {
+      const raw = p[3].trim()
+      args[p[1]] = p[2] === 'false' && raw !== '' && !isNaN(Number(raw))
+        ? Number(raw)
+        : raw
+    }
+    calls.push({
+      id: `dsml_${Date.now()}_${calls.length}`,
+      type: 'function',
+      function: { name: m[1], arguments: JSON.stringify(args) }
+    })
+  }
+  return calls.length > 0 ? calls : null
+}
+
+/** @param {string} text */
+function stripDsml (text) {
+  if (!text) return text
+  return text.replace(DSML_BLOCK_RE, '').trim() || ''
+}

package/js/session/adapters/_errors.js

@@ -0,0 +1,85 @@
+/**
+ * Shared error classification for provider adapters.
+ *
+ * Maps SDK errors (by HTTP status) to a canonical `TypedError` with
+ * stable `type` tags (AUTH_INVALID, RATE_LIMIT, PROVIDER_COOLDOWN,
+ * PROVIDER_UNAVAILABLE, …). 401/403 messages stay generic to avoid
+ * echoing provider bodies that may contain the API key back on the
+ * wire; for other statuses the provider's own detail is preserved
+ * on `.detail` so callers can debug 400s (schema rejects, etc).
+ *
+ * @module session/adapters/_errors
+ */
+
+const DETAIL_CAP = 500
+
+/**
+ * Extract a short human-readable detail from an SDK error. Trimmed
+ * to `DETAIL_CAP` chars so a verbose provider body doesn't blow up
+ * log pipelines.
+ * @param {any} err
+ * @returns {string | undefined}
+ */
+function extractDetail (err) {
+  if (!err) return undefined
+  // OpenAI SDK: err.error.message; Google SDK: err.message is the full
+  // body sometimes. Prefer the structured field when present.
+  const nested = err.error?.message || err.response?.data?.error?.message
+  const raw = nested || err.message
+  if (!raw) return undefined
+  const str = typeof raw === 'string' ? raw : JSON.stringify(raw)
+  return str.length > DETAIL_CAP ? str.slice(0, DETAIL_CAP) + '…' : str
+}
+
+/**
+ * @param {unknown} e
+ * @returns {import('#core/errors.js').TypedError}
+ */
+export function classifyProviderError (e) {
+  const err = /** @type {any} */(e)
+  const status = err?.status
+
+  if (status === 401 || status === 403) {
+    // Deliberately no detail — 401/403 bodies can echo the key.
+    return {
+      message: 'authentication failed',
+      severity: 'error',
+      retryable: false,
+      type: 'AUTH_INVALID'
+    }
+  }
+  if (status === 429) {
+    return {
+      message: 'rate limit exceeded',
+      severity: 'warn',
+      retryable: true,
+      type: 'RATE_LIMIT',
+      detail: extractDetail(err)
+    }
+  }
+  if (typeof status === 'number' && status >= 500) {
+    return {
+      message: `provider error ${status}`,
+      severity: 'warn',
+      retryable: true,
+      type: 'PROVIDER_UNAVAILABLE',
+      detail: extractDetail(err)
+    }
+  }
+  if (typeof status === 'number' && status >= 400) {
+    return {
+      message: `provider error ${status}`,
+      severity: 'error',
+      retryable: false,
+      type: 'PROVIDER_ERROR',
+      detail: extractDetail(err)
+    }
+  }
+  return {
+    message: err?.message ? String(err.message).slice(0, 200) : 'network error',
+    severity: 'warn',
+    retryable: true,
+    type: 'NET_ERROR',
+    detail: extractDetail(err)
+  }
+}