@ekairos/story 1.6.2 → 1.6.3

package/dist/document-parser.d.ts

@@ -1,16 +1,16 @@
-export interface DocumentToProcess {
-    buffer: Buffer;
-    fileName: string;
-    path: string;
-    fileId: string;
-}
-/**
- * Procesa un documento utilizando LlamaParse y almacena el resultado en la base de datos
- */
-export declare function parseAndStoreDocument(db: any, buffer: Buffer, fileName: string, path: string, fileId: string): Promise<string>;
-/**
- * Procesa un conjunto de documentos en segundo plano
- * Puede ser utilizado con after() en Next.js o en cualquier contexto de procesamiento asíncrono
- */
-export declare function processBatchDocuments(db: any, documents: DocumentToProcess[]): Promise<string[]>;
+export interface DocumentToProcess {
+    buffer: Buffer;
+    fileName: string;
+    path: string;
+    fileId: string;
+}
+/**
+ * Procesa un documento utilizando LlamaParse y almacena el resultado en la base de datos
+ */
+export declare function parseAndStoreDocument(db: any, buffer: Buffer, fileName: string, path: string, fileId: string): Promise<string>;
+/**
+ * Procesa un conjunto de documentos en segundo plano
+ * Puede ser utilizado con after() en Next.js o en cualquier contexto de procesamiento asíncrono
+ */
+export declare function processBatchDocuments(db: any, documents: DocumentToProcess[]): Promise<string[]>;
 //# sourceMappingURL=document-parser.d.ts.map

package/dist/document-parser.js

