bazilion 0.0.0 → 0.1.0

package/apps/daemon/src/runtime/auth/openai-codex.ts

@@ -1,121 +0,0 @@
-// OpenAI ChatGPT / Codex OAuth — token storage + refresh on top of pi-ai.
-//
-// Pi-ai ships a complete OAuth flow for the ChatGPT backend (`@mariozechner/pi-ai`
-// exports `loginOpenAICodex` + `refreshOpenAICodexToken`), so this module is
-// thin: it adapts the credential I/O to Bazilion's encrypted secrets store
-// and exposes a single `loadAccessToken(db, authToken)` call that refreshes
-// when the token is about to expire.
-//
-// Storage: the JSON blob `{refresh, access, expires}` lives under the
-// secrets key `OPENAI_CODEX_OAUTH` in the `secrets` table. The blob is
-// never copied into the env (unlike plain-API-key providers) — refresh is
-// stateful, so every call reads and writes through the live secrets store.
-
-import type { OpenAICodexStatus } from '@bazilion/api-types'
-import type { OAuthCredentials } from '@mariozechner/pi-ai'
-import { loginOpenAICodex, refreshOpenAICodexToken } from '@mariozechner/pi-ai/oauth'
-import { type BazilionDb, openSecrets } from '../../core/index.ts'
-
-export const OPENAI_CODEX_SECRET_KEY = 'OPENAI_CODEX_OAUTH'
-
-/** Refresh when the access token has less than this much life left. */
-const REFRESH_MARGIN_MS = 60_000
-
-export interface StoredCredentials {
-  refresh: string
-  access: string
-  expires: number
-}
-
-function readCredentials(db: BazilionDb, authToken: string): StoredCredentials | null {
-  const raw = openSecrets(db, authToken).get(OPENAI_CODEX_SECRET_KEY)
-  if (!raw) return null
-  try {
-    const parsed = JSON.parse(raw) as Partial<StoredCredentials>
-    if (
-      typeof parsed.refresh === 'string' &&
-      typeof parsed.access === 'string' &&
-      typeof parsed.expires === 'number'
-    ) {
-      return { refresh: parsed.refresh, access: parsed.access, expires: parsed.expires }
-    }
-    return null
-  } catch {
-    return null
-  }
-}
-
-function writeCredentials(db: BazilionDb, authToken: string, creds: StoredCredentials): void {
-  openSecrets(db, authToken).set(OPENAI_CODEX_SECRET_KEY, JSON.stringify(creds))
-}
-
-export function clearCredentials(db: BazilionDb, authToken: string): void {
-  openSecrets(db, authToken).remove(OPENAI_CODEX_SECRET_KEY)
-}
-
-export function hasCredentials(db: BazilionDb, authToken: string): boolean {
-  return readCredentials(db, authToken) !== null
-}
-
-function decodeAccountId(accessToken: string): string | null {
-  const parts = accessToken.split('.')
-  if (parts.length !== 3) return null
-  try {
-    const payload = JSON.parse(Buffer.from(parts[1] as string, 'base64').toString('utf8')) as {
-      'https://api.openai.com/auth'?: { chatgpt_account_id?: string }
-    }
-    return payload['https://api.openai.com/auth']?.chatgpt_account_id ?? null
-  } catch {
-    return null
-  }
-}
-
-export function getStatus(db: BazilionDb, authToken: string): OpenAICodexStatus {
-  const creds = readCredentials(db, authToken)
-  if (!creds) return { connected: false, expiresAt: null, accountId: null }
-  return {
-    connected: true,
-    expiresAt: creds.expires,
-    accountId: decodeAccountId(creds.access),
-  }
-}
-
-/**
- * Returns a valid access token, refreshing via pi-ai if the stored one is
- * within `REFRESH_MARGIN_MS` of expiry. Throws when no credentials are stored
- * so callers can surface an actionable "run `bazilion auth openai login`"
- * error rather than a 401 from the upstream API.
- */
-export async function loadAccessToken(db: BazilionDb, authToken: string): Promise<string> {
-  const creds = readCredentials(db, authToken)
-  if (!creds) {
-    throw new Error(
-      'OpenAI ChatGPT OAuth not configured — run `bazilion auth openai login` (or use the Connect button on /config)',
-    )
-  }
-  if (creds.expires > Date.now() + REFRESH_MARGIN_MS) return creds.access
-
-  const refreshed = (await refreshOpenAICodexToken(creds.refresh)) as OAuthCredentials
-  const next: StoredCredentials = {
-    refresh: refreshed.refresh,
-    access: refreshed.access,
-    expires: refreshed.expires,
-  }
-  writeCredentials(db, authToken, next)
-  return next.access
-}
-
-/** Persist credentials fetched by pi-ai's `loginOpenAICodex`. */
-export function saveLoginCredentials(
-  db: BazilionDb,
-  authToken: string,
-  creds: OAuthCredentials,
-): void {
-  writeCredentials(db, authToken, {
-    refresh: creds.refresh,
-    access: creds.access,
-    expires: creds.expires,
-  })
-}
-
-export { loginOpenAICodex, refreshOpenAICodexToken }

