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

package/dist/heart/core.js

@@ -0,0 +1,515 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasToolIntent = exports.buildSystem = exports.toResponsesTools = exports.toResponsesInput = exports.streamResponsesApi = exports.streamChatCompletion = exports.getToolsForChannel = exports.summarizeArgs = exports.execTool = exports.tools = void 0;
+exports.createProviderRegistry = createProviderRegistry;
+exports.getModel = getModel;
+exports.getProvider = getProvider;
+exports.createSummarize = createSummarize;
+exports.getProviderDisplayLabel = getProviderDisplayLabel;
+exports.stripLastToolCalls = stripLastToolCalls;
+exports.isTransientError = isTransientError;
+exports.classifyTransientError = classifyTransientError;
+exports.runAgent = runAgent;
+const config_1 = require("./config");
+const identity_1 = require("./identity");
+const tools_1 = require("../repertoire/tools");
+const channel_1 = require("../mind/friends/channel");
+// Kick detection preserved but disabled — see comment in agent loop below.
+// import { detectKick } from "./kicks";
+// import type { KickReason } from "./kicks";
+const runtime_1 = require("../nerves/runtime");
+const context_1 = require("../mind/context");
+const prompt_1 = require("../mind/prompt");
+const associative_recall_1 = require("../mind/associative-recall");
+const anthropic_1 = require("./providers/anthropic");
+const azure_1 = require("./providers/azure");
+const minimax_1 = require("./providers/minimax");
+const openai_codex_1 = require("./providers/openai-codex");
+let _providerRuntime = null;
+function createProviderRegistry() {
+    const factories = {
+        azure: azure_1.createAzureProviderRuntime,
+        anthropic: anthropic_1.createAnthropicProviderRuntime,
+        minimax: minimax_1.createMinimaxProviderRuntime,
+        "openai-codex": openai_codex_1.createOpenAICodexProviderRuntime,
+    };
+    return {
+        resolve() {
+            const provider = (0, identity_1.loadAgentConfig)().provider;
+            return factories[provider]();
+        },
+    };
+}
+function getProviderRuntime() {
+    if (!_providerRuntime) {
+        try {
+            _providerRuntime = createProviderRegistry().resolve();
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "engine.provider_init_error",
+                component: "engine",
+                message: msg,
+                meta: {},
+            });
+            // eslint-disable-next-line no-console -- pre-boot guard: provider init failure
+            console.error(`\n[fatal] ${msg}\n`);
+            process.exit(1);
+            throw new Error("unreachable");
+        }
+        if (!_providerRuntime) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "engine.provider_init_error",
+                component: "engine",
+                message: "provider runtime could not be initialized.",
+                meta: {},
+            });
+            process.exit(1);
+            throw new Error("unreachable");
+        }
+    }
+    return _providerRuntime;
+}
+function getModel() {
+    return getProviderRuntime().model;
+}
+function getProvider() {
+    return getProviderRuntime().id;
+}
+function createSummarize() {
+    return async (transcript, instruction) => {
+        const runtime = getProviderRuntime();
+        const client = runtime.client;
+        const response = await client.chat.completions.create({
+            model: runtime.model,
+            messages: [
+                { role: "system", content: instruction },
+                { role: "user", content: transcript },
+            ],
+            max_tokens: 500,
+        });
+        return response.choices?.[0]?.message?.content ?? transcript;
+    };
+}
+function getProviderDisplayLabel() {
+    const model = getModel();
+    const providerLabelBuilders = {
+        azure: () => `azure openai (${(0, config_1.getAzureConfig)().deployment || "default"}, model: ${model})`,
+        anthropic: () => `anthropic (${model})`,
+        minimax: () => `minimax (${model})`,
+        "openai-codex": () => `openai codex (${model})`,
+    };
+    return providerLabelBuilders[getProvider()]();
+}
+// Re-export tools, execTool, summarizeArgs from ./tools for backward compat
+var tools_2 = require("../repertoire/tools");
+Object.defineProperty(exports, "tools", { enumerable: true, get: function () { return tools_2.tools; } });
+Object.defineProperty(exports, "execTool", { enumerable: true, get: function () { return tools_2.execTool; } });
+Object.defineProperty(exports, "summarizeArgs", { enumerable: true, get: function () { return tools_2.summarizeArgs; } });
+Object.defineProperty(exports, "getToolsForChannel", { enumerable: true, get: function () { return tools_2.getToolsForChannel; } });
+// Re-export streaming functions for backward compat
+var streaming_1 = require("./streaming");
+Object.defineProperty(exports, "streamChatCompletion", { enumerable: true, get: function () { return streaming_1.streamChatCompletion; } });
+Object.defineProperty(exports, "streamResponsesApi", { enumerable: true, get: function () { return streaming_1.streamResponsesApi; } });
+Object.defineProperty(exports, "toResponsesInput", { enumerable: true, get: function () { return streaming_1.toResponsesInput; } });
+Object.defineProperty(exports, "toResponsesTools", { enumerable: true, get: function () { return streaming_1.toResponsesTools; } });
+// Re-export prompt functions for backward compat
+var prompt_2 = require("../mind/prompt");
+Object.defineProperty(exports, "buildSystem", { enumerable: true, get: function () { return prompt_2.buildSystem; } });
+// Re-export kick utilities for backward compat
+var kicks_1 = require("./kicks");
+Object.defineProperty(exports, "hasToolIntent", { enumerable: true, get: function () { return kicks_1.hasToolIntent; } });
+function upsertSystemPrompt(messages, systemText) {
+    const systemMessage = { role: "system", content: systemText };
+    if (messages[0]?.role === "system") {
+        messages[0] = systemMessage;
+    }
+    else {
+        messages.unshift(systemMessage);
+    }
+}
+// Remove orphan tool_calls from the last assistant message and any
+// trailing tool-result messages that lack a matching tool_call.
+// This keeps the conversation valid after an abort or tool-loop limit.
+function stripLastToolCalls(messages) {
+    // Pop any trailing tool-result messages
+    while (messages.length && messages[messages.length - 1].role === "tool") {
+        messages.pop();
+    }
+    // Strip tool_calls from the last assistant message
+    const last = messages[messages.length - 1];
+    if (last?.role === "assistant") {
+        const asst = last;
+        if (asst.tool_calls) {
+            delete asst.tool_calls;
+            // If the assistant message is now empty, remove it entirely
+            if (!asst.content)
+                messages.pop();
+        }
+    }
+}
+// Detect context overflow errors from Azure or MiniMax
+function isContextOverflow(err) {
+    if (!(err instanceof Error))
+        return false;
+    const code = err.code;
+    const msg = err.message || "";
+    if (code === "context_length_exceeded")
+        return true;
+    if (msg.includes("context_length_exceeded"))
+        return true;
+    if (msg.includes("context window exceeds limit"))
+        return true;
+    return false;
+}
+// Detect transient network errors worth retrying
+function isTransientError(err) {
+    if (!(err instanceof Error))
+        return false;
+    const msg = err.message || "";
+    const code = err.code || "";
+    // Node.js network error codes
+    if (["ECONNRESET", "ECONNREFUSED", "ENOTFOUND", "ETIMEDOUT", "EPIPE",
+        "EAI_AGAIN", "EHOSTUNREACH", "ENETUNREACH", "ECONNABORTED"].includes(code))
+        return true;
+    // OpenAI SDK / fetch errors
+    if (msg.includes("fetch failed"))
+        return true;
+    if (msg.includes("network") && !msg.includes("context"))
+        return true;
+    if (msg.includes("ECONNRESET") || msg.includes("ETIMEDOUT"))
+        return true;
+    if (msg.includes("socket hang up"))
+        return true;
+    if (msg.includes("getaddrinfo"))
+        return true;
+    // HTTP 429 / 500 / 502 / 503 / 504
+    const status = err.status;
+    if (status === 429 || status === 500 || status === 502 || status === 503 || status === 504)
+        return true;
+    return false;
+}
+function classifyTransientError(err) {
+    if (!(err instanceof Error))
+        return "unknown error";
+    const status = err.status;
+    if (status === 429)
+        return "rate limited";
+    if (status === 401 || status === 403)
+        return "auth error";
+    if (status && status >= 500)
+        return "server error";
+    return "network error";
+}
+const MAX_RETRIES = 3;
+const RETRY_BASE_MS = 2000;
+async function runAgent(messages, callbacks, channel, signal, options) {
+    const providerRuntime = getProviderRuntime();
+    const provider = providerRuntime.id;
+    const toolChoiceRequired = options?.toolChoiceRequired ?? true;
+    const traceId = options?.traceId;
+    (0, runtime_1.emitNervesEvent)({
+        event: "engine.turn_start",
+        trace_id: traceId,
+        component: "engine",
+        message: "runAgent turn started",
+        meta: { channel: channel ?? "unknown", provider },
+    });
+    // Per-turn friend refresh: re-read friend record from disk for fresh context
+    const friendStore = options?.toolContext?.friendStore;
+    const friendId = options?.toolContext?.context?.friend?.id;
+    let currentContext = options?.toolContext?.context;
+    if (friendStore && friendId) {
+        const freshFriend = await friendStore.get(friendId);
+        if (freshFriend) {
+            currentContext = { ...currentContext, friend: freshFriend };
+        }
+    }
+    // Refresh system prompt at start of each turn when channel is provided.
+    // If refresh fails, keep existing system prompt (or inject a minimal safe fallback)
+    // so turn execution remains consistent and non-fatal.
+    if (channel) {
+        try {
+            const refreshed = await (0, prompt_1.buildSystem)(channel, options, currentContext);
+            upsertSystemPrompt(messages, refreshed);
+        }
+        catch (error) {
+            const hadExistingSystemPrompt = messages[0]?.role === "system" && typeof messages[0].content === "string";
+            const existingSystemText = hadExistingSystemPrompt ? messages[0].content : undefined;
+            const fallback = existingSystemText ?? "You are a helpful assistant.";
+            upsertSystemPrompt(messages, fallback);
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                event: "mind.step_error",
+                trace_id: traceId,
+                component: "mind",
+                message: "buildSystem refresh failed; using fallback prompt",
+                meta: {
+                    channel,
+                    reason: error instanceof Error ? error.message : String(error),
+                    used_existing_prompt: hadExistingSystemPrompt,
+                },
+            });
+        }
+    }
+    await (0, associative_recall_1.injectAssociativeRecall)(messages);
+    // kickCount and lastKickReason preserved but unused while kick detection is disabled.
+    // let kickCount = 0;
+    // let lastKickReason: KickReason | null = null;
+    let done = false;
+    let lastUsage;
+    let overflowRetried = false;
+    let retryCount = 0;
+    // Prevent MaxListenersExceeded warning — each iteration adds a listener
+    try {
+        require("events").setMaxListeners(50, signal);
+    }
+    catch { /* unsupported */ }
+    const toolPreferences = currentContext?.friend?.toolPreferences;
+    const baseTools = (0, tools_1.getToolsForChannel)(channel ? (0, channel_1.getChannelCapabilities)(channel) : undefined, toolPreferences && Object.keys(toolPreferences).length > 0 ? toolPreferences : undefined);
+    // Rebase provider-owned turn state from canonical messages at user-turn start.
+    // This prevents stale provider caches from replaying prior-turn context.
+    providerRuntime.resetTurnState(messages);
+    while (!done) {
+        // When toolChoiceRequired is true (the default), include final_answer
+        // so the model can signal completion. With tool_choice: required, the
+        // model must call a tool every turn — final_answer is how it exits.
+        // Overridable via options.toolChoiceRequired = false (e.g. CLI).
+        const activeTools = toolChoiceRequired ? [...baseTools, tools_1.finalAnswerTool] : baseTools;
+        const steeringFollowUps = options?.drainSteeringFollowUps?.() ?? [];
+        if (steeringFollowUps.length > 0) {
+            for (const followUp of steeringFollowUps) {
+                messages.push({ role: "user", content: followUp.text });
+            }
+            providerRuntime.resetTurnState(messages);
+        }
+        // Yield so pending I/O (stdin Ctrl-C) can be processed between iterations
+        await new Promise((r) => setImmediate(r));
+        if (signal?.aborted)
+            break;
+        try {
+            callbacks.onModelStart();
+            const result = await providerRuntime.streamTurn({
+                messages,
+                activeTools,
+                callbacks,
+                signal,
+                traceId,
+                toolChoiceRequired,
+            });
+            // Track usage from the latest API call
+            if (result.usage)
+                lastUsage = result.usage;
+            retryCount = 0; // reset on success
+            // SHARED: build CC-format assistant message from TurnResult
+            const msg = {
+                role: "assistant",
+            };
+            if (result.content)
+                msg.content = result.content;
+            if (result.toolCalls.length)
+                msg.tool_calls = result.toolCalls.map((tc) => ({
+                    id: tc.id,
+                    type: "function",
+                    function: { name: tc.name, arguments: tc.arguments },
+                }));
+            // Store reasoning items from the API response on the assistant message
+            // so they persist through session save/load and can be restored in toResponsesInput
+            const reasoningItems = result.outputItems.filter((item) => "type" in item && item.type === "reasoning");
+            if (reasoningItems.length > 0) {
+                msg._reasoning_items = reasoningItems;
+            }
+            if (!result.toolCalls.length) {
+                // Kick detection is disabled while tool_choice: required + final_answer
+                // is the primary loop control mechanism. The model should never reach
+                // this path (tool_choice: required forces a tool call), but if it does,
+                // accept the response as-is rather than risk false-positive kicks.
+                //
+                // Preserved for future use — re-enable by uncommenting:
+                // const kick = detectKick(result.content, options);
+                // if (kick) {
+                //   kickCount++;
+                //   lastKickReason = kick.reason;
+                //   callbacks.onKick?.();
+                //   const kickContent = result.content
+                //     ? result.content + "\n\n" + kick.message
+                //     : kick.message;
+                //   messages.push({ role: "assistant", content: kickContent });
+                //   providerRuntime.resetTurnState(messages);
+                //   continue;
+                // }
+                messages.push(msg);
+                done = true;
+            }
+            else {
+                // Check for final_answer sole call: intercept before tool execution
+                const isSoleFinalAnswer = result.toolCalls.length === 1 && result.toolCalls[0].name === "final_answer";
+                if (isSoleFinalAnswer) {
+                    // Extract answer from the tool call arguments.
+                    // Supports: {"answer":"text"}, "text" (JSON string), retry on failure.
+                    let answer;
+                    try {
+                        const parsed = JSON.parse(result.toolCalls[0].arguments);
+                        if (typeof parsed === "string") {
+                            answer = parsed;
+                        }
+                        else if (parsed.answer != null) {
+                            answer = parsed.answer;
+                        }
+                        // else: valid JSON but no answer field — answer stays undefined (retry)
+                    }
+                    catch {
+                        // JSON parsing failed (e.g. truncated output) — answer stays undefined (retry)
+                    }
+                    if (answer != null) {
+                        if (result.finalAnswerStreamed) {
+                            // The streaming layer already parsed and emitted the answer
+                            // progressively via FinalAnswerParser. Skip clearing and
+                            // re-emitting to avoid double-delivery.
+                        }
+                        else {
+                            // Clear any streamed noise (e.g. refusal text) before emitting.
+                            callbacks.onClearText?.();
+                            // Emit the answer through the callback pipeline so channels receive it.
+                            // Never truncate -- channel adapters handle splitting long messages.
+                            callbacks.onTextChunk(answer);
+                        }
+                        // Keep the full assistant message (with tool_calls) for debuggability,
+                        // plus a synthetic tool response so the conversation stays valid on resume.
+                        messages.push(msg);
+                        messages.push({ role: "tool", tool_call_id: result.toolCalls[0].id, content: "(delivered)" });
+                        providerRuntime.appendToolOutput(result.toolCalls[0].id, "(delivered)");
+                        done = true;
+                    }
+                    else {
+                        // Answer is undefined -- the model's final_answer was incomplete or
+                        // malformed. Clear any partial streamed text or noise, then push the
+                        // assistant msg + error tool result and let the model try again.
+                        callbacks.onClearText?.();
+                        const retryError = "your final_answer was incomplete or malformed. call final_answer again with your complete response.";
+                        messages.push(msg);
+                        messages.push({ role: "tool", tool_call_id: result.toolCalls[0].id, content: retryError });
+                        providerRuntime.appendToolOutput(result.toolCalls[0].id, retryError);
+                    }
+                    continue;
+                }
+                messages.push(msg);
+                // SHARED: execute tools (final_answer in mixed calls is rejected inline)
+                for (const tc of result.toolCalls) {
+                    if (signal?.aborted)
+                        break;
+                    // Intercept final_answer in mixed call: reject it
+                    if (tc.name === "final_answer") {
+                        const rejection = "rejected: final_answer must be the only tool call. Finish your work first, then call final_answer alone.";
+                        messages.push({ role: "tool", tool_call_id: tc.id, content: rejection });
+                        providerRuntime.appendToolOutput(tc.id, rejection);
+                        continue;
+                    }
+                    let args = {};
+                    try {
+                        args = JSON.parse(tc.arguments);
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                    const argSummary = (0, tools_1.summarizeArgs)(tc.name, args);
+                    // Confirmation check for mutate tools
+                    if ((0, tools_1.isConfirmationRequired)(tc.name) && !options?.skipConfirmation) {
+                        let decision = "denied";
+                        if (callbacks.onConfirmAction) {
+                            decision = await callbacks.onConfirmAction(tc.name, args);
+                        }
+                        if (decision !== "confirmed") {
+                            const cancelled = "Action cancelled by user.";
+                            callbacks.onToolStart(tc.name, args);
+                            callbacks.onToolEnd(tc.name, argSummary, false);
+                            messages.push({ role: "tool", tool_call_id: tc.id, content: cancelled });
+                            providerRuntime.appendToolOutput(tc.id, cancelled);
+                            continue;
+                        }
+                    }
+                    callbacks.onToolStart(tc.name, args);
+                    let toolResult;
+                    let success;
+                    try {
+                        toolResult = await (0, tools_1.execTool)(tc.name, args, options?.toolContext);
+                        success = true;
+                    }
+                    catch (e) {
+                        toolResult = `error: ${e}`;
+                        success = false;
+                    }
+                    callbacks.onToolEnd(tc.name, argSummary, success);
+                    messages.push({ role: "tool", tool_call_id: tc.id, content: toolResult });
+                    providerRuntime.appendToolOutput(tc.id, toolResult);
+                }
+            }
+        }
+        catch (e) {
+            // Abort is not an error — just stop cleanly
+            if (signal?.aborted) {
+                stripLastToolCalls(messages);
+                break;
+            }
+            // Context overflow: trim aggressively and retry once
+            if (isContextOverflow(e) && !overflowRetried) {
+                overflowRetried = true;
+                stripLastToolCalls(messages);
+                const { maxTokens, contextMargin } = (0, config_1.getContextConfig)();
+                const trimmed = (0, context_1.trimMessages)(messages, maxTokens, contextMargin, maxTokens * 2);
+                messages.splice(0, messages.length, ...trimmed);
+                providerRuntime.resetTurnState(messages);
+                callbacks.onError(new Error("context trimmed, retrying..."), "transient");
+                continue;
+            }
+            // Transient errors: retry with exponential backoff
+            if (isTransientError(e) && retryCount < MAX_RETRIES) {
+                retryCount++;
+                const delay = RETRY_BASE_MS * Math.pow(2, retryCount - 1);
+                const cause = classifyTransientError(e);
+                callbacks.onError(new Error(`${cause}, retrying in ${delay / 1000}s (${retryCount}/${MAX_RETRIES})...`), "transient");
+                // Wait with abort support
+                const aborted = await new Promise((resolve) => {
+                    const timer = setTimeout(() => resolve(false), delay);
+                    if (signal) {
+                        const onAbort = () => { clearTimeout(timer); resolve(true); };
+                        if (signal.aborted) {
+                            clearTimeout(timer);
+                            resolve(true);
+                            return;
+                        }
+                        signal.addEventListener("abort", onAbort, { once: true });
+                    }
+                });
+                if (aborted) {
+                    stripLastToolCalls(messages);
+                    break;
+                }
+                providerRuntime.resetTurnState(messages);
+                continue;
+            }
+            callbacks.onError(e instanceof Error ? e : new Error(String(e)), "terminal");
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "engine.error",
+                trace_id: traceId,
+                component: "engine",
+                message: e instanceof Error ? e.message : String(e),
+                meta: {},
+            });
+            stripLastToolCalls(messages);
+            done = true;
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        event: "engine.turn_end",
+        trace_id: traceId,
+        component: "engine",
+        message: "runAgent turn completed",
+        meta: { done },
+    });
+    return { usage: lastUsage };
+}