openbot 0.2.2 → 0.2.5

package/dist/plugins/llm/index.js

@@ -1,47 +1,154 @@
 import { streamText } from "ai";
-/**
- * Builds a simple history summary from recent messages.
- * Keeps the last N messages as simple role/content pairs.
- */
-function getRecentHistory(messages, maxMessages) {
-    return messages.slice(-maxMessages);
+async function toModelMessages(messages) {
+    return messages.map((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) {
+                return {
+                    role: "user",
+                    content: [
+                        { type: "text", text: message.content },
+                        ...message.attachments.map((a) => {
+                            if (a.mimeType.startsWith("image/")) {
+                                return {
+                                    type: "image",
+                                    image: a.url,
+                                };
+                            }
+                            return {
+                                type: "file",
+                                data: a.url,
+                                mimeType: a.mimeType,
+                            };
+                        }),
+                    ],
+                };
+            }
+            return {
+                role: "user",
+                content: message.content,
+            };
+        }
+        return {
+            role: message.role,
+            content: message.content,
+        };
+    });
 }
-async function buildMessageContent(message) {
-    if (!message.attachments?.length)
-        return message.content;
-    const parts = [];
-    const trimmed = message.content.trim();
-    if (trimmed) {
-        parts.push({ type: "text", text: trimmed });
-    }
-    for (const attachment of message.attachments) {
-        if (!attachment?.mimeType?.startsWith("image/"))
-            continue;
-        if (!attachment.url)
-            continue;
-        try {
-            const response = await fetch(attachment.url);
-            if (!response.ok)
-                continue;
-            const bytes = await response.arrayBuffer();
-            parts.push({
-                type: "image",
-                image: Buffer.from(bytes),
-                mimeType: attachment.mimeType,
+// 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);
             });
         }
-        catch {
-            // Best-effort multimodal handling: skip failed image fetches.
+        if (msg.role === "assistant" && Array.isArray(msg.content)) {
+            if (msg.content.some((c) => c.type === "tool-call")) {
+                lastAssistantWithTools = msg;
+            }
         }
     }
-    return parts.length > 0 ? parts : message.content;
+    if (lastAssistantWithTools) {
+        return lastAssistantWithTools.content.filter((c) => c.type === "tool-call" && !toolResults.has(c.toolCallId));
+    }
+    return [];
 }
-async function toModelMessages(messages) {
-    const built = await Promise.all(messages.map(async (message) => ({
-        role: message.role,
-        content: await buildMessageContent(message),
-    })));
-    return built;
+// 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.
@@ -49,32 +156,76 @@ async function toModelMessages(messages) {
  * It can also automatically trigger events based on tool calls.
  */
 export const llmPlugin = (options) => (builder) => {
-    const { model, system, toolDefinitions = {}, actionEventPrefix = "action:", promptInputType = "user:text", actionResultInputType = "action:taskResult", completionEventType, usageEventType = "usage:update", usageScope = "default", modelId, } = options;
+    const { model, system, toolDefinitions = {}, actionEventPrefix = "action:", promptInputType = "agent:input", actionResultInputType = "action:result", completionEventType = "agent:output", usageEventType = "usage:update", usageScope = "default", modelId, } = options;
     async function* routeToLLM(newMessage, context, silent = false) {
         const state = context.state;
         if (!state.messages) {
             state.messages = [];
         }
-        // Add new message to history
-        state.messages.push(newMessage);
+        // 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 recentMessages = getRecentHistory(state.messages, 20);
-        const modelMessages = await toModelMessages(recentMessages);
+        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,
+            onError: (error) => {
+                console.error("streamText error:::::", JSON.stringify(error, null, 2));
+            },
         });
         for await (const delta of result.textStream) {
             assistantMessage.content += delta;
             if (!silent) {
                 yield {
-                    type: "assistant:text-delta",
+                    type: "agent:output-delta",
                     data: { delta, content: assistantMessage.content },
                 };
             }
@@ -82,8 +233,21 @@ export const llmPlugin = (options) => (builder) => {
         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) {
+        if (!assistantText && (!toolCalls || toolCalls.length === 0)) {
             state.messages = state.messages.filter((m) => m !== assistantMessage);
         }
         else {
@@ -141,12 +305,22 @@ export const llmPlugin = (options) => (builder) => {
         const attachments = Array.isArray(event.data?.attachments) ? event.data.attachments : undefined;
         yield* routeToLLM({ role: "user", content, attachments }, context);
     });
-    // Feed action results back to the LLM as user messages (with a System prefix)
-    // We use "user" role instead of "system" to avoid errors with providers like Anthropic
-    // that don't support multiple system messages or system messages after the first turn.
+    // Feed action results back as system-role feedback to the model.
     builder.on(actionResultInputType, async function* (event, context) {
-        const { action, result } = event.data;
+        const { action, result, toolCallId } = event.data;
+        const normalizedAction = typeof action === "string" ? action : "unknown";
         const summary = typeof result === "string" ? result : JSON.stringify(result);
-        yield* routeToLLM({ role: "user", content: `System: Action "${action}" completed: ${summary}` }, context);
+        yield* routeToLLM({
+            role: "tool",
+            content: [{
+                    type: 'tool-result',
+                    toolCallId,
+                    toolName: normalizedAction,
+                    output: {
+                        type: 'text',
+                        value: summary,
+                    },
+                }],
+        }, context);
     });
 };

package/dist/plugins/memory/index.js

@@ -0,0 +1,220 @@
+import { ui } from "@melony/ui-kit/server";
+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 ui.event(statusWidget(event.data.message, event.data.severity));
+    });
+};
+export default memoryPlugin;

package/dist/plugins/memory/memory.js

@@ -0,0 +1,122 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+// --- Factory ---
+export function createMemoryModule(baseDir) {
+    const memoryDir = path.join(baseDir, "memory");
+    const indexPath = path.join(memoryDir, "index.json");
+    const journalDir = path.join(memoryDir, "journal");
+    // --- Helpers ---
+    async function loadIndex() {
+        try {
+            const data = await fs.readFile(indexPath, "utf-8");
+            return JSON.parse(data);
+        }
+        catch {
+            return { entries: [] };
+        }
+    }
+    async function saveIndex(index) {
+        await fs.mkdir(memoryDir, { recursive: true });
+        await fs.writeFile(indexPath, JSON.stringify(index, null, 2), "utf-8");
+    }
+    function generateId() {
+        const timestamp = Date.now().toString(36);
+        const random = Math.random().toString(36).substring(2, 6);
+        return `mem_${timestamp}_${random}`;
+    }
+    /**
+     * Simple keyword-based relevance scoring.
+     * Splits query into terms (ignoring short words) and counts how many
+     * appear in the entry's content + tags. Returns a 0-1 score.
+     */
+    function scoreMatch(entry, query) {
+        const queryTerms = query
+            .toLowerCase()
+            .split(/\s+/)
+            .filter((t) => t.length > 2);
+        if (queryTerms.length === 0)
+            return 0;
+        const searchable = `${entry.content} ${entry.tags.join(" ")}`.toLowerCase();
+        let matched = 0;
+        for (const term of queryTerms) {
+            if (searchable.includes(term)) {
+                matched++;
+            }
+        }
+        return matched / queryTerms.length;
+    }
+    // --- Module ---
+    return {
+        async initialize() {
+            await fs.mkdir(memoryDir, { recursive: true });
+            await fs.mkdir(journalDir, { recursive: true });
+            try {
+                await fs.access(indexPath);
+            }
+            catch {
+                await saveIndex({ entries: [] });
+            }
+        },
+        async store(content, tags = []) {
+            const index = await loadIndex();
+            const entry = {
+                id: generateId(),
+                content,
+                tags,
+                createdAt: new Date().toISOString(),
+            };
+            index.entries.push(entry);
+            await saveIndex(index);
+            return entry;
+        },
+        async recall(query, options) {
+            const { tags, limit = 5 } = options || {};
+            const index = await loadIndex();
+            let candidates = index.entries;
+            // Filter by tags if provided
+            if (tags && tags.length > 0) {
+                candidates = candidates.filter((entry) => tags.some((tag) => entry.tags.includes(tag)));
+            }
+            // Score and sort by relevance
+            const scored = candidates
+                .map((entry) => ({ entry, score: scoreMatch(entry, query) }))
+                .filter(({ score }) => score > 0)
+                .sort((a, b) => b.score - a.score)
+                .slice(0, limit);
+            // If no keyword matches found, fall back to most recent entries
+            if (scored.length === 0) {
+                return candidates.slice(-limit).reverse();
+            }
+            return scored.map(({ entry }) => entry);
+        },
+        async forget(memoryId) {
+            const index = await loadIndex();
+            const before = index.entries.length;
+            index.entries = index.entries.filter((e) => e.id !== memoryId);
+            if (index.entries.length < before) {
+                await saveIndex(index);
+                return true;
+            }
+            return false;
+        },
+        async addJournalEntry(content) {
+            const today = new Date().toISOString().split("T")[0]; // e.g., "2026-02-12"
+            const journalPath = path.join(journalDir, `${today}.md`);
+            const timestamp = new Date().toLocaleTimeString();
+            const entry = `\n## ${timestamp}\n${content}\n`;
+            await fs.mkdir(journalDir, { recursive: true });
+            try {
+                await fs.access(journalPath);
+                await fs.appendFile(journalPath, entry, "utf-8");
+            }
+            catch {
+                const header = `# Journal - ${today}\n`;
+                await fs.writeFile(journalPath, header + entry, "utf-8");
+            }
+        },
+        async getRecentFacts(limit = 3) {
+            const index = await loadIndex();
+            return (index?.entries ?? []).slice(-limit);
+        },
+    };
+}