package/apps/daemon/src/runtime/auto-reply/heartbeat.ts

@@ -1,31 +0,0 @@
-// Default heartbeat prompt. Users paste this constant as a trigger's
-// `message` (or call `resolveHeartbeatPrompt` with a custom one) to wire
-// HEARTBEAT.md into a scheduled wake-up without reinventing the framing.
-export const HEARTBEAT_PROMPT =
-  'Read HEARTBEAT.md if it exists (workspace context). Follow it strictly. Do not infer or repeat old tasks from prior chats. If nothing needs attention, reply HEARTBEAT_OK.'
-
-export const DEFAULT_HEARTBEAT_EVERY_SEC = 30 * 60
-
-/**
- * A HEARTBEAT.md is "effectively empty" when it has no actionable task lines.
- * Whitespace, ATX headers, and stub checklist items (`- [ ]`) all count as
- * empty so we can skip a turn when the file has been left as a placeholder.
- * Missing content (undefined/null/non-string) returns false — the LLM should
- * still get a chance to act.
- */
-export function isHeartbeatContentEffectivelyEmpty(content: string | undefined | null): boolean {
-  if (typeof content !== 'string') return false
-  for (const line of content.split('\n')) {
-    const trimmed = line.trim()
-    if (!trimmed) continue
-    if (/^#+(\s|$)/.test(trimmed)) continue
-    if (/^[-*+]\s*(\[[\sXx]?\]\s*)?$/.test(trimmed)) continue
-    return false
-  }
-  return true
-}
-
-export function resolveHeartbeatPrompt(raw?: string | null): string {
-  const trimmed = typeof raw === 'string' ? raw.trim() : ''
-  return trimmed || HEARTBEAT_PROMPT
-}

package/apps/daemon/src/runtime/index.ts

@@ -1,77 +0,0 @@
-export type { OAuthAuthInfo, OAuthPrompt } from '@mariozechner/pi-ai'
-export type { StoredCredentials } from './auth/openai-codex.ts'
-export {
-  clearCredentials as clearOpenAICodexCredentials,
-  getStatus as getOpenAICodexStatus,
-  hasCredentials as hasOpenAICodexCredentials,
-  loadAccessToken as loadOpenAICodexAccessToken,
-  loginOpenAICodex,
-  OPENAI_CODEX_SECRET_KEY,
-  refreshOpenAICodexToken,
-  saveLoginCredentials as saveOpenAICodexLoginCredentials,
-} from './auth/openai-codex.ts'
-export {
-  DEFAULT_HEARTBEAT_EVERY_SEC,
-  HEARTBEAT_PROMPT,
-  isHeartbeatContentEffectivelyEmpty,
-  resolveHeartbeatPrompt,
-} from './auto-reply/heartbeat.ts'
-export { filesBackend } from './memory/files.ts'
-export { qmdBackend } from './memory/qmd.ts'
-export type { MemoryBackend } from './memory/types.ts'
-export {
-  extractAssistantText,
-  extractAssistantToolCalls,
-  extractToolResultText,
-  piMessagesToProviderView,
-  translatePiEvent,
-} from './pi/events.ts'
-export type { BazilionSessionHandle, CreateBazilionSessionOptions } from './pi/session.ts'
-export {
-  countSessionMessagesForTest,
-  createBazilionSession,
-  isProviderEnabled,
-  loadEnabledRegistry,
-  loadInitialMessages,
-  loadSessionHead,
-  seedSessionForTest,
-} from './pi/session.ts'
-// Pi-coding-agent integration surface. The worker runs inside a
-// `BazilionSession` (pi's AgentSession wrapper) and endpoints (/compact,
-// /context, /reset) drive pi session operations directly.
-export type { BazilionCustomToolsOpts } from './pi/tools.ts'
-export { createBazilionCustomTools, ourToolToPiTool } from './pi/tools.ts'
-export type { CatalogResult, LiveFetchResult } from './providers/catalog.ts'
-export { listCatalogModels, listCatalogModelsSync } from './providers/catalog.ts'
-export type { PiProviderConfig } from './providers/pi-adapter.ts'
-export { piProvider, resolveModel as resolvePiModel } from './providers/pi-adapter.ts'
-export type {
-  ProviderConfig,
-  ProviderMeta,
-  ProviderRegistry,
-  ResolvedModel,
-} from './providers/registry.ts'
-export {
-  createProviderRegistry,
-  listAllProviders,
-  loadProviderConfigFromEnv,
-} from './providers/registry.ts'
-export type { RetryOptions } from './providers/retry.ts'
-export { isRetryableError, withRetry } from './providers/retry.ts'
-export type {
-  Provider,
-  ProviderRequest,
-  ProviderResponse,
-  StopReason,
-} from './providers/types.ts'
-export { buildSystemPrompt } from './session/prompt.ts'
-export { bootstrapTool } from './tools/bootstrap.ts'
-export { memoryTools } from './tools/memory.ts'
-export { messagingTools } from './tools/messaging.ts'
-export { createToolRegistry } from './tools/registry.ts'
-export type { ToolHandler, ToolRegistry } from './tools/types.ts'
-export { webTools } from './tools/web.ts'
-
-export type { MessagingHost } from './worker/ipc-protocol.ts'
-export type { SpawnWorkerOpts } from './worker/spawn.ts'
-export { spawnWorkerTurn } from './worker/spawn.ts'

package/apps/daemon/src/runtime/memory/files.ts

@@ -1,103 +0,0 @@
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  rmSync,
-  statSync,
-  writeFileSync,
-} from 'node:fs'
-import { dirname, join } from 'node:path'
-import type { MemoryEntry, MemoryHit } from '@bazilion/api-types'
-import type { MemoryBackend } from './types.ts'
-
-const SNIPPET_PAD = 60
-
-/**
- * Filesystem-backed memory: every entry is a file under `root`. Search is
- * substring matching across all files. Index = the filesystem itself.
- */
-export function filesBackend(root: string): MemoryBackend {
-  function safe(key: string): string {
-    if (key.includes('..') || key.startsWith('/') || key.includes('\0')) {
-      throw new Error(`unsafe memory key: ${key}`)
-    }
-    return join(root, key)
-  }
-
-  function walk(dir: string, prefix: string, out: MemoryEntry[]): void {
-    if (!existsSync(dir)) return
-    for (const e of readdirSync(dir, { withFileTypes: true })) {
-      const full = join(dir, e.name)
-      const key = prefix ? `${prefix}/${e.name}` : e.name
-      if (e.isDirectory()) {
-        walk(full, key, out)
-      } else if (e.isFile()) {
-        const stats = statSync(full)
-        out.push({
-          key,
-          content: readFileSync(full, 'utf8'),
-          updatedAt: stats.mtimeMs,
-        })
-      }
-    }
-  }
-
-  return {
-    async init() {
-      mkdirSync(root, { recursive: true })
-    },
-
-    async read(key) {
-      const path = safe(key)
-      if (!existsSync(path)) {
-        throw new Error(`memory entry not found: ${key}`)
-      }
-      const stats = statSync(path)
-      return {
-        key,
-        content: readFileSync(path, 'utf8'),
-        updatedAt: stats.mtimeMs,
-      }
-    },
-
-    async write(key, content) {
-      const path = safe(key)
-      mkdirSync(dirname(path), { recursive: true })
-      writeFileSync(path, content)
-      const stats = statSync(path)
-      return { key, content, updatedAt: stats.mtimeMs }
-    },
-
-    async search(query, opts) {
-      const limit = opts?.limit ?? 10
-      const all: MemoryEntry[] = []
-      walk(root, '', all)
-      const q = query.toLowerCase()
-      const hits: MemoryHit[] = []
-      for (const entry of all) {
-        const idx = entry.content.toLowerCase().indexOf(q)
-        if (idx === -1) continue
-        const start = Math.max(0, idx - SNIPPET_PAD)
-        const end = Math.min(entry.content.length, idx + query.length + SNIPPET_PAD)
-        hits.push({
-          key: entry.key,
-          snippet: entry.content.slice(start, end),
-          score: 1,
-        })
-      }
-      return hits.slice(0, limit)
-    },
-
-    async list() {
-      const out: MemoryEntry[] = []
-      walk(root, '', out)
-      return out.sort((a, b) => a.key.localeCompare(b.key))
-    },
-
-    async remove(key) {
-      const path = safe(key)
-      if (existsSync(path)) rmSync(path)
-    },
-  }
-}

