ghostykit 0.3.2 → 0.4.1

package/dist/chunks/chunk-TMEHQZWL.js

@@ -0,0 +1,89 @@
+// src/transport/index.ts
+var PilotHttpError = class extends Error {
+  constructor(message, status, code, retryAfter) {
+    super(message);
+    this.name = "PilotHttpError";
+    this.status = status;
+    this.code = code;
+    this.retryAfter = retryAfter;
+  }
+};
+async function readSse(body, onMessage) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let event = "message";
+  let data = [];
+  const flush = () => {
+    if (data.length) onMessage({ event, data: data.join("\n") });
+    event = "message";
+    data = [];
+  };
+  for (; ; ) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    let nl;
+    while ((nl = buffer.search(/\r\n|\r|\n/)) >= 0) {
+      const line = buffer.slice(0, nl);
+      buffer = buffer.slice(nl + (buffer[nl] === "\r" && buffer[nl + 1] === "\n" ? 2 : 1));
+      if (line === "") flush();
+      else if (line.startsWith(":")) continue;
+      else {
+        const i = line.indexOf(":");
+        const field = i < 0 ? line : line.slice(0, i);
+        const val = i < 0 ? "" : line.slice(i + 1).replace(/^ /, "");
+        if (field === "event") event = val;
+        else if (field === "data") data.push(val);
+      }
+    }
+  }
+  flush();
+}
+function createAgUiTransport(opts) {
+  const doFetch = (...a) => (opts.fetch ?? fetch)(...a);
+  const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const retries = opts.retries ?? 6;
+  return {
+    async run(input, onEvent, signal) {
+      const body = JSON.stringify(input);
+      for (let attempt = 0; ; attempt++) {
+        const res = await doFetch(opts.url, {
+          method: "POST",
+          credentials: opts.credentials ?? "same-origin",
+          headers: { "content-type": "application/json", accept: "text/event-stream", ...opts.headers },
+          body,
+          signal
+        });
+        const retryAfter = Number(res.headers.get("Retry-After")) || void 0;
+        if (res.status === 503 && attempt < retries) {
+          await sleep((retryAfter ?? 3) * 1e3);
+          continue;
+        }
+        if (!res.ok) {
+          const json = await res.json().catch(() => null);
+          throw new PilotHttpError(json?.message ?? json?.error ?? `Error ${res.status}`, res.status, json?.error, retryAfter);
+        }
+        if (!res.body) return;
+        const serverDate = Date.parse(res.headers.get("date") ?? "");
+        const skew = Number.isNaN(serverDate) ? null : serverDate - Date.now();
+        await readSse(res.body, ({ data }) => {
+          if (!data) return;
+          try {
+            const event = JSON.parse(data);
+            if (skew !== null && typeof event.timestamp !== "number") event.timestamp = Date.now() + skew;
+            onEvent(event);
+          } catch {
+          }
+        });
+        return;
+      }
+    }
+  };
+}
+
+export {
+  PilotHttpError,
+  readSse,
+  createAgUiTransport
+};

package/dist/core/index.d.ts

@@ -1,7 +1,6 @@
 export * from "./types";
-export { RESTART_NOTICE, RESUME_TEXT, appendAgentMessages, applyHistory, beginSend, createPilotState, dropLastExchange, expiryMs, lastUserTurn, reconcileWith, reducePilotEvent, resolvePermission, resumeMode, sendAccepted, sendFailed, sendRejectedBusy, stopTurn, } from "./reducer";
-export { reconcileTurns } from "./reconcile";
+export { argsDetail, beginSend, createPilotState, dropLastExchange, expiryMs, lastUserTurn, messagesToTurns, reduceAgUiEvent, resolvePermission, sendFailed, stopTurn, toPermission, } from "./reducer";
 export { isNarration, narrationToMarkdown, splitNarration } from "./narration";
 export { cleanReplyOption, extractReplyOptions, type ReplyOptions } from "./options";
