@markusylisiurunen/tau 0.3.43 → 0.3.45

package/dist/protocol/session_protocol.d.ts

@@ -1,5 +1,5 @@
 import type { AssistantMessage, Message, TextContent, ThinkingContent, Tool, ToolCall } from "@earendil-works/pi-ai";
-export declare const SESSION_PROTOCOL_VERSION: 9;
+export declare const SESSION_PROTOCOL_VERSION: 10;
 export declare const SESSION_PROTOCOL_MAX_EXEC_CAPTURE_BYTES: number;
 export declare const SESSION_PROTOCOL_MAX_EXEC_STDIN_BYTES: number;
 export declare const SESSION_PROTOCOL_METHODS: readonly ["initialize", "session.create", "session.list", "session.observe", "session.unobserve", "session.record", "session.submit", "session.queue", "session.steer", "session.cancelPendingMessages", "session.retry", "session.exec", "session.cancelExec", "session.sample", "session.interrupt", "session.snapshot", "session.startGoal", "session.resumeGoal", "session.clearGoal", "session.setReasoning", "session.setPersona", "session.resolvePrompt", "session.autocompletePaths", "session.reload", "session.compact", "session.rewind", "session.interruptSubagent", "session.ephemeral.create", "session.ephemeral.submit", "session.ephemeral.close", "session.clientTool.ack", "session.clientTool.result"];
@@ -213,6 +213,14 @@ export type SessionProtocolTurnOutcome = {
     reason: "auto-compaction-failed";
     message: string;
 };
+export type SessionProtocolTurnRecord = {
+    userHistoryEntryId: string;
+    state: "running";
+} | {
+    userHistoryEntryId: string;
+    state: "settled";
+    outcome: SessionProtocolTurnOutcome;
+};
 export type SessionProtocolTurnResult = {
     turn: SessionProtocolTurnOutcome;
 };
@@ -496,6 +504,7 @@ export type SessionProtocolSnapshot = {
     catalog: SessionProtocolContentCatalogSnapshot;
     executionEnvironment: SessionProtocolExecutionEnvironmentSnapshot;
     messages: SessionProtocolMessage[];
+    turns: Record<string, SessionProtocolTurnRecord>;
     timeline: SessionProtocolTimeline;
     tools: Record<string, SessionProtocolToolRun>;
     operations: Record<string, SessionProtocolOperation>;
@@ -743,6 +752,9 @@ export type SessionProtocolChange = {
 } | {
     type: "settings.set";
     settings: SessionProtocolSettingsSnapshot;
+} | {
+    type: "turn.set";
+    turn: SessionProtocolTurnRecord;
 } | {
     type: "message.append";
     message: SessionProtocolMessage;

package/dist/protocol/session_protocol.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-export const SESSION_PROTOCOL_VERSION = 9;
+export const SESSION_PROTOCOL_VERSION = 10;
 export const SESSION_PROTOCOL_MAX_EXEC_CAPTURE_BYTES = 24 * 1024 * 1024;
 export const SESSION_PROTOCOL_MAX_EXEC_STDIN_BYTES = 16 * 1024 * 1024;
 const SESSION_PROTOCOL_NOTICE_TITLE_MAX_CHARS = 512;
@@ -105,6 +105,7 @@ const nonEmptyStringSchema = z
     .string()
     .min(1)
     .refine((value) => value.trim().length > 0);
+const historyEntryIdSchema = nonEmptyStringSchema.transform((value) => value.trim());
 const noticeTitleSchema = nonEmptyStringSchema
     .max(SESSION_PROTOCOL_NOTICE_TITLE_MAX_CHARS)
     .refine((value) => !value.includes("\n") && !value.includes("\r"), "notice title must be one line");
@@ -370,7 +371,7 @@ const sessionProtocolUserMessageParamsSchema = z
     .object({
     sessionId: nonEmptyStringSchema,
     text: nonEmptyStringSchema,
-    historyEntryId: nonEmptyStringSchema.optional(),
+    historyEntryId: historyEntryIdSchema.optional(),
 })
     .strip();
 const sessionProtocolStartGoalParamsSchema = z
@@ -484,7 +485,7 @@ const sessionProtocolCompactParamsSchema = z
 const sessionProtocolRewindParamsSchema = z
     .object({
     sessionId: nonEmptyStringSchema,
-    historyEntryId: nonEmptyStringSchema,
+    historyEntryId: historyEntryIdSchema,
 })
     .strip();
 const sessionProtocolInterruptSubagentParamsSchema = z
@@ -1055,6 +1056,16 @@ const sessionProtocolAgentStateSnapshotSchema = z
         .optional(),
 })
     .strip();
