ghostykit 0.3.2 → 0.4.1

package/README.md

@@ -1,12 +1,17 @@
-# Piloto UI · `ghostykit`
+# Ghosty Autopilot · `ghostykit`
 
-**An in-app copilot for React.** Piloto UI is the agent chat from
+**An autopilot for your React app, not a copilot or kit.** You don't drive: you say where you're going and
+the agent flies the app for you, stopping only to ask before anything risky. Ghosty Autopilot is the agent chat from
 [Ghosty Studio](https://www.ghosty.studio) (`/c`), packaged as a library: same components, same
 markup, same look ([side by side](https://raw.githubusercontent.com/blissito/ghostykit/main/docs/screenshots/parity/desktop-done-gs-vs-ghostykit.png)). You drop it into an app you already
 have. It sees what the user has on screen, streams what the agent says and does, and **stops to ask
 before anything risky** (human in the loop).
 
-> El copiloto de tu app: el chat de Ghosty, probado en producción, como biblioteca. Español por default, inglés incluido.
+It speaks **[AG-UI](https://docs.ag-ui.com)**, the open agent ↔ app protocol, so it works with
+**LangGraph**, Mastra, CrewAI, Pydantic AI, Google ADK, or your own backend. No adapter of ours in
+between.
+
+> El piloto de tu app, no el copiloto: tú no manejas, vas de pasajero y le dices a dónde ir. Es el chat de Ghosty, probado en producción, como biblioteca. Español por default, inglés incluido.
 
 **[Open the playground →](https://blissito.github.io/ghostykit/)** (a fake backend, a real chat)
 
@@ -18,9 +23,13 @@ before anything risky** (human in the loop).
 - **Agent steps**: every tool call as a line ("Read 2 files", "Searched the web"). Steps fold into a card when the turn ends, and you can show your own labels and icons.
 - **The permission pass**: risky actions arrive as a card with a countdown, *Approve* and *Reject*. A stamp lands when you answer, and the decision stays recorded under the reply.
 - **Context and references**: what the user is looking at travels with every turn. Rows from your app can be "@-mentioned" into the message.
-- **Resilience**: reconnects after a dropped network or a deploy, re-attaches to a running turn, retries while the server drains, and offers *Resume* when a turn is cut short.
-- **The composer**: attachments (you provide `upload`), voice notes (you provide `transcribe`), stop, model picker and reply-option buttons.
-- **Solid core**: the whole chat state is a pure reducer, `reducePilotEvent(state, name, data)`, tested by replaying real SSE sessions.
+- **Resilience**: the thread lives on your server. A dropped connection or a reload asks for it again
+  and repaints from `MESSAGES_SNAPSHOT`, pending approvals included; a deploy (`503`) is retried with
+  the same run.
+- **The composer**: attachments (you provide `upload`), voice notes (you provide `transcribe`), stop and reply-option buttons.
+- **Solid core**: the whole chat state is a pure reducer over AG-UI events, `reduceAgUiEvent(state, event)`, tested by replaying streams recorded from a real LangGraph agent.
+
+> **En español:** Ghosty Autopilot le pone piloto a tu app con un solo componente: la persona dice qué quiere y el agente lo hace por ella. Tus usuarios ven la respuesta escribirse en vivo y cada paso del agente («Leí 2 archivos»), y aprueban o rechazan cualquier acción riesgosa con una tarjeta antes de que ocurra. El agente sabe qué pantalla y qué registro está viendo la persona. Habla AG-UI, el protocolo abierto entre agentes y apps, así que funciona con LangGraph, Mastra, CrewAI o tu propio backend. El chat se recupera solo de cortes de red y de deploys, y trae adjuntos, notas de voz y botón para detener. Por dentro, todo el estado es una función pura probada con sesiones reales, así que se puede actualizar sin miedo.
 
 ## 30-second quickstart
 
@@ -29,70 +38,47 @@ npm i ghostykit motion streamdown
 ```
 
 ```tsx
-import { Piloto, useSseTransport } from "ghostykit";
+import { Piloto, createAgUiTransport } from "ghostykit";
 import "ghostykit/styles.css";
-import "ghostykit/fonts.css"; // optional: the house typefaces
 
-export function Copilot() {
-  const transport = useSseTransport("/api/copilot/conversations/123");
+const transport = createAgUiTransport({ url: "/api/agent" }); // any AG-UI endpoint
+
+export function Pilot() {
   return <Piloto transport={transport} />;
 }
 ```
 
 `<Piloto transport={…} />` works with nothing else. Give its container a height: Piloto fills it.
+The product is **Ghosty Autopilot**; the component is `<Piloto>`.
 
-## Transports
-
-A transport is how Piloto talks to your agent. It is a small interface: `subscribe`, `send`, `cancel`,
-plus optional `setModel`, `respondPermission` and `history`. Two are included.
-
-### 1. Split stream: `createSseTransport(base)` (Ghosty's contract)
-
-The event stream stays open (`EventSource`) and messages go by POST.
+## Works with LangGraph (and any AG-UI agent)
 
-| | |
-|---|---|
-| `GET  {base}/events` | Named SSE events: `started`, `status`, `chunk`, `thought`, `tool`, `permission`, `permission-resolved`, `usage`, `models`, `title`, `done{reposo?,interrumpido?,ultimo?}`, `error`… |
-| `POST {base}/messages` | `{content, images, primerTurno, retomar?, context?}` → `{inyectado?, estado?, turnId?}` |
-| `POST {base}/cancel` · `/model` · `/permission` | stop, switch model, answer a card |
+Serve your LangGraph graph with its official AG-UI adapter and point Piloto at it:
 
-Messages sent during a running turn are injected into it (steer). A silent connection during a turn is
-reopened, and the server says whether the turn continued, finished or was cut short.
+```ts
+// server: one POST endpoint (full file in examples/langgraph/src/server.ts)
+import { LangGraphAgent } from "@ag-ui/langgraph";
+import { EventEncoder } from "@ag-ui/encoder";
 
-### 2. POST returns the stream: `createPostStreamTransport({ url })` (EasyBits' contract)
-
-The POST that starts a turn *is* the SSE. A GET re-attaches to a running turn.
-
-| | |
-|---|---|
-| `POST {url}` | `{text, context?, turnId, continueTurnId?}` → SSE `started`, `chunk`, `tool{title,status}`, `permission{…, expiresAt}`, `done{turnId,text}`, `error`, `capacity`, `interrupted{turnId,canContinue}`, `idle` |
-| `GET {url}?attach=1` | `started`, one `permission` per open card, `snapshot{turnId,text,tools}`, then live |
-| `GET {url}` | `{messages:[{role,text}]}`, loaded as the thread |
-
-A 503 (deploy draining) is retried with the same `turnId`. A 409 `turn_busy` re-attaches to the turn
-that is already running. Approvals usually go through your own route:
+const agent = new LangGraphAgent({ graphId: "crons", deploymentUrl: "http://localhost:2024", emitInterruptOutcome: true });
+// POST /agent → agent.run(runAgentInput).subscribe(e => res.write(new EventEncoder().encode(e)))
+```
 
 ```tsx
-<Piloto
-  transport={useMemo(() => createPostStreamTransport({ url: "/api/v2/admin/copilot/chat" }), [])}
-  context={{ page: "crons", job: selectedJob }}
-  onPermission={async (id, optionId) => {
-    const res = await fetch(`/api/v2/admin/agent-actions/${id}`, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ decision: optionId === "approve" ? "approve" : "reject" }),
-    });
-    if (res.status === 409 || res.status === 404) return { resolved: false }; // expired or already answered
-    if (!res.ok) throw new Error("approval failed");
-    return { resolved: true, detail: (await res.json()).status };
-  }}
-/>
+<Piloto transport={createAgUiTransport({ url: "http://localhost:8000/agent" })} />
 ```
 
-### 3. Your own
+`interrupt()` in your graph becomes the approval card; *Approve*/*Reject* resume it
+(`Command(resume={approved})` on the graph side). A runnable example with a tool and an approval is in
+[`examples/langgraph`](examples/langgraph); the playground can point at it with
+`?backend=agui&url=http://localhost:8000/agent`.
+
+## The contract
 
-Implement `PilotTransport` and emit the same event names (see `ghostykit/core` types). If you only need
-the state, use the reducer directly: `ghostykit/core` has no React dependency.
+One `POST <url>` with an AG-UI `RunAgentInput`, answered by a stream of standard AG-UI events. That's
+all a backend serves. **[docs/protocol.md](docs/protocol.md)** is the exact spec: request, events,
+approvals (`RUN_FINISHED.outcome: interrupt` + `resume`), reopening a thread (`MESSAGES_SNAPSHOT`),
+stopping and errors.
 
 ## Make it yours
 
@@ -109,7 +95,8 @@ const ref = useRef<PilotoHandle>(null);
   welcome="How can I help with your crons?"
   suggestions={["Why did the monitor fail?"]}
   draft={{ text: "Why did the monitor fail?", key: row.id }} // prefilled + focused, not sent
-  context={() => ({ screen: "crons", selected })}            // sent with EVERY turn
+  threadId={conversationId}                                   // reopen a stored thread
+  context={() => ({ screen: "crons", selected })}            // AG-UI `context`, every run
   toolVerbs={{ run_cron: { one: "Ran a cron", many: "Ran %n crons", running: "Running the cron…" } }}
   upload={async (file) => ({ url: await myUpload(file) })}
   transcribe={async (audio) => myWhisper(audio)}
@@ -122,9 +109,9 @@ ref.current?.send("Why did this fail?");                     // ask on the user'
 ```
 
 Other options: `strings`, `toolIcons`, `formatUserText`, `markdown`, `features`
-(`attachments`, `retry`, `copy`, `usage`, `models`, `replyOptions`, `duration`), `references` /
+(`attachments`, `retry`, `copy`, `usage`, `replyOptions`, `duration`), `references` /
 `onReferencesChange`, `voiceNoteText`, `placeholder`, `avatar`, `initialTurns`, and the callbacks
-`onTurnStart`, `onTitle`, `onNeedsLogin`, `onDisconnected`, `onEvent`, `onSend`. To read the state
+`onTurnStart`, `onTitle`, `onEvent` (every raw AG-UI event: STATE_*, CUSTOM…), `onSend`. To read the state
 outside the chat, call `usePilot(transport)` yourself and pass the result as `pilot`. Every piece is
 exported (`AgentBubble`, `AgentSteps`, `Composer`, `ConfirmCard`, `Markdown`, …) if you want to build
 your own layout.

package/dist/chunks/chunk-JQEB37IY.js

@@ -0,0 +1,479 @@
+// src/core/reducer.ts
+function createPilotState(turns = []) {
+  return { turns, busy: false, error: null, notice: null, usage: null, permissions: [], turnStartedAt: 0, runId: null, effects: [] };
+}
+function patchAssistant(s, patch) {
+  const turns = [...s.turns];
+  const last = turns[turns.length - 1];
+  if (last?.role === "assistant") turns[turns.length - 1] = patch(last);
+  else turns.push(patch({ role: "assistant", text: "" }));
+  return { ...s, turns };
+}
+function argsDetail(json) {
+  if (!json) return void 0;
+  try {
+    const v = JSON.parse(json);
+    if (!v || typeof v !== "object") return String(v);
+    const parts = Object.entries(v).filter(([, x]) => x !== null && x !== void 0 && x !== "").map(([k, x]) => `${k}: ${typeof x === "object" ? JSON.stringify(x) : String(x)}`);
+    const s = parts.join(", ");
+    return s ? s.length > 80 ? `${s.slice(0, 79)}\u2026` : s : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function upsertTool(s, id, patch) {
+  return patchAssistant(s, (t) => {
+    const tools = [...t.tools ?? []];
+    const i = tools.findIndex((x) => x.id === id);
+    let cuts = t.cuts;
+    if (i === -1) {
+      tools.push({ id, ...patch });
+      const len = t.text.length;
+      if (t.text.trim() && cuts?.[cuts.length - 1] !== len) cuts = [...cuts ?? [], len];
+    } else tools[i] = { ...tools[i], ...patch };
+    return { ...t, tools, cuts };
+  });
+}
+var APPROVE = { optionId: "approve", name: "Aprobar", kind: "allow_once" };
+var REJECT = { optionId: "reject", name: "Rechazar", kind: "reject_once" };
+function toPermission(i, turns, clockOffset = 0) {
+  const meta = i.metadata ?? {};
+  const toolName2 = (typeof meta.tool === "string" ? meta.tool : void 0) ?? turns.flatMap((t) => t.tools ?? []).find((x) => x.id === i.toolCallId)?.title;
+  return {
+    id: i.id,
+    title: i.message ?? (toolName2 ? `${toolName2}` : i.reason),
+    ...toolName2 ? { tool: toolName2 } : {},
+    ...i.toolCallId ? { toolCallId: i.toolCallId } : {},
+    reason: i.reason,
+    options: [REJECT, APPROVE],
+    ...i.expiresAt ? { expiresAt: i.expiresAt, deadline: expiryMs(i.expiresAt) + clockOffset } : {}
+  };
+}
+function closeOpenTools(turns, status) {
+  return turns.map(
+    (t) => t.tools?.some((x) => x.status === "in_progress") ? { ...t, tools: t.tools.map((x) => x.status === "in_progress" ? { ...x, status } : x) } : t
+  );
+}
+function textOf(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) return content.map((p) => p && typeof p === "object" && p.type === "text" ? p.text ?? "" : "").join("");
+  return "";
+}
+function attachmentsOf(content) {
+  if (!Array.isArray(content)) return void 0;
+  const out = [];
+  for (const p of content) {
+    if (!p || p.type === "text" || !p.source) continue;
+    const mime = p.mimeType ?? p.source.mimeType ?? (p.type === "image" ? "image/*" : "application/octet-stream");
+    out.push(p.source.type === "data" ? { mimeType: mime, data: p.source.value, name: p.filename } : { mimeType: mime, url: p.source.value, name: p.filename });
+  }
+  return out.length ? out : void 0;
+}
+function messagesToTurns(messages) {
+  const turns = [];
+  let cur = null;
+  const assistant = () => {
+    if (!cur) {
+      cur = { role: "assistant", text: "" };
+      turns.push(cur);
+    }
+    return cur;
+  };
+  for (const m of messages) {
+    if (m.role === "user") {
+      cur = null;
+      turns.push({ role: "user", text: textOf(m.content), ...attachmentsOf(m.content) ? { attachments: attachmentsOf(m.content) } : {} });
+    } else if (m.role === "assistant") {
+      const t = assistant();
+      const text = m.content ?? "";
+      if (text) t.text = t.text ? `${t.text}
+
+${text}` : text;
+      for (const c of m.toolCalls ?? []) {
+        t.tools = [...t.tools ?? [], { id: c.id, title: c.function.name, status: "pending", args: c.function.arguments, detail: argsDetail(c.function.arguments) }];
+        if (t.text.trim() && t.cuts?.[t.cuts.length - 1] !== t.text.length) t.cuts = [...t.cuts ?? [], t.text.length];
+      }
+    } else if (m.role === "tool") {
+      const t = assistant();
+      const failed = Boolean(m.error);
+      t.tools = (t.tools ?? []).map((x) => x.id === m.toolCallId ? { ...x, status: failed ? "failed" : "completed" } : x);
+    } else if (m.role === "reasoning") {
+      const t = assistant();
+      t.thought = (t.thought ?? "") + textOf(m.content);
+    }
+  }
+  return turns;
+}
+function applySnapshot(s, messages) {
+  const fresh = messagesToTurns(messages);
+  const old = s.turns;
+  const turns = fresh.map((t, i) => {
+    const o = old[i];
+    if (!o || o.role !== t.role) return t;
+    return {
+      ...t,
+      ...o.seconds !== void 0 ? { seconds: o.seconds } : {},
+      ...o.usage ? { usage: o.usage } : {},
+      ...o.decisions ? { decisions: o.decisions } : {},
+      ...o.thought && !t.thought ? { thought: o.thought } : {},
+      ...o.attachments && !t.attachments ? { attachments: o.attachments } : {},
+      ...o.tools && t.tools ? { tools: t.tools.map((x) => ({ ...o.tools.find((y) => y.id === x.id), ...x })) } : {}
+    };
+  });
+  return { ...s, turns };
+}
+function reduceAgUiEvent(prev, e, now = Date.now()) {
+  const s = prev.effects.length ? { ...prev, effects: [] } : prev;
+  switch (e.type) {
+    case "RUN_STARTED":
+      return { ...s, busy: true, error: null, runId: e.runId ?? s.runId };
+    case "TEXT_MESSAGE_START":
+      if (e.role && e.role !== "assistant") return s;
+      return patchAssistant(s, (t) => ({ ...t, text: t.text && !t.text.endsWith("\n") ? `${t.text}
+
+` : t.text }));
+    case "TEXT_MESSAGE_CONTENT":
+    case "TEXT_MESSAGE_CHUNK":
+      if (e.role && e.role !== "assistant") return s;
+      if (typeof e.delta !== "string" || !e.delta) return s;
+      return patchAssistant(s, (t) => ({ ...t, text: t.text + e.delta }));
+    case "TEXT_MESSAGE_END":
+      return s;
+    case "TOOL_CALL_START":
+      return upsertTool(s, e.toolCallId, { title: e.toolCallName, status: "in_progress" });
+    case "TOOL_CALL_CHUNK": {
+      const known = s.turns[s.turns.length - 1]?.tools?.find((x) => x.id === e.toolCallId);
+      let next = known ? s : upsertTool(s, e.toolCallId, { title: e.toolCallName, status: "in_progress" });
+      if (typeof e.delta === "string" && e.delta) next = upsertTool(next, e.toolCallId, { args: (known?.args ?? "") + e.delta });
+      return next;
+    }
+    case "TOOL_CALL_ARGS": {
+      const known = s.turns[s.turns.length - 1]?.tools?.find((x) => x.id === e.toolCallId);
+      return upsertTool(s, e.toolCallId, { args: (known?.args ?? "") + (e.delta ?? "") });
+    }
+    case "TOOL_CALL_END": {
+      const known = s.turns[s.turns.length - 1]?.tools?.find((x) => x.id === e.toolCallId);
+      return upsertTool(s, e.toolCallId, { detail: argsDetail(known?.args) });
+    }
+    case "TOOL_CALL_RESULT": {
+      const failed = Boolean(e.metadata?.error);
+      return upsertTool(s, e.toolCallId, { status: failed ? "failed" : "completed" });
+    }
+    case "REASONING_MESSAGE_CONTENT":
+    case "REASONING_MESSAGE_CHUNK":
+      if (typeof e.delta !== "string" || !e.delta) return s;
+      return patchAssistant(s, (t) => ({ ...t, thought: (t.thought ?? "") + e.delta }));
+    case "MESSAGES_SNAPSHOT":
+      return Array.isArray(e.messages) ? applySnapshot(s, e.messages) : s;
+    case "RUN_FINISHED":
+      return finish(s, e, now);
+    case "RUN_ERROR":
+      return finish({ ...s, error: typeof e.message === "string" ? e.message : "El agente fall\xF3." }, e, now, true);
+    case "CUSTOM":
+      if (e.name === "ghosty.title") return { ...s, effects: [{ type: "title", title: e.value?.title }] };
+      return s;
+    default:
+      return s;
+  }
+}
+function finish(s0, e, now, failed = false) {
+  let s = { ...s0, busy: false };
+  const outcome = e.outcome;
+  const interrupted = outcome?.type === "interrupt" && Array.isArray(outcome.interrupts) && outcome.interrupts.length > 0;
+  const clockOffset = typeof e.timestamp === "number" ? now - e.timestamp : 0;
+  s.permissions = interrupted ? outcome.interrupts.map((i) => toPermission(i, s.turns, clockOffset)) : [];
+  if (outcome?.type === "cancelled" || failed) s = { ...s, turns: closeOpenTools(s.turns, failed ? "failed" : "cancelled") };
+  if (interrupted) {
+    const waiting = new Set(s.permissions.map((p) => p.toolCallId).filter(Boolean));
+    if (waiting.size) {
+      s = { ...s, turns: s.turns.map((t) => t.tools?.some((x) => waiting.has(x.id)) ? { ...t, tools: t.tools.map((x) => waiting.has(x.id) && x.status !== "completed" ? { ...x, status: "pending" } : x) } : t) };
+    }
+  }
+  const usage = Array.isArray(e.usage) && e.usage.length ? e.usage.reduce(
+    (a, u) => ({ ...a, used: a.used + (u.totalTokens ?? (u.inputTokens ?? 0) + (u.outputTokens ?? 0)), input: (a.input ?? 0) + (u.inputTokens ?? 0), output: (a.output ?? 0) + (u.outputTokens ?? 0) }),
+    { used: 0, size: 0, cost: 0 }
+  ) : null;
+  const t0 = s.turnStartedAt;
+  const seconds = t0 ? Math.max(1, Math.round((now - t0) / 1e3)) : void 0;
+  const turns = [...s.turns];
+  const last = turns[turns.length - 1];
+  if (last?.role === "assistant") turns[turns.length - 1] = { ...last, ...seconds !== void 0 ? { seconds } : {}, ...usage ? { usage } : {} };
+  s = { ...s, turns, turnStartedAt: 0, ...usage ? { usage } : {} };
+  if (!t0) return s;
+  const effect = {
+    type: "turn-done",
+    text: last?.role === "assistant" ? last.text : "",
+    runId: e.runId ?? s.runId ?? void 0,
+    ...seconds !== void 0 ? { seconds } : {},
+    ...failed ? { error: s.error ?? void 0 } : {},
+    ...interrupted ? { interrupted: true } : {}
+  };
+  return { ...s, effects: [effect] };
+}
+function beginSend(prev, text, attachments = [], now = Date.now()) {
+  const turns = text || attachments.length ? [...prev.turns, { role: "user", text, ...attachments.length ? { attachments } : {} }] : prev.turns;
+  return { ...prev, turns, busy: true, error: null, notice: null, turnStartedAt: now, effects: [{ type: "turn-start" }] };
+}
+function sendFailed(prev, message) {
+  return { ...prev, busy: false, turnStartedAt: 0, error: message, effects: [] };
+}
+function stopTurn(prev) {
+  return { ...prev, busy: false, turnStartedAt: 0, turns: closeOpenTools(prev.turns, "cancelled"), effects: [] };
+}
+function dropLastExchange(prev) {
+  const turns = [...prev.turns];
+  while (turns.length && turns[turns.length - 1].role === "assistant") turns.pop();
+  return { ...prev, turns: turns.slice(0, -1), effects: [] };
+}
+function lastUserTurn(turns) {
+  for (let i = turns.length - 1; i >= 0; i--) if (turns[i].role === "user") return turns[i];
+  return null;
+}
+function resolvePermission(prev, id, status, asked) {
+  const req = prev.permissions.find((p) => p.id === id) ?? asked;
+  const s = { ...prev, effects: [], permissions: prev.permissions.filter((p) => p.id !== id) };
+  if (!req) return s;
+  const decision = { id, title: req.title, status };
+  const turns = [...s.turns];
+  let i = turns.length - 1;
+  while (i >= 0 && turns[i].role !== "assistant") i--;
+  if (i >= 0) turns[i] = { ...turns[i], decisions: [...turns[i].decisions ?? [], decision] };
+  return { ...s, turns };
+}
+function expiryMs(v) {
+  return typeof v === "number" ? v : Date.parse(v);
+}
+
+// src/core/narration.ts
+var MARK = "\u2713";
+var LINE = /^- ✓ (.+)$/;
+function isNarration(chunk) {
+  const t = chunk.trim();
+  return t.length > 0 && t.length <= 300 && !/\n\s*\n/.test(t) && !t.includes("```");
+}
+function splitNarration(text, cuts) {
+  if (cuts?.length) {
+    const valid = cuts.filter((c) => c > 0 && c <= text.length);
+    if (valid.length) {
+      const chunks = [];
+      let from = 0;
+      for (const c of valid) {
+        const t = text.slice(from, c).trim();
+        if (t) chunks.push(t);
+        from = c;
+      }
+      if (chunks.every(isNarration)) {
+        return { steps: chunks.map((t) => t.replace(/\s*\n\s*/g, " ")), rest: text.slice(from).replace(/^\s+/, "") };
+      }
+    }
+    return { steps: [], rest: text };
+  }
+  const lines = text.split("\n");
+  const steps = [];
+  let i = 0;
+  for (; i < lines.length; i++) {
+    const m = LINE.exec(lines[i]);
+    if (!m) break;
+    steps.push(m[1].trim());
+  }
+  if (!steps.length) return { steps, rest: text };
+  return { steps, rest: lines.slice(i).join("\n").replace(/^\s+/, "") };
+}
+function narrationToMarkdown(chunks, answer) {
+  const steps = chunks.map((t) => t.trim()).filter(Boolean);
+  if (!steps.length || !steps.every(isNarration)) return answer;
+  const list = steps.map((p) => `- ${MARK} ${p.replace(/\s*\n\s*/g, " ")}`).join("\n");
+  return answer.trim() ? `${list}
+
+${answer.trim()}` : list;
+}
+
+// src/core/options.ts
+var BULLET = /^\s*(?:[-*•+]|(\d{1,2})[.)])\s+(.+?)\s*$/;
+var INVITES = /(puedo|quieres|elige|eliges|prefieres|opciones|caminos|can i|would you|want me|choose|prefer|options)/i;
+function extractReplyOptions(text) {
+  const lines = text.replace(/\s+$/, "").split("\n");
+  const items = [];
+  let numbered = false;
+  let i = lines.length - 1;
+  for (; i >= 0; i--) {
+    const m = BULLET.exec(lines[i]);
+    if (!m) break;
+    if (m[1]) numbered = true;
+    items.unshift(m[2]);
+  }
+  if (items.length < 2 || items.length > 5) return null;
+  if (items.some((t) => t.length > 140 || /```|`|https?:\/\/|\]\(/.test(t))) return null;
+  let j = i;
+  while (j >= 0 && !lines[j].trim()) j--;
+  if (j < 0) return null;
+  const invitation = lines[j].trim();
+  if (!invitation.endsWith(":") && !INVITES.test(invitation)) return null;
+  return { before: lines.slice(0, i + 1).join("\n").trimEnd(), items, numbered };
+}
+function cleanReplyOption(t) {
+  let s = t.replace(/\*\*|__/g, "").trim();
+  s = s.replace(/^(?:o|y|u|or|and)\s+/i, "").replace(/[\s,.;]+$/, "").trim();
+  return s.charAt(0).toLocaleUpperCase() + s.slice(1);
+}
+
+// src/core/steps.ts
+var isRunning = (t) => t.status !== "completed" && t.status !== "failed" && t.status !== "cancelled";
+function toolNames(t) {
+  const title = t.title ?? "";
+  if (!title) return [];
+  const out = [title];
+  const double = /^mcp__.+?__(.+)$/i.exec(title);
+  if (double) out.push(double[1]);
+  else if (/^mcp_/i.test(title)) {
+    const parts = title.slice(4).split("_");
+    for (let i = 0; i < parts.length; i++) out.push(parts.slice(i).join("_"));
+  }
+  return [...new Set(out)];
+}
+function toolName(t) {
+  const names = toolNames(t);
+  return /^mcp__/i.test(names[0] ?? "") ? names[1] ?? names[0] : names[0] ?? null;
+}
+function namedVerb(t, verbs) {
+  for (const name of toolNames(t)) if (verbs[name]) return { key: name, verb: verbs[name] };
+  return null;
+}
+function stepLabel(t, verbs, fallback = "Paso") {
+  const named = namedVerb(t, verbs);
+  if (named) return isRunning(t) && named.verb.running ? named.verb.running : named.verb.one;
+  return t.title ?? t.kind ?? fallback;
+}
+function summarizeTools(tools, verbs) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const t of tools) {
+    const named = namedVerb(t, verbs);
+    const key = named?.key ?? t.kind ?? "other";
+    const g = groups.get(key) ?? { n: 0, verb: named?.verb ?? verbs[key] };
+    g.n++;
+    groups.set(key, g);
+  }
+  const parts = [];
+  for (const [key, { n, verb }] of groups) {
+    if (verb) parts.push(n === 1 ? verb.one : verb.many.replace("%n", String(n)));
+    else parts.push(`${n} \xD7 ${key.replace(/[_-]/g, " ")}`);
+  }
+  return parts.join(" \xB7 ");
+}
+function groupSteps(tools, label) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const t of tools) {
+    const k = `${label(t)}\0${t.detail ?? ""}`;
+    const g = groups.get(k);
+    if (!g) {
+      groups.set(k, { tool: t, times: 1 });
+      continue;
+    }
+    g.times++;
+    const wins = isRunning(t) || t.status === "failed" || !(isRunning(g.tool) || g.tool.status === "failed");
+    if (wins) g.tool = { ...t, id: g.tool.id };
+  }
+  return [...groups.values()];
+}
+var TOOL_VERBS_ES = {
+  read: { one: "Le\xED un archivo", many: "Le\xED %n archivos" },
+  read_file: { one: "Le\xED un archivo", many: "Le\xED %n archivos" },
+  write: { one: "Escrib\xED un archivo", many: "Escrib\xED %n archivos" },
+  write_file: { one: "Escrib\xED un archivo", many: "Escrib\xED %n archivos" },
+  edit: { one: "Edit\xE9 un archivo", many: "Edit\xE9 %n archivos" },
+  edit_file: { one: "Edit\xE9 un archivo", many: "Edit\xE9 %n archivos" },
+  bash: { one: "Corr\xED un comando", many: "Corr\xED %n comandos" },
+  shell: { one: "Corr\xED un comando", many: "Corr\xED %n comandos" },
+  terminal: { one: "Corr\xED un comando", many: "Corr\xED %n comandos" },
+  execute: { one: "Corr\xED un comando", many: "Corr\xED %n comandos" },
+  grep: { one: "Busqu\xE9 en el c\xF3digo", many: "Busqu\xE9 en el c\xF3digo" },
+  glob: { one: "Busqu\xE9 archivos", many: "Busqu\xE9 archivos" },
+  search: { one: "Busqu\xE9", many: "Busqu\xE9 %n veces" },
+  tool_search: { one: "Busqu\xE9 una herramienta", many: "Busqu\xE9 %n herramientas" },
+  web_search: { one: "Busqu\xE9 en la web", many: "Busqu\xE9 en la web" },
+  web_fetch: { one: "Abr\xED una p\xE1gina", many: "Abr\xED %n p\xE1ginas" },
+  fetch: { one: "Abr\xED una p\xE1gina", many: "Abr\xED %n p\xE1ginas" },
+  site_publish: { one: "Publiqu\xE9 una p\xE1gina", many: "Publiqu\xE9 %n p\xE1ginas" },
+  pdf: { one: "Gener\xE9 un PDF", many: "Gener\xE9 %n PDF" },
+  connector: { one: "Us\xE9 tu sistema", many: "Us\xE9 tu sistema %n veces" },
+  mcp: { one: "Us\xE9 una herramienta", many: "Us\xE9 %n herramientas" },
+  browser: { one: "Us\xE9 el navegador", many: "Us\xE9 el navegador" },
+  todo: { one: "Anot\xE9 el plan", many: "Anot\xE9 el plan" },
+  delete: { one: "Borr\xE9 un archivo", many: "Borr\xE9 %n archivos" },
+  move: { one: "Mov\xED un archivo", many: "Mov\xED %n archivos" },
+  think: { one: "Lo pens\xE9", many: "Lo pens\xE9" },
+  image: { one: "Cre\xE9 una imagen", many: "Cre\xE9 %n im\xE1genes" },
+  delegate: { one: "Delegu\xE9 una tarea", many: "Delegu\xE9 %n tareas" },
+  collect: { one: "Recog\xED un resultado", many: "Recog\xED %n resultados" },
+  status: { one: "Pregunt\xE9 c\xF3mo iba", many: "Pregunt\xE9 %n veces c\xF3mo iba" },
+  stop: { one: "Detuve una tarea", many: "Detuve %n tareas" },
+  guide: { one: "Le\xED una gu\xEDa", many: "Le\xED %n gu\xEDas" },
+  deliver: { one: "Entregu\xE9 un archivo", many: "Entregu\xE9 %n archivos" },
+  sheet: { one: "Consult\xE9 una hoja", many: "Consult\xE9 %n hojas" },
+  view: { one: "Arm\xE9 una vista", many: "Arm\xE9 %n vistas" }
+};
+var TOOL_VERBS_EN = {
+  read: { one: "Read a file", many: "Read %n files" },
+  read_file: { one: "Read a file", many: "Read %n files" },
+  write: { one: "Wrote a file", many: "Wrote %n files" },
+  write_file: { one: "Wrote a file", many: "Wrote %n files" },
+  edit: { one: "Edited a file", many: "Edited %n files" },
+  edit_file: { one: "Edited a file", many: "Edited %n files" },
+  bash: { one: "Ran a command", many: "Ran %n commands" },
+  shell: { one: "Ran a command", many: "Ran %n commands" },
+  terminal: { one: "Ran a command", many: "Ran %n commands" },
+  execute: { one: "Ran a command", many: "Ran %n commands" },
+  grep: { one: "Searched the code", many: "Searched the code" },
+  glob: { one: "Searched for files", many: "Searched for files" },
+  search: { one: "Searched", many: "Searched %n times" },
+  tool_search: { one: "Looked for a tool", many: "Looked for %n tools" },
+  web_search: { one: "Searched the web", many: "Searched the web" },
+  web_fetch: { one: "Opened a page", many: "Opened %n pages" },
+  fetch: { one: "Opened a page", many: "Opened %n pages" },
+  site_publish: { one: "Published a page", many: "Published %n pages" },
+  pdf: { one: "Generated a PDF", many: "Generated %n PDFs" },
+  connector: { one: "Used your system", many: "Used your system %n times" },
+  mcp: { one: "Used a tool", many: "Used %n tools" },
+  browser: { one: "Used the browser", many: "Used the browser" },
+  todo: { one: "Wrote down the plan", many: "Wrote down the plan" },
+  delete: { one: "Deleted a file", many: "Deleted %n files" },
+  move: { one: "Moved a file", many: "Moved %n files" },
+  think: { one: "Thought it through", many: "Thought it through" },
+  image: { one: "Created an image", many: "Created %n images" },
+  delegate: { one: "Delegated a task", many: "Delegated %n tasks" },
+  collect: { one: "Collected a result", many: "Collected %n results" },
+  status: { one: "Checked how it was going", many: "Checked %n times how it was going" },
+  stop: { one: "Stopped a task", many: "Stopped %n tasks" },
+  guide: { one: "Read a guide", many: "Read %n guides" },
+  deliver: { one: "Delivered a file", many: "Delivered %n files" },
+  sheet: { one: "Checked a sheet", many: "Checked %n sheets" },
+  view: { one: "Built a view", many: "Built %n views" }
+};
+
+export {
+  createPilotState,
+  argsDetail,
+  toPermission,
+  messagesToTurns,
+  reduceAgUiEvent,
+  beginSend,
+  sendFailed,
+  stopTurn,
+  dropLastExchange,
+  lastUserTurn,
+  resolvePermission,
+  expiryMs,
+  isNarration,
+  splitNarration,
+  narrationToMarkdown,
+  extractReplyOptions,
+  cleanReplyOption,
+  isRunning,
+  toolNames,
+  toolName,
+  stepLabel,
+  summarizeTools,
+  groupSteps,
+  TOOL_VERBS_ES,
+  TOOL_VERBS_EN
+};