openbot 0.2.12 → 0.2.13

package/dist/plugins/llm/index.js

@@ -1,380 +0,0 @@
-import { streamText, Output } from "ai";
-async function toInlineDataUrl(url, mimeType) {
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw new Error(`Failed to fetch image: ${response.status} ${response.statusText}`);
-    }
-    const arrayBuffer = await response.arrayBuffer();
-    const base64 = Buffer.from(arrayBuffer).toString("base64");
-    return `data:${mimeType};base64,${base64}`;
-}
-async function toModelMessages(messages) {
-    return Promise.all(messages.map(async (message) => {
-        if (message.role === "tool") {
-            return {
-                role: "tool",
-                content: Array.isArray(message.content)
-                    ? message.content.map((c) => {
-                        const result = c.result ?? c.output?.value ?? c.output;
-                        return {
-                            type: "tool-result",
-                            toolCallId: c.toolCallId,
-                            toolName: c.toolName,
-                            output: typeof result === "string"
-                                ? { type: "text", value: result }
-                                : { type: "json", value: result },
-                        };
-                    })
-                    : [],
-            };
-        }
-        if (message.role === "assistant") {
-            if (Array.isArray(message.content)) {
-                return {
-                    role: "assistant",
-                    content: message.content.map((c) => {
-                        if (c.type === "tool-call") {
-                            return {
-                                type: "tool-call",
-                                toolCallId: c.toolCallId,
-                                toolName: c.toolName,
-                                input: c.input,
-                            };
-                        }
-                        if (c.type === "text") {
-                            return c;
-                        }
-                        // Fallback for character spread bug fix
-                        if (typeof c === "string") {
-                            return { type: "text", text: c };
-                        }
-                        return c;
-                    }),
-                };
-            }
-            return {
-                role: "assistant",
-                content: message.content,
-            };
-        }
-        if (message.role === "user") {
-            if (message.attachments && message.attachments.length > 0) {
-                const attachmentParts = await Promise.all(message.attachments.map(async (a) => {
-                    if (a.mimeType.startsWith("image/")) {
-                        try {
-                            return {
-                                type: "image",
-                                image: await toInlineDataUrl(a.url, a.mimeType),
-                            };
-                        }
-                        catch (error) {
-                            console.warn(`Failed to inline image attachment (${a.name}). Falling back to URL: ${a.url}`, error);
-                            return {
-                                type: "image",
-                                image: a.url,
-                            };
-                        }
-                    }
-                    return {
-                        type: "file",
-                        data: a.url,
-                        mimeType: a.mimeType,
-                    };
-                }));
-                return {
-                    role: "user",
-                    content: [
-                        { type: "text", text: message.content },
-                        ...attachmentParts,
-                    ],
-                };
-            }
-            return {
-                role: "user",
-                content: message.content,
-            };
-        }
-        return {
-            role: message.role,
-            content: message.content,
-        };
-    }));
-}
-// Helper to find pending tool calls in history
-function getPendingToolCalls(messages) {
-    const toolResults = new Set();
-    let lastAssistantWithTools = null;
-    for (let i = 0; i < messages.length; i++) {
-        const msg = messages[i];
-        if (msg.role === "tool" && Array.isArray(msg.content)) {
-            msg.content.forEach((c) => {
-                if (c.toolCallId)
-                    toolResults.add(c.toolCallId);
-            });
-        }
-        if (msg.role === "assistant" && Array.isArray(msg.content)) {
-            if (msg.content.some((c) => c.type === "tool-call")) {
-                lastAssistantWithTools = msg;
-            }
-        }
-    }
-    if (lastAssistantWithTools) {
-        return lastAssistantWithTools.content.filter((c) => c.type === "tool-call" && !toolResults.has(c.toolCallId));
-    }
-    return [];
-}
-// Helper to insert tool result message in correct position (immediately after corresponding assistant msg)
-function insertToolResult(messages, toolResultMsg) {
-    if (toolResultMsg.role !== "tool" || !Array.isArray(toolResultMsg.content))
-        return;
-    const toolCallId = toolResultMsg.content[0]?.toolCallId;
-    if (!toolCallId)
-        return;
-    // Find the assistant message that called this tool
-    let assistantIdx = -1;
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const msg = messages[i];
-        if (msg.role === "assistant" && Array.isArray(msg.content)) {
-            if (msg.content.some((c) => c.toolCallId === toolCallId)) {
-                assistantIdx = i;
-                break;
-            }
-        }
-    }
-    if (assistantIdx !== -1) {
-        // Find if there's already a tool message after this assistant message
-        let toolMsgIdx = -1;
-        for (let i = assistantIdx + 1; i < messages.length; i++) {
-            if (messages[i].role === "tool") {
-                toolMsgIdx = i;
-                break;
-            }
-            if (messages[i].role === "assistant")
-                break;
-        }
-        if (toolMsgIdx !== -1) {
-            // Merge into existing tool message
-            const toolMsg = messages[toolMsgIdx];
-            if (Array.isArray(toolMsg.content)) {
-                toolMsg.content.push(...toolResultMsg.content);
-            }
-        }
-        else {
-            // Insert new tool message after assistant
-            messages.splice(assistantIdx + 1, 0, toolResultMsg);
-        }
-    }
-    else {
-        // Fallback: push to end
-        messages.push(toolResultMsg);
-    }
-}
-/**
- * LLM Plugin for Melony.
- * Automatically handles text events and routes them through an LLM using Vercel AI SDK.
- * It can also automatically trigger events based on tool calls.
- */
-export const llmPlugin = (options) => (builder) => {
-    const { model, system, toolDefinitions = {}, actionEventPrefix = "action:", promptInputType = "agent:input", actionResultInputType = "action:result", completionEventType = "agent:output", usageEventType = "usage:update", usageScope = "default", modelId, outputSchema, } = options;
-    async function* routeToLLM(newMessage, context, silent = false) {
-        const state = context.state;
-        if (!state.messages) {
-            state.messages = [];
-        }
-        // 1. Add new message to history with correct positioning and unblocking logic.
-        if (newMessage) {
-            if (newMessage.role === "tool") {
-                insertToolResult(state.messages, newMessage);
-            }
-            else {
-                // If a new user message arrives while tools are pending, we unblock by failing the tools.
-                if (newMessage.role === "user") {
-                    const pending = getPendingToolCalls(state.messages);
-                    if (pending.length > 0) {
-                        console.warn(`User message received while tools are pending. Failing pending tools to unblock: ${pending
-                            .map((p) => p.toolName)
-                            .join(", ")}`);
-                        for (const p of pending) {
-                            insertToolResult(state.messages, {
-                                role: "tool",
-                                content: [
-                                    {
-                                        type: "tool-result",
-                                        toolCallId: p.toolCallId,
-                                        toolName: p.toolName,
-                                        output: {
-                                            type: "text",
-                                            value: "Tool failed to respond in time (unblocked by user message).",
-                                        },
-                                    },
-                                ],
-                            });
-                        }
-                    }
-                }
-                state.messages.push(newMessage);
-            }
-        }
-        // 2. Check for pending tool calls. We MUST have results for all tool calls before continuing.
-        const pending = getPendingToolCalls(state.messages);
-        if (pending.length > 0) {
-            console.log(`Waiting for ${pending.length} pending tool results: ${pending
-                .map((p) => p.toolName)
-                .join(", ")}`);
-            return;
-        }
-        // Evaluate dynamic system prompt if it's a function
-        const systemPrompt = typeof system === "function" ? await system(context) : system;
-        const modelMessages = await toModelMessages(state.messages);
-        // Initialize an empty assistant message to be populated as we stream
-        const assistantMessage = { role: "assistant", content: "" };
-        state.messages.push(assistantMessage);
-        // console.log("messages:::::", JSON.stringify(state.messages, null, 2));
-        // console.log("modelMessages:::::", JSON.stringify(modelMessages, null, 2));
-        const result = streamText({
-            model,
-            system: systemPrompt,
-            messages: modelMessages,
-            tools: toolDefinitions,
-            output: outputSchema ? Output.object({ schema: outputSchema }) : undefined,
-            onError: (error) => {
-                console.error("streamText error:::::", JSON.stringify(error, null, 2));
-            },
-        });
-        if (outputSchema) {
-            for await (const delta of result.partialOutputStream) {
-                if (!silent) {
-                    yield {
-                        type: "agent:output-delta",
-                        data: { delta: "", content: JSON.stringify(delta) },
-                    };
-                }
-            }
-            const finalObject = await result.output;
-            assistantMessage.content = JSON.stringify(finalObject);
-            if (completionEventType && !silent) {
-                yield {
-                    type: completionEventType,
-                    data: finalObject,
-                };
-            }
-        }
-        else {
-            for await (const delta of result.textStream) {
-                assistantMessage.content += delta;
-                if (!silent) {
-                    yield {
-                        type: "agent:output-delta",
-                        data: { delta, content: assistantMessage.content },
-                    };
-                }
-            }
-        }
-        const assistantText = assistantMessage.content;
-        // Wait for tool calls to complete
-        const toolCalls = await result.toolCalls;
-        if (toolCalls && toolCalls.length > 0) {
-            const parts = [];
-            if (assistantText) {
-                parts.push({ type: "text", text: assistantText });
-            }
-            parts.push(...toolCalls.map((c) => ({
-                type: "tool-call",
-                toolCallId: c.toolCallId,
-                toolName: c.toolName,
-                input: c.input,
-            })));
-            assistantMessage.content = parts;
-        }
-        // Remove the message if it's empty (e.g. only tool calls)
-        if (!assistantText && (!toolCalls || toolCalls.length === 0)) {
-            state.messages = state.messages.filter((m) => m !== assistantMessage);
-        }
-        else {
-            if (completionEventType && !silent) {
-                // If it's structured output, we already yielded the final object
-                if (!outputSchema) {
-                    yield {
-                        type: completionEventType,
-                        data: { content: assistantText },
-                    };
-                }
-            }
-        }
-        const usage = await result.usage;
-        if (!state.usage) {
-            state.usage = {
-                inputTokens: 0,
-                outputTokens: 0,
-                totalTokens: 0,
-            };
-        }
-        state.usage.inputTokens += usage.inputTokens ?? 0;
-        state.usage.outputTokens += usage.outputTokens ?? 0;
-        state.usage.totalTokens += usage.totalTokens ?? 0;
-        if (!silent) {
-            yield {
-                type: usageEventType,
-                data: {
-                    scope: usageScope,
-                    model: modelId,
-                    turn: {
-                        inputTokens: usage.inputTokens ?? 0,
-                        outputTokens: usage.outputTokens ?? 0,
-                        totalTokens: usage.totalTokens ?? 0,
-                    },
-                    session: {
-                        inputTokens: state.usage.inputTokens,
-                        outputTokens: state.usage.outputTokens,
-                        totalTokens: state.usage.totalTokens,
-                    },
-                },
-            };
-        }
-        // Emit tool call events
-        for (const call of toolCalls) {
-            yield {
-                type: `${actionEventPrefix}${call.toolName}`,
-                data: {
-                    ...call.input,
-                    toolCallId: call.toolCallId,
-                },
-            };
-        }
-    }
-    // Handle user text input
-    builder.on(promptInputType, async function* (event, context) {
-        const content = typeof event.data?.content === "string" ? event.data.content : "";
-        const attachments = Array.isArray(event.data?.attachments) ? event.data.attachments : undefined;
-        yield* routeToLLM({ role: "user", content, attachments }, context);
-    });
-    // Feed action results back as system-role feedback to the model.
-    builder.on(actionResultInputType, async function* (event, context) {
-        const { action, result, toolCallId, halt } = event.data;
-        const normalizedAction = typeof action === "string" ? action : "unknown";
-        const summary = typeof result === "string" ? result : JSON.stringify(result);
-        const toolResultMessage = {
-            role: "tool",
-            content: [{
-                    type: "tool-result",
-                    toolCallId,
-                    toolName: normalizedAction,
-                    output: {
-                        type: "text",
-                        value: summary,
-                    },
-                }],
-        };
-        // Hard-stop mode: record tool result to unblock pending calls, but do not
-        // continue the autonomous tool loop in this turn.
-        if (halt === true) {
-            const state = context.state;
-            if (!state.messages) {
-                state.messages = [];
-            }
-            insertToolResult(state.messages, toolResultMessage);
-            return;
-        }
-        yield* routeToLLM(toolResultMessage, context);
-    });
-};

