@schlenkr/ragents 0.1.5 → 0.1.7

package/packages/ragents/src/domain/event-semantics.ts

@@ -1,6 +1,7 @@
 import { resolve } from "node:path";
 
 import type { JournalEvent } from "./events.ts";
+import type { JsonValue } from "./json.ts";
 import type {
     Actor,
     AgentExecution,
@@ -12,28 +13,26 @@ import type {
     RunState,
     Turn,
 } from "./model.ts";
-import { isPendingActorInput, actorStatePluginId } from "./model.ts";
+import { eventSubjectOf, isPendingActorInput, actorStatePluginId } from "./model.ts";
 import { isObservableEventType } from "./vocabulary.ts";
 
-type ToolCall = {
-    turnId: string;
-    toolCallId: string;
-    name: string;
-    status: "running" | "completed" | "failed" | "interrupted";
-    sourceRecorded: boolean;
-};
-
 export type EventSemanticContext = {
     events: Map<string, JournalEvent>;
-    toolCalls: Map<string, ToolCall>;
+    /** Tool calls with a recorded source, by turn and call; their state stands in the turn. */
+    sourcedToolCalls: Set<string>;
+    /** Inputs and tool results already presented to the model, by turn and input or call. */
+    presented: Set<string>;
 };
 
 export const eventSemanticContext = (): EventSemanticContext => ({
     events: new Map(),
-    toolCalls: new Map(),
+    sourcedToolCalls: new Set(),
+    presented: new Set(),
 });
 
-const actorOf = (state: RunState, actorId: string): Actor => {
+const modelContextEventTypes: ReadonlySet<string> = new Set(["model.input.presented", "model.step.completed", "model.tool-result.presented"]);
+
+const existingActorOf = (state: RunState, actorId: string): Actor => {
     const actor = state.actors.get(actorId);
 
     if (!actor)
@@ -43,7 +42,7 @@ const actorOf = (state: RunState, actorId: string): Actor => {
 };
 
 const executableOf = (state: RunState, actorId: string): ExecutableActor => {
-    const actor = actorOf(state, actorId);
+    const actor = existingActorOf(state, actorId);
 
     if (actor.kind === "human")
         throw new Error(`Actor ${actorId} is not executable.`);
@@ -96,24 +95,20 @@ const assertUnique = (values: readonly string[], kind: string) => {
         throw new Error(`${kind} contains duplicate references.`);
 };
 
+const isBlankResult = (result: JsonValue | null) =>
+    result === null || (typeof result === "string" && result.trim() === "");
+
 const toolCallKey = (turnId: string, toolCallId: string) => `${turnId}\0${toolCallId}`;
 
-const toolCallOf = (
-    context: EventSemanticContext,
-    turnId: string,
-    toolCallId: string,
-) => {
-    const call = context.toolCalls.get(toolCallKey(turnId, toolCallId));
+const toolCallOf = (turn: Turn, toolCallId: string) => {
+    const call = turn.toolCalls.find((entry) => entry.id === toolCallId);
 
     if (!call)
-        throw new Error(`Tool call ${toolCallId} does not exist in turn ${turnId}.`);
+        throw new Error(`Tool call ${toolCallId} does not exist in turn ${turn.id}.`);
 
     return call;
 };
 
-const runningToolCallsOf = (context: EventSemanticContext, turnId: string) =>
-    [...context.toolCalls.values()].filter((call) => call.turnId === turnId && call.status === "running");
-
 const assertExistingEvents = (context: EventSemanticContext, eventIds: readonly string[]) => {
     assertUnique(eventIds, "sourceEventIds");
 
@@ -141,7 +136,7 @@ const assertArtifactRead = (state: RunState, actorId: string, artifactId: string
 };
 
 const commandActorOf = (state: RunState, actorId: string) => {
-    const actor = actorOf(state, actorId);
+    const actor = existingActorOf(state, actorId);
 
     if (actor.kind !== "human" && actor.lifecycle.kind !== "running")
         throw new Error(`Actor ${actor.id} cannot author a command while ${actor.lifecycle.kind}.`);
@@ -268,14 +263,16 @@ const assertSubscriptionSource = (
     if (!isObservableEventType(source.type) || !subscription.eventTypes.includes(source.type))
         throw new Error(`Source event ${sourceEventId} does not match subscription ${subscription.id}.`);
 
-    if (!subscription.includeSelf && source.actorId === subscription.subscriberId)
+    const subjectId = eventSubjectOf(state, source);
+
+    if (!subscription.includeSelf && subjectId === subscription.subscriberId)
         throw new Error(`Source event ${sourceEventId} is excluded by subscription ${subscription.id}.`);
 
-    if (subscription.sourceActorIds && !subscription.sourceActorIds.includes(source.actorId))
+    if (subscription.sourceActorIds && !subscription.sourceActorIds.includes(subjectId))
         throw new Error(`Source event ${sourceEventId} has the wrong actor for subscription ${subscription.id}.`);
 
     if (subscription.sourceActorKinds) {
-        const sourceActor = actorOf(state, source.actorId);
+        const sourceActor = existingActorOf(state, subjectId);
 
         if (!subscription.sourceActorKinds.includes(sourceActor.kind))
             throw new Error(`Source event ${sourceEventId} has the wrong actor kind for subscription ${subscription.id}.`);
@@ -311,7 +308,7 @@ export const assertEventSemantics = (
     if (!state)
         throw new Error(`Run ${event.runId} has no creation event.`);
 
-    actorOf(state, event.actorId);
+    existingActorOf(state, event.actorId);
 
     switch (event.type) {
         case "run.forked":
@@ -403,14 +400,36 @@ export const assertEventSemantics = (
             break;
         }
 
+        case "turn.input-steered": {
+            const turn = runningTurnOf(state, event.payload.turnId);
+            assertTurnAuthor(turn, event);
+            const input = state.inputs.get(event.payload.inputId);
+
+            if (!input)
+                throw new Error(`Input ${event.payload.inputId} does not exist.`);
+
+            if (input.actorId !== turn.actorId)
+                throw new Error(`Input ${input.id} is not addressed to actor ${turn.actorId}.`);
+
+            if (!isPendingActorInput(input))
+                throw new Error(`Input ${input.id} is no longer pending and cannot join turn ${turn.id}.`);
+
+            const earlier = [...state.inputs.values()].find((entry) =>
+                entry.actorId === input.actorId && isPendingActorInput(entry) && entry.sequence < input.sequence);
+
+            if (earlier)
+                throw new Error(`Input ${input.id} cannot join turn ${turn.id} before the earlier input ${earlier.id}.`);
+            break;
+        }
+
         case "turn.finished": {
             const turn = runningTurnOf(state, event.payload.turnId);
             assertTurnAuthor(turn, event);
-            const openCalls = runningToolCallsOf(context, turn.id);
+            const openCalls = turn.toolCalls.filter((call) => call.status === "running");
 
-            if (openCalls.length > 0)
+            if (event.payload.outcome === "completed" && openCalls.length > 0)
                 throw new Error(
-                    `Turn ${turn.id} still has running tool calls: ${openCalls.map((call) => call.toolCallId).join(", ")}.`,
+                    `Turn ${turn.id} still has running tool calls: ${openCalls.map((call) => call.id).join(", ")}.`,
                 );
             break;
         }
@@ -424,7 +443,48 @@ export const assertEventSemantics = (
             break;
         }
 
+        case "model.input.presented": {
+            const turn = runningTurnOf(state, event.payload.turnId);
+            assertTurnAuthor(turn, event);
+
+            if (event.payload.inputId !== null) {
+                const input = state.inputs.get(event.payload.inputId);
+
+                if (!input || input.lifecycle.kind !== "claimed" || input.lifecycle.turnId !== turn.id)
+                    throw new Error(`Input ${event.payload.inputId} does not belong to turn ${turn.id}.`);
+
+                if (context.presented.has(`${turn.id}\0input\0${input.id}`))
+                    throw new Error(`Input ${input.id} was already presented in turn ${turn.id}.`);
+            }
+            break;
+        }
+
+        case "model.tool-result.presented": {
+            const turn = runningTurnOf(state, event.payload.turnId);
+            assertTurnAuthor(turn, event);
+            const call = toolCallOf(turn, event.payload.toolCallId);
+
+            if (call.status === "running")
+                throw new Error(`Tool call ${call.id} in turn ${turn.id} has no result yet.`);
+
+            if (context.presented.has(`${turn.id}\0call\0${call.id}`))
+                throw new Error(`The result of tool call ${call.id} in turn ${turn.id} was already presented.`);
+            break;
+        }
+
+        case "context.compacted": {
+            const turn = runningTurnOf(state, event.payload.turnId);
+            assertTurnAuthor(turn, event);
+            const firstKept = context.events.get(event.payload.firstKeptEventId);
+
+            if (!firstKept || !modelContextEventTypes.has(firstKept.type))
+                throw new Error(`Compaction keeps from ${event.payload.firstKeptEventId}, which is no model context event.`);
+            break;
+        }
+
+        case "model.step.completed":
         case "model.output.completed":
+        case "model.output.interrupted":
         case "model.reasoning.completed":
         case "runtime.output.recorded": {
             const turn = runningTurnOf(state, event.payload.turnId);
@@ -435,9 +495,8 @@ export const assertEventSemantics = (
         case "tool.call.started": {
             const turn = runningTurnOf(state, event.payload.turnId);
             assertTurnAuthor(turn, event);
-            const key = toolCallKey(turn.id, event.payload.toolCallId);
 
-            if (context.toolCalls.has(key))
+            if (turn.toolCalls.some((call) => call.id === event.payload.toolCallId))
                 throw new Error(`Tool call ${event.payload.toolCallId} already exists in turn ${turn.id}.`);
             break;
         }
@@ -446,24 +505,24 @@ export const assertEventSemantics = (
         case "tool.call.failed": {
             const turn = runningTurnOf(state, event.payload.turnId);
             assertTurnAuthor(turn, event);
-            const call = toolCallOf(context, turn.id, event.payload.toolCallId);
+            const call = toolCallOf(turn, event.payload.toolCallId);
 
             if (call.status !== "running")
-                throw new Error(`Tool call ${call.toolCallId} in turn ${call.turnId} is already ${call.status}.`);
+                throw new Error(`Tool call ${call.id} in turn ${turn.id} is already ${call.status}.`);
 
             if (call.name !== event.payload.name)
-                throw new Error(`Tool call ${call.toolCallId} started as ${call.name}, not ${event.payload.name}.`);
+                throw new Error(`Tool call ${call.id} started as ${call.name}, not ${event.payload.name}.`);
             break;
         }
 
         case "tool.call.source": {
             const turn = runningTurnOf(state, event.payload.turnId);
             assertTurnAuthor(turn, event);
-            const call = toolCallOf(context, turn.id, event.payload.toolCallId);
+            const call = toolCallOf(turn, event.payload.toolCallId);
             if (call.status !== "running")
-                throw new Error(`Tool call ${call.toolCallId} in turn ${call.turnId} is already ${call.status}.`);
-            if (call.sourceRecorded)
-                throw new Error(`Tool call ${call.toolCallId} in turn ${call.turnId} already has a source snapshot.`);
+                throw new Error(`Tool call ${call.id} in turn ${turn.id} is already ${call.status}.`);
+            if (context.sourcedToolCalls.has(toolCallKey(turn.id, call.id)))
+                throw new Error(`Tool call ${call.id} in turn ${turn.id} already has a source snapshot.`);
             break;
         }
 
@@ -514,7 +573,7 @@ export const assertEventSemantics = (
             assertUnique(event.payload.eventTypes, "eventTypes");
 
             for (const actorId of event.payload.sourceActorIds ?? [])
-                actorOf(state, actorId);
+                existingActorOf(state, actorId);
             break;
         }
 
@@ -573,7 +632,7 @@ export const assertEventSemantics = (
             const author = commandActorOf(state, event.actorId);
 
             if (event.payload.scope.kind === "actor") {
-                actorOf(state, event.payload.scope.actorId);
+                existingActorOf(state, event.payload.scope.actorId);
 
                 if (author.id !== state.ownerId && author.id !== event.payload.scope.actorId)
                     throw new Error(`Actor ${author.id} cannot replace plugin state for ${event.payload.scope.actorId}.`);
@@ -595,7 +654,7 @@ export const assertEventSemantics = (
             const author = commandActorOf(state, event.actorId);
             assertNewId(state.actions, event.payload.actionId, "Action");
 
-            if (event.payload.kind === "action" && !hasRunCapability(author, "action.propose"))
+            if (event.payload.owner === null && !hasRunCapability(author, "action.propose"))
                 throw new Error(`Actor ${author.id} lacks action.propose.`);
             break;
         }
@@ -609,11 +668,11 @@ export const assertEventSemantics = (
             if (action.status !== "pending")
                 throw new Error(`Action ${action.id} is already ${action.status}.`);
 
-            if (actorOf(state, event.actorId).kind !== "human")
+            if (existingActorOf(state, event.actorId).kind !== "human")
                 throw new Error(`Action ${action.id} was not resolved by a human actor.`);
 
-            if (event.payload.decision === "approved" && action.input?.required && !event.payload.response?.trim())
-                throw new Error(`Action ${action.id} requires a response.`);
+            if (event.payload.decision === "approved" && action.input?.required && isBlankResult(event.payload.result))
+                throw new Error(`Action ${action.id} requires a result.`);
             break;
         }
 
@@ -637,32 +696,12 @@ export const assertEventSemantics = (
 export const recordEventSemantics = (event: JournalEvent, context: EventSemanticContext) => {
     context.events.set(event.eventId, event);
 
-    if (event.type === "tool.call.started") {
-        context.toolCalls.set(toolCallKey(event.payload.turnId, event.payload.toolCallId), {
-            turnId: event.payload.turnId,
-            toolCallId: event.payload.toolCallId,
-            name: event.payload.name,
-            status: "running",
-            sourceRecorded: false,
-        });
-    }
-
-    if (event.type === "tool.call.source") {
-        const call = toolCallOf(context, event.payload.turnId, event.payload.toolCallId);
-        call.sourceRecorded = true;
-    }
-
-    if (event.type === "tool.call.completed" || event.type === "tool.call.failed") {
-        const call = context.toolCalls.get(toolCallKey(event.payload.turnId, event.payload.toolCallId));
+    if (event.type === "tool.call.source")
+        context.sourcedToolCalls.add(toolCallKey(event.payload.turnId, event.payload.toolCallId));
 
-        if (!call)
-            throw new Error(`Tool call ${event.payload.toolCallId} was not validated.`);
+    if (event.type === "model.input.presented" && event.payload.inputId !== null)
+        context.presented.add(`${event.payload.turnId}\0input\0${event.payload.inputId}`);
 
-        call.status = event.type === "tool.call.completed" ? "completed" : "failed";
-    }
-
-    if (event.type === "turn.interrupted") {
-        for (const call of runningToolCallsOf(context, event.payload.turnId))
-            call.status = "interrupted";
-    }
+    if (event.type === "model.tool-result.presented")
+        context.presented.add(`${event.payload.turnId}\0call\0${event.payload.toolCallId}`);
 };

package/packages/ragents/src/domain/event-validation.ts

@@ -200,6 +200,98 @@ const usageOf = (value: unknown, path: string) => {
         fail(`${path}.costUsd`, "must not be negative");
 };
 
+const sha256Of = (value: unknown, path: string) => {
+    if (typeof value !== "string" || !/^[0-9a-f]{64}$/.test(value))
+        fail(path, "must be a lowercase SHA-256");
+};
+
+const modelTextPartOf = (value: unknown, path: string) => {
+    const part = exactObject(value, path, ["type", "text"]);
+    stringOf(part.text, `${path}.text`);
+};
+
+const modelInputPartOf = (value: unknown, path: string) => {
+    const candidate = objectOf(value, path);
+
+    if (candidate.type === "text")
+        return modelTextPartOf(value, path);
+
+    if (candidate.type !== "image" && candidate.type !== "video" && candidate.type !== "file")
+        fail(`${path}.type`, "must be text, image, video or file");
+
+    const part = exactObject(value, path, candidate.type === "file" ? ["type", "mimeType", "filename", "hash"] : ["type", "mimeType", "hash"]);
+    nonEmptyStringOf(part.mimeType, `${path}.mimeType`);
+    sha256Of(part.hash, `${path}.hash`);
+
+    if (candidate.type === "file")
+        stringOf(part.filename, `${path}.filename`);
+};
+
+const modelToolResultPartOf = (value: unknown, path: string) => {
+    const candidate = objectOf(value, path);
+
+    if (candidate.type === "text")
+        return modelTextPartOf(value, path);
+
+    if (candidate.type !== "image")
+        fail(`${path}.type`, "must be text or image");
+
+    const part = exactObject(value, path, ["type", "mimeType", "hash"]);
+    nonEmptyStringOf(part.mimeType, `${path}.mimeType`);
+    sha256Of(part.hash, `${path}.hash`);
+};
+
+const optionalStringOf = (payload: ObjectValue, key: string, path: string) => {
+    if (Object.hasOwn(payload, key))
+        stringOf(payload[key], `${path}.${key}`);
+};
+
+const modelStepBlockOf = (value: unknown, path: string) => {
+    const candidate = objectOf(value, path);
+
+    if (candidate.type === "text") {
+        const block = exactObject(value, path, ["type"], ["text", "textSignature"]);
+        optionalStringOf(block, "text", path);
+        optionalStringOf(block, "textSignature", path);
+        return;
+    }
+
+    if (candidate.type === "thinking") {
+        const block = exactObject(value, path, ["type"], ["thinking", "thinkingSignature", "redacted"]);
+        optionalStringOf(block, "thinking", path);
+        optionalStringOf(block, "thinkingSignature", path);
+
+        if (Object.hasOwn(block, "redacted"))
+            booleanOf(block.redacted, `${path}.redacted`);
+
+        return;
+    }
+
+    if (candidate.type !== "toolCall")
+        fail(`${path}.type`, "must be text, thinking or toolCall");
+
+    const block = exactObject(value, path, ["type", "id", "name", "arguments"], ["thoughtSignature"]);
+    nonEmptyStringOf(block.id, `${path}.id`);
+    stringOf(block.name, `${path}.name`);
+    objectOf(block.arguments, `${path}.arguments`);
+    assertJsonValue(block.arguments, `${path}.arguments`);
+    optionalStringOf(block, "thoughtSignature", path);
+};
+
+const modelStepUsageOf = (value: unknown, path: string) => {
+    const usage = exactObject(value, path, ["input", "output", "cacheRead", "cacheWrite", "totalTokens", "cost"], ["cacheWrite1h", "reasoning"]);
+
+    for (const key of ["input", "output", "cacheRead", "cacheWrite", "totalTokens", "cacheWrite1h", "reasoning"]) {
+        if (Object.hasOwn(usage, key))
+            finiteNumberOf(usage[key], `${path}.${key}`);
+    }
+
+    const cost = exactObject(usage.cost, `${path}.cost`, ["input", "output", "cacheRead", "cacheWrite", "total"]);
+
+    for (const key of Object.keys(cost))
+        finiteNumberOf(cost[key], `${path}.cost.${key}`);
+};
+
 const pluginScopeOf = (value: unknown, path: string) => {
     const candidate = objectOf(value, path);
 
@@ -217,13 +309,12 @@ const pluginScopeOf = (value: unknown, path: string) => {
     fail(`${path}.kind`, "must be run or actor");
 };
 
-const questionOf = (value: unknown, path: string) => {
+const actionPayloadOf = (value: unknown, path: string) => {
     if (value === null)
         return;
 
-    const question = exactObject(value, path, ["options", "multi"]);
-    stringArrayOf(question.options, `${path}.options`);
-    booleanOf(question.multi, `${path}.multi`);
+    objectOf(value, path);
+    assertJsonValue(value, path);
 };
 
 const actionInputOf = (value: unknown, path: string) => {
@@ -262,8 +353,9 @@ const eventTypeArrayOf = (value: unknown, path: string) => arrayOf(value, path,
 });
 
 const scriptDefinitionOf = (payload: ObjectValue, path: string) => {
-    const definition = exactObject(payload, path, ["scriptId", "handle", "displayName", "execution", "grants", "toolNames"]);
+    const definition = exactObject(payload, path, ["scriptId", "handle", "displayName", "execution", "grants", "toolNames"], ["description"]);
     actorIdOf(definition.scriptId, `${path}.scriptId`);
+    if (definition.description !== undefined) nonEmptyStringOf(definition.description, `${path}.description`);
     stringOf(definition.handle, `${path}.handle`);
     stringOf(definition.displayName, `${path}.displayName`);
     executionOf(definition.execution, `${path}.execution`);
@@ -275,12 +367,13 @@ const payloadOf = (type: EventType, value: unknown, path: string) => {
     switch (type) {
         case "run.created": {
             const payload = exactObject(value, path, ["title", "owner"]);
-            const owner = exactObject(payload.owner, `${path}.owner`, ["id", "handle", "displayName", "grants"]);
+            const owner = exactObject(payload.owner, `${path}.owner`, ["id", "handle", "displayName", "grants"], ["userId"]);
             stringOf(payload.title, `${path}.title`);
             actorIdOf(owner.id, `${path}.owner.id`);
             stringOf(owner.handle, `${path}.owner.handle`);
             stringOf(owner.displayName, `${path}.owner.displayName`);
             grantsOf(owner.grants, `${path}.owner.grants`);
+            if (owner.userId !== undefined) stringOf(owner.userId, `${path}.owner.userId`);
             return;
         }
 
@@ -312,9 +405,10 @@ const payloadOf = (type: EventType, value: unknown, path: string) => {
                 "execution",
                 "grants",
                 "toolNames",
-            ], ["forkOf"]);
+            ], ["forkOf", "description"]);
             actorIdOf(payload.agentId, `${path}.agentId`);
             if (payload.forkOf !== undefined) actorIdOf(payload.forkOf, `${path}.forkOf`);
+            if (payload.description !== undefined) nonEmptyStringOf(payload.description, `${path}.description`);
             stringOf(payload.handle, `${path}.handle`);
             stringOf(payload.displayName, `${path}.displayName`);
             stringOf(payload.prompt, `${path}.prompt`);
@@ -356,7 +450,8 @@ const payloadOf = (type: EventType, value: unknown, path: string) => {
             return;
         }
 
-        case "turn.started": {
+        case "turn.started":
+        case "turn.input-steered": {
             const payload = exactObject(value, path, ["turnId", "inputId"]);
             stringOf(payload.turnId, `${path}.turnId`);
             stringOf(payload.inputId, `${path}.inputId`);
@@ -388,7 +483,82 @@ const payloadOf = (type: EventType, value: unknown, path: string) => {
             return;
         }
 
+        case "model.input.presented": {
+            const payload = exactObject(value, path, ["turnId", "inputId", "content"]);
+            stringOf(payload.turnId, `${path}.turnId`);
+            nullableStringOf(payload.inputId, `${path}.inputId`);
+
+            if (typeof payload.content !== "string")
+                arrayOf(payload.content, `${path}.content`, modelInputPartOf);
+
+            return;
+        }
+
+        case "model.step.completed": {
+            const payload = exactObject(
+                value,
+                path,
+                ["turnId", "api", "provider", "model", "usage", "stopReason", "timestamp", "content"],
+                ["responseModel", "responseId", "errorMessage", "diagnostics"],
+            );
+            stringOf(payload.turnId, `${path}.turnId`);
+            nonEmptyStringOf(payload.api, `${path}.api`);
+            nonEmptyStringOf(payload.provider, `${path}.provider`);
+            nonEmptyStringOf(payload.model, `${path}.model`);
+            optionalStringOf(payload, "responseModel", path);
+            optionalStringOf(payload, "responseId", path);
+            optionalStringOf(payload, "errorMessage", path);
+            modelStepUsageOf(payload.usage, `${path}.usage`);
+
+            if (!["stop", "length", "toolUse", "error"].includes(payload.stopReason as string))
+                fail(`${path}.stopReason`, "must be stop, length, toolUse or error");
+
+            finiteNumberOf(payload.timestamp, `${path}.timestamp`);
+            arrayOf(payload.content, `${path}.content`, modelStepBlockOf);
+
+            if (Object.hasOwn(payload, "diagnostics"))
+                arrayOf(payload.diagnostics, `${path}.diagnostics`, assertJsonValue);
+
+            return;
+        }
+
+        case "model.tool-result.presented": {
+            const payload = exactObject(value, path, ["turnId", "toolCallId", "toolName", "isError"], ["content"]);
+            stringOf(payload.turnId, `${path}.turnId`);
+            nonEmptyStringOf(payload.toolCallId, `${path}.toolCallId`);
+            stringOf(payload.toolName, `${path}.toolName`);
+            booleanOf(payload.isError, `${path}.isError`);
+
+            if (Object.hasOwn(payload, "content"))
+                arrayOf(payload.content, `${path}.content`, modelToolResultPartOf);
+
+            return;
+        }
+
+        case "context.compacted": {
+            const payload = exactObject(value, path, [
+                "turnId",
+                "summary",
+                "firstKeptEventId",
+                "tokensBefore",
+                "provider",
+                "model",
+                "readFiles",
+                "modifiedFiles",
+            ]);
+            stringOf(payload.turnId, `${path}.turnId`);
+            nonEmptyStringOf(payload.summary, `${path}.summary`);
+            nonEmptyStringOf(payload.firstKeptEventId, `${path}.firstKeptEventId`);
+            nonNegativeIntegerOf(payload.tokensBefore, `${path}.tokensBefore`);
+            nonEmptyStringOf(payload.provider, `${path}.provider`);
+            nonEmptyStringOf(payload.model, `${path}.model`);
+            stringArrayOf(payload.readFiles, `${path}.readFiles`);
+            stringArrayOf(payload.modifiedFiles, `${path}.modifiedFiles`);
+            return;
+        }
+
         case "model.output.completed":
+        case "model.output.interrupted":
         case "model.reasoning.completed":
         case "runtime.output.recorded": {
             const payload = exactObject(value, path, ["turnId", "text"]);
@@ -510,39 +680,36 @@ const payloadOf = (type: EventType, value: unknown, path: string) => {
         }
 
         case "action.proposed": {
+            if (Object.hasOwn(objectOf(value, path), "kind"))
+                fail(`${path}.kind`, "belongs to a journal written before actions became opaque and is not migrated");
+
             const payload = exactObject(value, path, [
                 "actionId",
-                "kind",
+                "owner",
                 "title",
                 "description",
                 "parameters",
                 "input",
-            ], ["question"]);
+                "payload",
+            ]);
             stringOf(payload.actionId, `${path}.actionId`);
-
-            if (payload.kind !== "action" && payload.kind !== "question")
-                fail(`${path}.kind`, "must be action or question");
-
-            if (payload.kind === "question")
-                questionOf(payload.question, `${path}.question`);
-            else if (Object.hasOwn(payload, "question"))
-                fail(`${path}.question`, "is only supported for questions");
-
+            nullableStringOf(payload.owner, `${path}.owner`);
             stringOf(payload.title, `${path}.title`);
             nullableStringOf(payload.description, `${path}.description`);
             stringRecordOf(payload.parameters, `${path}.parameters`);
             actionInputOf(payload.input, `${path}.input`);
+            actionPayloadOf(payload.payload, `${path}.payload`);
             return;
         }
 
         case "action.resolved": {
-            const payload = exactObject(value, path, ["actionId", "decision", "response"]);
+            const payload = exactObject(value, path, ["actionId", "decision", "result"]);
             stringOf(payload.actionId, `${path}.actionId`);
 
             if (payload.decision !== "approved" && payload.decision !== "dismissed")
                 fail(`${path}.decision`, "must be approved or dismissed");
 
-            nullableStringOf(payload.response, `${path}.response`);
+            assertJsonValue(payload.result, `${path}.result`);
             return;
         }