@theoremjs/web 0.3.4-next.711.g78e504a → 0.3.4-next.717.gd16ffc6

package/README.md

@@ -131,8 +131,13 @@ const boundary = await createTheoremSessionBoundary({
 });
 const open = parseLiveOpenMessage(firstFrame);
 const session = await runSession(
-  { profile, ...await boundary.prepareLiveOpen(open, hostContext) },
-  { vault: hostKeyVault, execution: boundary.toolExecution, pageExecution: boundary.pageExecution },
+  {
+    profile,
+    ...await boundary.prepareLiveOpen(open, hostContext),
+    execution: boundary.toolExecution,
+    pageExecution: boundary.pageExecution,
+  },
+  { vault: hostKeyVault },
 );
 for await (const event of session.events()) {
   if ((event.type === 'done' || event.type === 'provider_checkpoint') && event.providerState) {
@@ -447,9 +452,9 @@ These claims do not provide exactly-once effects at the destination. Use the ope
 Concurrent pending attempts can reach preparation before one claims the body.
 Permission checks and pre-body hooks must be read-only or independently idempotent. The kernel cannot prove hook purity.
 A live session does not restore a dispatched call after an unexpected failure. It retains an uncertain call on that connection.
-To retain execution claims across connections, supply a durable coordinator through `RunSessionOptions.execution`.
+To retain execution claims across connections, supply a durable coordinator as `execution` on `SessionRequest`.
 Browser dispatch uses a host-owned `PageToolExecution` service beside the execution coordinator.
-`createTheoremHandler` supplies both services. Live relays pass the session boundary's `pageExecution` and `toolExecution` to `runSession`.
+`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`.
 Forward live page results to `answerPageResult`. Preserve checkpoint ownership through `beforeEvent` when using the Studio bridge.

package/client/live/live-page-tool.d.ts

@@ -19,6 +19,10 @@ export type LiveCallOptions = {
     slots?: Record<string, string>;
     /** Which prompt lines the call gets, for a host that lets its page choose (`pageStatesTurn`). */
     stated?: StatedTurn;
+    /** The model picked for the call, read as the call starts, when the profile allows it. */
+    model?: string;
+    /** That model's effort, read as the call starts, when the binding allows it. */
+    effort?: string;
     /**
      * What the page tells the agent: any JSON. It goes with the call's opening, and
      * again whenever it changes, as background the agent reads without replying.

package/client/live-client.d.ts

@@ -26,6 +26,10 @@ export interface LiveClientOptions {
     slots?: Record<string, string>;
     /** Which prompt lines the call gets, for a host that lets its page choose (`pageStatesTurn`). */
     stated?: StatedTurn;
+    /** The model picked for the call, when the profile allows it. */
+    model?: string;
+    /** That model's effort, when the binding allows it. */
+    effort?: string;
     /** What the page tells the agent as the call opens; `setContext` replaces it during the call. */
     context?: unknown;
     relayUrl?: string;

package/client/live-client.js

@@ -228,12 +228,14 @@ export class LiveSessionClient {
     }
     /** The first message: the call's values, and the handle and time away when it takes a dropped call up again. */
     openMessage() {
-        const { slots, stated, openMessage: host } = this.options;
+        const { slots, stated, model, effort, openMessage: host } = this.options;
         return {
             type: 'open',
             ...(this.history.length ? { history: structuredClone(this.history) } : {}),
             ...(slots ? { slots } : {}),
             ...(stated ? { stated } : {}),
+            ...(model ? { model } : {}),
+            ...(effort ? { effort } : {}),
             ...(this.context === undefined ? {} : { context: this.context }),
             ...(this.providerState
                 ? {

package/client/live-messages.d.ts

@@ -22,6 +22,10 @@ export type LiveOpenMessage = {
     context?: unknown;
     /** Which prompt lines the call gets, for a host that lets its page choose (`pageStatesTurn`). */
     stated?: StatedTurn;
+    /** The model picked for the call, when the profile allows it. */
+    model?: string;
+    /** That model's effort, when the binding allows it. */
+    effort?: string;
     /** A call that dropped, taken up again: the provider's handle, and how long the caller was away. */
     resume?: {
         providerState: ProviderCheckpoint;

package/client/live-messages.js

@@ -15,6 +15,8 @@ const liveOpenMessage = z.object({
     slots: z.record(z.string(), z.string()).optional(),
     context: z.unknown().optional(),
     stated: statedTurnSchema.optional(),
+    model: z.string().optional(),
+    effort: z.string().optional(),
     resume: z
         .object({ providerState: providerCheckpointSchema, awayMs: z.number().nonnegative() })
         .optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theoremjs/web",
-  "version": "0.3.4-next.711.g78e504a",
+  "version": "0.3.4-next.717.gd16ffc6",
   "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.711.g78e504a"
+    "@theoremjs/agents": "^0.3.4-next.717.gd16ffc6"
   }
 }

package/server/conversation.d.ts

@@ -14,9 +14,9 @@
  *
  * @module
  */
-import { type GateReference, type LabelOverrides, type Profile, type ProviderCheckpoint, TheoremError, type ToolId, type TurnEvent, type TurnHistoryMessage, type TurnInput } from '@theoremjs/agents';
+import { type GateReference, type LabelOverrides, type Profile, type ProviderCheckpoint, TheoremError, type TurnEvent, type TurnHistoryMessage, type TurnInput } from '@theoremjs/agents';
 import { type ClientTurnOptions } from '@theoremjs/agents/host';
-import { type ComposerProfileInterface, streamThoughtsEnabled, type TranscriptBlock, type UserTurnDraft, type UserTurnHistoryMedia } from '@theoremjs/agents/interface';
+import { type ComposerProfileInterface, type ReplyCarried, streamThoughtsEnabled, type TranscriptBlock, type UserTurnDraft, type UserTurnHistoryMedia } from '@theoremjs/agents/interface';
 import type { ConversationLine, ConversationView, StatedTurn, TheoremTurnInput } from '../client/transport.ts';
 import { type StoredConversation, type TheoremConversationStore } from './conversation-store.ts';
 /** One walked-away call: its id, and the run that settles it (`invokeTool` with the abandoned resume). */
@@ -120,8 +120,8 @@ export type ReplyTurn = {
     model?: string;
     effort?: string;
     stated?: StatedTurn;
-    /** The tools the reply had when it paused, for a reply that goes on. */
-    promoted?: ToolId[];
+    /** The tools and steps the reply had when it paused, for a reply that goes on. */
+    carried?: ReplyCarried;
 };
 /** What a reply's model run takes from the host. */
 export type ReplyRunner = {
@@ -135,7 +135,7 @@ export type ReplyRunner = {
     model?: string;
     effort?: string;
     stated?: StatedTurn;
-    promoted?: ToolId[];
+    carried?: ReplyCarried;
     signal: AbortSignal;
 };
 /** A line of a reply's stream: an event, or the ref of what the store wrote. */

package/server/conversation.js

@@ -17,7 +17,7 @@
 import { attachmentsRefused, labelText, TheoremError, toErrorEvent, } from '@theoremjs/agents';
 import { sanitizeTurnRequestWithEvents, withPublicLabels } from '@theoremjs/agents/guardrails';
 import { forClient } from '@theoremjs/agents/host';
-import { appendAssistantEventsToHistory, appendUserDraftToHistory, applyTurnEventsToSession, emptyInterfaceTurnSession, foldTurnEvents, gatedToolsFromEvents, historyFromTranscriptBlocks, prepareUserTurn, replyToolIdsFromEvents, settlesToolCall, streamThoughtsEnabled, } from '@theoremjs/agents/interface';
+import { appendAssistantEventsToHistory, appendUserDraftToHistory, applyTurnEventsToSession, emptyInterfaceTurnSession, foldTurnEvents, gatedToolsFromEvents, historyFromTranscriptBlocks, prepareUserTurn, replyCarriedFromEvents, settlesToolCall, streamThoughtsEnabled, } from '@theoremjs/agents/interface';
 import { base64ToBytes } from '@theoremjs/agents/kernel';
 import { stampWorked, stoppedReply } from "../client/run-commit.js";
 import { emptyConversation, unknownConversation, } from "./conversation-store.js";
@@ -236,7 +236,7 @@ async function* runReply(host, opened, reply, runner, input, withMessage) {
             model: runner.model,
             effort: runner.effort,
             ...(runner.stated ? { stated: runner.stated } : {}),
-            ...(runner.promoted ? { promoted: runner.promoted } : {}),
+            ...(runner.carried ? { carried: runner.carried } : {}),
         });
         for await (const event of events) {
             reply.events.push(event);
@@ -493,7 +493,7 @@ export async function* answerReply(args) {
         model: runner.model ?? paused.model,
         effort: runner.effort ?? paused.effort,
         ...(paused.stated ? { stated: paused.stated } : {}),
-        promoted: replyToolIdsFromEvents(reply.events),
+        carried: replyCarriedFromEvents(reply.events),
     }, {
         history: replyHistory(reply),
         ...(waiting.inputTokens === undefined ? {} : { inputTokens: waiting.inputTokens }),

package/server/handler.js

@@ -426,7 +426,7 @@ async function* chatTurn(ctx, request, session, turn, key, stop) {
             host,
             ...(turn.model ? { model: turn.model } : {}),
             ...(turn.effort ? { effort: turn.effort } : {}),
-            ...(turn.promoted ? { promoted: turn.promoted } : {}),
+            ...turn.carried,
             ...turn.stated,
         }, {
             credentials: sessionCredentials(ctx, session.id),

package/server/turn-input.d.ts

@@ -7,4 +7,4 @@ export declare function kernelTurnInput(input: TheoremTurnInput, server?: unknow
  * What a live call's first message asks of the session, as `runSession` takes
  * it: the page's context is the client's, and `server` is the host's own.
  */
-export declare function liveSessionOpen(open: LiveOpenMessage, server?: unknown): Pick<SessionRequest, 'slots' | 'context' | 'providerState' | 'awayMs' | 'history' | 'path' | 'conditions'>;
+export declare function liveSessionOpen(open: LiveOpenMessage, server?: unknown): Pick<SessionRequest, 'slots' | 'context' | 'providerState' | 'awayMs' | 'history' | 'path' | 'conditions' | 'model' | 'effort'>;

package/server/turn-input.js

@@ -23,6 +23,8 @@ export function liveSessionOpen(open, server) {
         ...(open.slots ? { slots: open.slots } : {}),
         ...(context ? { context } : {}),
         ...open.stated,
+        ...(open.model ? { model: open.model } : {}),
+        ...(open.effort ? { effort: open.effort } : {}),
         ...(open.resume
             ? { providerState: open.resume.providerState, awayMs: open.resume.awayMs }
             : {}),