@ouro.bot/cli 0.0.1-alpha.0 → 0.1.0-alpha.1

package/dist/heart/streaming.js

@@ -0,0 +1,412 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FinalAnswerParser = void 0;
+exports.toResponsesInput = toResponsesInput;
+exports.toResponsesTools = toResponsesTools;
+exports.streamChatCompletion = streamChatCompletion;
+exports.streamResponsesApi = streamResponsesApi;
+const runtime_1 = require("../nerves/runtime");
+// Character-level state machine that extracts the answer value from
+// `final_answer` tool call JSON arguments as they stream in.
+// Scans for prefix `"answer":"` or `"answer": "` in the character stream,
+// then emits text handling JSON escapes, stopping at unescaped closing `"`.
+class FinalAnswerParser {
+    // Possible prefixes to match (with and without space after colon)
+    static PREFIXES = ['"answer":"', '"answer": "'];
+    // Buffer of characters seen so far (pre-activation only)
+    buf = "";
+    _active = false;
+    _complete = false;
+    inEscape = false;
+    get active() { return this._active; }
+    get complete() { return this._complete; }
+    process(delta) {
+        if (this._complete)
+            return "";
+        let out = "";
+        for (let i = 0; i < delta.length; i++) {
+            const ch = delta[i];
+            if (!this._active) {
+                this.buf += ch;
+                // Check if any prefix has been fully matched in the buffer
+                for (const prefix of FinalAnswerParser.PREFIXES) {
+                    if (this.buf.endsWith(prefix)) {
+                        this._active = true;
+                        break;
+                    }
+                }
+            }
+            else {
+                // Active: emit characters, handling JSON escapes
+                if (this.inEscape) {
+                    this.inEscape = false;
+                    switch (ch) {
+                        case '"':
+                            out += '"';
+                            break;
+                        case '\\':
+                            out += '\\';
+                            break;
+                        case 'n':
+                            out += '\n';
+                            break;
+                        case 't':
+                            out += '\t';
+                            break;
+                        case '/':
+                            out += '/';
+                            break;
+                        default:
+                            out += ch;
+                            break; // unknown escape: pass through character
+                    }
+                }
+                else if (ch === '\\') {
+                    this.inEscape = true;
+                }
+                else if (ch === '"') {
+                    this._complete = true;
+                    return out; // stop processing, closing quote found
+                }
+                else {
+                    out += ch;
+                }
+            }
+        }
+        return out;
+    }
+}
+exports.FinalAnswerParser = FinalAnswerParser;
+function toResponsesInput(messages) {
+    let instructions = "";
+    const input = [];
+    for (const msg of messages) {
+        if (msg.role === "system") {
+            if (!instructions) {
+                const sys = msg;
+                instructions = (typeof sys.content === "string" ? sys.content : "") || "";
+            }
+            continue;
+        }
+        if (msg.role === "user") {
+            const u = msg;
+            input.push({ role: "user", content: typeof u.content === "string" ? u.content : "" });
+            continue;
+        }
+        if (msg.role === "assistant") {
+            const a = msg;
+            // Restore reasoning items before content (matching API item order)
+            if (a._reasoning_items) {
+                for (const ri of a._reasoning_items) {
+                    input.push(ri);
+                }
+            }
+            if (a.content) {
+                input.push({ role: "assistant", content: typeof a.content === "string" ? a.content : "" });
+            }
+            if (a.tool_calls) {
+                for (const tc of a.tool_calls) {
+                    input.push({
+                        type: "function_call",
+                        call_id: tc.id,
+                        name: tc.function.name,
+                        arguments: tc.function.arguments,
+                        status: "completed",
+                    });
+                }
+            }
+            continue;
+        }
+        if (msg.role === "tool") {
+            const t = msg;
+            input.push({
+                type: "function_call_output",
+                call_id: t.tool_call_id,
+                output: typeof t.content === "string" ? t.content : "",
+            });
+            continue;
+        }
+    }
+    return { instructions, input };
+}
+function toResponsesTools(ccTools) {
+    return ccTools.map((t) => ({
+        type: "function",
+        name: t.function.name,
+        description: t.function.description ?? null,
+        parameters: t.function.parameters ?? null,
+        strict: false,
+    }));
+}
+async function streamChatCompletion(client, createParams, callbacks, signal) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.stream_start",
+        message: "chat completion stream start",
+        meta: {},
+    });
+    // Request usage data in the final streaming chunk
+    createParams.stream_options = { include_usage: true };
+    const response = await client.chat.completions.create(createParams, signal ? { signal } : {});
+    let content = "";
+    let toolCalls = {};
+    let streamStarted = false;
+    let usage;
+    const answerParser = new FinalAnswerParser();
+    let finalAnswerDetected = false;
+    // State machine for parsing inline <think> tags (MiniMax pattern)
+    let contentBuf = "";
+    let inThinkTag = false;
+    const OPEN_TAG = "<think>";
+    const CLOSE_TAG = "</think>";
+    function processContentBuf(flush) {
+        while (contentBuf.length > 0) {
+            if (inThinkTag) {
+                const end = contentBuf.indexOf(CLOSE_TAG);
+                if (end !== -1) {
+                    const reasoning = contentBuf.slice(0, end);
+                    if (reasoning)
+                        callbacks.onReasoningChunk(reasoning);
+                    contentBuf = contentBuf.slice(end + CLOSE_TAG.length);
+                    inThinkTag = false;
+                }
+                else {
+                    // Check if buffer ends with a partial </think> prefix
+                    if (!flush) {
+                        let retain = 0;
+                        for (let i = 1; i < CLOSE_TAG.length && i <= contentBuf.length; i++) {
+                            if (contentBuf.endsWith(CLOSE_TAG.slice(0, i)))
+                                retain = i;
+                        }
+                        if (retain > 0) {
+                            const reasoning = contentBuf.slice(0, -retain);
+                            if (reasoning)
+                                callbacks.onReasoningChunk(reasoning);
+                            contentBuf = contentBuf.slice(-retain);
+                            return;
+                        }
+                    }
+                    // All reasoning, flush it
+                    callbacks.onReasoningChunk(contentBuf);
+                    contentBuf = "";
+                }
+            }
+            else {
+                const start = contentBuf.indexOf(OPEN_TAG);
+                if (start !== -1) {
+                    const text = contentBuf.slice(0, start);
+                    if (text)
+                        callbacks.onTextChunk(text);
+                    contentBuf = contentBuf.slice(start + OPEN_TAG.length);
+                    inThinkTag = true;
+                }
+                else {
+                    // Check if buffer ends with a partial <think> prefix
+                    if (!flush) {
+                        let retain = 0;
+                        for (let i = 1; i < OPEN_TAG.length && i <= contentBuf.length; i++) {
+                            if (contentBuf.endsWith(OPEN_TAG.slice(0, i)))
+                                retain = i;
+                        }
+                        if (retain > 0) {
+                            const text = contentBuf.slice(0, -retain);
+                            if (text)
+                                callbacks.onTextChunk(text);
+                            contentBuf = contentBuf.slice(-retain);
+                            return;
+                        }
+                    }
+                    // All content, flush it
+                    callbacks.onTextChunk(contentBuf);
+                    contentBuf = "";
+                }
+            }
+        }
+    }
+    for await (const chunk of response) {
+        if (signal?.aborted)
+            break;
+        // Capture usage from final chunk (sent when stream_options.include_usage is true)
+        if (chunk.usage) {
+            const u = chunk.usage;
+            usage = {
+                input_tokens: u.prompt_tokens,
+                output_tokens: u.completion_tokens,
+                reasoning_tokens: u.completion_tokens_details?.reasoning_tokens ?? 0,
+                total_tokens: u.total_tokens,
+            };
+        }
+        const d = chunk.choices[0]?.delta;
+        if (!d)
+            continue;
+        // Handle reasoning_content (Azure AI models like DeepSeek-R1)
+        if (d.reasoning_content) {
+            if (!streamStarted) {
+                callbacks.onModelStreamStart();
+                streamStarted = true;
+            }
+            callbacks.onReasoningChunk(d.reasoning_content);
+        }
+        if (d.content) {
+            if (!streamStarted) {
+                callbacks.onModelStreamStart();
+                streamStarted = true;
+            }
+            content += d.content;
+            contentBuf += d.content;
+            processContentBuf(false);
+        }
+        if (d.tool_calls) {
+            for (const tc of d.tool_calls) {
+                if (!toolCalls[tc.index])
+                    toolCalls[tc.index] = {
+                        id: tc.id ?? "",
+                        name: tc.function?.name ?? "",
+                        arguments: "",
+                    };
+                if (tc.id)
+                    toolCalls[tc.index].id = tc.id;
+                if (tc.function?.name) {
+                    toolCalls[tc.index].name = tc.function.name;
+                    // 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
+                        && tc.index === 0 && Object.keys(toolCalls).length === 1) {
+                        finalAnswerDetected = true;
+                        callbacks.onClearText?.();
+                    }
+                }
+                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"
+                        && Object.keys(toolCalls).length === 1) {
+                        const text = answerParser.process(tc.function.arguments);
+                        if (text)
+                            callbacks.onTextChunk(text);
+                    }
+                }
+            }
+        }
+    }
+    // Flush any remaining buffer at end of stream
+    if (contentBuf)
+        processContentBuf(true);
+    return {
+        content,
+        toolCalls: Object.values(toolCalls),
+        outputItems: [],
+        usage,
+        finalAnswerStreamed: answerParser.active,
+    };
+}
+async function streamResponsesApi(client, createParams, callbacks, signal) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.stream_start",
+        message: "responses API stream start",
+        meta: {},
+    });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Azure Responses API not in OpenAI SDK types
+    const response = await client.responses.create(createParams, signal ? { signal } : {});
+    let content = "";
+    let streamStarted = false;
+    const toolCalls = [];
+    const outputItems = [];
+    let currentToolCall = null;
+    let usage;
+    const answerParser = new FinalAnswerParser();
+    let functionCallCount = 0;
+    let finalAnswerDetected = false;
+    for await (const event of response) {
+        if (signal?.aborted)
+            break;
+        switch (event.type) {
+            case "response.output_text.delta":
+            case "response.reasoning_summary_text.delta": {
+                if (!streamStarted) {
+                    callbacks.onModelStreamStart();
+                    streamStarted = true;
+                }
+                const delta = String(event.delta);
+                if (event.type === "response.output_text.delta") {
+                    callbacks.onTextChunk(delta);
+                    content += delta;
+                }
+                else {
+                    callbacks.onReasoningChunk(delta);
+                }
+                break;
+            }
+            case "response.output_item.added": {
+                if (event.item?.type === "function_call") {
+                    functionCallCount++;
+                    currentToolCall = {
+                        call_id: String(event.item.call_id),
+                        name: String(event.item.name),
+                        arguments: "",
+                    };
+                    // Detect final_answer function call -- clear any streamed noise.
+                    // 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?.();
+                    }
+                }
+                break;
+            }
+            case "response.function_call_arguments.delta": {
+                if (currentToolCall) {
+                    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"
+                        && functionCallCount === 1) {
+                        const text = answerParser.process(String(event.delta));
+                        if (text)
+                            callbacks.onTextChunk(text);
+                    }
+                }
+                break;
+            }
+            case "response.output_item.done": {
+                outputItems.push(event.item);
+                if (event.item?.type === "function_call") {
+                    toolCalls.push({
+                        id: String(event.item.call_id),
+                        name: String(event.item.name),
+                        arguments: String(event.item.arguments),
+                    });
+                    currentToolCall = null;
+                }
+                break;
+            }
+            case "response.completed":
+            case "response.done": {
+                const u = event.response?.usage;
+                if (u) {
+                    usage = {
+                        input_tokens: u.input_tokens,
+                        output_tokens: u.output_tokens,
+                        reasoning_tokens: u.output_tokens_details?.reasoning_tokens ?? 0,
+                        total_tokens: u.total_tokens,
+                    };
+                }
+                break;
+            }
+            default:
+                // Unknown/unhandled events silently ignored
+                break;
+        }
+    }
+    return {
+        content,
+        toolCalls,
+        outputItems,
+        usage,
+        finalAnswerStreamed: answerParser.active,
+    };
+}