+const sessionProtocolTurnRecordSchema = z.discriminatedUnion("state", [
+    z.object({ userHistoryEntryId: nonEmptyStringSchema, state: z.literal("running") }).strip(),
+    z
+        .object({
+        userHistoryEntryId: nonEmptyStringSchema,
+        state: z.literal("settled"),
+        outcome: sessionProtocolTurnOutcomeSchema,
+    })
+        .strip(),
+]);
 const sessionProtocolSnapshotSchema = z
     .object({
     sessionId: nonEmptyStringSchema,
@@ -1070,6 +1081,7 @@ const sessionProtocolSnapshotSchema = z
     catalog: sessionProtocolContentCatalogSnapshotSchema,
     executionEnvironment: sessionProtocolExecutionEnvironmentSnapshotSchema,
     messages: z.array(sessionProtocolMessageSchema),
+    turns: z.record(nonEmptyStringSchema, sessionProtocolTurnRecordSchema),
     timeline: sessionProtocolTimelineSchema,
     tools: z.record(nonEmptyStringSchema, sessionProtocolToolRunSchema),
     operations: z.record(nonEmptyStringSchema, sessionProtocolOperationSchema),
@@ -1294,6 +1306,15 @@ const sessionProtocolSnapshotSchema = z
             }
         }
     }
+    for (const [id, turn] of Object.entries(snapshot.turns)) {
+        if (id !== turn.userHistoryEntryId) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["turns", id],
+                message: `turn map key '${id}' does not match embedded user history entry id '${turn.userHistoryEntryId}'`,
+            });
+        }
+    }
     for (const [id, agent] of Object.entries(snapshot.agents)) {
         if (id !== agent.id) {
             ctx.addIssue({
@@ -1387,6 +1408,12 @@ const sessionProtocolChangeSchema = z.discriminatedUnion("type", [
         settings: sessionProtocolSettingsSnapshotSchema,
     })
         .strip(),
+    z
+        .object({
+        type: z.literal("turn.set"),
+        turn: sessionProtocolTurnRecordSchema,
+    })
+        .strip(),
     z
         .object({
         type: z.literal("message.append"),
@@ -1937,6 +1964,9 @@ export function applySessionProtocolDelta(snapshot, message) {
             case "settings.set":
                 next.settings = structuredClone(change.settings);
                 break;
+            case "turn.set":
+                setSessionProtocolTurn(next.turns, change.turn);
+                break;
             case "message.append":
                 next.messages.push(structuredClone(change.message));
                 break;
@@ -2017,6 +2047,7 @@ function changeCanInvalidateSnapshot(snapshot, change) {
         case "goal.set":
         case "cost.set":
         case "settings.set":
+        case "turn.set":
         case "agent.set":
             return false;
         case "tool.set": {
@@ -2066,14 +2097,33 @@ function hasSameFacetSubject(previous, facet) {
         (previous.subject.type === "session" ||
             (facet.subject.type !== "session" && previous.subject.id === facet.subject.id)));
 }
+function setSessionProtocolTurn(turns, turn) {
+    const previous = Object.hasOwn(turns, turn.userHistoryEntryId)
+        ? turns[turn.userHistoryEntryId]
+        : undefined;
+    if (previous?.state === "settled" && JSON.stringify(previous) !== JSON.stringify(turn)) {
+        throw new Error(`settled turn '${turn.userHistoryEntryId}' cannot be changed`);
+    }
+    Object.defineProperty(turns, turn.userHistoryEntryId, {
+        configurable: true,
+        enumerable: true,
+        value: structuredClone(turn),
+        writable: true,
+    });
+}
 function applyKeyedRecordDelta(snapshot, message) {
     if (message.delta.type !== "snapshot.patch") {
         return undefined;
     }
+    let nextTurns;
     let nextTools;
     let nextOperations;
     let nextAgents;
     let nextFacets;
+    const cloneTurns = () => {
+        nextTurns ??= { ...snapshot.turns };
+        return nextTurns;
+    };
     const cloneTools = () => {
         nextTools ??= { ...snapshot.tools };
         return nextTools;
@@ -2092,6 +2142,9 @@ function applyKeyedRecordDelta(snapshot, message) {
     };
     for (const change of message.delta.changes) {
         switch (change.type) {
+            case "turn.set":
+                setSessionProtocolTurn(cloneTurns(), change.turn);
+                break;
             case "tool.set":
                 cloneTools()[change.tool.id] = structuredClone(change.tool);
                 break;
@@ -2123,6 +2176,7 @@ function applyKeyedRecordDelta(snapshot, message) {
     return {
         ...snapshot,
         revision: message.toRevision,
+        ...(nextTurns ? { turns: nextTurns } : {}),
         ...(nextTools ? { tools: nextTools } : {}),
         ...(nextOperations ? { operations: nextOperations } : {}),
         ...(nextAgents ? { agents: nextAgents } : {}),