@ouro.bot/cli 0.1.0-alpha.11 → 0.1.0-alpha.111

package/dist/heart/session-activity.js

@@ -0,0 +1,169 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listSessionActivity = listSessionActivity;
+exports.findFreshestFriendSession = findFreshestFriendSession;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+const DEFAULT_ACTIVE_THRESHOLD_MS = 24 * 60 * 60 * 1000;
+function activityPriority(source) {
+    return source === "friend-facing" ? 0 : 1;
+}
+function resolveFriendName(friendId, friendsDir, agentName) {
+    if (friendId === "self")
+        return agentName;
+    try {
+        const raw = fs.readFileSync(path.join(friendsDir, `${friendId}.json`), "utf-8");
+        const parsed = JSON.parse(raw);
+        return parsed.name ?? friendId;
+    }
+    catch {
+        return friendId;
+    }
+}
+function parseFriendActivity(sessionPath) {
+    let mtimeMs;
+    try {
+        mtimeMs = fs.statSync(sessionPath).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+    try {
+        const raw = fs.readFileSync(sessionPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const explicit = parsed?.state?.lastFriendActivityAt;
+        if (typeof explicit === "string") {
+            const parsedMs = Date.parse(explicit);
+            if (Number.isFinite(parsedMs)) {
+                return {
+                    lastActivityMs: parsedMs,
+                    lastActivityAt: new Date(parsedMs).toISOString(),
+                    activitySource: "friend-facing",
+                };
+            }
+        }
+    }
+    catch {
+        // fall back to file mtime below
+    }
+    return {
+        lastActivityMs: mtimeMs,
+        lastActivityAt: new Date(mtimeMs).toISOString(),
+        activitySource: "mtime-fallback",
+    };
+}
+function listSessionActivity(query) {
+    const { sessionsDir, friendsDir, agentName, activeThresholdMs = DEFAULT_ACTIVE_THRESHOLD_MS, currentSession = null, } = query;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.session_activity_scan",
+        message: "scanning session activity",
+        meta: {
+            sessionsDir,
+            currentSession: currentSession ? `${currentSession.friendId}/${currentSession.channel}/${currentSession.key}` : null,
+        },
+    });
+    if (!fs.existsSync(sessionsDir))
+        return [];
+    const now = Date.now();
+    const results = [];
+    let friendDirs;
+    try {
+        friendDirs = fs.readdirSync(sessionsDir);
+    }
+    catch {
+        return [];
+    }
+    for (const friendId of friendDirs) {
+        const friendPath = path.join(sessionsDir, friendId);
+        let channels;
+        try {
+            channels = fs.readdirSync(friendPath);
+        }
+        catch {
+            continue;
+        }
+        for (const channel of channels) {
+            const channelPath = path.join(friendPath, channel);
+            let keys;
+            try {
+                keys = fs.readdirSync(channelPath);
+            }
+            catch {
+                continue;
+            }
+            for (const keyFile of keys) {
+                if (!keyFile.endsWith(".json"))
+                    continue;
+                const key = keyFile.replace(/\.json$/, "");
+                if (currentSession && friendId === currentSession.friendId && channel === currentSession.channel && key === currentSession.key) {
+                    continue;
+                }
+                const sessionPath = path.join(channelPath, keyFile);
+                const activity = parseFriendActivity(sessionPath);
+                if (!activity)
+                    continue;
+                if (now - activity.lastActivityMs > activeThresholdMs)
+                    continue;
+                results.push({
+                    friendId,
+                    friendName: resolveFriendName(friendId, friendsDir, agentName),
+                    channel,
+                    key,
+                    sessionPath,
+                    lastActivityAt: activity.lastActivityAt,
+                    lastActivityMs: activity.lastActivityMs,
+                    activitySource: activity.activitySource,
+                });
+            }
+        }
+    }
+    return results.sort((a, b) => {
+        const sourceDiff = activityPriority(a.activitySource) - activityPriority(b.activitySource);
+        if (sourceDiff !== 0)
+            return sourceDiff;
+        return b.lastActivityMs - a.lastActivityMs;
+    });
+}
+function findFreshestFriendSession(query) {
+    const { activeOnly = false, activeThresholdMs = DEFAULT_ACTIVE_THRESHOLD_MS, ...rest } = query;
+    const currentSession = rest.currentSession ?? null;
+    const all = activeOnly
+        ? listSessionActivity({ ...rest, activeThresholdMs, currentSession })
+        : listSessionActivity({ ...rest, activeThresholdMs: Number.MAX_SAFE_INTEGER, currentSession });
+    return all.find((entry) => entry.friendId === query.friendId) ?? null;
+}

