@theoremjs/web 0.3.4-next.717.gd16ffc6 → 0.3.4-next.721.g7ff150a

package/README.md

@@ -456,7 +456,7 @@ To retain execution claims across connections, supply a durable coordinator as `
 Browser dispatch uses a host-owned `PageToolExecution` service beside the execution coordinator.
 `createTheoremHandler` supplies both services. Live relays put the session boundary's `pageExecution` and `toolExecution` on `SessionRequest`.
 
-A tool with a `background` setting runs inline until you pass the `background` option to `createTheoremHandler`. The option takes `{ request, sessionId }` and returns a `ToolBackgroundService`, which receives each detached call and its late events. The session keeps the call as `background` until it settles, and a late settlement does not invalidate a checkpoint. Keep the service's values valid after the request ends. A live relay passes its service to `runSession`.
+A tool with a `background` setting runs inline until you pass the `background` option to `createTheoremHandler`. The option takes `{ request, sessionId }` and returns a `ToolBackgroundService`, which receives each detached call and its late events. The session keeps the call as `background` until it settles, and a late settlement does not invalidate a checkpoint. A conversation read shows the call as it stands: running, then its result, or an error for a marked call. An open page reads it on its next turn or reload. When the session has dropped a settled operation, the block reads an error with the code `outcome_not_retained`. On a durable store, a worker that dies leaves the operation as `background`, so your sweep marks it `uncertain` with `worker_lost` through `compareAndSwap`. Keep the service's values valid after the request ends. A live relay passes its service to `runSession`.
 Forward live page results to `answerPageResult`. Preserve checkpoint ownership through `beforeEvent` when using the Studio bridge.
 The default `PageToolBroker` keeps active result waiters in process memory. Several workers need a shared broker or request affinity.
 Use `pageToolBroker` to supply that broker. It carries results; the atomic session store retains execution authority.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theoremjs/web",
-  "version": "0.3.4-next.717.gd16ffc6",
+  "version": "0.3.4-next.721.g7ff150a",
   "description": "Theorem on the web platform, with no UI framework: Web-standard server handlers that serve a profile, and the browser client that talks to them.",
   "license": "MIT",
   "type": "module",
@@ -25,6 +25,6 @@
   },
   "peerDependencies": {
     "zod": "^4.6.5",
-    "@theoremjs/agents": "^0.3.4-next.717.gd16ffc6"
+    "@theoremjs/agents": "^0.3.4-next.721.g7ff150a"
   }
 }

package/server/handler.js

@@ -42,7 +42,7 @@ import { answerGatedCall, resolveGateTtlMs, } from '@theoremjs/agents/kernel';
 import { hostInterface, theoremHostCallRequestSchema, } from "../client/host-transport.js";
 import { theoremConversationRequestSchema, theoremInvokeRequestSchema, theoremRewindRequestSchema, theoremSteerRequestSchema, theoremStopRequestSchema, theoremTurnRequestSchema, } from "../client/transport.js";
 import { answerReply, conversationView, messageReply, openConversation, postedMessage, readerConversationHost, requiredOperationId, rewindConversation, statelessRefusal, waitingCalls, } from "./conversation.js";
-import { unknownConversation } from "./conversation-store.js";
+import { unknownConversation, } from "./conversation-store.js";
 import { createMemoryCredentialStore, } from "./credential-store.js";
 import { sessionStateStore, } from "./session-authority.js";
 import { theoremSession } from "./session-identity.js";
@@ -519,7 +519,57 @@ async function conversation(ctx, request, session) {
     if (!host)
         throw statelessRefusal('read');
     const opened = await openConversation(host, body.conversation, { kind: 'read' });
-    return jsonResponse(200, conversationView(host, opened.conversation));
+    return jsonResponse(200, await currentView(ctx, session, host, opened.conversation));
+}
+/**
+ * why: The transcript keeps a detached call as the turn left it. The session holds what became of
+ * it, so a call that has ended does not read as running.
+ */
+async function currentView(ctx, session, host, conversation) {
+    const view = conversationView(host, conversation);
+    if (!view.transcript.some(isDetachedBlock))
+        return view;
+    const { operations } = await ctx.sessions.read(session.id);
+    return {
+        ...view,
+        transcript: view.transcript.map((block) => isDetachedBlock(block) ? lateBlock(block, operations, host, ctx.profile) : block),
+    };
+}
+function isDetachedBlock(block) {
+    return block.kind === 'tool' && block.tool.state?.phase === 'background';
+}
+/** A detached call's block as its operation stands. One the session no longer holds has no known end. */
+function lateBlock(block, operations, host, profile) {
+    const { tool } = block;
+    const id = tool.operationId;
+    const operation = id && Object.hasOwn(operations, id) ? operations[id] : undefined;
+    if (operation?.status === 'running' || operation?.status === 'background')
+        return block;
+    if (operation?.status === 'settled') {
+        const settled = host.forReader(operation.outcome.event);
+        if (settled.type !== 'tool')
+            return block;
+        const { tool: state } = settled;
+        if (!('phase' in state) || (state.phase !== 'complete' && state.phase !== 'error'))
+            return block;
+        return { ...block, tool: { ...tool, state, endedAt: operation.settledAt } };
+    }
+    const message = labelText('tool.execution_uncertain', {}, profile.labels);
+    const failure = {
+        code: operation?.status === 'uncertain' ? operation.reason : 'outcome_not_retained',
+        kind: 'internal',
+        message,
+    };
+    const { name, callId } = tool;
+    const at = operation?.status === 'uncertain' ? operation.detectedAt : (tool.state?.at ?? Date.now());
+    return {
+        ...block,
+        tool: {
+            ...tool,
+            state: { name, callId, at, phase: 'error', failure, readBack: message },
+            endedAt: at,
+        },
+    };
 }
 /** The conversation cut after one block; a reply that waits on gates is walked away from first. */
 async function rewind(ctx, request, session) {
@@ -542,7 +592,7 @@ async function rewind(ctx, request, session) {
         throw new TheoremError('internal', labelText('error.internal'));
     const rewound = {
         conversation: next.ref,
-        view: conversationView(host, next.conversation),
+        view: await currentView(ctx, session, host, next.conversation),
     };
     return jsonResponse(200, rewound);
 }