package/apps/daemon/src/runtime/memory/qmd.ts

@@ -1,152 +0,0 @@
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  rmSync,
-  statSync,
-  writeFileSync,
-} from 'node:fs'
-import { dirname, join } from 'node:path'
-import type { MemoryEntry, MemoryHit } from '@bazilion/api-types'
-import { createStore, extractSnippet, type QMDStore } from '@tobilu/qmd'
-import type { MemoryBackend } from './types.ts'
-
-const INDEX_FILENAME = '.qmd-index.sqlite'
-const COLLECTION_NAME = 'memory'
-const PATTERN = '**/*.md'
-
-// One store per memory directory per process. createStore opens a SQLite
-// handle; we dedupe so concurrent chat requests for the same agent reuse it.
-const storeCache = new Map<string, Promise<QMDStore>>()
-
-function getStore(dir: string): Promise<QMDStore> {
-  let p = storeCache.get(dir)
-  if (!p) {
-    p = createStore({
-      dbPath: join(dir, INDEX_FILENAME),
-      config: {
-        collections: {
-          [COLLECTION_NAME]: { path: dir, pattern: PATTERN },
-        },
-      },
-    })
-    storeCache.set(dir, p)
-  }
-  return p
-}
-
-function safeKey(root: string, key: string): string {
-  if (key.includes('..') || key.startsWith('/') || key.includes('\0')) {
-    throw new Error(`unsafe memory key: ${key}`)
-  }
-  return join(root, key)
-}
-
-function walkMd(dir: string, prefix: string, out: MemoryEntry[]): void {
-  if (!existsSync(dir)) return
-  for (const e of readdirSync(dir, { withFileTypes: true })) {
-    if (e.name.startsWith('.')) continue // skip .qmd-index.sqlite and friends
-    const full = join(dir, e.name)
-    const key = prefix ? `${prefix}/${e.name}` : e.name
-    if (e.isDirectory()) {
-      walkMd(full, key, out)
-    } else if (e.isFile() && e.name.endsWith('.md')) {
-      const stats = statSync(full)
-      out.push({
-        key,
-        content: readFileSync(full, 'utf8'),
-        updatedAt: stats.mtimeMs,
-      })
-    }
-  }
-}
-
-/**
- * Memory backend backed by @tobilu/qmd — BM25 keyword search over markdown
- * files under `root`. Writes markdown to disk, then asks qmd to reindex.
- *
- * Uses `searchLex` only; no embeddings, no LLM rerank, no model download.
- * The hybrid `search()` / `searchVector()` paths exist in the qmd SDK and
- * can be wired in later if we want semantic search — they'd add a dependency
- * on `node-llama-cpp` and several GB of GGUF models.
- */
-export function qmdBackend(root: string): MemoryBackend {
-  return {
-    async init() {
-      mkdirSync(root, { recursive: true })
-      // Opening the store + initial scan. update() is idempotent.
-      const store = await getStore(root)
-      await store.update()
-    },
-
-    async read(key) {
-      const path = safeKey(root, key)
-      if (!existsSync(path)) {
-        throw new Error(`memory entry not found: ${key}`)
-      }
-      const stats = statSync(path)
-      return {
-        key,
-        content: readFileSync(path, 'utf8'),
-        updatedAt: stats.mtimeMs,
-      }
-    },
-
-    async write(key, content) {
-      const path = safeKey(root, key)
-      mkdirSync(dirname(path), { recursive: true })
-      writeFileSync(path, content)
-      const stats = statSync(path)
-      // Reindex so the newly-written file is searchable on the next search().
-      // update() re-scans the collection; for typical memory sizes (tens of
-      // files) this is sub-millisecond.
-      const store = await getStore(root)
-      await store.update()
-      return { key, content, updatedAt: stats.mtimeMs }
-    },
-
-    async search(query, opts) {
-      const limit = opts?.limit ?? 10
-      const store = await getStore(root)
-      const results = await store.searchLex(query, {
-        limit,
-        collection: COLLECTION_NAME,
-      })
-      const hits: MemoryHit[] = []
-      for (const r of results) {
-        // qmd's filepath is a synthetic URI (`qmd://<collection>/<path>`);
-        // displayPath is collection-prefixed (`<collection>/<path>`). Strip
-        // the leading `<collection>/` to get the key the caller wrote.
-        const prefix = `${COLLECTION_NAME}/`
-        const key = r.displayPath.startsWith(prefix)
-          ? r.displayPath.slice(prefix.length)
-          : r.displayPath
-        let content = r.body ?? ''
-        if (!content) {
-          try {
-            content = readFileSync(join(root, key), 'utf8')
-          } catch {
-            content = ''
-          }
-        }
-        const snippet = extractSnippet(content, query).snippet
-        hits.push({ key, snippet, score: r.score })
-      }
-      return hits
-    },
-
-    async list() {
-      const out: MemoryEntry[] = []
-      walkMd(root, '', out)
-      return out.sort((a, b) => a.key.localeCompare(b.key))
-    },
-
-    async remove(key) {
-      const path = safeKey(root, key)
-      if (existsSync(path)) rmSync(path)
-      const store = await getStore(root)
-      await store.update()
-    },
-  }
-}