package/dist/heart/session-recall.js

@@ -0,0 +1,216 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recallSession = recallSession;
+exports.searchSessionTranscript = searchSessionTranscript;
+const fs = __importStar(require("fs"));
+const runtime_1 = require("../nerves/runtime");
+function normalizeContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => (part && typeof part === "object" && "type" in part && part.type === "text" && "text" in part
+        ? String(part.text ?? "")
+        : ""))
+        .filter((text) => text.length > 0)
+        .join("");
+}
+function normalizeSessionMessages(messages) {
+    if (!Array.isArray(messages))
+        return [];
+    return messages
+        .map((message) => {
+        const record = message && typeof message === "object" ? message : {};
+        return {
+            role: typeof record.role === "string" ? record.role : "",
+            content: normalizeContent(record.content),
+        };
+    })
+        .filter((message) => message.role !== "system" && message.content.length > 0);
+}
+function buildSummaryInstruction(friendId, channel, trustLevel) {
+    if (friendId === "self" && channel === "inner") {
+        return "summarize this session transcript fully and transparently. this is my own inner dialog — include all details, decisions, and reasoning.";
+    }
+    return `summarize this session transcript. the person asking has trust level: ${trustLevel}. family=full transparency, friend=share work and general topics but protect other people's identities, acquaintance=very guarded minimal disclosure.`;
+}
+function clip(text, limit = 160) {
+    const compact = text.replace(/\s+/g, " ").trim();
+    return compact.length > limit ? compact.slice(0, limit - 1) + "…" : compact;
+}
+function buildSnapshot(summary, tailMessages) {
+    const lines = [`recent focus: ${clip(summary, 240)}`];
+    const latestUser = [...tailMessages].reverse().find((message) => message.role === "user")?.content;
+    const latestAssistant = [...tailMessages].reverse().find((message) => message.role === "assistant")?.content;
+    if (latestUser) {
+        lines.push(`latest user: ${clip(latestUser)}`);
+    }
+    if (latestAssistant) {
+        lines.push(`latest assistant: ${clip(latestAssistant)}`);
+    }
+    return lines.join("\n");
+}
+function buildSearchSnapshot(query, messages, includeLatestTurn = true) {
+    const lines = [`history query: "${clip(query, 120)}"`];
+    if (!includeLatestTurn) {
+        return lines.join("\n");
+    }
+    const latestUser = [...messages].reverse().find((message) => message.role === "user")?.content;
+    const latestAssistant = [...messages].reverse().find((message) => message.role === "assistant")?.content;
+    if (latestUser) {
+        lines.push(`latest user: ${clip(latestUser)}`);
+    }
+    if (latestAssistant) {
+        lines.push(`latest assistant: ${clip(latestAssistant)}`);
+    }
+    return lines.join("\n");
+}
+function buildSearchExcerpts(messages, query, maxMatches) {
+    const normalizedQuery = query.trim().toLowerCase();
+    if (!normalizedQuery)
+        return [];
+    const candidates = [];
+    let lastMatchIndex = -2;
+    for (let i = 0; i < messages.length; i++) {
+        if (!messages[i].content.toLowerCase().includes(normalizedQuery))
+            continue;
+        if (i <= lastMatchIndex + 1)
+            continue;
+        lastMatchIndex = i;
+        const start = Math.max(0, i - 1);
+        const end = Math.min(messages.length, i + 2);
+        const excerpt = messages
+            .slice(start, end)
+            .map((message) => `[${message.role}] ${clip(message.content, 200)}`)
+            .join("\n");
+        const score = messages
+            .slice(start, end)
+            .filter((message) => message.content.toLowerCase().includes(normalizedQuery))
+            .length;
+        candidates.push({ excerpt, score, index: i });
+    }
+    const seen = new Set();
+    return candidates
+        .sort((a, b) => b.score - a.score || a.index - b.index)
+        .filter((candidate) => {
+        if (seen.has(candidate.excerpt))
+            return false;
+        seen.add(candidate.excerpt);
+        return true;
+    })
+        .slice(0, maxMatches)
+        .map((candidate) => candidate.excerpt);
+}
+async function recallSession(options) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.session_recall",
+        message: "recalling session transcript tail",
+        meta: {
+            friendId: options.friendId,
+            channel: options.channel,
+            key: options.key,
+            messageCount: options.messageCount,
+        },
+    });
+    let raw;
+    try {
+        raw = fs.readFileSync(options.sessionPath, "utf-8");
+    }
+    catch {
+        return { kind: "missing" };
+    }
+    const parsed = JSON.parse(raw);
+    const tailMessages = normalizeSessionMessages(parsed.messages).slice(-options.messageCount);
+    if (tailMessages.length === 0) {
+        return { kind: "empty" };
+    }
+    const transcript = tailMessages
+        .map((message) => `[${message.role}] ${message.content}`)
+        .join("\n");
+    const summary = options.summarize
+        ? await options.summarize(transcript, buildSummaryInstruction(options.friendId, options.channel, options.trustLevel ?? "family"))
+        : transcript;
+    return {
+        kind: "ok",
+        transcript,
+        summary,
+        snapshot: buildSnapshot(summary, tailMessages),
+        tailMessages,
+    };
+}
+async function searchSessionTranscript(options) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.session_search",
+        message: "searching session transcript",
+        meta: {
+            friendId: options.friendId,
+            channel: options.channel,
+            key: options.key,
+            query: options.query,
+            maxMatches: options.maxMatches ?? 5,
+        },
+    });
+    let raw;
+    try {
+        raw = fs.readFileSync(options.sessionPath, "utf-8");
+    }
+    catch {
+        return { kind: "missing" };
+    }
+    const parsed = JSON.parse(raw);
+    const messages = normalizeSessionMessages(parsed.messages);
+    if (messages.length === 0) {
+        return { kind: "empty" };
+    }
+    const query = options.query.trim();
+    const matches = buildSearchExcerpts(messages, query, options.maxMatches ?? 5);
+    if (matches.length === 0) {
+        return {
+            kind: "no_match",
+            query,
+            snapshot: buildSearchSnapshot(query, messages),
+        };
+    }
+    return {
+        kind: "ok",
+        query,
+        snapshot: buildSearchSnapshot(query, messages, false),
+        matches,
+    };
+}

