ghostykit 0.0.0-stage → 0.2.0

package/dist/react/strings.d.ts

@@ -0,0 +1,89 @@
+import type { ConnectPhase } from "../core/types";
+export interface PilotStrings {
+    /** Para formatear números y moneda. */
+    numberLocale: string;
+    placeholder: (agentName: string) => string;
+    /** Sin `agentName`. */
+    placeholderDefault: string;
+    placeholderConnecting: string;
+    send: string;
+    stop: string;
+    uploading: string;
+    uploadingN: (n: number) => string;
+    attachImage: string;
+    attachFile: string;
+    noImages: string;
+    removeAttachment: string;
+    removeReference: string;
+    dropFiles: string;
+    dropHint: string;
+    tooBig: (name: string, mb: number) => string;
+    tooMany: (max: number) => string;
+    cantSeeImage: (name: string) => string;
+    cantUpload: (name: string) => string;
+    uploadFailed: string;
+    recordVoice: string;
+    voiceNote: string;
+    cancelVoice: string;
+    stopAndSendVoice: string;
+    micDenied: string;
+    voiceEmpty: string;
+    voiceFailed: string;
+    model: string;
+    thinking: string;
+    steered: string;
+    /** Lo que se ve mientras conecta, por fase (en primera persona: habla el agente). */
+    waitPhase: Record<ConnectPhase, string>;
+    /** Qué dice el agente de un turno del que sólo sabe cuánto lleva. */
+    howItGoes: (seconds: number) => string;
+    /** Frases propias mientras piensa (rotan cada 4 s en lugar de `howItGoes`). */
+    thinkingPhrases?: string[];
+    stillWorking: string;
+    cantStart: string;
+    retry: string;
+    resume: string;
+    /** Con `interrupted.canContinue`: el servidor continúa ESE turno. */
+    continueTurn: string;
+    interrupted: (reason: string) => string;
+    interruptedOurFault: string;
+    copy: string;
+    copied: string;
+    copyMessage: string;
+    worked: (seconds: number) => string;
+    stepsExpand: string;
+    stepsCollapse: string;
+    earlierSteps: (n: number) => string;
+    withProblems: (n: number) => string;
+    running: string;
+    done: string;
+    failed: string;
+    step: string;
+    replyOptions: string;
+    connectSteps: {
+        label: string;
+        hint: string;
+    }[];
+    connectRetry: string;
+    linkTitle: string;
+    linkCopy: string;
+    linkCopied: string;
+    linkOpen: string;
+    close: string;
+    goToLatest: string;
+    confirmTitle: string;
+    approve: string;
+    reject: string;
+    confirmExpired: string;
+    confirmFailed: string;
+    /** «Vence en 14:32». */
+    expiresIn: (mmss: string) => string;
+    expiredNow: string;
+    decisionApproved: string;
+    decisionRejected: string;
+    decisionExpired: string;
+    stampApproved: string;
+    stampRejected: string;
+    stampExpired: string;
+}
+export declare const STRINGS_ES: PilotStrings;
+export declare const STRINGS_EN: PilotStrings;

package/dist/react/usePilot.d.ts

@@ -0,0 +1,67 @@
+import type { Attachment, Interrupted, PermissionRequest, PilotState, Reference, SendInput, Turn } from "../core/types";
+import { type PilotTransport, type SseTransportOptions } from "../transport";
+export interface TurnDoneInfo {
+    /** El texto final de la respuesta. */
+    text: string;
+    turnId?: string;
+    /** Cuánto tardó (sólo si lo encargó este cliente). */
+    seconds?: number;
+    /** Se cortó por falla del servidor (el chat ofrece Retomar). */
+    interrupted?: Interrupted;
+}
+export interface UsePilotOptions {
+    /** El hilo guardado. Si cambia (la app volvió a leerlo), se reconcilia en reposo. */
+    initialTurns?: Turn[];
+    /** Lo que el usuario ve en pantalla: viaja con CADA turno. Una función se evalúa al mandar. */
+    context?: unknown | (() => unknown);
+    onTurnStart?: () => void;
+    /** Fin de turno con su texto: aquí la app re-lee datos, repinta efectos, avisa. */
+    onTurnDone?: (info: TurnDoneInfo) => void;
+    /** El servidor bautizó el hilo. */
+    onTitle?: (title?: string) => void;
+    /** El servidor pide cuenta (cupo sin cuenta agotado). */
+    onNeedsLogin?: () => void;
+    /** El stream se cerró (el hilo sigue en el servidor y se puede reabrir). */
+    onDisconnected?: () => void;
+    /** Cada evento crudo, antes del reductor (analítica, efectos propios). */
+    onEvent?: (name: string, data: unknown) => void;
+    /** Cada mensaje que sale (analítica: «primer mensaje»). */
+    onSend?: (input: SendInput) => void;
+}
+export interface SendOptions {
+    resume?: boolean;
+    resumeTurnId?: string;
+    references?: Reference[];
+}
+export interface Pilot {
+    state: PilotState;
+    send: (text: string, attachments?: Attachment[], opts?: SendOptions) => Promise<void>;
+    stop: () => void;
+    /** Reintenta el último mensaje (quita la respuesta anterior). */
+    retry: () => void;
+    /** Turno PERDIDO (no arrancó): se abandona y se reenvía. */
+    abandonAndRetry: () => void;
+    /** «Retomar» un turno cortado por el servidor. */
+    resume: () => void;
+    setModel: (value: string) => void;
+    /**
+     * Contesta una tarjeta. `via` = cómo la contesta la app (p. ej. su ruta de aprobación con la
+     * sesión); sin él, `transport.respondPermission`. La decisión queda anotada en la respuesta.
+     */
+    respondPermission: (id: string, optionId: string, via?: PermissionHandler) => Promise<PermissionAnswer>;
+    /** Anota lo que ya contestó la app (sin volver a contestar): la tarjeta sale y queda la decisión. */
+    recordDecision: (id: string, optionId: string, answer: PermissionAnswer, asked?: PermissionRequest) => void;
+    /** Una tarjeta que venció sin contestarse: sale de las abiertas como «venció». */
+    expirePermission: (id: string) => void;
+    /** Un mensaje del agente que llegó fuera de un turno: espera a que cierre el turno vivo. */
+    appendAgentMessage: (text: string) => void;
+}
+/** Lo que contesta la app al resolver una tarjeta. `resolved: false` = ya no estaba abierta. */
+export type PermissionAnswer = {
+    resolved: boolean;
+    detail?: string;
+} | void;
+export type PermissionHandler = (id: string, optionId: string) => Promise<PermissionAnswer> | PermissionAnswer;
+export declare function usePilot(transport: PilotTransport | null, opts?: UsePilotOptions): Pilot;
+/** Un transporte SSE estable por `base` (crearlo en cada render reabriría el stream). */
+export declare function useSseTransport(base: string | null | undefined, opts?: SseTransportOptions): PilotTransport | null;