@@ -1,157 +1,157 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseAndStoreDocument = parseAndStoreDocument;
-exports.processBatchDocuments = processBatchDocuments;
-const admin_1 = require("@instantdb/admin");
-const LLAMA_CLOUD_BASE_URL = 'https://api.cloud.llamaindex.ai/api/v1';
-/**
- * Sube un archivo a LlamaCloud para procesamiento
- */
-async function uploadToLlamaCloud(buffer, fileName) {
-    const formData = new FormData();
-    const uint8Array = new Uint8Array(buffer);
-    const blob = new Blob([uint8Array], { type: 'application/pdf' });
-    formData.append('file', blob, fileName);
-    formData.append('parse_mode', 'parse_page_with_llm');
-    formData.append('high_res_ocr', 'true');
-    formData.append('adaptive_long_table', 'true');
-    formData.append('outlined_table_extraction', 'true');
-    formData.append('output_tables_as_HTML', 'true');
-    const response = await fetch(`${LLAMA_CLOUD_BASE_URL}/parsing/upload`, {
-        method: 'POST',
-        headers: {
-            'Authorization': `Bearer ${process.env.LLAMA_CLOUD_API_KEY}`,
-        },
-        body: formData
-    });
-    if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`LlamaCloud upload failed: ${response.status} ${errorText}`);
-    }
-    const result = await response.json();
-    return result.id;
-}
-/**
- * Obtiene el estado del job de procesamiento
- */
-async function getJobStatus(jobId) {
-    const response = await fetch(`${LLAMA_CLOUD_BASE_URL}/parsing/job/${jobId}`, {
-        method: 'GET',
-        headers: {
-            'Authorization': `Bearer ${process.env.LLAMA_CLOUD_API_KEY}`,
-        }
-    });
-    if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`LlamaCloud status fetch failed: ${response.status} ${errorText}`);
-    }
-    return await response.json();
-}
-/**
- * Obtiene el resultado del procesamiento de LlamaCloud
- */
-async function getParseResult(jobId) {
-    const response = await fetch(`${LLAMA_CLOUD_BASE_URL}/parsing/job/${jobId}/result/markdown`, {
-        method: 'GET',
-        headers: {
-            'Authorization': `Bearer ${process.env.LLAMA_CLOUD_API_KEY}`,
-        }
-    });
-    if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`LlamaCloud result fetch failed: ${response.status} ${errorText}`);
-    }
-    return await response.json();
-}
-/**
- * Espera hasta que el procesamiento esté completo
- */
-async function waitForProcessing(jobId, maxAttempts = 60) {
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-        const statusResponse = await getJobStatus(jobId);
-        console.log(`Job ${jobId} status: ${statusResponse.status} (attempt ${attempt + 1}/${maxAttempts})`);
-        if (statusResponse.status === 'SUCCESS' || statusResponse.status === 'COMPLETED') {
-            return await getParseResult(jobId);
-        }
-        if (statusResponse.status === 'ERROR' || statusResponse.status === 'FAILED') {
-            throw new Error(`LlamaCloud processing failed with status: ${statusResponse.status}`);
-        }
-        await new Promise(resolve => setTimeout(resolve, 2000));
-    }
-    throw new Error('LlamaCloud processing timeout');
-}
-/**
- * Procesa un documento utilizando LlamaParse y almacena el resultado en la base de datos
- */
-async function parseAndStoreDocument(db, buffer, fileName, path, fileId) {
-    try {
-        const existingDocument = await db.query({
-            documents: {
-                $: {
-                    where: { 'file.id': fileId }
-                },
-                file: {}
-            }
-        });
-        if (existingDocument.documents && existingDocument.documents.length > 0) {
-            const docId = existingDocument.documents[0].id;
-            console.log(`Documento ya existe para el archivo ${fileName}: ${docId}`);
-            return docId;
-        }
-        console.log(`Procesando nuevo documento: ${fileName}`);
-        const jobId = await uploadToLlamaCloud(buffer, fileName);
-        console.log(`Documento subido a LlamaCloud con job ID: ${jobId}`);
-        const result = await waitForProcessing(jobId);
-        const pages = [];
-        if (result.markdown) {
-            pages.push({
-                id: (0, admin_1.id)(),
-                text: result.markdown
-            });
-        }
-        if (result.pages && result.pages.length > 0) {
-            for (const page of result.pages) {
-                pages.push({
-                    id: (0, admin_1.id)(),
-                    text: page.text
-                });
-            }
-        }
-        if (pages.length === 0) {
-            throw new Error('No se pudo extraer contenido del documento');
-        }
-        const documentId = (0, admin_1.id)();
-        await db.transact([
-            db.tx.documents[documentId].update({
-                content: { pages },
-                processedAt: new Date().toISOString()
-            }),
-            db.tx.documents[documentId].link({
-                file: fileId
-            })
-        ]);
-        console.log(`Documento procesado con éxito: ${fileName} -> ${documentId}`);
-        return documentId;
-    }
-    catch (error) {
-        console.error(`Error al procesar el documento ${fileName}:`, error);
-        throw error;
-    }
-}
-/**
- * Procesa un conjunto de documentos en segundo plano
- * Puede ser utilizado con after() en Next.js o en cualquier contexto de procesamiento asíncrono
- */
-async function processBatchDocuments(db, documents) {
-    try {
-        const promises = documents.map(doc => parseAndStoreDocument(db, doc.buffer, doc.fileName, doc.path, doc.fileId));
-        const results = await Promise.all(promises);
-        console.log('Todos los documentos procesados correctamente');
-        return results;
-    }
-    catch (error) {
-        console.error('Error en el procesamiento por lotes de documentos:', error);
-        throw error;
-    }
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAndStoreDocument = parseAndStoreDocument;
+exports.processBatchDocuments = processBatchDocuments;
+const admin_1 = require("@instantdb/admin");
+const LLAMA_CLOUD_BASE_URL = 'https://api.cloud.llamaindex.ai/api/v1';
+/**
+ * Sube un archivo a LlamaCloud para procesamiento
+ */
+async function uploadToLlamaCloud(buffer, fileName) {
+    const formData = new FormData();
+    const uint8Array = new Uint8Array(buffer);
+    const blob = new Blob([uint8Array], { type: 'application/pdf' });
+    formData.append('file', blob, fileName);
+    formData.append('parse_mode', 'parse_page_with_llm');
+    formData.append('high_res_ocr', 'true');
+    formData.append('adaptive_long_table', 'true');
+    formData.append('outlined_table_extraction', 'true');
+    formData.append('output_tables_as_HTML', 'true');
+    const response = await fetch(`${LLAMA_CLOUD_BASE_URL}/parsing/upload`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${process.env.LLAMA_CLOUD_API_KEY}`,
+        },
+        body: formData
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`LlamaCloud upload failed: ${response.status} ${errorText}`);
+    }
+    const result = await response.json();
+    return result.id;
+}
+/**
+ * Obtiene el estado del job de procesamiento
+ */
+async function getJobStatus(jobId) {
+    const response = await fetch(`${LLAMA_CLOUD_BASE_URL}/parsing/job/${jobId}`, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${process.env.LLAMA_CLOUD_API_KEY}`,
+        }
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`LlamaCloud status fetch failed: ${response.status} ${errorText}`);
+    }
+    return await response.json();
+}
+/**
+ * Obtiene el resultado del procesamiento de LlamaCloud
+ */
+async function getParseResult(jobId) {
+    const response = await fetch(`${LLAMA_CLOUD_BASE_URL}/parsing/job/${jobId}/result/markdown`, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${process.env.LLAMA_CLOUD_API_KEY}`,
+        }
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`LlamaCloud result fetch failed: ${response.status} ${errorText}`);
+    }
+    return await response.json();
+}
+/**
+ * Espera hasta que el procesamiento esté completo
+ */
+async function waitForProcessing(jobId, maxAttempts = 60) {
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        const statusResponse = await getJobStatus(jobId);
+        console.log(`Job ${jobId} status: ${statusResponse.status} (attempt ${attempt + 1}/${maxAttempts})`);
+        if (statusResponse.status === 'SUCCESS' || statusResponse.status === 'COMPLETED') {
+            return await getParseResult(jobId);
+        }
+        if (statusResponse.status === 'ERROR' || statusResponse.status === 'FAILED') {
+            throw new Error(`LlamaCloud processing failed with status: ${statusResponse.status}`);
+        }
+        await new Promise(resolve => setTimeout(resolve, 2000));
+    }
+    throw new Error('LlamaCloud processing timeout');
+}
+/**
+ * Procesa un documento utilizando LlamaParse y almacena el resultado en la base de datos
+ */
+async function parseAndStoreDocument(db, buffer, fileName, path, fileId) {
+    try {
+        const existingDocument = await db.query({
+            documents: {
+                $: {
+                    where: { 'file.id': fileId }
+                },
+                file: {}
+            }
+        });
+        if (existingDocument.documents && existingDocument.documents.length > 0) {
+            const docId = existingDocument.documents[0].id;
+            console.log(`Documento ya existe para el archivo ${fileName}: ${docId}`);
+            return docId;
+        }
+        console.log(`Procesando nuevo documento: ${fileName}`);
+        const jobId = await uploadToLlamaCloud(buffer, fileName);
+        console.log(`Documento subido a LlamaCloud con job ID: ${jobId}`);
+        const result = await waitForProcessing(jobId);
+        const pages = [];
+        if (result.markdown) {
+            pages.push({
+                id: (0, admin_1.id)(),
+                text: result.markdown
+            });
+        }
+        if (result.pages && result.pages.length > 0) {
+            for (const page of result.pages) {
+                pages.push({
+                    id: (0, admin_1.id)(),
+                    text: page.text
+                });
+            }
+        }
+        if (pages.length === 0) {
+            throw new Error('No se pudo extraer contenido del documento');
+        }
+        const documentId = (0, admin_1.id)();
+        await db.transact([
+            db.tx.documents[documentId].update({
+                content: { pages },
+                processedAt: new Date().toISOString()
+            }),
+            db.tx.documents[documentId].link({
+                file: fileId
+            })
+        ]);
+        console.log(`Documento procesado con éxito: ${fileName} -> ${documentId}`);
+        return documentId;
+    }
+    catch (error) {
+        console.error(`Error al procesar el documento ${fileName}:`, error);
+        throw error;
+    }
+}
+/**
+ * Procesa un conjunto de documentos en segundo plano
+ * Puede ser utilizado con after() en Next.js o en cualquier contexto de procesamiento asíncrono
+ */
+async function processBatchDocuments(db, documents) {
+    try {
+        const promises = documents.map(doc => parseAndStoreDocument(db, doc.buffer, doc.fileName, doc.path, doc.fileId));
+        const results = await Promise.all(promises);
+        console.log('Todos los documentos procesados correctamente');
+        return results;
+    }
+    catch (error) {
+        console.error('Error en el procesamiento por lotes de documentos:', error);
+        throw error;
+    }
+}
 //# sourceMappingURL=document-parser.js.map

package/dist/engine.d.ts

@@ -1,22 +1,22 @@
-export declare function evaluateToolCallsStep(params: {
-    storyKey: string;
-    toolCalls: Array<{
-        toolCallId: string;
-        toolName: string;
-        args: any;
-    }>;
-    contextId: string;
-}): Promise<{
-    success: boolean;
-    message?: string;
-} | {
-    success: boolean;
-    message: any;
-}>;
-export declare function onEndStep(params: {
-    storyKey: string;
-    lastEvent: any;
-}): Promise<{
-    end: boolean;
-}>;
+export declare function evaluateToolCallsStep(params: {
+    storyKey: string;
+    toolCalls: Array<{
+        toolCallId: string;
+        toolName: string;
+        args: any;
+    }>;
+    contextId: string;
+}): Promise<{
+    success: boolean;
+    message?: string;
+} | {
+    success: boolean;
+    message: any;
+}>;
+export declare function onEndStep(params: {
+    storyKey: string;
+    lastEvent: any;
+}): Promise<{
+    end: boolean;
+}>;
 //# sourceMappingURL=engine.d.ts.map

package/dist/engine.js

@@ -1,36 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.evaluateToolCallsStep = evaluateToolCallsStep;
-exports.onEndStep = onEndStep;
-const storyEngine_1 = require("./storyEngine");
-async function evaluateToolCallsStep(params) {
-    "use step";
-    try {
-        const rt = storyEngine_1.engine.get(params.storyKey);
-        if (!rt?.callbacks?.evaluateToolCalls)
-            return { success: true };
-        return await rt.callbacks.evaluateToolCalls(params.toolCalls);
-    }
-    catch (error) {
-        return { success: false, message: error?.message ?? String(error) };
-    }
-}
-async function onEndStep(params) {
-    "use step";
-    try {
-        const rt = storyEngine_1.engine.get(params.storyKey);
-        if (!rt?.callbacks?.onEnd)
-            return { end: true };
-        const result = await rt.callbacks.onEnd(params.lastEvent);
-        if (typeof result === "boolean")
-            return { end: result };
-        if (result && typeof result === "object" && Object.prototype.hasOwnProperty.call(result, "end")) {
-            return { end: Boolean(result.end) };
-        }
-        return { end: true };
-    }
-    catch {
-        return { end: true };
-    }
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateToolCallsStep = evaluateToolCallsStep;
+exports.onEndStep = onEndStep;
+const storyEngine_1 = require("./storyEngine");
+async function evaluateToolCallsStep(params) {
+    "use step";
+    try {
+        const rt = storyEngine_1.engine.get(params.storyKey);
+        if (!rt?.callbacks?.evaluateToolCalls)
+            return { success: true };
+        return await rt.callbacks.evaluateToolCalls(params.toolCalls);
+    }
+    catch (error) {
+        return { success: false, message: error?.message ?? String(error) };
+    }
+}
+async function onEndStep(params) {
+    "use step";
+    try {
+        const rt = storyEngine_1.engine.get(params.storyKey);
+        if (!rt?.callbacks?.onEnd)
+            return { end: true };
+        const result = await rt.callbacks.onEnd(params.lastEvent);
+        if (typeof result === "boolean")
+            return { end: result };
+        if (result && typeof result === "object" && Object.prototype.hasOwnProperty.call(result, "end")) {
+            return { end: Boolean(result.end) };
+        }
+        return { end: true };
+    }
+    catch {
+        return { end: true };
+    }
+}
 //# sourceMappingURL=engine.js.map

package/dist/events.d.ts

@@ -1,28 +1,28 @@
-import { type ModelMessage, type UIMessage } from "ai";
-import type { ContextEvent } from "./service";
-export declare const USER_MESSAGE_TYPE = "user.message";
-export declare const ASSISTANT_MESSAGE_TYPE = "assistant.message";
-export declare const SYSTEM_MESSAGE_TYPE = "system.message";
-export declare const WEB_CHANNEL = "web";
-export declare const AGENT_CHANNEL = "whatsapp";
-export declare const EMAIL_CHANNEL = "email";
-export declare function createUserEventFromUIMessages(messages: UIMessage[]): ContextEvent;
-export declare function createAssistantEventFromUIMessages(eventId: string, messages: UIMessage[]): ContextEvent;
-export declare function convertToUIMessage(event: ContextEvent): UIMessage;
-export declare function convertEventsToModelMessages(events: ContextEvent[]): Promise<ModelMessage[]>;
-export declare function convertEventToModelMessages(event: ContextEvent): Promise<ModelMessage[]>;
-export type AIMessage = {
-    id: string;
-    role: "user" | "assistant" | "system";
-    content: string;
-    createdAt: Date;
-};
-export type ResponseMessage = {
-    id: string;
-    timestamp: Date;
-    modelId: string;
-    headers?: Record<string, string>;
-    message: ModelMessage;
-};
-export declare function convertModelMessageToEvent(eventId: string, message: ResponseMessage): ContextEvent;
+import { type ModelMessage, type UIMessage } from "ai";
+import type { ContextEvent } from "./service";
+export declare const USER_MESSAGE_TYPE = "user.message";
+export declare const ASSISTANT_MESSAGE_TYPE = "assistant.message";
+export declare const SYSTEM_MESSAGE_TYPE = "system.message";
+export declare const WEB_CHANNEL = "web";
+export declare const AGENT_CHANNEL = "whatsapp";
+export declare const EMAIL_CHANNEL = "email";
+export declare function createUserEventFromUIMessages(messages: UIMessage[]): ContextEvent;
+export declare function createAssistantEventFromUIMessages(eventId: string, messages: UIMessage[]): ContextEvent;
+export declare function convertToUIMessage(event: ContextEvent): UIMessage;
+export declare function convertEventsToModelMessages(events: ContextEvent[]): Promise<ModelMessage[]>;
+export declare function convertEventToModelMessages(event: ContextEvent): Promise<ModelMessage[]>;
+export type AIMessage = {
+    id: string;
+    role: "user" | "assistant" | "system";
+    content: string;
+    createdAt: Date;
+};
+export type ResponseMessage = {
+    id: string;
+    timestamp: Date;
+    modelId: string;
+    headers?: Record<string, string>;
+    message: ModelMessage;
+};
+export declare function convertModelMessageToEvent(eventId: string, message: ResponseMessage): ContextEvent;
 //# sourceMappingURL=events.d.ts.map