@ouro.bot/cli 0.1.0-alpha.20 → 0.1.0-alpha.200

package/dist/senses/shared-turn.js

@@ -0,0 +1,196 @@
+"use strict";
+// Shared turn runner for non-interactive senses (MCP, future senses).
+// Follows the CLI pattern: resolves context, constructs InboundTurnInput,
+// calls handleInboundTurn, collects response text, detects ponder deferral.
+//
+// Does NOT refactor CLI — CLI is stable with 2280+ tests. This is a new
+// code path for new senses that follows the same pipeline pattern.
+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.runSenseTurn = runSenseTurn;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const core_1 = require("../heart/core");
+const identity_1 = require("../heart/identity");
+const config_1 = require("../heart/config");
+const context_1 = require("../mind/context");
+const prompt_1 = require("../mind/prompt");
+const channel_1 = require("../mind/friends/channel");
+const resolver_1 = require("../mind/friends/resolver");
+const store_file_1 = require("../mind/friends/store-file");
+const pending_1 = require("../mind/pending");
+const context_2 = require("../mind/context");
+const tokens_1 = require("../mind/friends/tokens");
+const trust_gate_1 = require("./trust-gate");
+const pipeline_1 = require("./pipeline");
+const runtime_1 = require("../nerves/runtime");
+const RESPONSE_CAP = 50_000;
+/**
+ * Run a single agent turn through the inbound pipeline.
+ * Caller provides channel, session key, friend, and message;
+ * this function handles all pipeline wiring.
+ */
+async function runSenseTurn(options) {
+    const { agentName, channel, sessionKey, friendId, userMessage } = options;
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.shared_turn_start",
+        message: "shared turn runner starting",
+        meta: { agentName, channel, sessionKey, friendId },
+    });
+    // Resolve context
+    const agentRoot = (0, identity_1.getAgentRoot)(agentName);
+    const friendsPath = path.join(agentRoot, "friends");
+    const friendStore = new store_file_1.FileFriendStore(friendsPath);
+    const capabilities = (0, channel_1.getChannelCapabilities)(channel);
+    // If friendId looks like a UUID, look up the friend record directly and use its identity.
+    // Otherwise, resolve as a local user (same pattern as CLI sense).
+    const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-/.test(friendId);
+    let resolverParams;
+    if (isUuid) {
+        const existingFriend = await friendStore.get(friendId);
+        if (existingFriend) {
+            // Use the friend's first external ID for resolver context
+            const ext = existingFriend.externalIds?.[0];
+            resolverParams = {
+                provider: (ext?.provider ?? "local"),
+                externalId: ext?.externalId ?? friendId,
+                displayName: existingFriend.name ?? friendId,
+                channel,
+            };
+        }
+        else {
+            resolverParams = { provider: "local", externalId: friendId, displayName: friendId, channel };
+        }
+    }
+    else {
+        // Treat as local user identity (username@hostname pattern)
+        const username = os.userInfo().username;
+        const hostname = os.hostname();
+        resolverParams = { provider: "local", externalId: `${username}@${hostname}`, displayName: username, channel };
+    }
+    const resolver = new resolver_1.FriendResolver(friendStore, resolverParams);
+    // Session path and loading
+    const sessPath = (0, config_1.sessionPath)(friendId, channel, sessionKey);
+    const existing = (0, context_1.loadSession)(sessPath);
+    let sessionState = existing?.state;
+    const sessionMessages = existing?.messages && existing.messages.length > 0
+        ? existing.messages
+        : [{ role: "system", content: await (0, prompt_1.buildSystem)(channel, {}, undefined) }];
+    // Pending dir
+    const pendingDir = (0, pending_1.getPendingDir)(agentName, friendId, channel, sessionKey);
+    // Accumulate response text via callbacks
+    let responseText = "";
+    /* v8 ignore start — no-op callback stubs; only onTextChunk does real work (covered via mock) */
+    const callbacks = {
+        onModelStart: () => { },
+        onModelStreamStart: () => { },
+        onTextChunk: (chunk) => { responseText += chunk; },
+        onReasoningChunk: () => { },
+        onToolStart: () => { },
+        onToolEnd: () => { },
+        onError: () => { },
+    };
+    /* v8 ignore stop */
+    // Run the pipeline
+    const result = await (0, pipeline_1.handleInboundTurn)({
+        channel,
+        sessionKey,
+        capabilities,
+        messages: [{ role: "user", content: userMessage }],
+        callbacks,
+        /* v8 ignore start — delegation wrappers; pipeline integration tested separately */
+        friendResolver: { resolve: () => resolver.resolve() },
+        sessionLoader: {
+            loadOrCreate: () => Promise.resolve({
+                messages: sessionMessages,
+                sessionPath: sessPath,
+                state: sessionState,
+            }),
+        },
+        /* v8 ignore stop */
+        pendingDir,
+        friendStore,
+        provider: "local",
+        externalId: friendId,
+        enforceTrustGate: trust_gate_1.enforceTrustGate,
+        drainPending: pending_1.drainPending,
+        /* v8 ignore start — delegation wrappers; these just forward to the real functions */
+        runAgent: (msgs, cb, ch, sig, opts) => (0, core_1.runAgent)(msgs, cb, ch, sig, opts),
+        postTurn: (turnMessages, sessionPathArg, usage, hooks, state) => {
+            (0, context_2.postTurn)(turnMessages, sessionPathArg, usage, hooks, state);
+            sessionState = state;
+        },
+        /* v8 ignore stop */
+        accumulateFriendTokens: tokens_1.accumulateFriendTokens,
+    });
+    // Detect ponder deferral
+    const ponderDeferred = result.turnOutcome === "pondered";
+    // Build response
+    let finalResponse;
+    if (ponderDeferred) {
+        finalResponse = "the agent is pondering this — check back shortly via check_response.";
+    }
+    else if (responseText.length === 0) {
+        // Agent settled but no text came through callbacks — check session transcript for the settle answer
+        const postTurnSession = (0, context_1.loadSession)(sessPath);
+        if (postTurnSession?.messages) {
+            const lastAssistant = [...postTurnSession.messages].reverse().find(m => m.role === "assistant");
+            if (lastAssistant && typeof lastAssistant.content === "string" && lastAssistant.content.trim()) {
+                finalResponse = lastAssistant.content;
+            }
+            else {
+                finalResponse = "(agent responded but response was empty)";
+            }
+        }
+        else {
+            finalResponse = "(agent responded but response was empty)";
+        }
+    }
+    else {
+        finalResponse = responseText;
+    }
+    // Cap response length
+    if (finalResponse.length > RESPONSE_CAP) {
+        finalResponse = finalResponse.slice(0, RESPONSE_CAP) + "\n\n[truncated — response exceeded 50K characters]";
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.shared_turn_end",
+        message: "shared turn runner complete",
+        meta: { agentName, channel, sessionKey, friendId, ponderDeferred, responseLength: finalResponse.length },
+    });
+    return { response: finalResponse, ponderDeferred };
+}

