@100xprompt/brain 0.0.0-stage → 0.1.1

package/src/adapters/opencode/reader.ts

@@ -0,0 +1,452 @@
+import type { Database } from "bun:sqlite"
+import { dirname, join } from "node:path"
+import { exists, gitInfo, ls, readJson } from "../../fsutil.ts"
+import { withSnapshot } from "../../sqlite.ts"
+import type { Attachment, Session, Turn, Usage } from "../../session/types.ts"
+import { asText, clip, header, iso, lossCounter, noteModel, toolKindOf } from "../../session/util.ts"
+import type { Reader, SessionRef } from "../types.ts"
+import { compareIds } from "./ids.ts"
+import { CONTINUED_NOTE } from "./note.ts"
+import { listV2Db, readV2Db } from "./v2.ts"
+
+// OpenCode 1.x and 100xprompt, its fork (catalogue entries 8, 9 and 71). Both keep a session as an info
+// record, its messages, and each message's parts; a tool call and its result are one `tool` part keyed by
+// callID. Two stores hold that same shape:
+//   <data>/storage/session/<projectID>/<sessionID>.json, message/<sessionID>/<messageID>.json,
+//     part/<messageID>/<partID>.json: 100xprompt today, OpenCode before 2026
+//   <data>/opencode.db (opencode-<channel>.db on other channels): OpenCode 1.x since 2026, tables session,
+//     message and part, with each message's and part's JSON in a `data` column, less its ids
+// 100xprompt's own 100xprompt.db and store.db are abandoned stores the runtime never opens, so they are not read.
+// OpenCode 2.x keeps the same file with a different schema (session_v2, session_message), read by v2.ts.
+// Kilo CLI is a fork with the 1.x tables in <data>/kilo.db (kilo-cli/).
+
+/** A session as `export` writes it: the info record and every message with its parts, oldest first. */
+export interface Bundle {
+  info: Record<string, any>
+  messages: Array<{ info: Record<string, any>; parts: Array<Record<string, any>> }>
+}
+
+interface Family {
+  tool: string
+  label: string
+  /** Folder name under ~/.local/share. */
+  app: string
+  /** Whether the tool also keeps sessions in SQLite. */
+  sqlite: boolean
+}
+
+/** One store's sessions by id. */
+interface Store {
+  bundle(id: string): { bundle: Bundle; path: string; bad: number } | undefined
+  children(id: string): string[]
+}
+
+const dataDir = (home: string, app: string) => join(home, ".local", "share", app)
+
+/** A real session record: test leftovers and half-written files under session/ have no `ses` id or no times. */
+const isSession = (v: any): v is Record<string, any> =>
+  !!v && typeof v === "object" && typeof v.id === "string" && v.id.startsWith("ses") && typeof v.time?.created === "number"
+
+export function familyReader(f: Family): Reader {
+  return {
+    tool: f.tool,
+    label: f.label,
+    async list(home) {
+      const refs: SessionRef[] = []
+      const seen = new Set<string>()
+      if (f.sqlite)
+        for (const db of dbFiles(home, f.app)) {
+          try {
+            for (const r of withSnapshot(db, (d) => [...listDb(d, db, f.tool), ...listV2Db(d, db, f.tool)])) {
+              if (seen.has(r.sourceId)) continue
+              seen.add(r.sourceId)
+              refs.push(r)
+            }
+          } catch {
+            // A database that cannot be copied or opened lists nothing; read() reports why for a session in it.
+          }
+        }
+      const sessions = join(dataDir(home, f.app), "storage", "session")
+      for (const project of ls(sessions))
+        for (const name of ls(join(sessions, project))) {
+          if (!name.endsWith(".json")) continue
+          const path = join(sessions, project, name)
+          const info = readJson(path)
+          // Subagent sessions are read as children of the session that started them.
+          if (!isSession(info) || info.parentID || seen.has(info.id)) continue
+          seen.add(info.id)
+          refs.push({
+            tool: f.tool,
+            sourceId: info.id,
+            path,
+            ...(typeof info.title === "string" ? { title: info.title } : {}),
+            ...(typeof info.directory === "string" ? { cwd: info.directory } : {}),
+            ...(iso(info.time.updated) ? { updatedAt: iso(info.time.updated)! } : {}),
+            extra: { source: "json", projectID: project },
+          })
+        }
+      return refs.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))
+    },
+    async read(ref) {
+      if (ref.extra?.source === "db2") {
+        if (!exists(ref.path)) throw new Error(`database not found: ${ref.path}`)
+        return withSnapshot(ref.path, (d) => readV2Db(d, ref.path, f.tool, ref.sourceId))
+      }
+      if (ref.extra?.source === "db" || ref.path.endsWith(".db")) {
+        if (!exists(ref.path)) throw new Error(`database not found: ${ref.path}`)
+        return withSnapshot(ref.path, (d) => readDb(d, ref.path, f.tool, ref.sourceId))
+      }
+      if (!exists(ref.path)) throw new Error(`session file not found: ${ref.path}`)
+      return toSession(f.tool, jsonStore(ref.path), ref.sourceId)
+    },
+  }
+}
+
+function dbFiles(home: string, app: string): string[] {
+  return ls(dataDir(home, app))
+    .filter((n) => new RegExp(`^${app}(-[\\w.-]+)?\\.db$`).test(n))
+    .map((n) => join(dataDir(home, app), n))
+}
+
+/** Top-level sessions in an open v1 database (the reader opens a snapshot of it); none in a 2.x database. */
+export function listDb(d: Database, path: string, tool: string): SessionRef[] {
+  if (!hasTable(d, "session")) return []
+  const rows = d.query("SELECT id, title, directory, time_updated, project_id FROM session WHERE parent_id IS NULL").all() as Array<Record<string, any>>
+  return rows.map((r) => ({
+    tool,
+    sourceId: String(r.id),
+    path,
+    ...(r.title ? { title: String(r.title) } : {}),
+    ...(r.directory ? { cwd: String(r.directory) } : {}),
+    ...(iso(r.time_updated) ? { updatedAt: iso(r.time_updated)! } : {}),
+    extra: { source: "db", projectID: r.project_id },
+  }))
+}
+
+/** One session from an open v1 database, with its subagent sessions. */
+export function readDb(d: Database, path: string, tool: string, id: string): Session {
+  if (!hasTable(d, "session")) throw new Error(`no v1 session table in ${path} (an OpenCode 2.x database is read by readV2Db)`)
+  return toSession(tool, dbStore(d, path), id)
+}
+
+function hasTable(d: Database, name: string): boolean {
+  return !!d.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(name)
+}
+
+function dbStore(d: Database, path: string): Store {
+  const json = (s: unknown) => {
+    try {
+      return JSON.parse(String(s)) as Record<string, any>
+    } catch {
+      return undefined
+    }
+  }
+  return {
+    bundle(id) {
+      const s = d.query("SELECT * FROM session WHERE id = ?").get(id) as Record<string, any> | null
+      if (!s) return undefined
+      const info = {
+        id: s.id,
+        projectID: s.project_id,
+        directory: s.directory,
+        title: s.title,
+        version: s.version,
+        ...(s.parent_id ? { parentID: s.parent_id } : {}),
+        time: { created: s.time_created, updated: s.time_updated },
+      }
+      let bad = 0
+      const parts = new Map<string, Array<Record<string, any>>>()
+      for (const p of d.query("SELECT id, message_id, data FROM part WHERE session_id = ?").all(id) as Array<Record<string, any>>) {
+        const data = json(p.data)
+        if (!data) {
+          bad++
+          continue
+        }
+        const list = parts.get(p.message_id) ?? []
+        list.push({ ...data, id: p.id, sessionID: id, messageID: p.message_id })
+        parts.set(p.message_id, list)
+      }
+      const messages: Bundle["messages"] = []
+      for (const m of d.query("SELECT id, time_created, data FROM message WHERE session_id = ?").all(id) as Array<Record<string, any>>) {
+        const data = json(m.data)
+        if (!data) {
+          bad++
+          continue
+        }
+        messages.push({ info: { time: { created: m.time_created }, ...data, id: m.id, sessionID: id }, parts: parts.get(m.id) ?? [] })
+      }
+      return { bundle: { info, messages }, path, bad }
+    },
+    children(id) {
+      return (d.query("SELECT id FROM session WHERE parent_id = ?").all(id) as Array<{ id: string }>).map((r) => r.id)
+    },
+  }
+}
+
+/** The JSON store a session file belongs to: <root>/session/<projectID>/<id>.json. */
+function jsonStore(sessionFile: string): Store {
+  const projectDir = dirname(sessionFile)
+  const root = dirname(dirname(projectDir))
+  let infos: Map<string, Record<string, any>> | undefined
+  // Every session record in the project, read once: children are found by their parentID.
+  const project = () => {
+    if (!infos) {
+      infos = new Map()
+      for (const n of ls(projectDir)) {
+        const v = n.endsWith(".json") ? readJson(join(projectDir, n)) : undefined
+        if (isSession(v)) infos.set(v.id, v)
+      }
+    }
+    return infos
+  }
+  return {
+    bundle(id) {
+      const path = join(projectDir, `${id}.json`)
+      const info = readJson(path) ?? project().get(id)
+      if (!isSession(info)) return undefined
+      let bad = 0
+      const messages: Bundle["messages"] = []
+      for (const n of ls(join(root, "message", id))) {
+        if (!n.endsWith(".json")) continue
+        const m = readJson<Record<string, any>>(join(root, "message", id, n))
+        if (!m || typeof m.id !== "string") {
+          bad++
+          continue
+        }
+        const parts: Array<Record<string, any>> = []
+        for (const pn of ls(join(root, "part", m.id))) {
+          if (!pn.endsWith(".json")) continue
+          const p = readJson<Record<string, any>>(join(root, "part", m.id, pn))
+          if (p && typeof p.type === "string") parts.push(p)
+          else bad++
+        }
+        messages.push({ info: m, parts })
+      }
+      return { bundle: { info, messages }, path, bad }
+    },
+    children(id) {
+      return [...project().values()].filter((s) => s.parentID === id).map((s) => s.id as string)
+    },
+  }
+}
+
+/** Parts that carry nothing a conversation needs: step bounds, snapshot ids, @agent mentions, retry records. */
+const SKIPPED_PARTS = new Set(["step-start", "step-finish", "snapshot", "agent", "retry"])
+
+function toSession(tool: string, store: Store, id: string, depth = 0): Session {
+  const got = store.bundle(id)
+  if (!got) throw new Error(`session ${id} not found`)
+  const s = bundleToSession(tool, got.bundle, got.path)
+  if (got.bad) s.header.lost.push(`unreadable message or part records (${got.bad})`)
+  // Subagent sessions, two levels down at most: a child's own children are rarely worth the reading time.
+  if (depth < 2) {
+    const children: Session[] = []
+    for (const childId of store.children(id)) {
+      try {
+        children.push(toSession(tool, store, childId, depth + 1))
+      } catch {
+        s.header.lost.push(`unreadable subagent session (${childId})`)
+      }
+    }
+    if (children.length) s.children = children
+  }
+  return s
+}
+
+/** The portable session for an export-shaped bundle. Exported for tests and for reading `export` files. */
+export function bundleToSession(tool: string, b: Bundle, sourcePath?: string): Session {
+  const info = b.info
+  const cwd = typeof info.directory === "string" ? info.directory : undefined
+  const h = header(tool, String(info.id), {
+    ...(typeof info.version === "string" ? { toolVersion: info.version } : {}),
+    ...(sourcePath ? { sourcePath } : {}),
+    ...(typeof info.title === "string" ? { title: info.title } : {}),
+    project: { ...(cwd ? { cwd } : {}), ...gitInfo(cwd) },
+    ...(iso(info.time?.created) ? { startedAt: iso(info.time.created)! } : {}),
+    ...(iso(info.time?.updated) ? { updatedAt: iso(info.time.updated)! } : {}),
+    ...(info.parentID ? { parent: { id: `${tool}:${info.parentID}`, kind: "subagent" as const } } : {}),
+  })
+  const lost = lossCounter()
+  const turns: Turn[] = []
+  const callIds = new Set<string>()
+  const now = Date.now()
+  const messages = [...b.messages].sort((x, y) => (x.info.time?.created ?? 0) - (y.info.time?.created ?? 0) || compareIds(String(x.info.id), String(y.info.id), now))
+
+  for (const { info: m, parts: unsorted } of messages) {
+    const parts = [...unsorted].sort((x, y) => compareIds(String(x.id), String(y.id), now))
+    const msgAt = iso(m.time?.created)
+    if (m.role === "user") {
+      // The user message that asks for a compaction holds only a `compaction` part; its summary follows.
+      if (parts.some((p) => p.type === "compaction")) continue
+      // A user-role message the tool injected (a "continue" nudge, the verification gate, a background
+      // notification) is not the person's: 100xprompt tells them apart the same way (MessageV2.userAuthored).
+      if (!userAuthored(parts)) {
+        const texts = parts.filter((p) => p.type === "text" && typeof p.text === "string" && p.text.trim())
+        // brain's note on a continued session says where it came from; it is not a turn.
+        const continued = texts.length === 1 ? String(texts[0]!.text).match(CONTINUED_NOTE)?.[1] : undefined
+        if (continued) h.parent ??= { id: continued, kind: "continued" }
+        else if (texts.length) lost.add("messages the tool injected as the user")
+        continue
+      }
+      const own: string[] = []
+      const injected: string[] = []
+      const attachments: Attachment[] = []
+      for (const p of parts) {
+        if (p.type === "text") {
+          if (p.ignored || typeof p.text !== "string" || !p.text.trim()) continue
+          // Synthetic text is what the tool added (a mentioned file's contents, a reminder): kept after the person's words.
+          ;(p.synthetic ? injected : own).push(p.text)
+        } else if (p.type === "file") attachments.push(attachmentOf(p, lost))
+        else if (p.type === "compaction" || SKIPPED_PARTS.has(p.type)) continue
+        else if (p.type === "subtask") lost.add("subtask parts")
+        else if (p.type === "tombstone") lost.add("parts the tool had removed")
+        else lost.add(`unknown part types: ${String(p.type)}`)
+      }
+      const text = [...own, ...injected].join("\n\n")
+      if (text || attachments.length) turns.push({ kind: "user", ...(msgAt ? { at: msgAt } : {}), text, ...(attachments.length ? { attachments } : {}) })
+      continue
+    }
+    if (m.role !== "assistant") {
+      lost.add(`unknown message roles: ${String(m.role)}`)
+      continue
+    }
+    if (m.error && typeof m.error === "object") lost.add("error notices on replies")
+    if (m.summary === true) {
+      // 100xprompt's summary message also carries synthetic parts sent only to the model: files re-read after
+      // the compaction, the last messages verbatim (already turns here) and an instruction to carry on.
+      const texts = parts.filter((p) => p.type === "text" && typeof p.text === "string" && p.text.trim())
+      const shown = texts.filter((p) => !p.synthetic)
+      if (shown.length && shown.length < texts.length) lost.add("context the tool re-attached after a compaction")
+      const summary = (shown.length ? shown : texts).map((p) => p.text).join("\n\n")
+      if (summary.trim()) turns.push({ kind: "compaction", ...(msgAt ? { at: msgAt } : {}), summary })
+      continue
+    }
+    const model = typeof m.modelID === "string" ? m.modelID : undefined
+    if (model && parts.some((p) => (p.type === "text" && !p.synthetic) || p.type === "tool")) noteModel(h, model)
+    let usage = usageOf(m.tokens)
+    const edited = new Set<string>()
+    for (const p of parts) {
+      switch (p.type) {
+        case "text": {
+          if (typeof p.text !== "string" || !p.text.trim()) break
+          // Synthetic text on a reply is the tool's note (the verification gate's verdict), not the model's answer.
+          if (p.synthetic) {
+            lost.add("notes the tool added to replies")
+            break
+          }
+          const at = iso(p.time?.start) ?? msgAt
+          turns.push({ kind: "assistant", ...(at ? { at } : {}), text: p.text, ...(model ? { model } : {}), ...(usage ? { usage } : {}) })
+          usage = undefined // the message's usage goes on its first text turn
+          break
+        }
+        case "reasoning": {
+          const signed = hasProviderData(p.metadata)
+          if (typeof p.text === "string" && p.text.trim()) {
+            const at = iso(p.time?.start) ?? msgAt
+            turns.push({ kind: "reasoning", ...(at ? { at } : {}), text: p.text })
+            if (signed) lost.add("reasoning signatures")
+          } else if (signed) lost.add("signed reasoning")
+          break
+        }
+        case "tool":
+          toolTurns(tool, p, turns, callIds, edited, lost)
+          break
+        case "patch":
+          // The files a step changed, from the tool's snapshots: those not already shown by an edit tool's diff.
+          for (const file of Array.isArray(p.files) ? p.files : [])
+            if (typeof file === "string" && !edited.has(file)) {
+              edited.add(file)
+              turns.push({ kind: "file_edit", ...(msgAt ? { at: msgAt } : {}), path: file })
+            }
+          break
+        case "file":
+          lost.add("files attached to assistant messages")
+          break
+        case "tombstone":
+          lost.add("parts the tool had removed")
+          break
+        default:
+          if (!SKIPPED_PARTS.has(p.type) && p.type !== "compaction") lost.add(`unknown part types: ${String(p.type)}`)
+      }
+    }
+  }
+  lost.flush(h)
+  return { header: h, turns }
+}
+
+function toolTurns(tool: string, p: Record<string, any>, turns: Turn[], callIds: Set<string>, edited: Set<string>, lost: ReturnType<typeof lossCounter>) {
+  const st = (p.state ?? {}) as Record<string, any>
+  const md = (st.metadata ?? {}) as Record<string, any>
+  const name = String(p.tool ?? "unknown")
+  // Call ids are the provider's; some providers repeat them across a session, and turns need them unique.
+  let id = String(p.callID ?? p.id)
+  for (let n = 2; callIds.has(id); n++) id = `${String(p.callID ?? p.id)}#${n}`
+  callIds.add(id)
+  const input = st.input ?? {}
+  const start = iso(st.time?.start)
+  const end = iso(st.time?.end) ?? start
+  if (hasProviderData(p.metadata)) lost.add("tool-call signatures")
+  turns.push({ kind: "tool_call", ...(start ? { at: start } : {}), id, name, toolKind: toolKindOf(name), input })
+  if (st.status === "completed" || st.status === "error") {
+    if (Array.isArray(st.attachments) && st.attachments.length) lost.add("attachments in tool results", st.attachments.length)
+    const raw = st.status === "completed" ? asText(st.output) : asText(st.error)
+    const c = clip(raw)
+    // Long outputs were spilled to a file by the tool itself; point at it when it is still there.
+    const full = typeof md.outputPath === "string" && exists(md.outputPath) ? md.outputPath : undefined
+    const truncated = c.truncated || md.truncated === true
+    turns.push({
+      kind: "tool_result",
+      ...(end ? { at: end } : {}),
+      callId: id,
+      ok: st.status === "completed",
+      output: c.text,
+      ...(truncated ? { truncated: true } : {}),
+      ...(full && truncated ? { fullPath: full } : {}),
+    })
+  }
+  // Edit tools record the diff they applied.
+  const file = md.filediff?.file ?? input.filePath ?? input.file_path ?? input.path
+  if (typeof md.diff === "string" && md.diff && typeof file === "string") {
+    edited.add(file)
+    turns.push({ kind: "file_edit", ...(end ? { at: end } : {}), path: file, patch: clip(md.diff).text, callId: id })
+  }
+  // The task tool names the subagent session it ran.
+  if (typeof md.sessionId === "string" && md.sessionId.startsWith("ses"))
+    turns.push({
+      kind: "subagent",
+      ...(end ? { at: end } : {}),
+      sessionId: `${tool}:${md.sessionId}`,
+      callId: id,
+      ...(typeof input.description === "string" ? { description: input.description } : {}),
+    })
+}
+
+/** Whether the person wrote a user message: their own text, a file, an @agent mention or a subtask (100xprompt's MessageV2.userAuthored). */
+function userAuthored(parts: Array<Record<string, any>>): boolean {
+  return parts.some(
+    (p) => (p.type === "text" && !p.synthetic && typeof p.text === "string" && p.text.trim()) || p.type === "file" || p.type === "agent" || p.type === "subtask",
+  )
+}
+
+function usageOf(t: any): Usage | undefined {
+  if (!t || typeof t !== "object") return undefined
+  const u: Usage = {}
+  if (typeof t.input === "number") u.input = t.input
+  if (typeof t.output === "number") u.output = t.output
+  if (typeof t.cache?.read === "number") u.cacheRead = t.cache.read
+  if (typeof t.cache?.write === "number") u.cacheWrite = t.cache.write
+  return Object.values(u).some((v) => v) ? u : undefined
+}
+
+/** Provider replay data on a part: Anthropic signatures, OpenRouter reasoning_details, Gemini thought signatures, OpenAI item ids. */
+function hasProviderData(md: unknown): boolean {
+  return !!md && typeof md === "object" && Object.values(md as Record<string, unknown>).some((v) => v && typeof v === "object" && Object.keys(v).length > 0)
+}
+
+function attachmentOf(p: Record<string, any>, lost: ReturnType<typeof lossCounter>): Attachment {
+  const url = typeof p.url === "string" ? p.url : ""
+  const path = url.startsWith("file://") ? decodeURIComponent(url.slice(7)) : undefined
+  if (!path) lost.add("attachment data")
+  const kind = typeof p.mime === "string" && p.mime.startsWith("image/") ? "image" : "file"
+  return { kind, ...(path ? { path } : {}), ...(typeof p.mime === "string" ? { mime: p.mime } : {}), ...(typeof p.filename === "string" ? { name: p.filename } : {}) }
+}

