@ouro.bot/cli 0.1.0-alpha.6 → 0.1.0-alpha.61

package/dist/senses/pipeline.js

@@ -0,0 +1,278 @@
+"use strict";
+// Shared per-turn pipeline for all senses.
+// Senses are thin transport adapters; this module owns the common lifecycle:
+//   resolve friend -> trust gate -> load session -> drain pending -> runAgent -> postTurn -> token accumulation.
+//
+// Transport-level concerns (BB API calls, Teams cards, readline) stay in sense adapters.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleInboundTurn = handleInboundTurn;
+const runtime_1 = require("../nerves/runtime");
+const continuity_1 = require("./continuity");
+const manager_1 = require("../heart/bridges/manager");
+const identity_1 = require("../heart/identity");
+const tasks_1 = require("../repertoire/tasks");
+const session_activity_1 = require("../heart/session-activity");
+const active_work_1 = require("../heart/active-work");
+const delegation_1 = require("../heart/delegation");
+const target_resolution_1 = require("../heart/target-resolution");
+const thoughts_1 = require("../heart/daemon/thoughts");
+const pending_1 = require("../mind/pending");
+function emptyTaskBoard() {
+    return {
+        compact: "",
+        full: "",
+        byStatus: {
+            drafting: [],
+            processing: [],
+            validating: [],
+            collaborating: [],
+            paused: [],
+            blocked: [],
+            done: [],
+        },
+        actionRequired: [],
+        unresolvedDependencies: [],
+        activeSessions: [],
+        activeBridges: [],
+    };
+}
+function readInnerWorkState() {
+    try {
+        const agentRoot = (0, identity_1.getAgentRoot)();
+        const pendingDir = (0, pending_1.getInnerDialogPendingDir)((0, identity_1.getAgentName)());
+        const sessionPath = (0, thoughts_1.getInnerDialogSessionPath)(agentRoot);
+        const status = (0, thoughts_1.readInnerDialogStatus)(sessionPath, pendingDir);
+        return {
+            status: status.processing === "started" ? "running" : "idle",
+            hasPending: status.queue !== "clear",
+        };
+    }
+    catch {
+        return {
+            status: "idle",
+            hasPending: false,
+        };
+    }
+}
+// ── Pipeline ──────────────────────────────────────────────────────
+async function handleInboundTurn(input) {
+    // Step 1: Resolve friend
+    const resolvedContext = await input.friendResolver.resolve();
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.pipeline_start",
+        message: "inbound turn pipeline started",
+        meta: {
+            channel: input.channel,
+            friendId: resolvedContext.friend.id,
+            senseType: input.capabilities.senseType,
+        },
+    });
+    // Step 2: Trust gate
+    const gateInput = {
+        friend: resolvedContext.friend,
+        provider: input.provider ?? "local",
+        externalId: input.externalId ?? "",
+        tenantId: input.tenantId,
+        channel: input.channel,
+        senseType: input.capabilities.senseType,
+        isGroupChat: input.isGroupChat ?? false,
+        groupHasFamilyMember: input.groupHasFamilyMember ?? false,
+        hasExistingGroupWithFamily: input.hasExistingGroupWithFamily ?? false,
+    };
+    const gateResult = input.enforceTrustGate(gateInput);
+    // Gate rejection: return early, no agent turn
+    if (!gateResult.allowed) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.pipeline_gate_reject",
+            message: "trust gate rejected inbound turn",
+            meta: {
+                channel: input.channel,
+                friendId: resolvedContext.friend.id,
+                reason: gateResult.reason,
+            },
+        });
+        return {
+            resolvedContext,
+            gateResult,
+        };
+    }
+    // Step 3: Load/create session
+    const session = await input.sessionLoader.loadOrCreate();
+    const sessionMessages = session.messages;
+    let mustResolveBeforeHandoff = (0, continuity_1.resolveMustResolveBeforeHandoff)(session.state?.mustResolveBeforeHandoff === true, input.continuityIngressTexts);
+    const lastFriendActivityAt = input.channel === "inner"
+        ? session.state?.lastFriendActivityAt
+        : new Date().toISOString();
+    const currentObligation = input.continuityIngressTexts
+        ?.map((text) => text.trim())
+        .filter((text) => text.length > 0)
+        .at(-1);
+    const currentSession = {
+        friendId: resolvedContext.friend.id,
+        channel: input.channel,
+        key: input.sessionKey ?? "session",
+        sessionPath: session.sessionPath,
+    };
+    const activeBridges = (0, manager_1.createBridgeManager)().findBridgesForSession({
+        friendId: currentSession.friendId,
+        channel: currentSession.channel,
+        key: currentSession.key,
+    });
+    const bridgeContext = (0, manager_1.formatBridgeContext)(activeBridges) || undefined;
+    let sessionActivity = [];
+    try {
+        const agentRoot = (0, identity_1.getAgentRoot)();
+        sessionActivity = (0, session_activity_1.listSessionActivity)({
+            sessionsDir: `${agentRoot}/state/sessions`,
+            friendsDir: `${agentRoot}/friends`,
+            agentName: (0, identity_1.getAgentName)(),
+            currentSession: {
+                friendId: currentSession.friendId,
+                channel: currentSession.channel,
+                key: currentSession.key,
+            },
+        });
+    }
+    catch {
+        sessionActivity = [];
+    }
+    let targetCandidates = [];
+    try {
+        if (input.channel !== "inner") {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            targetCandidates = await (0, target_resolution_1.listTargetSessionCandidates)({
+                sessionsDir: `${agentRoot}/state/sessions`,
+                friendsDir: `${agentRoot}/friends`,
+                agentName: (0, identity_1.getAgentName)(),
+                currentSession: {
+                    friendId: currentSession.friendId,
+                    channel: currentSession.channel,
+                    key: currentSession.key,
+                },
+                friendStore: input.friendStore,
+            });
+        }
+    }
+    catch {
+        targetCandidates = [];
+    }
+    const activeWorkFrame = (0, active_work_1.buildActiveWorkFrame)({
+        currentSession,
+        currentObligation,
+        mustResolveBeforeHandoff,
+        inner: readInnerWorkState(),
+        bridges: activeBridges,
+        taskBoard: (() => {
+            try {
+                return (0, tasks_1.getTaskModule)().getBoard();
+            }
+            catch {
+                return emptyTaskBoard();
+            }
+        })(),
+        friendActivity: sessionActivity,
+        targetCandidates,
+    });
+    const delegationDecision = (0, delegation_1.decideDelegation)({
+        channel: input.channel,
+        ingressTexts: input.continuityIngressTexts ?? [],
+        activeWork: activeWorkFrame,
+        mustResolveBeforeHandoff,
+    });
+    // Step 4: Drain deferred friend returns, then ordinary per-session pending.
+    const deferredReturns = input.channel === "inner"
+        ? []
+        : (input.drainDeferredReturns?.(resolvedContext.friend.id) ?? []);
+    const sessionPending = input.drainPending(input.pendingDir);
+    const pending = [...deferredReturns, ...sessionPending];
+    // Assemble messages: session messages + pending (formatted) + inbound user messages
+    if (pending.length > 0) {
+        // Format pending messages and prepend to the user content
+        const pendingSection = pending
+            .map((msg) => `[pending from ${msg.from}]: ${msg.content}`)
+            .join("\n");
+        // If there are inbound user messages, prepend pending to the first one
+        if (input.messages.length > 0) {
+            const firstMsg = input.messages[0];
+            if (firstMsg.role === "user") {
+                if (typeof firstMsg.content === "string") {
+                    input.messages[0] = {
+                        ...firstMsg,
+                        content: `## pending messages\n${pendingSection}\n\n${firstMsg.content}`,
+                    };
+                }
+                else {
+                    input.messages[0] = {
+                        ...firstMsg,
+                        content: [
+                            { type: "text", text: `## pending messages\n${pendingSection}\n\n` },
+                            ...firstMsg.content,
+                        ],
+                    };
+                }
+            }
+        }
+    }
+    // Append user messages from the inbound turn
+    for (const msg of input.messages) {
+        sessionMessages.push(msg);
+    }
+    // Step 5: runAgent
+    const existingToolContext = input.runAgentOptions?.toolContext;
+    const runAgentOptions = {
+        ...input.runAgentOptions,
+        bridgeContext,
+        activeWorkFrame,
+        delegationDecision,
+        currentSessionKey: currentSession.key,
+        currentObligation,
+        mustResolveBeforeHandoff,
+        setMustResolveBeforeHandoff: (value) => {
+            mustResolveBeforeHandoff = value;
+        },
+        toolContext: {
+            /* v8 ignore next -- default no-op signin satisfies interface; real signin injected by sense adapter @preserve */
+            signin: async () => undefined,
+            ...existingToolContext,
+            context: resolvedContext,
+            friendStore: input.friendStore,
+            currentSession,
+            activeBridges,
+        },
+    };
+    const result = await input.runAgent(sessionMessages, input.callbacks, input.channel, input.signal, runAgentOptions);
+    // Step 6: postTurn
+    const continuingState = {
+        ...(mustResolveBeforeHandoff ? { mustResolveBeforeHandoff: true } : {}),
+        ...(typeof lastFriendActivityAt === "string" ? { lastFriendActivityAt } : {}),
+    };
+    const nextState = result.outcome === "complete" || result.outcome === "blocked" || result.outcome === "superseded"
+        ? (typeof lastFriendActivityAt === "string"
+            ? { lastFriendActivityAt }
+            : undefined)
+        : (Object.keys(continuingState).length > 0 ? continuingState : undefined);
+    input.postTurn(sessionMessages, session.sessionPath, result.usage, undefined, nextState);
+    // Step 7: Token accumulation
+    await input.accumulateFriendTokens(input.friendStore, resolvedContext.friend.id, result.usage);
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.pipeline_end",
+        message: "inbound turn pipeline completed",
+        meta: {
+            channel: input.channel,
+            friendId: resolvedContext.friend.id,
+        },
+    });
+    return {
+        resolvedContext,
+        gateResult,
+        usage: result.usage,
+        turnOutcome: result.outcome,
+        completion: result.completion,
+        sessionPath: session.sessionPath,
+        messages: sessionMessages,
+        drainedPending: pending,
+    };
+}