package/dist/heart/streaming.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FinalAnswerParser = void 0;
+exports.FinalAnswerStreamer = exports.FinalAnswerParser = void 0;
 exports.toResponsesInput = toResponsesInput;
 exports.toResponsesTools = toResponsesTools;
 exports.streamChatCompletion = streamChatCompletion;
@@ -77,6 +77,95 @@ class FinalAnswerParser {
     }
 }
 exports.FinalAnswerParser = FinalAnswerParser;
+// Shared helper: wraps FinalAnswerParser with onClearText + onTextChunk wiring.
+// Used by all streaming providers (Chat Completions, Responses API, Anthropic)
+// so the eager-match streaming pattern lives in one place.
+class FinalAnswerStreamer {
+    parser = new FinalAnswerParser();
+    _detected = false;
+    callbacks;
+    enabled;
+    constructor(callbacks, enabled = true) {
+        this.callbacks = callbacks;
+        this.enabled = enabled;
+    }
+    get detected() { return this._detected; }
+    get streamed() { return this.parser.active; }
+    /** Mark final_answer as detected. Calls onClearText on the callbacks. */
+    activate() {
+        if (!this.enabled)
+            return;
+        if (this._detected)
+            return;
+        this._detected = true;
+        this.callbacks.onClearText?.();
+    }
+    /** Feed an argument delta through the parser. Emits text via onTextChunk. */
+    processDelta(delta) {
+        if (!this.enabled)
+            return;
+        if (!this._detected)
+            return;
+        const text = this.parser.process(delta);
+        if (text)
+            this.callbacks.onTextChunk(text);
+    }
+}
+exports.FinalAnswerStreamer = FinalAnswerStreamer;
+function toResponsesUserContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    const parts = [];
+    for (const part of content) {
+        if (!part || typeof part !== "object") {
+            continue;
+        }
+        if (part.type === "text" && typeof part.text === "string") {
+            parts.push({ type: "input_text", text: part.text });
+            continue;
+        }
+        if (part.type === "image_url") {
+            const imageUrl = typeof part.image_url?.url === "string" ? part.image_url.url : "";
+            if (!imageUrl)
+                continue;
+            parts.push({
+                type: "input_image",
+                image_url: imageUrl,
+                detail: part.image_url?.detail ?? "auto",
+            });
+            continue;
+        }
+        if (part.type === "input_audio" &&
+            typeof part.input_audio?.data === "string" &&
+            (part.input_audio.format === "mp3" || part.input_audio.format === "wav")) {
+            parts.push({
+                type: "input_audio",
+                input_audio: {
+                    data: part.input_audio.data,
+                    format: part.input_audio.format,
+                },
+            });
+            continue;
+        }
+        if (part.type === "file") {
+            const fileRecord = { type: "input_file" };
+            if (typeof part.file?.file_data === "string")
+                fileRecord.file_data = part.file.file_data;
+            if (typeof part.file?.file_id === "string")
+                fileRecord.file_id = part.file.file_id;
+            if (typeof part.file?.filename === "string")
+                fileRecord.filename = part.file.filename;
+            if (typeof part.file?.file_data === "string" || typeof part.file?.file_id === "string") {
+                parts.push(fileRecord);
+            }
+        }
+    }
+    return parts.length > 0 ? parts : "";
+}
 function toResponsesInput(messages) {
     let instructions = "";
     const input = [];
@@ -90,7 +179,7 @@ function toResponsesInput(messages) {
         }
         if (msg.role === "user") {
             const u = msg;
-            input.push({ role: "user", content: typeof u.content === "string" ? u.content : "" });
+            input.push({ role: "user", content: toResponsesUserContent(u.content) });
             continue;
         }
         if (msg.role === "assistant") {
@@ -102,7 +191,10 @@ function toResponsesInput(messages) {
                 }
             }
             if (a.content) {
-                input.push({ role: "assistant", content: typeof a.content === "string" ? a.content : "" });
+                const assistantItem = { role: "assistant", content: typeof a.content === "string" ? a.content : "" };
+                if (a.phase)
+                    assistantItem.phase = a.phase;
+                input.push(assistantItem);
             }
             if (a.tool_calls) {
                 for (const tc of a.tool_calls) {
@@ -141,7 +233,7 @@ function toResponsesTools(ccTools) {
         strict: false,
     }));
 }