-export { TOOL_VERBS_EN, TOOL_VERBS_ES, groupSteps, isRunning, stepLabel, summarizeTools, toolName, type ToolVerb, type ToolVerbs, } from "./steps";
+export { TOOL_VERBS_EN, TOOL_VERBS_ES, groupSteps, isRunning, stepLabel, summarizeTools, toolName, toolNames, type ToolVerb, type ToolVerbs, } from "./steps";
 export { applyReferences, cleanUserText, formatDuration, systemNoteOf } from "./text";

package/dist/core/index.js

@@ -1,10 +1,7 @@
 import {
-  RESTART_NOTICE,
-  RESUME_TEXT,
   TOOL_VERBS_EN,
   TOOL_VERBS_ES,
-  appendAgentMessages,
-  applyHistory,
+  argsDetail,
   beginSend,
   cleanReplyOption,
   createPilotState,
@@ -15,21 +12,19 @@ import {
   isNarration,
   isRunning,
   lastUserTurn,
+  messagesToTurns,
   narrationToMarkdown,
-  reconcileTurns,
-  reconcileWith,
-  reducePilotEvent,
+  reduceAgUiEvent,
   resolvePermission,
-  resumeMode,
-  sendAccepted,
   sendFailed,
-  sendRejectedBusy,
   splitNarration,
   stepLabel,
   stopTurn,
   summarizeTools,
-  toolName
-} from "../chunks/chunk-O6FCE4CS.js";
+  toPermission,
+  toolName,
+  toolNames
+} from "../chunks/chunk-JQEB37IY.js";
 import {
   applyReferences,
   cleanUserText,
@@ -37,13 +32,10 @@ import {
   systemNoteOf
 } from "../chunks/chunk-6U545WJG.js";
 export {
-  RESTART_NOTICE,
-  RESUME_TEXT,
   TOOL_VERBS_EN,
   TOOL_VERBS_ES,
-  appendAgentMessages,
-  applyHistory,
   applyReferences,
+  argsDetail,
   beginSend,
   cleanReplyOption,
   cleanUserText,
@@ -56,19 +48,17 @@ export {
   isNarration,
   isRunning,
   lastUserTurn,
+  messagesToTurns,
   narrationToMarkdown,
-  reconcileTurns,
-  reconcileWith,
-  reducePilotEvent,
+  reduceAgUiEvent,
   resolvePermission,
-  resumeMode,
-  sendAccepted,
   sendFailed,
-  sendRejectedBusy,
   splitNarration,
   stepLabel,
   stopTurn,
   summarizeTools,
   systemNoteOf,
-  toolName
+  toPermission,
+  toolName,
+  toolNames
 };

package/dist/core/reducer.d.ts

@@ -1,54 +1,36 @@
-import type { Attachment, PermissionRequest, PilotState, SendResult, Turn } from "./types";
-/** El aviso de reinicio del servidor. Se retira solo si el agente sigue mandando algo. */
-export declare const RESTART_NOTICE = "El servidor se reinici\u00F3 a media respuesta. Vuelve a enviar el mensaje.";
-/** Lo que se ve en el hilo al retomar (el servidor manda al agente la continuación entera). */
-export declare const RESUME_TEXT = "Contin\u00FAa donde te quedaste.";
+import type { Interrupt, Message } from "@ag-ui/core";
+import type { Attachment, Decision, PermissionRequest, PilotState, Turn } from "./types";
 export declare function createPilotState(turns?: Turn[]): PilotState;
+type Ev = {
+    type: string;
+    [k: string]: any;
+};
+/** Los argumentos de una tool en corto, para el renglón del paso: «job: purge-notifications». */
+export declare function argsDetail(json?: string): string | undefined;
+/** Un `Interrupt` de AG-UI como tarjeta: título, herramienta (por su toolCallId) y vencimiento. */
+export declare function toPermission(i: Interrupt, turns: Turn[], clockOffset?: number): PermissionRequest;
 /**
- * Un evento del stream → estado nuevo. `data` ya viene parseado (JSON); `null` si no traía.
- * `now` se inyecta para que el reductor sea puro (tiempos de turno y de página).
+ * El hilo guardado (mensajes AG-UI) como turnos: cada mensaje del usuario abre uno; lo que sigue del
+ * asistente y de las herramientas se junta en un turno, con sus pasos y su narración.
  */
-export declare function reducePilotEvent(prev: PilotState, name: string, data: unknown, now?: number): PilotState;
-/** `expiresAt` (ISO o epoch ms) → epoch ms. */
-export declare function expiryMs(v: string | number): number;
-/**
- * El usuario manda un mensaje. Con turno en vuelo es una CORRECCIÓN: el servidor intenta meterlo
- * al turno (steer) y, hasta saber si entró, la burbuja viva se conserva.
- */
-export declare function beginSend(prev: PilotState, text: string, attachments: Attachment[], now?: number): PilotState;
-/** El servidor aceptó el encargo. `inFlight` = había turno en vuelo al mandar. */
-export declare function sendAccepted(prev: PilotState, r: SendResult, inFlight: boolean, now?: number): PilotState;
-/**
- * El servidor ya tiene un turno corriendo (409 `turn_busy`): el mensaje de este cliente NO entró.
- * Se quita de la pantalla y se avisa; el transporte se re-engancha al turno que sí corre.
- */
-export declare function sendRejectedBusy(prev: PilotState, message: string): PilotState;
-/** El encargo fue rechazado (sin saldo, sin cuenta…): se DICE, para que no se quede pensando. */
-export declare function sendFailed(prev: PilotState, message: string, needsLogin?: boolean): PilotState;
-/** Detener el turno en curso (el POST de cancelar lo hace el transporte). */
+export declare function messagesToTurns(messages: Message[]): Turn[];
+/** Un evento AG-UI → estado nuevo. `now` se inyecta para que el reductor sea puro. */
+export declare function reduceAgUiEvent(prev: PilotState, e: Ev, now?: number): PilotState;
+/** El usuario manda un mensaje (o contesta una tarjeta: `text` vacío, sin burbuja). */
+export declare function beginSend(prev: PilotState, text: string, attachments?: Attachment[], now?: number): PilotState;
+/** El servidor no aceptó el encargo (HTTP): se DICE, para que no se quede pensando. */
+export declare function sendFailed(prev: PilotState, message: string): PilotState;
+/** Detener: el cliente cortó la conexión (el servidor corta el run). */
 export declare function stopTurn(prev: PilotState): PilotState;
 /** Quita el último intercambio (las respuestas del final y el último mensaje del usuario). */
 export declare function dropLastExchange(prev: PilotState): PilotState;
-/**
- * El usuario contestó una tarjeta: sale de las abiertas y queda anotada en la última respuesta
- * («Aprobaste: correr la purga»). `resolved: false` = ya no estaba abierta (venció o la contestó otro).
- */
-export declare function resolvePermission(prev: PilotState, id: string, optionId: string, resolved: boolean, detail?: string, 
-/** La tarjeta como estaba al contestarla (el stream pudo retirarla mientras tanto). */
-asked?: PermissionRequest): PilotState;
-/**
- * El historial guardado (al montar): el hilo, si la pantalla sigue vacía, y las tarjetas de permiso
- * que siguen abiertas (sin duplicar las que el stream ya trajo).
- */
-export declare function applyHistory(prev: PilotState, turns: Turn[], permissions?: PermissionRequest[]): PilotState;
-/** Un mensaje del agente que entró fuera de un turno (el remate de los subagentes). */
-export declare function appendAgentMessages(prev: PilotState, texts: string[]): PilotState;
-/** La copia del hilo cambió: trae los mensajes que el usuario mandó desde OTRO cliente. Sólo en reposo. */
-export declare function reconcileWith(prev: PilotState, fresh: Turn[]): PilotState;
-/** El último mensaje del usuario (para reintentar o retomar). */
+/** El último mensaje del usuario (para reintentar). */
 export declare function lastUserTurn(turns: Turn[]): Turn | null;
 /**
- * «Retomar»: si el agente alcanzó a trabajar (texto o pasos tras el último mensaje), se le pide
- * CONTINUAR; si no, es reenviar el mensaje tal cual.
+ * El usuario contestó (o dejó vencer) una tarjeta: sale de las abiertas y queda anotada en la última
+ * respuesta («Aprobaste: correr la purga»).
  */
-export declare function resumeMode(turns: Turn[]): "continue" | "resend";
+export declare function resolvePermission(prev: PilotState, id: string, status: Decision["status"], asked?: PermissionRequest): PilotState;
+/** `expiresAt` (ISO o epoch ms) → epoch ms. */
+export declare function expiryMs(v: string | number): number;
+export {};

package/dist/core/steps.d.ts

@@ -10,7 +10,15 @@ export interface ToolVerb {
 export type ToolVerbs = Record<string, ToolVerb>;
 /** ¿Sigue corriendo? `pending` también: es el instante entre pedirla y arrancarla. */
 export declare const isRunning: (t: ToolEntry) => boolean;
-/** `mcp__servidor__nombre` → `nombre`; cualquier otro título, tal cual. */
+/**
+ * Los nombres con los que se puede buscar el verbo/ícono de una herramienta, del más específico al
+ * menos: el título tal cual, y sin el prefijo de MCP. Los MCP la nombran `mcp__servidor__tool` (dos
+ * guiones bajos) o `mcp_servidor_tool` (uno, visto en EasyBits); como el servidor y la tool también
+ * llevan guiones bajos, con uno solo se prueban todos los cortes: `mcp_easy_bits_list_crons` →
+ * `easy_bits_list_crons`, `bits_list_crons`, `list_crons`, `crons`.
+ */
+export declare function toolNames(t: ToolEntry): string[];
+/** El nombre «corto» de la herramienta (sin el prefijo de MCP de dos guiones bajos). */
 export declare function toolName(t: ToolEntry): string | null;
 /** El rótulo de un paso: el verbo de su nombre, o el título que manda el servidor, o su clase. */
 export declare function stepLabel(t: ToolEntry, verbs: ToolVerbs, fallback?: string): string;

package/dist/core/types.d.ts

@@ -1,86 +1,28 @@
-/** Por dónde va la conexión con el agente antes de que conteste. */
-export type ConnectPhase = "waking" | "connecting" | "session";
-/** Un modelo que el agente ofrece para la sesión (selector ACP). */
-export interface ModelOption {
-    value: string;
-    name: string;
-}
-/**
- * Un adjunto listo para el agente: base64 sin prefijo + su MIME, o una URL ya subida.
- * Viaja en el cuerpo del POST como `images` (nombre histórico del contrato).
- */
+import type { BaseEvent, Interrupt, Message, RunAgentInput } from "@ag-ui/core";
+export type { BaseEvent, Interrupt, Message, RunAgentInput };
+/** Un adjunto del mensaje del usuario (viaja como parte de contenido AG-UI). */
 export interface Attachment {
     name?: string;
     mimeType: string;
-    /** Base64 sin el prefijo `data:`. Vacío cuando el archivo viaja por `uri`. */
-    data: string;
-    /** URL del archivo ya subido (lo que el agente descarga cuando no es imagen ni texto). */
-    uri?: string;
-    /** Id del archivo en la app, si la app lo guarda. */
-    fileId?: string;
+    /** Base64 sin el prefijo `data:` (imágenes y texto que caben en el mensaje). */
+    data?: string;
+    /** URL del archivo ya subido (lo demás). */
+    url?: string;
 }
-/** Un paso del agente (una herramienta), según ACP: pending → in_progress → completed | failed. */
+/** Un paso del agente: una llamada a herramienta (TOOL_CALL_*). */
 export interface ToolEntry {
     id: string;
+    /** El nombre de la herramienta (`toolCallName`): es la llave de los verbos de la app. */
     title?: string;
     kind?: string;
+    /** `in_progress` mientras corre; `completed` | `failed` con su resultado; `pending` = espera
+     *  aprobación; `cancelled` = el run se detuvo antes de que terminara. */
     status?: string;
     path?: string;
-    /** Qué hace, en palabras de persona (el comando, el archivo, el prompt de la imagen). */
+    /** Los argumentos, en corto («job: purge-notifications»). */
     detail?: string;
-}
-/** Lo que el agente ENTREGÓ en el turno (evento `artifact`). `raw` es el payload tal cual. */
-export interface Delivery {
-    kind: "file" | "artifact";
-    name: string;
-    fileId?: string;
-    /** Documento editable de la app (Ghosty: `@ghostystudio/docs`). */
-    docId?: string;
-    mime?: string;
-    size?: number;
-    /** Captura de pantalla del navegador: se pinta en su tira, no como entrega suelta. */
-    capture?: boolean;
-    raw?: Record<string, unknown>;
-}
-/** Una sección de la página que el turno arma (constructor por secciones). */
-export interface PageBuildSection {
-    id: string;
-    label: string;
-    kind: string;
-    status: "pending" | "building" | "done" | "failed";
-    html?: string;
-}
-/** La revisión de la página armada: corriendo, o terminada con sus arreglos. */
-export interface PageReview {
-    status: "running" | "done";
-    fixes: {
-        name: string;
-        sectionId: string;
-    }[];
-    skipped: string[];
-    thumb?: string | null;
-    seconds?: number;
-}
-/** Una página que el turno está armando, por `pageId` (eventos `page-plan` … `page-ready`). */
-export interface PageBuild {
-    pageId: string;
-    title: string;
-    /** Opaco para Piloto: lo interpreta quien pinta la página (slot `renderDeliveries`). */
-    theme: unknown;
-    sections: PageBuildSection[];
-    startedAt: number;
-    readyAt?: number;
-    url?: string | null;
-    n?: number;
-    error?: string;
-    mode?: "build" | "edit";
-    focus?: {
-        sectionId: string;
-        nodeId: string;
-    };
-    editLabel?: string;
-    editSummary?: string;
-    review?: PageReview;
+    /** Los argumentos en JSON tal como llegaron (TOOL_CALL_ARGS). */
+    args?: string;
 }
 export interface Usage {
     used: number;
@@ -89,13 +31,17 @@ export interface Usage {
     input?: number;
     output?: number;
 }
+/** Una tarjeta de aprobación ya contestada. */
+export interface Decision {
+    id: string;
+    title: string;
+    status: "approved" | "rejected" | "expired" | "cancelled";
+    detail?: string;
+}
 export interface Turn {
     role: "user" | "assistant";
     text: string;
-    /** Llegó entero fuera de un turno (el remate de los subagentes): se escribe al ritmo. */
-    arrived?: boolean;
-    deliveries?: Delivery[];
-    /** Cuánto tardó, en segundos. Se rellena al cerrar el turno. */
+    /** Cuánto tardó, en segundos (sólo los turnos vistos en vivo). */
     seconds?: number;
     thought?: string;
     tools?: ToolEntry[];
@@ -103,48 +49,33 @@ export interface Turn {
     cuts?: number[];
     attachments?: Attachment[];
     usage?: Usage;
-    /** Lo que el usuario decidió en las tarjetas de permiso de este turno (sólo en vivo). */
+    /** Lo que el usuario decidió en las tarjetas de este turno (sólo en vivo). */
     decisions?: Decision[];
-    /** Mensaje del usuario que ENTRÓ al turno en vuelo (steer): la respuesta sigue arriba. */
-    steer?: boolean;
-    pages?: PageBuild[];
-    /** El servidor ya está planeando una página (antes de que llegue su plan). */
-    planning?: boolean;
-    planningAt?: number;
-}
-/** Un turno que se cortó por falla del servidor (deploy, caja caída). Lo dice el servidor. */
-export interface Interrupted {
-    reason: string;
-    turnId?: string;
-    /** El servidor puede CONTINUAR ese turno (EasyBits: `continueTurnId`). */
-    canContinue?: boolean;
 }
-/** Una tarjeta de permiso ya contestada. */
-export interface Decision {
-    id: string;
-    title: string;
-    status: "approved" | "rejected" | "expired";
-    /** Lo que devolvió la app al resolverla (p. ej. «ejecutada»). */
-    detail?: string;
-}
-/** Una opción de un pedido de permiso, tal cual la manda el agente (ACP). */
+/** Una opción de la tarjeta de aprobación. */
 export interface PermissionOption {
     optionId: string;
     name: string;
-    /** `allow_once` | `allow_always` | `reject_once` | `reject_always` | otra. */
+    /** `allow_once` | `reject_once`. */
     kind?: string;
 }
-/** El agente pide permiso antes de algo riesgoso: el turno está DETENIDO hasta que alguien conteste. */
+/** Una aprobación pendiente (un `Interrupt` de AG-UI, listo para pintar). */
 export interface PermissionRequest {
+    /** El `id` del interrupt: con él se contesta (`resume[].interruptId`). */
     id: string;
     title: string;
     tool?: string;
+    toolCallId?: string;
+    reason?: string;
     options: PermissionOption[];
+    /** Hasta cuándo se puede contestar (ISO, reloj del SERVIDOR). */
+    expiresAt?: string | number;
     /**
-     * Hasta cuándo se puede contestar (ISO o epoch ms). Una tarjeta CON vencimiento no depende del
-     * turno (EasyBits: la propuesta vive 15 min aunque el turno ya cerró) y sobrevive al `done`.
+     * El mismo vencimiento en el reloj de ESTE navegador (epoch ms): `expiresAt` menos la hora del
+     * servidor al mandar el evento, más la hora local al recibirlo. Así un reloj local desfasado no
+     * adelanta ni atrasa la cuenta regresiva.
      */
-    expiresAt?: string | number;
+    deadline?: number;
 }
 /** Lo que una transición pide hacer FUERA del estado (avisos a la app). */
 export type PilotEffect = {
@@ -152,85 +83,37 @@ export type PilotEffect = {
 } | {
     type: "turn-done";
     text: string;
-    turnId?: string;
+    runId?: string;
     seconds?: number;
-} | {
-    type: "turn-interrupted";
-    reason: string;
-    turnId?: string;
-} | {
-    type: "needs-login";
+    error?: string;
+    interrupted?: boolean;
 } | {
     type: "title";
     title?: string;
-} | {
-    type: "disconnected";
 };
 export interface PilotState {
     turns: Turn[];
+    /** Hay un run corriendo. */
     busy: boolean;
-    connected: boolean;
-    phase: ConnectPhase;
     error: string | null;
     notice: string | null;
     usage: Usage | null;
-    models: ModelOption[];
-    currentModel: string | null;
-    /** Qué puede el agente. Empieza en `true` para no bloquear mientras se conecta. */
-    canSeeImages: boolean;
-    /** El último turno se cortó por falla del servidor: el chat ofrece Retomar. */
-    interrupted: Interrupted | null;
-    /** El turno sigue en OTRA instancia del servidor (deploy azul/verde): «sigo trabajando». */
-    elsewhere: boolean;
-    /** Permisos abiertos, en el orden en que llegaron. */
+    /** Aprobaciones abiertas (del último RUN_FINISHED con outcome interrupt). */
     permissions: PermissionRequest[];
     /** Cuándo empezó el turno que ESTE cliente encargó (0 = ninguno). */
     turnStartedAt: number;
-    /** Hay una burbuja del asistente recibiendo eventos del turno en curso. */
-    streaming: boolean;
-    /** El `turnId` del turno que este cliente encargó (lo devuelve el POST). */
-    currentTurnId: string | null;
-    /** Cuántas veces se abrió el stream: >1 = reconexión. */
-    connections: number;
-    /** El servidor avisó (`caps.needAccount`) que hace falta cuenta: se avisa al cerrar el turno. */
-    needAccount: boolean;
-    /** Cada cuánto promete el servidor su latido (`started.latidoMs`). */
-    heartbeatMs: number | null;
+    runId: string | null;
     /** Efectos de la ÚLTIMA transición. El hook los ejecuta y los descarta. */
     effects: PilotEffect[];
 }
-/** Lo que se le pide al transporte al mandar un mensaje. */
-export interface SendInput {
-    text: string;
-    attachments: Attachment[];
-    /** Es el primer mensaje del hilo (el servidor lo bautiza al cerrar el turno). */
-    firstTurn: boolean;
-    /** «Retomar» un turno cortado: el servidor arma la continuación. */
-    resume?: boolean;
-    /** Con `resume`: el turno a continuar, si el servidor lo dijo (`interrupted.turnId`). */
-    resumeTurnId?: string;
-    /** Lo que el usuario ve en pantalla, para este turno. */
-    context?: unknown;
-    /** Las referencias que viajaron en el texto, también estructuradas. */
-    references?: Reference[];
-}
-/** Lo que contesta el servidor al encargo. */
-export interface SendResult {
-    /** El mensaje entró al turno en vuelo (steer). */
-    injected?: boolean;
-    /** `queued` = la caja está despertando. */
-    state?: string;
-    turnId?: string;
-}
 /**
  * Una referencia que acompaña al mensaje (una tarjeta del tablero, un elemento señalado).
  * Con `prompt`, ese renglón va ANTES del mensaje; sin él, las etiquetas van juntas como
- * `[#12 Rosa, #7 Javier] ` (el formato del tablero de Ghosty).
+ * `[#12 Rosa, #7 Javier] `.
  */
 export interface Reference {
     id: string;
     label: string;
     prompt?: string;
-    /** Texto secundario del chip («el texto señalado»). */
     hint?: string;
 }

package/dist/react/Bubble.d.ts

@@ -1,6 +1,6 @@
 import { type ReactNode } from "react";
 import { type ReplyOptions } from "../core/options";
-import type { Delivery, Turn, Usage } from "../core/types";
+import type { Turn, Usage } from "../core/types";
 export declare function UserBubble({ turn }: {
     turn: Turn;
 }): import("react").JSX.Element;
@@ -23,10 +23,6 @@ export declare function TurnFooter({ text, seconds, onRetry, showCopy, showDurat
     showCopy?: boolean;
     showDuration?: boolean;
 }): import("react").JSX.Element;
-/** Las entregas por defecto: una ficha por archivo (las apps pintan las suyas con `renderDeliveries`). */
-export declare function DeliveryChips({ deliveries }: {
-    deliveries: Delivery[];
-}): import("react").JSX.Element | null;
 export interface AgentBubbleProps {
     turn: Turn;
     /** El turno sigue escribiéndose. */
@@ -37,7 +33,7 @@ export interface AgentBubbleProps {
     showUsage?: boolean;
     showCopy?: boolean;
     showDuration?: boolean;
-    /** Las entregas (y lo que la app quiera bajo la respuesta). Sin esto, fichas simples. */
+    /** Lo que la app quiera pintar bajo la respuesta (archivos, tarjetas propias). */
     renderDeliveries?: (turn: Turn, live: boolean) => ReactNode;
 }
 export declare function AgentBubble({ turn, live, onRetry, onOption, showUsage, showCopy, showDuration, renderDeliveries }: AgentBubbleProps): import("react").JSX.Element;

package/dist/react/Composer.d.ts

@@ -1,5 +1,10 @@
 import { type ReactNode } from "react";
-import type { Attachment, ModelOption, Reference } from "../core/types";
+import type { Attachment, Reference } from "../core/types";
+/** Un modelo que la app ofrece elegir (AG-UI no lo define: la app lo manda en `forwardedProps`). */
+export interface ModelOption {
+    value: string;
+    name: string;
+}
 /** Lo que devuelve la app al subir un archivo: su URL (y su id, si lo guarda). */
 export interface UploadResult {
     url: string;

package/dist/react/ConfirmCard.d.ts

@@ -1,13 +1,12 @@
 import type { Decision, PermissionOption, PermissionRequest } from "../core/types";
-import type { PermissionAnswer } from "./usePilot";
 /** Las opciones de rechazo van primero y discretas; las de aprobar, al final y en color. */
 export declare const isRejectOption: (o: PermissionOption) => boolean;
 export declare function ConfirmCard({ request, onRespond, onSettled, onExpire, }: {
     request: PermissionRequest;
-    /** Contesta (el transporte o la ruta de la app). `{resolved:false}` = ya no estaba abierta. */
-    onRespond: (id: string, optionId: string) => Promise<PermissionAnswer> | PermissionAnswer;
+    /** Contesta: `approved` viaja como `payload` del `resume`. */
+    onRespond: (id: string, approved: boolean) => void;
     /** El sello ya se vio: anotar la decisión y retirar la tarjeta. */
-    onSettled?: (id: string, optionId: string, answer: PermissionAnswer) => void;
+    onSettled?: (id: string, status: Decision["status"]) => void;
     /** Venció sin contestarse. */
     onExpire?: (id: string) => void;
 }): import("react").JSX.Element;

package/dist/react/Piloto.d.ts

@@ -5,7 +5,7 @@ import type { PilotTransport } from "../transport";
 import { type UploadResult } from "./Composer";
 import { type MarkdownOptions, type PilotIcon, type PilotTheme } from "./context";
 import { type PilotStrings } from "./strings";
-import { type PermissionHandler, type Pilot, type UsePilotOptions } from "./usePilot";
+import { type Pilot, type UsePilotOptions } from "./usePilot";
 export interface PilotoFeatures {
     /** Botones de adjuntar. Default: sí si hay `upload`. */
     attachments?: boolean;
@@ -15,15 +15,13 @@ export interface PilotoFeatures {
     copy?: boolean;
     /** Tokens y costo bajo cada respuesta. Default: sí. */
     usage?: boolean;
-    /** Selector de modelo (si el agente ofrece varios). Default: sí. */
-    models?: boolean;
     /** Las opciones finales de la última respuesta como botones. Default: sí. */
     replyOptions?: boolean;
     /** «· 12 s» junto a la frase de espera. Default: sí. */
     duration?: boolean;
 }
 export interface PilotoSlots {
-    /** Las entregas de cada respuesta (archivos, páginas, tarjetas propias). */
+    /** Lo que la app pinte bajo cada respuesta (archivos, tarjetas propias). */
     renderDeliveries?: (turn: Turn, live: boolean) => ReactNode;
     /** Botones propios en la barra del composer. */
     composerExtras?: ReactNode;
@@ -61,12 +59,7 @@ export interface PilotoProps extends UsePilotOptions {
     voiceNoteText?: (transcript: string) => string;
     features?: PilotoFeatures;
     /**
-     * Contestar un permiso (p. ej. el POST de aprobación de la app, con su sesión). Default:
-     * `transport.respondPermission`. Devuelve `{resolved:false}` si ya no estaba abierto.
-     */
-    onPermission?: PermissionHandler;
-    /**
-     * Una pregunta lista en la caja (sin mandarla) y el foco en ella: al abrir el copiloto desde una
+     * Una pregunta lista en la caja (sin mandarla) y el foco en ella: al abrir el piloto desde una
      * fila («Pídeselo»). Cambiar el texto —o `key`, para repetir el mismo— la vuelve a poner.
      */
     draft?: string | {