package/dist/senses/surface-tool.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.surfaceToolDef = void 0;
+exports.handleSurface = handleSurface;
+const attention_queue_1 = require("./attention-queue");
+const runtime_1 = require("../nerves/runtime");
+// ── Tool definition ──────────────────────────────────────────────
+exports.surfaceToolDef = {
+    type: "function",
+    function: {
+        name: "surface",
+        description: "share a thought outward — deliver an answer, ask a follow-up, or surface progress to whoever needs to hear it. pass delegationId to address a held thought (see your attention queue above), or friendId for spontaneous outreach. does not end your turn.",
+        parameters: {
+            type: "object",
+            properties: {
+                content: {
+                    type: "string",
+                    description: "the message to deliver",
+                },
+                delegationId: {
+                    type: "string",
+                    description: "ID from your attention queue — addresses a specific held thought",
+                },
+                friendId: {
+                    type: "string",
+                    description: "friend to reach out to spontaneously (when not addressing a held thought)",
+                },
+            },
+            required: ["content"],
+        },
+    },
+};
+async function handleSurface(input) {
+    const { content, delegationId, friendId, queue, routeToFriend, advanceObligation, fulfillHeartObligation } = input;
+    // Resolve target friend
+    let targetFriendId;
+    let queueItem;
+    if (delegationId) {
+        // Look up in attention queue
+        const found = queue.find((item) => item.id === delegationId);
+        if (!found) {
+            return `no delegation found with id ${delegationId} — check your attention queue`;
+        }
+        targetFriendId = found.friendId;
+        queueItem = found;
+    }
+    else if (friendId) {
+        targetFriendId = friendId;
+    }
+    else {
+        return "specify who this thought is for — use delegationId to address a held thought, or friendId for spontaneous outreach";
+    }
+    // Route to target
+    const result = await routeToFriend(targetFriendId, content, queueItem);
+    (0, runtime_1.emitNervesEvent)({
+        event: "senses.surface_routed",
+        component: "senses",
+        message: `surface routed to ${targetFriendId}: ${result.status}`,
+        meta: {
+            targetFriendId,
+            status: result.status,
+            hasDelegationId: !!delegationId,
+            ...(result.detail ? { detail: result.detail } : {}),
+        },
+    });
+    // On successful routing with delegationId:
+    // 1. Advance obligation to "returned" (disk FIRST — crash safety)
+    // 2. Dequeue from in-memory queue (AFTER obligation advance)
+    if (delegationId && queueItem && result.status !== "failed") {
+        if (queueItem.obligationId) {
+            advanceObligation(queueItem.obligationId, {
+                status: "returned",
+                returnedAt: Date.now(),
+                returnTarget: "surface",
+            });
+        }
+        // Fulfill the heart obligation for this origin (separate from inner/mind obligation)
+        if (fulfillHeartObligation) {
+            try {
+                fulfillHeartObligation({
+                    friendId: queueItem.friendId,
+                    channel: queueItem.channel,
+                    key: queueItem.key,
+                });
+            }
+            catch {
+                // swallowed — heart obligation fulfillment must never break surface delivery
+            }
+        }
+        (0, attention_queue_1.dequeueAttentionItem)(queue, delegationId);
+    }
+    // Return delivery status
+    const detail = result.detail ? ` — ${result.detail}` : "";
+    return `${result.status}${detail}`;
+}