-async function streamChatCompletion(client, createParams, callbacks, signal) {
+async function streamChatCompletion(client, createParams, callbacks, signal, eagerFinalAnswerStreaming = true) {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.stream_start",
@@ -155,8 +247,7 @@ async function streamChatCompletion(client, createParams, callbacks, signal) {
     let toolCalls = {};
     let streamStarted = false;
     let usage;
-    const answerParser = new FinalAnswerParser();
-    let finalAnswerDetected = false;
+    const answerStreamer = new FinalAnswerStreamer(callbacks, eagerFinalAnswerStreaming);
     // State machine for parsing inline <think> tags (MiniMax pattern)
     let contentBuf = "";
     let inThinkTag = false;
@@ -274,21 +365,18 @@ async function streamChatCompletion(client, createParams, callbacks, signal) {
                     // Detect final_answer tool call on first name delta.
                     // Only activate streaming if this is the sole tool call (index 0
                     // and no other indices seen). Mixed calls are rejected by core.ts.
-                    if (tc.function.name === "final_answer" && !finalAnswerDetected
+                    if (tc.function.name === "final_answer" && !answerStreamer.detected
                         && tc.index === 0 && Object.keys(toolCalls).length === 1) {
-                        finalAnswerDetected = true;
-                        callbacks.onClearText?.();
+                        answerStreamer.activate();
                     }
                 }
                 if (tc.function?.arguments) {
                     toolCalls[tc.index].arguments += tc.function.arguments;
                     // Feed final_answer argument deltas to the parser for progressive
                     // streaming, but only when it appears to be the sole tool call.
-                    if (finalAnswerDetected && toolCalls[tc.index].name === "final_answer"
+                    if (answerStreamer.detected && toolCalls[tc.index].name === "final_answer"
                         && Object.keys(toolCalls).length === 1) {
-                        const text = answerParser.process(tc.function.arguments);
-                        if (text)
-                            callbacks.onTextChunk(text);
+                        answerStreamer.processDelta(tc.function.arguments);
                     }
                 }
             }
@@ -302,10 +390,10 @@ async function streamChatCompletion(client, createParams, callbacks, signal) {
         toolCalls: Object.values(toolCalls),
         outputItems: [],
         usage,
-        finalAnswerStreamed: answerParser.active,
+        finalAnswerStreamed: answerStreamer.streamed,
     };
 }
-async function streamResponsesApi(client, createParams, callbacks, signal) {
+async function streamResponsesApi(client, createParams, callbacks, signal, eagerFinalAnswerStreaming = true) {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.stream_start",
@@ -320,9 +408,8 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
     const outputItems = [];
     let currentToolCall = null;
     let usage;
-    const answerParser = new FinalAnswerParser();
+    const answerStreamer = new FinalAnswerStreamer(callbacks, eagerFinalAnswerStreaming);
     let functionCallCount = 0;
-    let finalAnswerDetected = false;
     for await (const event of response) {
         if (signal?.aborted)
             break;
@@ -355,8 +442,7 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
                     // Only activate when this is the first (and so far only) function call.
                     // Mixed calls are rejected by core.ts; no need to stream their args.
                     if (String(event.item.name) === "final_answer" && functionCallCount === 1) {
-                        finalAnswerDetected = true;
-                        callbacks.onClearText?.();
+                        answerStreamer.activate();
                     }
                 }
                 break;
@@ -366,11 +452,9 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
                     currentToolCall.arguments += event.delta;
                     // Feed final_answer argument deltas to the parser for progressive
                     // streaming, but only when it appears to be the sole function call.
-                    if (finalAnswerDetected && currentToolCall.name === "final_answer"
+                    if (answerStreamer.detected && currentToolCall.name === "final_answer"
                         && functionCallCount === 1) {
-                        const text = answerParser.process(String(event.delta));
-                        if (text)
-                            callbacks.onTextChunk(text);
+                        answerStreamer.processDelta(String(event.delta));
                     }
                 }
                 break;
@@ -410,6 +494,6 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
         toolCalls,
         outputItems,
         usage,
-        finalAnswerStreamed: answerParser.active,
+        finalAnswerStreamed: answerStreamer.streamed,
     };
 }