@ouro.bot/cli 0.1.0-alpha.742 → 0.1.0-alpha.743

package/dist/senses/shared-turn.js

@@ -41,6 +41,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stripThinkBlocks = stripThinkBlocks;
 exports.extractOutwardSenseDeliveryText = extractOutwardSenseDeliveryText;
+exports.getSenseSessionPath = getSenseSessionPath;
 exports.runSenseTurn = runSenseTurn;
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
@@ -175,6 +176,26 @@ function extractOutwardSenseDeliveryText(messages) {
     return assistantContentText(assistant.content)
         ?? outwardDeliveryTextFromAssistantTools(messages, assistantIndex);
 }
+function newOutwardCoordinates(events, existingEventIds) {
+    return events.flatMap((event) => {
+        if (existingEventIds.has(event.id) || event.role !== "assistant")
+            return [];
+        const outwardTools = event.toolCalls.filter((call) => call.function.name === "speak" || call.function.name === "settle");
+        if (outwardTools.length > 0)
+            return outwardTools.map((call) => ({ kind: call.function.name, eventId: event.id }));
+        return typeof event.content === "string" && event.content.trim() ? [{ kind: "text", eventId: event.id }] : [];
+    });
+}
+function causalSessionEventIds(events, existingEventIds, attempts) {
+    const coordinates = newOutwardCoordinates(events, existingEventIds);
+    const aligned = coordinates.length === attempts.length && coordinates.every((coordinate, index) => coordinate.kind === attempts[index].kind)
+        ? coordinates.map((coordinate) => coordinate.eventId)
+        : attempts.map(() => null);
+    return attempts.flatMap((attempt, index) => attempt.delivered ? [aligned[index] ?? null] : []);
+}
+function getSenseSessionPath(agentName, friendId, channel, sessionKey, agentRootOverride) {
+    return path.join(agentRootOverride ?? (0, identity_1.getAgentRoot)(agentName), "state", "sessions", friendId, channel, `${(0, config_1.sanitizeKey)(sessionKey)}.json`);
+}
 /**
  * Run a single agent turn through the inbound pipeline.
  * Caller provides channel, session key, friend, and message;
@@ -234,11 +255,20 @@ async function runSenseTurn(options) {
     // Session path and loading
     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 sessPath = getSenseSessionPath(agentName, friendId, channel, sessionKey, agentRoot);
     const runWithLease = options._withSessionTurnLease ?? session_transaction_1.withSessionTurnLease;
     return runWithLease(sessPath, async (sessionTurnLease) => {
         const baseSessionRevision = (0, session_transaction_1.readSessionTransaction)(sessPath, sessionTurnLease).revision;
         const existing = (0, context_1.loadSession)(sessPath);
+        if (options.precommittedIngress) {
+            const event = existing?.events?.find((candidate) => candidate.id === options.precommittedIngress.eventId);
+            const latestUserEvent = existing?.events?.filter((candidate) => candidate.role === "user").at(-1);
+            if (!event || event !== latestUserEvent || event.role !== "user" || event.content !== userMessage
+                || !event.relations.references.includes(options.precommittedIngress.reference)) {
+                throw new Error("shared turn precommitted ingress is missing, mismatched, or no longer current");
+            }
+        }
+        const existingEventIds = new Set(existing?.events?.map((event) => event.id) ?? []);
         let sessionState = existing?.state;
         let persistPromise;
         const sessionMessages = existing?.messages && existing.messages.length > 0
@@ -254,6 +284,7 @@ async function runSenseTurn(options) {
         let terminalDeliveryKind = "text";
         const deliveries = [];
         const deliveryFailures = [];
+        const deliveryAttempts = [];
         let providerInvocationCount = 0;
         let toolInvocationCount = 0;
         const commitResponseText = (text) => {
@@ -272,8 +303,11 @@ async function runSenseTurn(options) {
             if (!text)
                 return;
             const delivery = { kind, text };
+            const attempt = { kind, delivered: false };
+            deliveryAttempts.push(attempt);
             try {
                 await options.deliverySink?.onDelivery(delivery);
+                attempt.delivered = true;
                 deliveries.push(delivery);
                 commitResponseText(text);
             }
@@ -312,14 +346,20 @@ async function runSenseTurn(options) {
         };
         /* v8 ignore stop */
         // Run the pipeline
