ghostykit 0.3.2 → 0.4.0

package/dist/core/types.d.ts

@@ -1,86 +1,27 @@
-/** 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. */
     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 +30,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,47 +48,26 @@ 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 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`.
-     */
+    /** Hasta cuándo se puede contestar (ISO). */
     expiresAt?: string | number;
 }
 /** Lo que una transición pide hacer FUERA del estado (avisos a la app). */
@@ -152,85 +76,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 | {

package/dist/react/Status.d.ts

@@ -1,19 +1,7 @@
-import { type ReactNode } from "react";
-import type { ConnectPhase } from "../core/types";
 /** Los tres puntitos de «escribiendo» (color y animación en CSS: `gc-typing`). */
 export declare function TypingDots(): import("react").JSX.Element;
-export declare function WaitLabel({ phase, since, elsewhere, onLost, showDuration, }: {
-    phase: ConnectPhase;
+export declare function WaitLabel({ since, showDuration, }: {
     /** Desde que se MANDÓ el mensaje (no desde que se montó la etiqueta). */
     since?: number | null;
-    elsewhere?: boolean;
-    onLost?: () => void;
     showDuration?: boolean;
 }): import("react").JSX.Element;
-/** Lo que ocupa el hilo mientras se conecta: tres pasos reales en vez de un «Conectando…» mudo. */
-export declare function ConnectingState({ phase, error, avatar, onRetry }: {
-    phase: ConnectPhase;
-    error: string | null;
-    avatar?: ReactNode;
-    onRetry?: () => void;
-}): import("react").JSX.Element;

package/dist/react/index.d.ts

@@ -1,15 +1,15 @@
 export { Piloto, Piloto as default, type PilotoFeatures, type PilotoHandle, type PilotoProps, type PilotoSlots } from "./Piloto";
-export { usePilot, useSseTransport, type PermissionAnswer, type PermissionHandler, type Pilot, type SendOptions, type TurnDoneInfo, type UsePilotOptions } from "./usePilot";
-export { AgentBubble, CopyUserMessage, DeliveryChips, ReplyOptionButtons, TurnFooter, UsageStats, UserBubble, type AgentBubbleProps } from "./Bubble";
-export { AgentSteps, ClawIcon, DEFAULT_TOOL_ICONS, Narration, ToolRow } from "./Steps";
+export { toAgUiContext, usePilot, type Pilot, type SendOptions, type TurnDoneInfo, type UsePilotOptions } from "./usePilot";
+export { AgentBubble, CopyUserMessage, ReplyOptionButtons, TurnFooter, UsageStats, UserBubble, type AgentBubbleProps } from "./Bubble";
+export { AgentSteps, ArcadeIcon, ClawIcon, DEFAULT_TOOL_ICONS, Narration, RobotArmIcon, ToolRow } from "./Steps";
 export { LinkSafetyModal, Markdown } from "./Markdown";
 export { InlineMarkdown, renderInline } from "./InlineMarkdown";
 export { useTextAtPace } from "./TextAtPace";
-export { Composer, ModelPicker, mimeOf, type ComposerProps, type UploadResult } from "./Composer";
+export { Composer, ModelPicker, mimeOf, type ComposerProps, type ModelOption, type UploadResult } from "./Composer";
 export { ConfirmCard, DecisionLines } from "./ConfirmCard";
 export { ReferenceChips, Suggestions } from "./Chips";
-export { ConnectingState, TypingDots, WaitLabel } from "./Status";
+export { TypingDots, WaitLabel } from "./Status";
 export { PilotoContext, usePiloto, type MarkdownOptions, type PilotIcon, type PilotoConfig, type PilotTheme } from "./context";
 export { STRINGS_EN, STRINGS_ES, type PilotStrings } from "./strings";
 export * from "../core";
-export { PilotHttpError, createPostStreamTransport, createSseTransport, readSse, type PilotHistory, type PilotListener, type PilotTransport, type PostStreamTransportOptions, type SseTransportOptions, type SubscribeOptions, } from "../transport";
+export { PilotHttpError, createAgUiTransport, readSse, type AgUiTransportOptions, type PilotTransport, type SseMessage } from "../transport";