@ouro.bot/cli 0.1.0-alpha.729 → 0.1.0-alpha.730

package/dist/senses/shared-turn.js

@@ -58,6 +58,7 @@ const trust_gate_1 = require("./trust-gate");
 const pipeline_1 = require("./pipeline");
 const mcp_manager_1 = require("../repertoire/mcp-manager");
 const runtime_1 = require("../nerves/runtime");
+const session_transaction_1 = require("../mind/session-transaction");
 const RESPONSE_CAP = 50_000;
 const OUTWARD_DELIVERY_TOOL_ACKS = new Map([
     ["settle", "(delivered)"],
@@ -234,184 +235,190 @@ async function runSenseTurn(options) {
     const sessionDir = path.join(agentRoot, "state", "sessions", friendId, channel);
     fs.mkdirSync(sessionDir, { recursive: true });
     const sessPath = path.join(sessionDir, `${(0, config_1.sanitizeKey)(sessionKey)}.json`);
-    const existing = (0, context_1.loadSession)(sessPath);
-    let sessionState = existing?.state;
-    let persistPromise;
-    const sessionMessages = existing?.messages && existing.messages.length > 0
-        ? existing.messages
-        : [{ role: "system", content: (0, prompt_1.flattenSystemPrompt)(await (0, prompt_1.buildSystem)(channel, {}, undefined)) }];
-    // Pending dir
-    const pendingDir = (0, pending_1.getPendingDir)(agentName, friendId, channel, sessionKey);
-    // Accumulate outward text through the same callback boundary used by chat
-    // channels. `speak` flushes pending text immediately; `settle` is delivered
-    // once the turn completes.
-    let committedResponseText = "";
-    let pendingResponseText = "";
-    let terminalDeliveryKind = "text";
-    const deliveries = [];
-    const deliveryFailures = [];
-    const commitResponseText = (text) => {
-        const cleaned = stripThinkBlocks(text);
-        /* v8 ignore next -- deliverPending strips first; this is a defensive direct-call guard @preserve */
-        if (!cleaned)
-            return;
-        committedResponseText = committedResponseText
-            ? `${committedResponseText}\n${cleaned}`
-            : cleaned;
-    };
-    const deliveryErrorMessage = (error) => error instanceof Error ? error.message : String(error);
-    const deliverPending = async (kind, optionsForDelivery) => {
-        const text = stripThinkBlocks(pendingResponseText);
-        pendingResponseText = "";
-        if (!text)
-            return;
-        const delivery = { kind, text };
-        try {
-            await options.deliverySink?.onDelivery(delivery);
-            deliveries.push(delivery);
-            commitResponseText(text);
-        }
-        catch (error) {
-            const failure = { ...delivery, error: deliveryErrorMessage(error) };
-            deliveryFailures.push(failure);
-            (0, runtime_1.emitNervesEvent)({
-                level: "error",
-                component: "senses",
-                event: "senses.shared_turn_delivery_error",
-                message: "shared turn outward delivery failed",
-                meta: { agentName, channel, sessionKey, friendId, kind, error: failure.error, textLength: text.length },
-            });
-            if (optionsForDelivery.throwOnError)
-                throw error;
-            commitResponseText(text);
-        }
-    };
-    /* v8 ignore start — no-op callback stubs; only onTextChunk does real work (covered via mock) */
-    const callbacks = {
-        settleOutputMode: "retractable_buffer",
-        onModelStart: () => { },
-        onModelStreamStart: () => { },
-        onTextChunk: (chunk) => { pendingResponseText += chunk; },
-        onReasoningChunk: () => { },
-        onToolStart: () => { },
-        onToolEnd: (name, _summary, success) => {
-            if (name === "settle" && success)
-                terminalDeliveryKind = "settle";
-        },
-        onError: () => { },
-        onClearText: () => { pendingResponseText = ""; },
-        flushNow: () => deliverPending("speak", { throwOnError: true }),
-    };
-    /* v8 ignore stop */
-    // Run the pipeline
-    const userMsg = { role: "user", content: userMessage };
-    (0, session_events_1.stampIngressTime)(userMsg);
-    const turnResult = await (0, pipeline_1.handleInboundTurn)({
-        channel,
-        latencyMode: options.latencyMode,
-        sessionKey,
-        capabilities,
-        messages: [userMsg],
-        callbacks,
-        /* v8 ignore start — delegation wrappers; pipeline integration tested separately */
-        friendResolver: { resolve: () => resolver.resolve() },
-        sessionLoader: {
-            loadOrCreate: () => Promise.resolve({
-                messages: sessionMessages,
-                sessionPath: sessPath,
-                state: sessionState,
-                events: existing?.events,
-                structuredOutputs: existing?.structuredOutputs,
-            }),
-        },
-        /* v8 ignore stop */
-        pendingDir,
-        friendStore,
-        provider: resolverParams.provider,
-        externalId: resolverParams.externalId,
-        tenantId: resolverParams.tenantId,
-        enforceTrustGate: trust_gate_1.enforceTrustGate,
-        drainPending: pending_1.drainPending,
-        runAgentOptions: {
-            mcpManager,
-            ...(options.latencyMode === "live" ? { skipKeptNotes: true } : {}),
-            toolContext: {
-                signin: async () => undefined,
-                ...(options.toolContext ? options.toolContext : {}),
-                currentUserMessage: userMessage,
+    const runWithLease = options._withSessionTurnLease ?? session_transaction_1.withSessionTurnLease;
+    return runWithLease(sessPath, async (sessionTurnLease) => {
+        const existing = (0, context_1.loadSession)(sessPath);
+        let sessionState = existing?.state;
+        let persistPromise;
+        const sessionMessages = existing?.messages && existing.messages.length > 0
+            ? existing.messages
+            : [{ role: "system", content: (0, prompt_1.flattenSystemPrompt)(await (0, prompt_1.buildSystem)(channel, {}, undefined)) }];
+        // Pending dir
+        const pendingDir = (0, pending_1.getPendingDir)(agentName, friendId, channel, sessionKey);
+        // Accumulate outward text through the same callback boundary used by chat
+        // channels. `speak` flushes pending text immediately; `settle` is delivered
+        // once the turn completes.
+        let committedResponseText = "";
+        let pendingResponseText = "";
+        let terminalDeliveryKind = "text";
+        const deliveries = [];
+        const deliveryFailures = [];
+        const commitResponseText = (text) => {
+            const cleaned = stripThinkBlocks(text);
+            /* v8 ignore next -- deliverPending strips first; this is a defensive direct-call guard @preserve */
+            if (!cleaned)
+                return;
+            committedResponseText = committedResponseText
+                ? `${committedResponseText}\n${cleaned}`
+                : cleaned;
+        };
+        const deliveryErrorMessage = (error) => error instanceof Error ? error.message : String(error);
+        const deliverPending = async (kind, optionsForDelivery) => {
+            const text = stripThinkBlocks(pendingResponseText);
+            pendingResponseText = "";
+            if (!text)
+                return;
+            const delivery = { kind, text };
+            try {
+                await options.deliverySink?.onDelivery(delivery);
+                deliveries.push(delivery);
+                commitResponseText(text);
+            }
+            catch (error) {
+                const failure = { ...delivery, error: deliveryErrorMessage(error) };
+                deliveryFailures.push(failure);
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "senses",
+                    event: "senses.shared_turn_delivery_error",
+                    message: "shared turn outward delivery failed",
+                    meta: { agentName, channel, sessionKey, friendId, kind, error: failure.error, textLength: text.length },
+                });
+                if (optionsForDelivery.throwOnError)
+                    throw error;
+                commitResponseText(text);
+            }
+        };
+        /* v8 ignore start — no-op callback stubs; only onTextChunk does real work (covered via mock) */
+        const callbacks = {
+            settleOutputMode: "retractable_buffer",
+            onModelStart: () => { },
+            onModelStreamStart: () => { },
+            onTextChunk: (chunk) => { pendingResponseText += chunk; },
+            onReasoningChunk: () => { },
+            onToolStart: () => { },
+            onToolEnd: (name, _summary, success) => {
+                if (name === "settle" && success)
+                    terminalDeliveryKind = "settle";
             },
-        },
-        /* 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) => {
-            const prepared = (0, context_2.postTurnTrim)(turnMessages, usage, hooks);
-            sessionState = state;
-            persistPromise = (0, context_2.deferPostTurnPersist)(sessionPathArg, prepared, usage, state);
-        },
-        /* v8 ignore stop */
-        accumulateFriendTokens: friends_1.accumulateFriendTokens,
-    });
-    if (turnResult.gateResult && !turnResult.gateResult.allowed) {
-        const blockedResponse = "autoReply" in turnResult.gateResult
-            ? turnResult.gateResult.autoReply
-            : `(blocked by trust gate: ${turnResult.gateResult.reason})`;
-        return {
-            response: blockedResponse,
-            ponderDeferred: false,
-            deliveries,
-            deliveryFailures,
+            onError: () => { },
+            onClearText: () => { pendingResponseText = ""; },
+            flushNow: () => deliverPending("speak", { throwOnError: true }),
         };
-    }
-    await deliverPending(terminalDeliveryKind, { throwOnError: false });
-    const ponderDeferred = false;
-    // Build response
-    let finalResponse;
-    if (committedResponseText.length === 0) {
-        // Agent settled but no text came through callbacks — check session transcript for the settle answer
-        // Await deferred persist so the session file is up-to-date before readback
-        /* v8 ignore next -- persistPromise set inside v8-ignored postTurn callback; tested via pipeline integration @preserve */
+        /* v8 ignore stop */
+        // Run the pipeline
+        const userMsg = { role: "user", content: userMessage };
+        (0, session_events_1.stampIngressTime)(userMsg);
+        const turnResult = await (0, pipeline_1.handleInboundTurn)({
+            channel,
+            latencyMode: options.latencyMode,
+            sessionKey,
+            capabilities,
+            messages: [userMsg],
+            callbacks,
+            sessionTurnLease,
+            /* v8 ignore start — delegation wrappers; pipeline integration tested separately */
+            friendResolver: { resolve: () => resolver.resolve() },
+            sessionLoader: {
+                loadOrCreate: () => Promise.resolve({
+                    messages: sessionMessages,
+                    sessionPath: sessPath,
+                    state: sessionState,
+                    events: existing?.events,
+                    structuredOutputs: existing?.structuredOutputs,
+                }),
+            },
+            /* v8 ignore stop */
+            pendingDir,
+            friendStore,
+            provider: resolverParams.provider,
+            externalId: resolverParams.externalId,
+            tenantId: resolverParams.tenantId,
+            enforceTrustGate: trust_gate_1.enforceTrustGate,
+            drainPending: pending_1.drainPending,
+            runAgentOptions: {
+                mcpManager,
+                ...(options.latencyMode === "live" ? { skipKeptNotes: true } : {}),
+                toolContext: {
+                    signin: async () => undefined,
+                    ...(options.toolContext ? options.toolContext : {}),
+                    currentUserMessage: userMessage,
+                },
+            },
+            /* 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) => {
+                const prepared = (0, context_2.postTurnTrim)(turnMessages, usage, hooks);
+                sessionState = state;
+                persistPromise = (0, context_2.deferPostTurnPersist)(sessionPathArg, prepared, usage, state);
+            },
+            /* v8 ignore stop */
+            accumulateFriendTokens: friends_1.accumulateFriendTokens,
+        });
+        if (turnResult.gateResult && !turnResult.gateResult.allowed) {
+            const blockedResponse = "autoReply" in turnResult.gateResult
+                ? turnResult.gateResult.autoReply
+                : `(blocked by trust gate: ${turnResult.gateResult.reason})`;
+            return {
+                response: blockedResponse,
+                ponderDeferred: false,
+                deliveries,
+                deliveryFailures,
+            };
+        }
         if (persistPromise)
             await persistPromise;
-        const postTurnSession = (0, context_1.loadSession)(sessPath);
-        if (postTurnSession?.messages) {
-            finalResponse = extractOutwardSenseDeliveryText(postTurnSession.messages)
-                ?? "(agent responded but response was empty)";
+        await deliverPending(terminalDeliveryKind, { throwOnError: false });
+        const ponderDeferred = false;
+        // Build response
+        let finalResponse;
+        if (committedResponseText.length === 0) {
+            // Agent settled but no text came through callbacks — check session transcript for the settle answer
+            // Await deferred persist so the session file is up-to-date before readback
+            /* v8 ignore next -- persistPromise set inside v8-ignored postTurn callback; tested via pipeline integration @preserve */
+            if (persistPromise)
+                await persistPromise;
+            const postTurnSession = (0, context_1.loadSession)(sessPath);
+            if (postTurnSession?.messages) {
+                finalResponse = extractOutwardSenseDeliveryText(postTurnSession.messages)
+                    ?? "(agent responded but response was empty)";
+            }
+            else {
+                finalResponse = "(agent responded but response was empty)";
+            }
         }
         else {
-            finalResponse = "(agent responded but response was empty)";
+            finalResponse = committedResponseText;
+        }
+        // Strip MiniMax-style <think>...</think> blocks from the final response.
+        // When a reasoning-style model emits only a think block and no final answer
+        // (no settle tool call, no post-think text), the readback path above
+        // surfaces the raw saved assistant content — which includes the think tags
+        // and renders as empty (or as raw reasoning) on MCP/CLI clients. Strip
+        // here so the caller sees the actual delivered text. If only reasoning
+        // came through and nothing else, surface a clear diagnostic message
+        // instead of a blank response so the operator knows what happened.
+        finalResponse = stripThinkBlocks(finalResponse);
+        if (finalResponse.length === 0) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.shared_turn_only_reasoning",
+                message: "agent produced only <think> reasoning with no final answer — likely a model that closed the think tag without continuing",
+                meta: { agentName, channel, sessionKey, friendId },
+            });
+            finalResponse = "(agent produced reasoning but no final answer this turn — try again, or check the session transcript for the trace)";
+        }
+        // Cap response length
+        if (finalResponse.length > RESPONSE_CAP) {
+            finalResponse = finalResponse.slice(0, RESPONSE_CAP) + "\n\n[truncated — response exceeded 50K characters]";
         }
-    }
-    else {
-        finalResponse = committedResponseText;
-    }
-    // Strip MiniMax-style <think>...</think> blocks from the final response.
-    // When a reasoning-style model emits only a think block and no final answer
-    // (no settle tool call, no post-think text), the readback path above
-    // surfaces the raw saved assistant content — which includes the think tags
-    // and renders as empty (or as raw reasoning) on MCP/CLI clients. Strip
-    // here so the caller sees the actual delivered text. If only reasoning
-    // came through and nothing else, surface a clear diagnostic message
-    // instead of a blank response so the operator knows what happened.
-    finalResponse = stripThinkBlocks(finalResponse);
-    if (finalResponse.length === 0) {
         (0, runtime_1.emitNervesEvent)({
-            level: "warn",
             component: "senses",
-            event: "senses.shared_turn_only_reasoning",
-            message: "agent produced only <think> reasoning with no final answer — likely a model that closed the think tag without continuing",
-            meta: { agentName, channel, sessionKey, friendId },
+            event: "senses.shared_turn_end",
+            message: "shared turn runner complete",
+            meta: { agentName, channel, sessionKey, friendId, ponderDeferred, responseLength: finalResponse.length },
         });
-        finalResponse = "(agent produced reasoning but no final answer this turn — try again, or check the session transcript for the trace)";
-    }
-    // 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, deliveries, deliveryFailures };
     });
-    return { response: finalResponse, ponderDeferred, deliveries, deliveryFailures };
 }