package/apps/daemon/src/runtime/memory/types.ts

@@ -1,16 +0,0 @@
-import type { MemoryEntry, MemoryHit } from '@bazilion/api-types'
-
-export interface MemoryBackend {
-  /** Initialize storage. Idempotent. */
-  init(): Promise<void>
-  /** Read a memory entry by key. Throws if missing. */
-  read(key: string): Promise<MemoryEntry>
-  /** Write or overwrite a memory entry. */
-  write(key: string, content: string): Promise<MemoryEntry>
-  /** Search memory for matches against a query string. */
-  search(query: string, opts?: { limit?: number }): Promise<MemoryHit[]>
-  /** List all entries (sorted by key). */
-  list(): Promise<MemoryEntry[]>
-  /** Delete an entry. No-op if missing. */
-  remove(key: string): Promise<void>
-}

package/apps/daemon/src/runtime/pi/events.ts

@@ -1,173 +0,0 @@
-// Translator: pi `AgentSessionEvent` → Bazilion `SessionEvent[]`.
-//
-// The worker's NDJSON wire format (`ChatFrame`) is still the same discrete
-// event stream CLI / browser clients know how to render. This module is the
-// adapter at the single choke-point — pi event in, zero-or-more Bazilion
-// events out.
-//
-// Coverage:
-//   - user message_start   → one `user_message`
-//   - assistant text_delta → one `assistant_delta` per chunk
-//   - assistant message_end:
-//       - if the message carries text   → one `assistant_message`
-//       - for every tool-call content   → one `tool_call`
-//   - tool_execution_end   → `tool_result` or `tool_error` based on isError
-//   - message_end with aborted/error stopReason → one `error`
-//
-// Not surfaced (intentional):
-//   - agent_start / agent_end      — run-row lifecycle, not chat events
-//   - turn_start / turn_end        — too chatty, nothing to render
-//   - message_start (assistant)    — text will come via updates + end
-//   - message_update (non-text)    — thinking deltas etc; left for a later
-//                                    pass when UIs render thinking blocks
-//   - queue_update / compaction_*  — session meta, not assistant output
-//   - auto_retry_*                 — silently retried, user sees only the
-//                                    eventual success or failure
-
-import type { ProviderMessage, SessionEvent, ToolCall } from '@bazilion/api-types'
-import type { AgentMessage, AgentToolResult } from '@mariozechner/pi-agent-core'
-import type { AssistantMessage } from '@mariozechner/pi-ai'
-import type { AgentSessionEvent } from '@mariozechner/pi-coding-agent'
-
-export function translatePiEvent(e: AgentSessionEvent): SessionEvent[] {
-  switch (e.type) {
-    case 'message_start': {
-      if (e.message.role === 'user') {
-        return [{ type: 'user_message', text: stringifyContent(e.message.content) }]
-      }
-      return []
-    }
-
-    case 'message_update': {
-      const inner = e.assistantMessageEvent
-      if (inner.type === 'text_delta') {
-        return [{ type: 'assistant_delta', delta: inner.delta }]
-      }
-      return []
-    }
-
-    case 'message_end': {
-      const m = e.message
-      if (m.role !== 'assistant') return []
-      const out: SessionEvent[] = []
-      const text = extractAssistantText(m as AssistantMessage)
-      if (text) out.push({ type: 'assistant_message', text })
-      for (const block of (m as AssistantMessage).content ?? []) {
-        if (block.type === 'toolCall') {
-          out.push({
-            type: 'tool_call',
-            id: block.id,
-            name: block.name,
-            arguments: JSON.stringify(block.arguments ?? {}),
-          })
-        }
-      }
-      const stopReason = (m as AssistantMessage).stopReason
-      if (stopReason === 'aborted' || stopReason === 'error') {
-        const errText = (m as AssistantMessage).errorMessage ?? stopReason
-        out.push({ type: 'error', error: errText })
-      }
-      return out
-    }
-
-    case 'tool_execution_end': {
-      const text = extractToolResultText(e.result)
-      if (e.isError) {
-        return [{ type: 'tool_error', id: e.toolCallId, name: e.toolName, error: text }]
-      }
-      return [{ type: 'tool_result', id: e.toolCallId, name: e.toolName, result: text }]
-    }
-
-    default:
-      return []
-  }
-}
-
-export function extractAssistantText(m: AssistantMessage): string {
-  let out = ''
-  for (const block of m.content ?? []) {
-    if (block.type === 'text') out += block.text
-  }
-  return out
-}
-
-export function extractAssistantToolCalls(m: AssistantMessage): ToolCall[] {
-  const out: ToolCall[] = []
-  for (const block of m.content ?? []) {
-    if (block.type === 'toolCall') {
-      out.push({ id: block.id, name: block.name, arguments: JSON.stringify(block.arguments ?? {}) })
-    }
-  }
-  return out
-}
-
-/** Flatten `AgentToolResult.content` blocks into a single string — matches the
- *  shape Bazilion tools always returned before pi adoption. */
-export function extractToolResultText(result: unknown): string {
-  const r = result as AgentToolResult<unknown> | undefined
-  if (!r?.content) return ''
-  let out = ''
-  for (const block of r.content) {
-    if (block.type === 'text') out += block.text
-  }
-  return out
-}
-
-/** Stringify a pi user-message content array. */
-function stringifyContent(content: unknown): string {
-  if (typeof content === 'string') return content
-  if (!Array.isArray(content)) return ''
-  let out = ''
-  for (const block of content as { type: string; text?: string }[]) {
-    if (block.type === 'text' && typeof block.text === 'string') out += block.text
-  }
-  return out
-}
-
-/**
- * Convert pi's authoritative `session.state.messages` (AgentMessage[]) into
- * Bazilion's ProviderMessage[] shape, so the `done` ChatFrame stays
- * compatible with browser + CLI clients that rehydrate from it.
- *
- * Notes on role mapping: pi uses `"toolResult"` for tool-response messages;
- * Bazilion uses `"tool"`. AssistantMessage content arrays become either
- * `content` string (text blocks joined) or a `toolCalls` array (toolCall
- * blocks converted).
- */
-export function piMessagesToProviderView(messages: AgentMessage[]): ProviderMessage[] {
-  const out: ProviderMessage[] = []
-  for (const m of messages) {
-    // Custom Bazilion message types would land in this switch too, but we
-    // don't register any via CustomAgentMessages declaration merging yet.
-    switch (m.role) {
-      case 'user': {
-        out.push({ role: 'user', content: stringifyContent((m as { content: unknown }).content) })
-        break
-      }
-      case 'assistant': {
-        const am = m as AssistantMessage
-        const text = extractAssistantText(am)
-        const toolCalls = extractAssistantToolCalls(am)
-        const msg: ProviderMessage = { role: 'assistant', content: text }
-        if (toolCalls.length > 0) msg.toolCalls = toolCalls
-        out.push(msg)
-        break
-      }
-      case 'toolResult': {
-        const tr = m as { content: unknown; toolCallId?: string; toolName?: string }
-        out.push({
-          role: 'tool',
-          content: stringifyContent(tr.content),
-          toolCallId: tr.toolCallId,
-          toolName: tr.toolName,
-        })
-        break
-      }
-      default:
-        // System and other unknown roles are skipped — the runtime's system
-        // prompt is already wired via pi's settingsManager + our buildSystemPrompt.
-        break
-    }
-  }
-  return out
-}