package/src/adapters/opencode/tools.ts

@@ -0,0 +1,174 @@
+import type { ToolKind } from "../../session/types.ts"
+
+// A foreign tool call written as the target's own tool: the same tool name and the argument names that tool
+// takes, so the TUI draws it as one of its own and the model sees calls shaped like the tools it has. A call
+// whose arguments do not fit (apply_patch, MCP tools, anything unknown) keeps its own name and input.
+// Shared by OpenCode 1.x, 100xprompt, Kilo, OpenCode 2.x and Crush, whose tools differ in name and key style.
+
+export interface Dialect {
+  read: string
+  write: string
+  edit: string
+  shell: string
+  glob: string
+  grep: string
+  /** The folder-listing tool; without one, read is given the folder (OpenCode's read lists directories). */
+  list?: string
+  fetch: string
+  search: string
+  task: string
+  todo: string
+  /** The agent a session runs as: OpenCode's `build`, Kilo's `code` (corpus captures of OpenCode 1.17.20 and Kilo 7.5.0). */
+  agent?: string
+  keys: {
+    file: string
+    oldString: string
+    newString: string
+    replaceAll: string
+    workdir: string
+    /** The subagent tool's key for the agent to run; Crush's agent tool takes only a prompt. */
+    agent?: string
+  }
+}
+
+const V1_KEYS = { file: "filePath", oldString: "oldString", newString: "newString", replaceAll: "replaceAll", workdir: "workdir", agent: "subagent_type" }
+
+/** OpenCode 1.18 and Kilo 7.8 (packages/opencode/src/tool). */
+export const OPENCODE_V1: Dialect = { read: "read", write: "write", edit: "edit", shell: "bash", glob: "glob", grep: "grep", fetch: "webfetch", search: "websearch", task: "task", todo: "todowrite", keys: V1_KEYS }
+
+/** Kilo 7.x: OpenCode 1.x's tools under Kilo's own default agent, `code`. */
+export const KILO_V1: Dialect = { ...OPENCODE_V1, agent: "code" }
+
+/** 100xprompt kept OpenCode's tools and its list tool (src/6-harness/tool). */
+export const HUNDREDX: Dialect = { ...OPENCODE_V1, list: "list" }
+
+/** OpenCode 2.x (packages/core/src/tool/plugin): shell, subagent, and `path` for files. */
+export const OPENCODE_V2: Dialect = {
+  ...OPENCODE_V1,
+  shell: "shell",
+  task: "subagent",
+  keys: { ...V1_KEYS, file: "path", agent: "agent" },
+}
+
+/** Crush (internal/agent/tools): Claude-style snake_case arguments. */
+export const CRUSH: Dialect = {
+  read: "view",
+  write: "write",
+  edit: "edit",
+  shell: "bash",
+  glob: "glob",
+  grep: "grep",
+  list: "ls",
+  fetch: "fetch",
+  search: "web_search",
+  task: "agent",
+  todo: "todos",
+  keys: { file: "file_path", oldString: "old_string", newString: "new_string", replaceAll: "replace_all", workdir: "working_dir" },
+}
+
+const str = (v: unknown) => (typeof v === "string" && v ? v : undefined)
+const firstOf = (input: Record<string, unknown>, keys: string[]) => keys.map((k) => str(input[k])).find(Boolean)
+
+const FILE_KEYS = ["filePath", "file_path", "path", "target_file", "absolute_path", "file"]
+const DIR_KEYS = ["path", "dir", "directory", "target_directory", "relative_workspace_path"]
+
+/** A shell command as one line: Codex passes ["bash", "-lc", "…"]. */
+function commandOf(v: unknown): string | undefined {
+  if (typeof v === "string") return v || undefined
+  if (!Array.isArray(v) || !v.every((x) => typeof x === "string") || !v.length) return undefined
+  const [shell, flag, script] = v as string[]
+  if (v.length === 3 && /^(ba|z)?sh$/.test(shell!.split("/").pop()!) && /^-l?c$/.test(flag!)) return script
+  return v.join(" ")
+}
+
+/** The target's own tool for a call, or undefined when its arguments do not fit one. */
+export function nativeCall(d: Dialect, name: string, kind: ToolKind, input: Record<string, unknown>): { tool: string; input: Record<string, unknown> } | undefined {
+  const k = d.keys
+  switch (kind) {
+    case "read": {
+      const file = firstOf(input, FILE_KEYS)
+      if (!file) return undefined
+      const range = Object.fromEntries(["offset", "limit"].filter((x) => typeof input[x] === "number").map((x) => [x, input[x]]))
+      return { tool: d.read, input: { [k.file]: file, ...range } }
+    }
+    case "write": {
+      const file = firstOf(input, FILE_KEYS)
+      const content = [input.content, input.contents, input.file_text].find((v) => typeof v === "string")
+      if (!file || content === undefined) return undefined
+      return { tool: d.write, input: { [k.file]: file, content } }
+    }
+    case "edit": {
+      const file = firstOf(input, FILE_KEYS)
+      const oldString = [input.oldString, input.old_string, input.old_str].find((v) => typeof v === "string")
+      const newString = [input.newString, input.new_string, input.new_str].find((v) => typeof v === "string")
+      if (!file || oldString === undefined || newString === undefined) return undefined
+      const all = [input.replaceAll, input.replace_all].find((v) => typeof v === "boolean")
+      return { tool: d.edit, input: { [k.file]: file, [k.oldString]: oldString, [k.newString]: newString, ...(all !== undefined ? { [k.replaceAll]: all } : {}) } }
+    }
+    case "shell": {
+      const command = commandOf(input.command ?? input.cmd)
+      if (!command) return undefined
+      const workdir = firstOf(input, ["workdir", "cwd", "working_dir", "workingDirectory"])
+      const description = str(input.description)
+      return { tool: d.shell, input: { command, ...(description ? { description } : {}), ...(workdir ? { [k.workdir]: workdir } : {}) } }
+    }
+    case "search": {
+      const pattern = firstOf(input, ["pattern", "query", "regex", "glob_pattern"])
+      if (!pattern) return undefined
+      const path = firstOf(input, DIR_KEYS)
+      if (/glob|find_?files|file_search/i.test(name)) return { tool: d.glob, input: { pattern, ...(path ? { path } : {}) } }
+      if (!/grep|ripgrep|search_files|grep_search|^rg$/i.test(name)) return undefined
+      const include = firstOf(input, ["include", "glob", "includePattern"])
+      return { tool: d.grep, input: { pattern, ...(path ? { path } : {}), ...(include ? { include } : {}) } }
+    }
+    case "list": {
+      const path = firstOf(input, DIR_KEYS)
+      if (d.list) return { tool: d.list, input: path ? { path } : {} }
+      return path ? { tool: d.read, input: { [k.file]: path } } : undefined
+    }
+    case "web": {
+      const url = str(input.url)
+      if (url) return { tool: d.fetch, input: { url, format: "markdown" } }
+      const query = firstOf(input, ["query", "search_term", "q"])
+      return query ? { tool: d.search, input: { query } } : undefined
+    }
+    case "task": {
+      const prompt = firstOf(input, ["prompt", "message", "task", "instructions"])
+      if (!prompt) return undefined
+      if (!k.agent) return { tool: d.task, input: { prompt } }
+      const description = str(input.description) ?? prompt.split("\n")[0]!.slice(0, 60)
+      const agent = firstOf(input, ["subagent_type", "agent", "agent_type"]) ?? "general"
+      return { tool: d.task, input: { description, prompt, [k.agent]: agent } }
+    }
+    case "todo":
+      return Array.isArray(input.todos) ? { tool: d.todo, input: { todos: input.todos } } : undefined
+    default:
+      return undefined
+  }
+}
+
+/** A tool name every provider accepts, for a call kept under its own name. */
+export const safeToolName = (name: string) => name.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 64) || "tool"
+
+/** A tool's input as the record every one of these formats requires. */
+export function asRecord(v: unknown): Record<string, unknown> {
+  if (v && typeof v === "object" && !Array.isArray(v)) return v as Record<string, unknown>
+  if (typeof v === "string") {
+    try {
+      const parsed = JSON.parse(v)
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed
+    } catch {}
+  }
+  return v === undefined || v === null ? {} : { input: v }
+}
+
+/** The call as the target writes it, counting the ones moved onto its own tools. */
+export function mapCall(d: Dialect, name: string, kind: ToolKind, raw: unknown, mapped: { n: number }): { tool: string; input: Record<string, unknown> } {
+  const input = asRecord(raw)
+  const native = nativeCall(d, name, kind, input)
+  if (native) {
+    if (native.tool !== name || JSON.stringify(native.input) !== JSON.stringify(input)) mapped.n++
+    return native
+  }
+  return { tool: safeToolName(name), input }
+}