-        const userMsg = { role: "user", content: userMessage };
-        (0, session_events_1.stampIngressTime)(userMsg);
+        const inboundMessages = [];
+        if (!options.precommittedIngress) {
+            const userMsg = { role: "user", content: userMessage };
+            (0, session_events_1.stampIngressTime)(userMsg);
+            if (options.ingressRelations)
+                (0, session_events_1.stampIngressRelations)(userMsg, options.ingressRelations);
+            inboundMessages.push(userMsg);
+        }
         const turnResult = await (0, pipeline_1.handleInboundTurn)({
             channel,
             latencyMode: options.latencyMode,
             sessionKey,
             capabilities,
-            messages: [userMsg],
+            messages: inboundMessages,
             callbacks,
             sessionTurnLease,
             /* v8 ignore start — delegation wrappers; pipeline integration tested separately */
@@ -345,12 +385,14 @@ async function runSenseTurn(options) {
                 mcpManager,
                 ...(options.approvalCoordinatorFactory ? { approvalCoordinator: options.approvalCoordinatorFactory({ sessionPath: sessPath, baseSessionRevision }) } : {}),
                 ...(options.latencyMode === "live" ? { skipKeptNotes: true } : {}),
+                ...(options.orientationFrame ? { orientationFrame: options.orientationFrame } : {}),
                 toolContext: {
                     signin: async () => undefined,
                     ...(options.toolContext ? options.toolContext : {}),
                     currentUserMessage: userMessage,
                 },
             },
+            ...(options.prepareRunAgentOptions ? { prepareRunAgentOptions: options.prepareRunAgentOptions } : {}),
             /* 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) => {
@@ -372,14 +414,15 @@ async function runSenseTurn(options) {
                 deliveryFailures,
                 providerInvocationCount,
                 toolInvocationCount,
+                sessionPath: sessPath,
             };
         }
-        if (persistPromise)
-            await persistPromise;
+        const persistedEvents = persistPromise ? await persistPromise : [];
         await deliverPending(terminalDeliveryKind, { throwOnError: false });
         const ponderDeferred = false;
         // Build response
         let finalResponse;
+        let responseCausalSessionEventId;
         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
@@ -388,8 +431,10 @@ async function runSenseTurn(options) {
                 await persistPromise;
             const postTurnSession = (0, context_1.loadSession)(sessPath);
             if (postTurnSession?.messages) {
-                finalResponse = extractOutwardSenseDeliveryText(postTurnSession.messages)
-                    ?? "(agent responded but response was empty)";
+                const recovered = extractOutwardSenseDeliveryText(postTurnSession.messages);
+                finalResponse = recovered ?? "(agent responded but response was empty)";
+                if (recovered)
+                    responseCausalSessionEventId = newOutwardCoordinates(persistedEvents, existingEventIds).at(-1)?.eventId;
             }
             else {
                 finalResponse = "(agent responded but response was empty)";
@@ -427,6 +472,16 @@ async function runSenseTurn(options) {
             message: "shared turn runner complete",
             meta: { agentName, channel, sessionKey, friendId, ponderDeferred, responseLength: finalResponse.length },
         });
-        return { response: finalResponse, ponderDeferred, deliveries, deliveryFailures, providerInvocationCount, toolInvocationCount };
+        return {
+            response: finalResponse,
+            ponderDeferred,
+            deliveries,
+            deliveryFailures,
+            providerInvocationCount,
+            toolInvocationCount,
+            sessionPath: sessPath,
+            ...(deliveries.length > 0 ? { causalSessionEventIds: causalSessionEventIds(persistedEvents, existingEventIds, deliveryAttempts) } : {}),
+            ...(responseCausalSessionEventId ? { responseCausalSessionEventId } : {}),
+        };
     });
 }