@kybernesis/dispatch 0.6.1 → 0.6.3

package/dist/channel.js

@@ -1,4 +1,5 @@
-import { eveChannel } from "eve/channels/eve";
+import { defaultEveAuth, eveChannel } from "eve/channels/eve";
+import { recordCurrentSession } from "./current-session.js";
 import { localDev, placeholderAuth, vercelOidc, vercelSubject, } from "eve/channels/auth";
 /** Compose the OIDC subject string for a peer. Exposed for doctor checks and tests. */
 export function peerSubject(peer) {
@@ -58,6 +59,28 @@ export function dispatchChannel(options) {
         return governedAuth ? governedAuth(request) : null;
     };
     return eveChannel({
+        // Remember which conversation this agent is in.
+        //
+        // A schedule is handed `{ to, waitUntil, appAuth }` and has no way to name
+        // an existing session, so a routine cannot answer into the chat the person
+        // is actually looking at. This is the only place that knows — every inbound
+        // turn carries its session id — so it is written down here for the routine
+        // to find. See ./current-session.ts for why it is a file.
+        //
+        // `defaultEveAuth` is returned unchanged: this observes, it must never
+        // change who a turn runs as.
+        onMessage: (ctx) => {
+            const id = ctx.eve.sessionId;
+            if (typeof id === "string" && id !== "") {
+                const principal = ctx.eve.caller?.principalId;
+                recordCurrentSession({
+                    sessionId: id,
+                    ...(typeof principal === "string" ? { principalId: principal } : {}),
+                    at: new Date().toISOString(),
+                });
+            }
+            return { auth: defaultEveAuth(ctx) };
+        },
         auth: [
             // Verifies which deployment is calling: this project's own tokens are
             // always accepted; other projects only when enumerated as peers.

package/dist/current-session.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The conversation this agent is currently having with a person.
+ *
+ * A schedule cannot find this out for itself. It is handed `{ to, waitUntil,
+ * appAuth }` and nothing else — no session list, no way to address a session by
+ * id — so a routine that wants to answer *into the chat the person is actually
+ * looking at* has no way to name it. The information exists, but only here: the
+ * eve channel sees `sessionId` on every inbound turn.
+ *
+ * So the channel writes it down. This is deliberately a file and not memory:
+ * `@kybernesis/manage` restarts the agent whenever a routine is added, and an
+ * in-process variable would be empty exactly when the first routine fires.
+ *
+ * Agent-local by design. The control plane has no part in this — a routine is
+ * the agent's own business, and routing one through a hosted service would make
+ * a local conversation depend on a network it never needed.
+ */
+export interface CurrentSession {
+    /** The durable eve session id of the most recent inbound turn. */
+    sessionId: string;
+    /** Who was talking, when a verified principal was present. */
+    principalId?: string;
+    /** ISO timestamp, so a stale pointer is recognisable as stale. */
+    at: string;
+}
+/** Where the pointer lives, next to the agent's other runtime state. */
+export declare function currentSessionFile(appRoot?: string): string;
+/**
+ * Record the session this turn belongs to. Never throws: a read-only or full
+ * filesystem must not take a conversation down, and the cost of failing is one
+ * routine landing in a new thread instead of the open one.
+ */
+export declare function recordCurrentSession(input: CurrentSession, appRoot?: string): void;
+/** Read the pointer, or undefined when there has never been a turn. */
+export declare function readCurrentSession(appRoot?: string): CurrentSession | undefined;

package/dist/current-session.js

@@ -0,0 +1,45 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+/** Where the pointer lives, next to the agent's other runtime state. */
+export function currentSessionFile(appRoot) {
+    const root = appRoot ?? process.env.EVE_APP_DIR ?? process.cwd();
+    return join(root, ".eve", "current-session.json");
+}
+/**
+ * Record the session this turn belongs to. Never throws: a read-only or full
+ * filesystem must not take a conversation down, and the cost of failing is one
+ * routine landing in a new thread instead of the open one.
+ */
+export function recordCurrentSession(input, appRoot) {
+    try {
+        const file = currentSessionFile(appRoot);
+        mkdirSync(dirname(file), { recursive: true });
+        // Written to a sibling and renamed: a reader that arrives mid-write gets
+        // the old pointer rather than half a JSON document.
+        const tmp = `${file}.${process.pid}.tmp`;
+        writeFileSync(tmp, JSON.stringify(input), "utf8");
+        renameSync(tmp, file);
+    }
+    catch {
+        // Intentionally silent, see above.
+    }
+}
+/** Read the pointer, or undefined when there has never been a turn. */
+export function readCurrentSession(appRoot) {
+    try {
+        const raw = JSON.parse(readFileSync(currentSessionFile(appRoot), "utf8"));
+        if (typeof raw !== "object" || raw === null)
+            return undefined;
+        const o = raw;
+        if (typeof o.sessionId !== "string" || o.sessionId === "")
+            return undefined;
+        return {
+            sessionId: o.sessionId,
+            ...(typeof o.principalId === "string" ? { principalId: o.principalId } : {}),
+            at: typeof o.at === "string" ? o.at : new Date(0).toISOString(),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/index.d.ts

@@ -25,3 +25,4 @@ export { remotePeer, type RemotePeerOptions } from "./remote-peer.js";
 export { type GovernedOptions } from "./governed.js";
 export { dispatchChannel, peerSubject, type DispatchChannelOptions, type PeerRef, } from "./channel.js";
 export { governedPeers, type GovernedPeersOptions } from "./governed-peers.js";
+export { currentSessionFile, readCurrentSession, recordCurrentSession, type CurrentSession, } from "./current-session.js";

package/dist/index.js

@@ -24,3 +24,4 @@
 export { remotePeer } from "./remote-peer.js";
 export { dispatchChannel, peerSubject, } from "./channel.js";
 export { governedPeers } from "./governed-peers.js";
+export { currentSessionFile, readCurrentSession, recordCurrentSession, } from "./current-session.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kybernesis/dispatch",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Agent-to-agent dispatch for eve agents: declared remote-peer edges with principal forwarding on by default, and a receiver channel that makes trusting the wrong caller hard to express.",
   "license": "Apache-2.0",
   "type": "module",
@@ -33,12 +33,12 @@
   "devDependencies": {
     "@kybernesis/enterprise": "^0.8.0",
     "@types/node": "24.x",
-    "eve": "^0.53.1",
+    "eve": "^0.51.1",
     "typescript": "7.0.2"
   },
   "peerDependencies": {
     "@kybernesis/enterprise": ">=0.2.0",
-    "eve": ">=0.53.0 <0.54.0"
+    "eve": ">=0.51.0 <0.52.0"
   },
   "engines": {
     "node": ">=20"