@ekairos/story 1.21.30-beta.0 → 1.21.32-beta.0

package/dist/agent.js

@@ -1,610 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Agent = exports.Story = void 0;
-exports.agent = agent;
-exports.createAgent = createAgent;
-const admin_1 = require("@instantdb/admin");
-const ai_1 = require("ai");
-const openai_1 = require("@ai-sdk/openai");
-const zod_1 = require("zod");
-const braintrust_1 = require("braintrust");
-const service_1 = require("./service");
-const events_1 = require("./events");
-// Inicializar Braintrust logger
-const logger = (0, braintrust_1.initLogger)({
-    projectName: "pulzar platform",
-    apiKey: process.env.BRAINTRUST_API_KEY,
-});
-const createDataStream = ai_1.createUIMessageStream;
-class Story {
-    constructor(db, opts = {}) {
-        this.opts = opts;
-        this.db = db;
-        this.agentService = new service_1.AgentService(db);
-    }
-    getModel(context) {
-        return "openai/gpt-5";
-    }
-    includeBaseTools() {
-        return { createMessage: true, requestDirection: true, end: true };
-    }
-    async getFinalizationToolNames() {
-        return [];
-    }
-    getBaseTools(dataStream, threadId) {
-        const include = this.includeBaseTools();
-        const baseTools = {};
-        if (include.createMessage) {
-            baseTools.createMessage = (0, ai_1.tool)({
-                description: "Send a message to the user. Use for final confirmations or information.",
-                inputSchema: zod_1.z.object({
-                    message: zod_1.z.string().describe("Message for the user in markdown format")
-                }),
-            });
-        }
-        if (include.requestDirection) {
-            baseTools.requestDirection = (0, ai_1.tool)({
-                description: "Ask a human for guidance when blocked or unsure.",
-                inputSchema: zod_1.z.object({
-                    issue: zod_1.z.string(),
-                    context: zod_1.z.string(),
-                    suggestedActions: zod_1.z.array(zod_1.z.string()).optional(),
-                    urgency: zod_1.z.enum(["low", "medium", "high"]).default("medium"),
-                }),
-            });
-        }
-        if (include.end) {
-            baseTools.end = (0, ai_1.tool)({
-                description: "End the current interaction loop.",
-                inputSchema: zod_1.z.object({}).strict(),
-                execute: async () => {
-                    return { success: true, message: "Ended" };
-                },
-            });
-        }
-        return baseTools;
-    }
-    async executeCreateMessage(eventId, args, threadId, dataStream) {
-        const assistantMessage = { id: eventId, role: "assistant", content: args.message, createdAt: new Date() };
-        try {
-            await this.saveMessagesToThread(threadId, [assistantMessage]);
-        }
-        catch { }
-        if (dataStream) {
-            //dataStream.writeData({ type: "user-response", message: args.message, responseType: args.type, includeContext: Boolean(args.includeContext), timestamp: new Date().toISOString() } as any)
-        }
-        return { success: true, message: args.message, data: { messageId: assistantMessage.id, threadId } };
-    }
-    async executeRequestDirection(eventId, args, threadId, _dataStream) {
-        const systemMessage = { id: eventId, role: "assistant", content: `Direction requested: ${args.issue}\nContext: ${args.context}`, createdAt: new Date() };
-        return { success: true, message: "Direction requested", data: { messageId: systemMessage.id, threadId } };
-    }
-    async progressStream(incomingEvent, contextIdentifier, options) {
-        // get or create context
-        const currentContext = await this.agentService.getOrCreateContext(contextIdentifier);
-        const contextSelector = contextIdentifier?.id
-            ? { id: String(contextIdentifier.id) }
-            : contextIdentifier?.key
-                ? { key: contextIdentifier.key }
-                : { id: String(currentContext.id) };
-        // save incoming event
-        const triggerEvent = await this.agentService.saveEvent(contextSelector, incomingEvent);
-        const triggerEventId = triggerEvent.id; // trigger event id
-        const eventId = (0, admin_1.id)(); // reaction event id
-        // Set context status to "streaming" before creating execution
-        await this.agentService.updateContextStatus(contextSelector, "streaming");
-        // create execution and set context status
-        const execution = await this.agentService.createExecution(contextSelector, triggerEventId, eventId);
-        const executionId = execution.id;
-        let latestReactionEvent = null;
-        let executionStatus = "executing";
-        const markFailure = async () => {
-            if (latestReactionEvent && latestReactionEvent.status !== "failed") {
-                try {
-                    latestReactionEvent = await this.agentService.updateEvent(latestReactionEvent.id, {
-                        ...latestReactionEvent,
-                        status: "failed",
-                    });
-                }
-                catch (eventError) {
-                    console.error("Failed to mark reaction event as failed", eventError);
-                }
-            }
-            if (executionStatus === "executing") {
-                try {
-                    await this.agentService.completeExecution(contextSelector, executionId, "failed");
-                    executionStatus = "failed";
-                }
-                catch (executionError) {
-                    console.error("Failed to mark execution as failed", executionError);
-                }
-            }
-        };
-        const dataStreamResult = createDataStream({
-            execute: async ({ writer: dataStream }) => {
-                let loopSafety = 0;
-                const MAX_LOOPS = 20;
-                // load previous events (already in chronological order from InstantDB)
-                const events = await this.agentService.getEvents(contextSelector);
-                const contextId = currentContext.id;
-                console.log("[agent] Loaded events from InstantDB:", {
-                    contextId,
-                    eventsCount: events.length,
-                    eventsPreview: events.slice(-3).map((e) => ({
-                        id: e.id,
-                        type: e.type,
-                        createdAt: e.createdAt
-                    }))
-                });
-                let reactionEvent = await this.agentService.saveEvent(contextSelector, {
-                    id: eventId,
-                    type: "assistant",
-                    channel: "agent",
-                    createdAt: new Date().toISOString(),
-                    content: { parts: [] },
-                    status: "pending",
-                });
-                latestReactionEvent = reactionEvent;
-                dataStream.write({ type: "event-start", data: { eventId: eventId } });
-                while (loopSafety < MAX_LOOPS) {
-                    dataStream.write({ type: "start-step" });
-                    loopSafety++;
-                    // Read context
-                    const currentContext = await this.agentService.getContext(contextSelector);
-                    dataStream.write({ type: "data-context-id", data: { contextId: currentContext.id } });
-                    // Initialize on each loop and get new context data
-                    const contextContent = await this.initialize(currentContext);
-                    // Update context
-                    const updatedContext = await this.agentService.updateContextContent({ id: String(currentContext.id) }, contextContent);
-                    // Build tools
-                    const subclassToolsAll = await this.buildTools(updatedContext, dataStream);
-                    // Build base tools for agent loop control
-                    const baseTools = this.getBaseTools(dataStream, String(updatedContext.id));
-                    const tools = { ...subclassToolsAll, ...baseTools };
-                    // Add web search if enabled
-                    if (options?.webSearch) {
-                        tools.web_search = openai_1.openai.tools.webSearch();
-                    }
-                    // Extract execute functions from tools
-                    const executeMap = {};
-                    for (const [name, t] of Object.entries(subclassToolsAll)) {
-                        if (t.execute) {
-                            executeMap[name] = t.execute;
-                        }
-                    }
-                    const include = this.includeBaseTools();
-                    if (include.createMessage) {
-                        executeMap["createMessage"] = (args) => this.executeCreateMessage(eventId, args, String(updatedContext.id), dataStream);
-                    }
-                    if (include.requestDirection) {
-                        executeMap["requestDirection"] = (args) => this.executeRequestDirection(eventId, args, String(updatedContext.id), dataStream);
-                    }
-                    for (const [, t] of Object.entries(tools)) {
-                        delete t.execute;
-                    }
-                    const messagesForModel = await (0, events_1.convertEventsToModelMessages)(reactionEvent.status !== "pending"
-                        ? [...events, reactionEvent]
-                        : [...events], this.db);
-                    const systemPrompt = await this.buildSystemPrompt(updatedContext);
-                    const providerOptions = {};
-                    const hasReasoning = options?.reasoningEffort && options.reasoningEffort !== "off";
-                    if (hasReasoning) {
-                        providerOptions.openai = {
-                            reasoningEffort: options.reasoningEffort,
-                            reasoningSummary: 'detailed',
-                        };
-                        console.log("[agent] Reasoning enabled:", {
-                            reasoningEffort: options.reasoningEffort,
-                            model: this.getModel(updatedContext),
-                            providerOptions
-                        });
-                    }
-                    else {
-                        console.log("[agent] Reasoning disabled or off");
-                    }
-                    // Allow more steps when using reasoning to give the model time to think
-                    const maxSteps = hasReasoning ? 5 : 1;
-                    const result = (0, ai_1.streamText)({
-                        model: this.getModel(updatedContext),
-                        system: systemPrompt,
-                        messages: messagesForModel,
-                        tools,
-                        toolChoice: "required",
-                        onStepFinish: (step) => {
-                            console.log("onStepFinish", step);
-                        },
-                        stopWhen: (0, ai_1.stepCountIs)(maxSteps),
-                        experimental_transform: (0, ai_1.smoothStream)({
-                            delayInMs: 30,
-                            chunking: 'word',
-                        }),
-                        ...(Object.keys(providerOptions).length > 0 && { providerOptions }),
-                    });
-                    result.consumeStream();
-                    // create promise
-                    let resolveFinish;
-                    let rejectFinish;
-                    const finishPromise = new Promise((resolve, reject) => {
-                        resolveFinish = resolve;
-                        rejectFinish = reject;
-                    });
-                    dataStream.merge(result.toUIMessageStream({
-                        sendStart: false,
-                        generateMessageId: () => {
-                            return eventId;
-                        },
-                        messageMetadata(options) {
-                            return {
-                                eventId: eventId,
-                            };
-                        },
-                        onFinish: ({ messages }) => {
-                            console.log("[agent] Messages finished:", messages.map((m) => ({
-                                role: m.role,
-                                parts: m.parts?.map((p) => ({
-                                    type: p.type,
-                                    text: p.text?.substring(0, 100),
-                                    hasReasoning: p.type === "reasoning"
-                                }))
-                            })));
-                            const lastEvent = (0, events_1.createAssistantEventFromUIMessages)(eventId, messages);
-                            resolveFinish(lastEvent);
-                        },
-                        onError: (e) => {
-                            console.error("Agent error:", e);
-                            rejectFinish(e);
-                            const message = e instanceof Error ? e.message : String(e);
-                            return message;
-                        }
-                    }).pipeThrough(new TransformStream({
-                        transform(chunk, controller) {
-                            if (chunk.type === "start") {
-                                return;
-                            }
-                            if (chunk.type === "finish-step") {
-                                return;
-                            }
-                            if (chunk.type === "start-step") {
-                                return;
-                            }
-                            if (chunk.type === "finish") {
-                                return;
-                            }
-                            controller.enqueue(chunk);
-                        }
-                    })));
-                    // wait for the on finish here
-                    const lastEvent = await finishPromise;
-                    const toolCalls = lastEvent.content.parts.reduce((acc, p) => {
-                        if (typeof p.type === "string" && p.type.startsWith("tool-")) {
-                            const toolName = p.type.split("-")[1];
-                            acc.push({ toolCallId: p.toolCallId, toolName: toolName, args: p.input });
-                        }
-                        return acc;
-                    }, []);
-                    console.log("agent.toolCalls.detected", {
-                        eventId,
-                        toolCalls: toolCalls.map((call) => ({ toolCallId: call.toolCallId, toolName: call.toolName }))
-                    });
-                    if (!toolCalls.length) {
-                        const shouldEndInteraction = await this.callOnEnd(lastEvent);
-                        if (shouldEndInteraction) {
-                            break;
-                        }
-                        continue;
-                    }
-                    const reactionEventWithParts = {
-                        ...reactionEvent,
-                        content: { parts: [...reactionEvent.content.parts, ...lastEvent.content.parts] },
-                    };
-                    let currentEventState = await this.agentService.updateEvent(reactionEvent.id, reactionEventWithParts);
-                    latestReactionEvent = currentEventState;
-                    const executionResults = await Promise.all(toolCalls.map(async (tc) => {
-                        console.log("agent.toolCall.selected", {
-                            eventId,
-                            toolCallId: tc.toolCallId,
-                            toolName: tc.toolName
-                        });
-                        let execSuccess = true;
-                        let execMessage = "Executed";
-                        let execResult = null;
-                        try {
-                            const execFn = executeMap[tc.toolName];
-                            if (execFn) {
-                                console.log("agent.toolCall.execute.start", { toolCallId: tc.toolCallId, toolName: tc.toolName });
-                                execResult = await execFn(tc.args);
-                                execSuccess = execResult?.success !== false;
-                                execMessage = execResult?.message || execMessage;
-                                console.log("agent.toolCall.execute.success", {
-                                    toolCallId: tc.toolCallId,
-                                    toolName: tc.toolName,
-                                    success: execSuccess
-                                });
-                                console.log("agent.toolCall.execute.result", {
-                                    toolCallId: tc.toolCallId,
-                                    toolName: tc.toolName,
-                                    result: execResult
-                                });
-                            }
-                        }
-                        catch (err) {
-                            execSuccess = false;
-                            execMessage = err.message;
-                            console.error("agent.toolCall.execute.error", {
-                                toolCallId: tc.toolCallId,
-                                toolName: tc.toolName,
-                                error: err
-                            });
-                        }
-                        return { tc, execSuccess, execMessage, execResult };
-                    }));
-                    let exitOuterLoop = false;
-                    const customFinalizationTools = await this.getFinalizationToolNames();
-                    const allFinalToolNames = [...Story.FINAL_TOOL_NAMES, ...customFinalizationTools];
-                    for (const { tc, execSuccess, execMessage, execResult } of executionResults) {
-                        try {
-                            if (execSuccess) {
-                                dataStream.write({
-                                    type: "tool-output-available",
-                                    toolCallId: tc.toolCallId,
-                                    output: execResult,
-                                });
-                            }
-                            else {
-                                dataStream.write({
-                                    type: "tool-output-error",
-                                    toolCallId: tc.toolCallId,
-                                    errorText: String(execMessage || "Error"),
-                                });
-                            }
-                        }
-                        catch (e) {
-                            console.error("Failed to write tool result to stream", e);
-                        }
-                        const existingParts = currentEventState?.content?.parts || [];
-                        const mergedParts = existingParts.map((p) => {
-                            if (p.type === `tool-${tc.toolName}` && p.toolCallId === tc.toolCallId) {
-                                if (execSuccess) {
-                                    return {
-                                        ...p,
-                                        state: "output-available",
-                                        output: execResult,
-                                    };
-                                }
-                                return {
-                                    ...p,
-                                    state: "output-error",
-                                    errorText: String(execMessage || "Error"),
-                                };
-                            }
-                            return p;
-                        });
-                        currentEventState = await this.agentService.updateEvent(currentEventState.id, {
-                            id: currentEventState.id,
-                            type: currentEventState.type,
-                            channel: "agent",
-                            createdAt: currentEventState.createdAt,
-                            content: { parts: mergedParts },
-                        });
-                        dataStream.write({ type: "finish-step" });
-                        await this.opts.onToolCallExecuted?.({
-                            id: currentEventState.id,
-                            toolCall: tc,
-                            event: currentEventState.id,
-                            success: execSuccess,
-                            message: execMessage,
-                            result: execResult,
-                        });
-                        let shouldEnd = false;
-                        if (!execSuccess) {
-                            const shouldEndInteraction = await this.callOnEnd(lastEvent);
-                            if (shouldEndInteraction) {
-                                shouldEnd = true;
-                            }
-                        }
-                        if (!shouldEnd) {
-                            if (allFinalToolNames.includes(tc.toolName)) {
-                                const shouldEndInteraction = await this.callOnEnd(lastEvent);
-                                if (shouldEndInteraction) {
-                                    shouldEnd = true;
-                                }
-                            }
-                        }
-                        if (shouldEnd) {
-                            dataStream.write({ type: "finish", override: true });
-                            exitOuterLoop = true;
-                            break;
-                        }
-                    }
-                    reactionEvent = currentEventState;
-                    if (exitOuterLoop) {
-                        break;
-                    }
-                }
-                reactionEvent = await this.agentService.updateEvent(reactionEvent.id, {
-                    ...reactionEvent,
-                    status: "completed",
-                });
-                latestReactionEvent = reactionEvent;
-                try {
-                    await this.agentService.completeExecution(contextSelector, executionId, "completed");
-                    executionStatus = "completed";
-                }
-                catch (error) {
-                    console.error("Failed to mark execution as completed", error);
-                }
-            },
-            onError: (error) => {
-                console.error("Agent error:", error);
-                void markFailure();
-                return error instanceof Error ? error.message : String(error);
-            },
-            onFinish: async () => {
-                if (executionStatus === "executing") {
-                    try {
-                        await this.agentService.completeExecution(contextSelector, executionId, "completed");
-                        executionStatus = "completed";
-                    }
-                    catch (executionError) {
-                        console.error("Failed to finalize execution on finish", executionError);
-                    }
-                }
-                console.log("Agent finished");
-            }
-        });
-        // start the stream
-        const dataStreamFilteredResult = dataStreamResult.pipeThrough(new TransformStream({
-            transform(chunk, controller) {
-                if (chunk.type === "start") {
-                    console.log("start", chunk.data);
-                    return;
-                }
-                if (chunk.type === "event-start") {
-                    controller.enqueue({ type: "start", messageId: chunk.data.eventId });
-                    return;
-                }
-                controller.enqueue(chunk);
-            }
-        }));
-        return {
-            contextId: currentContext.id,
-            triggerEventId,
-            reactionEventId: eventId,
-            stream: dataStreamFilteredResult,
-            executionId,
-        };
-    }
-    async saveMessagesToThread(threadId, messages) {
-        // Placeholder for persistence hook. Not implemented in current scope.
-        return;
-    }
-    async callOnEnd(lastEvent) {
-        if (!this.opts.onEnd) {
-            return true;
-        }
-        try {
-            const result = await this.opts.onEnd(lastEvent);
-            if (typeof result === "boolean") {
-                return result;
-            }
-            if (result && typeof result === "object") {
-                if (Object.prototype.hasOwnProperty.call(result, "end")) {
-                    return Boolean(result.end);
-                }
-            }
-            return true;
-        }
-        catch (error) {
-            console.error("onEnd callback failed", error);
-            return true;
-        }
-    }
-}
-exports.Story = Story;
-exports.Agent = Story;
-Story.FINAL_TOOL_NAMES = ["createMessage", "requestDirection", "end"];
-function agent(config) {
-    class FunctionalAgent extends Story {
-        constructor() {
-            super(config.db, config.opts);
-            this.__config = config;
-        }
-        includeBaseTools() {
-            if (config.includeBaseTools) {
-                return {
-                    createMessage: config.includeBaseTools.createMessage ?? true,
-                    requestDirection: config.includeBaseTools.requestDirection ?? true,
-                    end: config.includeBaseTools.end ?? true,
-                };
-            }
-            return super.includeBaseTools();
-        }
-        async buildSystemPrompt(context) {
-            return config.systemPrompt(context);
-        }
-        async buildTools(context, dataStream) {
-            return config.tools(context, dataStream);
-        }
-        async initialize(context) {
-            return config.context(context);
-        }
-        getModel(context) {
-            if (typeof config.model === 'function') {
-                return config.model(context);
-            }
-            return config.model || super.getModel(context);
-        }
-    }
-    const instance = new FunctionalAgent();
-    return Object.assign(instance, { __config: config });
-}
-function assertConfigComplete(config) {
-    if (!config.db) {
-        throw new Error("createAgent: Debes proporcionar db como parámetro.");
-    }
-    if (!config.context) {
-        throw new Error("createAgent: Debes definir context() antes de construir el agente.");
-    }
-    if (!config.systemPrompt) {
-        throw new Error("createAgent: Debes definir systemPrompt() antes de construir el agente.");
-    }
-    if (!config.tools) {
-        throw new Error("createAgent: Debes definir tools() antes de construir el agente.");
-    }
-}
-function ensureInitializedContext(context) {
-    if (!context.content) {
-        throw new Error("createAgent: context() debe devolver datos antes de usar systemPrompt/tools.");
-    }
-    return context;
-}
-function createAgent(db) {
-    const initializeBuilder = (initializer) => {
-        const typedInitializer = (context) => initializer(context);
-        const fluentState = {
-            db,
-            context: typedInitializer,
-        };
-        const builder = {
-            systemPrompt(systemPrompt) {
-                fluentState.systemPrompt = (context) => systemPrompt(ensureInitializedContext(context));
-                return builder;
-            },
-            tools(toolsFactory) {
-                fluentState.tools = (context, dataStream) => toolsFactory(ensureInitializedContext(context), dataStream);
-                return builder;
-            },
-            model(model) {
-                if (typeof model === "function") {
-                    fluentState.model = (context) => model(ensureInitializedContext(context));
-                }
-                else {
-                    fluentState.model = model;
-                }
-                return builder;
-            },
-            opts(options) {
-                fluentState.opts = options;
-                return builder;
-            },
-            includeBaseTools(baseTools) {
-                fluentState.includeBaseTools = baseTools;
-                return builder;
-            },
-            config() {
-                assertConfigComplete(fluentState);
-                return fluentState;
-            },
-            build() {
-                assertConfigComplete(fluentState);
-                return agent(fluentState);
-            },
-        };
-        return builder;
-    };
-    return {
-        context: initializeBuilder,
-        initialize: initializeBuilder,
-    };
-}
+exports.createStory = exports.story = exports.Story = void 0;
+var agent_engine_1 = require("./agent.engine");
+// engine
+Object.defineProperty(exports, "Story", { enumerable: true, get: function () { return agent_engine_1.Story; } });
+var agent_builder_1 = require("./agent.builder");
+// builder
+Object.defineProperty(exports, "story", { enumerable: true, get: function () { return agent_builder_1.story; } });
+Object.defineProperty(exports, "createStory", { enumerable: true, get: function () { return agent_builder_1.createStory; } });
 //# sourceMappingURL=agent.js.map