package/dist/heart/turn-coordinator.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTurnCoordinator = createTurnCoordinator;
+const runtime_1 = require("../nerves/runtime");
+function createTurnCoordinator() {
+    const turnLocks = new Map();
+    const activeTurns = new Set();
+    const followUpBuffers = new Map();
+    return {
+        async withTurnLock(key, fn) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.turn_start",
+                message: "turn lock acquired",
+                meta: { key },
+            });
+            const prev = turnLocks.get(key) ?? Promise.resolve();
+            const run = prev.then(async () => {
+                activeTurns.add(key);
+                try {
+                    return await fn();
+                }
+                finally {
+                    activeTurns.delete(key);
+                }
+            });
+            const settled = run.then(() => undefined, () => undefined);
+            turnLocks.set(key, settled);
+            try {
+                return await run;
+            }
+            finally {
+                if (turnLocks.get(key) === settled)
+                    turnLocks.delete(key);
+            }
+        },
+        tryBeginTurn(key) {
+            if (activeTurns.has(key))
+                return false;
+            activeTurns.add(key);
+            return true;
+        },
+        endTurn(key) {
+            activeTurns.delete(key);
+        },
+        isTurnActive(key) {
+            return activeTurns.has(key);
+        },
+        enqueueFollowUp(key, followUp) {
+            const current = followUpBuffers.get(key) ?? [];
+            current.push(followUp);
+            followUpBuffers.set(key, current);
+        },
+        drainFollowUps(key) {
+            const current = followUpBuffers.get(key);
+            if (!current || current.length === 0)
+                return [];
+            followUpBuffers.delete(key);
+            return [...current];
+        },
+    };
+}