package/dist/plugins/memory/index.js

@@ -1,220 +0,0 @@
-import { uiEvent } from "../../ui/block.js";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { createMemoryModule } from "./memory.js";
-import { buildMemoryPrompt } from "./prompt.js";
-import { statusWidget } from "../../ui/widgets/status.js";
-// Re-exports
-export { memoryToolDefinitions } from "./types.js";
-export { buildMemoryPrompt } from "./prompt.js";
-function expandPath(p) {
-    if (p.startsWith("~/")) {
-        return path.join(process.env.HOME || "", p.slice(2));
-    }
-    return p;
-}
-const DEFAULT_AGENT_MD = `# Agent Profile
-
-You are the Manager Agent, the central orchestrator of this AI system.
-Your role is to analyze user intent, manage long-term memory, and coordinate specialized agents to solve complex tasks.
-
-## Persona
-- Professional yet approachable
-- Highly organized and efficient
-- Focused on providing clear, actionable results
-`;
-/**
- * Create a prompt-builder function bound to a baseDir.
- * Returns the memory's portion of the system prompt (agent definition + memory).
- */
-export function createMemoryPromptBuilder(baseDir) {
-    const expandedBase = expandPath(baseDir);
-    const modules = {
-        memory: createMemoryModule(expandedBase),
-    };
-    return async (context) => buildMemoryPrompt(expandedBase, modules, context);
-}
-// --- Plugin ---
-/**
- * Memory Plugin for Melony
- *
- * Provides the bot's "memory": agent definition and long-term memory with recall.
- * Skills are managed by the separate skills plugin.
- */
-export const memoryPlugin = (options) => (builder) => {
-    const { baseDir } = options;
-    const expandedBase = expandPath(baseDir);
-    // Create sub-modules
-    const memory = createMemoryModule(expandedBase);
-    // ─── Initialization ───────────────────────────────────────────────
-    builder.on("init", async function* (_event, _context) {
-        yield {
-            type: "memory:status",
-            data: { message: "Initializing memory..." },
-        };
-        await fs.mkdir(expandedBase, { recursive: true, mode: 0o700 });
-        // Initialize AGENT.md if it doesn't exist
-        const agentPath = path.join(expandedBase, "AGENT.md");
-        try {
-            await fs.access(agentPath);
-        }
-        catch {
-            await fs.writeFile(agentPath, DEFAULT_AGENT_MD, "utf-8");
-        }
-        await memory.initialize();
-        yield {
-            type: "memory:status",
-            data: { message: "Memory initialized", severity: "success" },
-        };
-    });
-    // ─── Memory: Remember ─────────────────────────────────────────────
-    builder.on("action:remember", async function* (event) {
-        const { content, tags = [], toolCallId } = event.data;
-        try {
-            const entry = await memory.store(content, tags);
-            yield {
-                type: "memory:status",
-                data: { message: "Remembered", severity: "success" },
-            };
-            yield {
-                type: "action:result",
-                data: {
-                    action: "remember",
-                    toolCallId,
-                    result: {
-                        success: true,
-                        memoryId: entry.id,
-                        message: `Stored in memory with id ${entry.id}`,
-                    },
-                },
-            };
-        }
-        catch (error) {
-            yield {
-                type: "memory:status",
-                data: {
-                    message: `Failed to remember: ${error.message}`,
-                    severity: "error",
-                },
-            };
-            yield {
-                type: "action:result",
-                data: {
-                    action: "remember",
-                    toolCallId,
-                    result: { error: error.message },
-                },
-            };
-        }
-    });
-    // ─── Memory: Recall ────────────────────────────────────────────────
-    builder.on("action:recall", async function* (event) {
-        const { query, tags, limit, toolCallId } = event.data;
-        try {
-            const results = await memory.recall(query, { tags, limit });
-            yield {
-                type: "action:result",
-                data: {
-                    action: "recall",
-                    toolCallId,
-                    result: {
-                        count: results.length,
-                        memories: results.map((e) => ({
-                            id: e.id,
-                            content: e.content,
-                            tags: e.tags,
-                            createdAt: e.createdAt,
-                        })),
-                    },
-                },
-            };
-        }
-        catch (error) {
-            yield {
-                type: "action:result",
-                data: {
-                    action: "recall",
-                    toolCallId,
-                    result: { error: error.message },
-                },
-            };
-        }
-    });
-    // ─── Memory: Forget ────────────────────────────────────────────────
-    builder.on("action:forget", async function* (event) {
-        const { memoryId, toolCallId } = event.data;
-        try {
-            const removed = await memory.forget(memoryId);
-            yield {
-                type: "memory:status",
-                data: {
-                    message: removed ? "Memory removed" : "Memory not found",
-                    severity: removed ? "success" : "error",
-                },
-            };
-            yield {
-                type: "action:result",
-                data: {
-                    action: "forget",
-                    toolCallId,
-                    result: {
-                        success: removed,
-                        message: removed
-                            ? "Memory removed"
-                            : `Memory "${memoryId}" not found`,
-                    },
-                },
-            };
-        }
-        catch (error) {
-            yield {
-                type: "action:result",
-                data: {
-                    action: "forget",
-                    toolCallId,
-                    result: { error: error.message },
-                },
-            };
-        }
-    });
-    // ─── Memory: Journal ───────────────────────────────────────────────
-    builder.on("action:journal", async function* (event) {
-        const { content, toolCallId } = event.data;
-        try {
-            await memory.addJournalEntry(content);
-            yield {
-                type: "memory:status",
-                data: { message: "Journal entry added", severity: "success" },
-            };
-            yield {
-                type: "action:result",
-                data: {
-                    action: "journal",
-                    toolCallId,
-                    result: { success: true, message: "Journal entry added" },
-                },
-            };
-        }
-        catch (error) {
-            yield {
-                type: "memory:status",
-                data: {
-                    message: `Failed to journal: ${error.message}`,
-                    severity: "error",
-                },
-            };
-            yield {
-                type: "action:result",
-                data: {
-                    action: "journal",
-                    toolCallId,
-                    result: { error: error.message },
-                },
-            };
-        }
-    });
-    builder.on("memory:status", async function* (event) {
-        yield uiEvent(statusWidget(event.data.message, event.data.severity));
-    });
-};
-export default memoryPlugin;