package/dist/inner-worker-entry.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Backward-compatible wrapper; unified runtime now lives at heart/agent-entry.
+require("./heart/agent-entry");

package/dist/mind/associative-recall.js

@@ -0,0 +1,176 @@
+"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.cosineSimilarity = cosineSimilarity;
+exports.recallFactsForQuery = recallFactsForQuery;
+exports.injectAssociativeRecall = injectAssociativeRecall;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("../heart/config");
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+const DEFAULT_EMBEDDING_MODEL = "text-embedding-3-small";
+const DEFAULT_MIN_SCORE = 0.5;
+const DEFAULT_TOP_K = 3;
+class OpenAIEmbeddingProvider {
+    apiKey;
+    model;
+    constructor(apiKey, model = DEFAULT_EMBEDDING_MODEL) {
+        this.apiKey = apiKey;
+        this.model = model;
+    }
+    async embed(texts) {
+        const response = await fetch("https://api.openai.com/v1/embeddings", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                model: this.model,
+                input: texts,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`embedding request failed: ${response.status} ${response.statusText}`);
+        }
+        const payload = (await response.json());
+        if (!payload.data || payload.data.length !== texts.length) {
+            throw new Error("embedding response missing expected vectors");
+        }
+        return payload.data.map((entry) => entry.embedding);
+    }
+}
+function createDefaultProvider() {
+    const apiKey = (0, config_1.getOpenAIEmbeddingsApiKey)();
+    if (!apiKey) {
+        throw new Error("openaiEmbeddingsApiKey not configured");
+    }
+    return new OpenAIEmbeddingProvider(apiKey);
+}
+function readFacts(memoryRoot) {
+    const factsPath = path.join(memoryRoot, "facts.jsonl");
+    if (!fs.existsSync(factsPath))
+        return [];
+    const raw = fs.readFileSync(factsPath, "utf8").trim();
+    if (!raw)
+        return [];
+    return raw.split("\n").map((line) => JSON.parse(line));
+}
+function getLatestUserText(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (message.role !== "user")
+            continue;
+        if (typeof message.content !== "string")
+            continue;
+        const text = message.content.trim();
+        if (text.length > 0)
+            return text;
+    }
+    return "";
+}
+function cosineSimilarity(left, right) {
+    if (left.length === 0 || right.length === 0 || left.length !== right.length)
+        return 0;
+    let dot = 0;
+    let leftNorm = 0;
+    let rightNorm = 0;
+    for (let i = 0; i < left.length; i++) {
+        dot += left[i] * right[i];
+        leftNorm += left[i] * left[i];
+        rightNorm += right[i] * right[i];
+    }
+    if (leftNorm === 0 || rightNorm === 0)
+        return 0;
+    return dot / (Math.sqrt(leftNorm) * Math.sqrt(rightNorm));
+}
+async function recallFactsForQuery(query, facts, provider, options) {
+    const trimmed = query.trim();
+    if (!trimmed)
+        return [];
+    const minScore = options?.minScore ?? DEFAULT_MIN_SCORE;
+    const topK = options?.topK ?? DEFAULT_TOP_K;
+    const [queryEmbedding] = await provider.embed([trimmed]);
+    return facts
+        .map((fact) => ({
+        ...fact,
+        score: cosineSimilarity(queryEmbedding, fact.embedding),
+    }))
+        .filter((fact) => fact.score >= minScore)
+        .sort((left, right) => right.score - left.score)
+        .slice(0, topK);
+}
+async function injectAssociativeRecall(messages, options) {
+    try {
+        if (messages[0]?.role !== "system" || typeof messages[0].content !== "string")
+            return;
+        const query = getLatestUserText(messages);
+        if (!query)
+            return;
+        const memoryRoot = options?.memoryRoot ?? path.join((0, identity_1.getAgentRoot)(), "psyche", "memory");
+        const facts = readFacts(memoryRoot);
+        if (facts.length === 0)
+            return;
+        const provider = options?.provider ?? createDefaultProvider();
+        const recalled = await recallFactsForQuery(query, facts, provider, options);
+        if (recalled.length === 0)
+            return;
+        const recallSection = recalled
+            .map((fact, index) => `${index + 1}. ${fact.text} [score=${fact.score.toFixed(3)} source=${fact.source}]`)
+            .join("\n");
+        messages[0] = {
+            role: "system",
+            content: `${messages[0].content}\n\n## recalled context\n${recallSection}`,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.associative_recall",
+            message: "associative recall injected",
+            meta: { count: recalled.length },
+        });
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "mind",
+            event: "mind.associative_recall_error",
+            message: "associative recall failed",
+            meta: {
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+    }
+}