@markusylisiurunen/tau 0.3.44 → 0.3.46

package/dist/protocol/session_protocol.d.ts

@@ -1,7 +1,14 @@
 import type { AssistantMessage, Message, TextContent, ThinkingContent, Tool, ToolCall } from "@earendil-works/pi-ai";
-export declare const SESSION_PROTOCOL_VERSION: 10;
+export declare const SESSION_PROTOCOL_VERSION: 11;
 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_MAX_SUBAGENT_ACTIVITIES = 64;
+export declare const SESSION_PROTOCOL_MAX_SUBAGENT_SHORT_TEXT_BYTES = 512;
+export declare const SESSION_PROTOCOL_MAX_SUBAGENT_TOOL_SUBJECT_BYTES: number;
+export declare const SESSION_PROTOCOL_MAX_SUBAGENT_ASSISTANT_TEXT_BYTES: number;
+export declare const SESSION_PROTOCOL_MAX_SUBAGENT_TOOL_DETAILS_BYTES: number;
+export declare const SESSION_PROTOCOL_MAX_SUBAGENT_TOOL_METADATA_BYTES: number;
+export declare const SESSION_PROTOCOL_MAX_SUBAGENT_NOTICE_CONTENT_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"];
 export type SessionProtocolMethod = (typeof SESSION_PROTOCOL_METHODS)[number];
 export declare const SESSION_PROTOCOL_ERROR_CODES: {
@@ -239,6 +246,47 @@ export type SessionProtocolPendingUserMessagesState = {
     revision: number;
     messages: SessionProtocolPendingUserMessage[];
 };
+export type SessionProtocolSubagentActivity = {
+    type: "assistant";
+    text: string;
+} | {
+    type: "tool";
+    toolName: string;
+    outcome: "succeeded" | "failed" | "blocked" | "cancelled";
+    presentation: {
+        action: string;
+        operation?: string;
+        subject: string;
+        subjectWrap: "word" | "character";
+        details: Array<{
+            text: string;
+            tone?: "added" | "removed";
+            wrap: "word" | "character";
+        }>;
+        metadata: string[];
+    };
+} | {
+    type: "notice";
+    severity: "info" | "warn" | "error";
+    title: string;
+    content?: string[];
+};
+export type SessionProtocolSubagentActivitiesAgentState = {
+    runRevision: number;
+    activities: SessionProtocolSubagentActivity[];
+};
+export type SessionProtocolSubagentActivitiesState = {
+    revision: number;
+    agents: Record<string, SessionProtocolSubagentActivitiesAgentState>;
+};
+export type SessionProtocolSubagentActivitiesChange = {
+    type: "agent.set";
+    agentId: string;
+    state: SessionProtocolSubagentActivitiesAgentState;
+} | {
+    type: "agent.remove";
+    agentId: string;
+};
 export type SessionProtocolCreateResult = {
     sessionId: string;
 };
@@ -248,6 +296,7 @@ export type SessionProtocolClearGoalResult = SessionProtocolSnapshot;
 export type SessionProtocolObserveResult = {
     snapshot: SessionProtocolSnapshot;
     pendingUserMessages: SessionProtocolPendingUserMessagesState;
+    subagentActivities: SessionProtocolSubagentActivitiesState;
 };
 export type SessionProtocolCancelPendingMessagesResult = {
     cancelled: SessionProtocolPendingUserMessage[];
@@ -326,6 +375,7 @@ export type SessionProtocolTimelineNotice = {
     data: Record<string, unknown>;
 };
 export declare function projectSessionProtocolNoticePresentation(title: string, content?: readonly string[]): SessionProtocolTimelineNotice["presentation"];
+export declare function projectSessionProtocolSubagentActivity(activity: SessionProtocolSubagentActivity): SessionProtocolSubagentActivity;
 export type SessionProtocolTimelineItem = {
     type: "message";
     id: string;
@@ -886,8 +936,15 @@ export type SessionProtocolPendingUserMessagesMessage = {
     sessionId: string;
     state: SessionProtocolPendingUserMessagesState;
 };
-export type SessionProtocolOutgoingMessage = SessionProtocolResponseMessage | SessionProtocolDeltaMessage | SessionProtocolEphemeralMessage | SessionProtocolPendingUserMessagesMessage | SessionProtocolClientToolMessage | SessionProtocolReadyMessage;
-export type SessionProtocolParsedOutgoingMessage = SessionProtocolParsedResponseMessage | SessionProtocolDeltaMessage | SessionProtocolEphemeralMessage | SessionProtocolPendingUserMessagesMessage | SessionProtocolClientToolMessage | SessionProtocolReadyMessage;
+export type SessionProtocolSubagentActivitiesMessage = {
+    version: typeof SESSION_PROTOCOL_VERSION;
+    type: "session.subagentActivities";
+    sessionId: string;
+    revision: number;
+    changes: SessionProtocolSubagentActivitiesChange[];
+};
+export type SessionProtocolOutgoingMessage = SessionProtocolResponseMessage | SessionProtocolDeltaMessage | SessionProtocolEphemeralMessage | SessionProtocolPendingUserMessagesMessage | SessionProtocolSubagentActivitiesMessage | SessionProtocolClientToolMessage | SessionProtocolReadyMessage;
+export type SessionProtocolParsedOutgoingMessage = SessionProtocolParsedResponseMessage | SessionProtocolDeltaMessage | SessionProtocolEphemeralMessage | SessionProtocolPendingUserMessagesMessage | SessionProtocolSubagentActivitiesMessage | SessionProtocolClientToolMessage | SessionProtocolReadyMessage;
 export type SessionProtocolOutgoingParseFailureReason = "invalid_payload" | "empty_line" | "parse_error" | "unsupported_version" | "unsupported_message_type" | "response_invalid_id";
 export type SessionProtocolOutgoingParseFailure = {
     ok: false;
@@ -944,6 +1001,12 @@ export declare function createSessionProtocolPendingUserMessagesMessage(options:
     sessionId: string;
     state: SessionProtocolPendingUserMessagesState;
 }): SessionProtocolPendingUserMessagesMessage;
+export declare function applySessionProtocolSubagentActivitiesMessage(state: SessionProtocolSubagentActivitiesState, message: SessionProtocolSubagentActivitiesMessage): SessionProtocolSubagentActivitiesState;
+export declare function createSessionProtocolSubagentActivitiesMessage(options: {
+    sessionId: string;
+    revision: number;
+    changes: SessionProtocolSubagentActivitiesChange[];
+}): SessionProtocolSubagentActivitiesMessage;
 export declare function applySessionProtocolDelta(snapshot: SessionProtocolSnapshot, message: SessionProtocolDeltaMessage): SessionProtocolSnapshot;
 export declare function createSessionProtocolReadyMessage(): SessionProtocolReadyMessage;
 export declare function serializeSessionProtocolMessage(message: SessionProtocolOutgoingMessage): string;

package/dist/protocol/session_protocol.js

@@ -1,10 +1,18 @@
 import { z } from "zod";
-export const SESSION_PROTOCOL_VERSION = 10;
+export const SESSION_PROTOCOL_VERSION = 11;
 export const SESSION_PROTOCOL_MAX_EXEC_CAPTURE_BYTES = 24 * 1024 * 1024;
 export const SESSION_PROTOCOL_MAX_EXEC_STDIN_BYTES = 16 * 1024 * 1024;
+export const SESSION_PROTOCOL_MAX_SUBAGENT_ACTIVITIES = 64;
+export const SESSION_PROTOCOL_MAX_SUBAGENT_SHORT_TEXT_BYTES = 512;
+export const SESSION_PROTOCOL_MAX_SUBAGENT_TOOL_SUBJECT_BYTES = 4 * 1024;
+export const SESSION_PROTOCOL_MAX_SUBAGENT_ASSISTANT_TEXT_BYTES = 32 * 1024;
+export const SESSION_PROTOCOL_MAX_SUBAGENT_TOOL_DETAILS_BYTES = 32 * 1024;
+export const SESSION_PROTOCOL_MAX_SUBAGENT_TOOL_METADATA_BYTES = 8 * 1024;
+export const SESSION_PROTOCOL_MAX_SUBAGENT_NOTICE_CONTENT_BYTES = 32 * 1024;
 const SESSION_PROTOCOL_NOTICE_TITLE_MAX_CHARS = 512;
 const SESSION_PROTOCOL_NOTICE_CONTENT_MAX_ENTRIES = 16;
 const SESSION_PROTOCOL_NOTICE_CONTENT_ENTRY_MAX_CHARS = 4_096;
+const UTF8_ENCODER = new TextEncoder();
 export const SESSION_PROTOCOL_METHODS = [
     "initialize",
     "session.create",
@@ -79,6 +87,149 @@ export function projectSessionProtocolNoticePresentation(title, content) {
         ...(projectedContent.length > 0 ? { content: projectedContent } : {}),
     };
 }
+export function projectSessionProtocolSubagentActivity(activity) {
+    if (activity.type === "assistant") {
+        return {
+            type: "assistant",
+            text: truncateUtf8Middle(activity.text, SESSION_PROTOCOL_MAX_SUBAGENT_ASSISTANT_TEXT_BYTES),
+        };
+    }
+    if (activity.type === "notice") {
+        const content = activity.content
+            ? truncateSubagentTextValues(activity.content, SESSION_PROTOCOL_MAX_SUBAGENT_NOTICE_CONTENT_BYTES)
+            : [];
+        return {
+            type: "notice",
+            severity: activity.severity,
+            title: truncateUtf8Middle(activity.title, SESSION_PROTOCOL_MAX_SUBAGENT_SHORT_TEXT_BYTES),
+            ...(content.length > 0 ? { content } : {}),
+        };
+    }
+    const toolName = activity.toolName.replace(/\s+/g, " ").trim() || "(invalid tool name)";
+    return {
+        type: "tool",
+        toolName: truncateUtf8Middle(toolName, SESSION_PROTOCOL_MAX_SUBAGENT_SHORT_TEXT_BYTES),
+        outcome: activity.outcome,
+        presentation: {
+            action: truncateUtf8Middle(activity.presentation.action, SESSION_PROTOCOL_MAX_SUBAGENT_SHORT_TEXT_BYTES),
+            ...(activity.presentation.operation
+                ? {
+                    operation: truncateUtf8Middle(activity.presentation.operation, SESSION_PROTOCOL_MAX_SUBAGENT_SHORT_TEXT_BYTES),
+                }
+                : {}),
+            subject: truncateUtf8Middle(activity.presentation.subject, SESSION_PROTOCOL_MAX_SUBAGENT_TOOL_SUBJECT_BYTES),
+            subjectWrap: activity.presentation.subjectWrap,
+            details: truncateSubagentActivityDetails(activity.presentation.details),
+            metadata: truncateSubagentTextValues(activity.presentation.metadata, SESSION_PROTOCOL_MAX_SUBAGENT_TOOL_METADATA_BYTES),
+        },
+    };
+}
+function truncateSubagentActivityDetails(details) {
+    return truncateSubagentTextEntries(details, SESSION_PROTOCOL_MAX_SUBAGENT_TOOL_DETAILS_BYTES, (omitted) => ({
+        text: `…${omitted} more ${omitted === 1 ? "line" : "lines"}…`,
+        wrap: "word",
+    }));
+}
+function truncateSubagentTextValues(values, maxBytes) {
+    return truncateSubagentTextEntries(values.map((text) => ({ text })), maxBytes, (omitted) => ({
+        text: `…${omitted} more ${omitted === 1 ? "entry" : "entries"}…`,
+    })).map((entry) => entry.text);
+}
+function truncateSubagentTextEntries(entries, maxBytes, omission) {
+    const cloned = structuredClone(entries);
+    if (subagentTextEntriesBytes(cloned) <= maxBytes) {
+        return cloned;
+    }
+    const perEntryBytes = cloned.length === 1
+        ? maxBytes
+        : cloned.length === 2
+            ? Math.floor((maxBytes - 1) / 2)
+            : Math.floor((maxBytes - utf8ByteLength(omission(cloned.length - 2).text) - 2) / 2);
+    const bounded = cloned.map((entry) => ({
+        ...entry,
+        text: truncateUtf8Middle(entry.text, perEntryBytes),
+    }));
+    if (subagentTextEntriesBytes(bounded) <= maxBytes) {
+        return bounded;
+    }
+    const itemBytes = bounded.map((entry) => utf8ByteLength(entry.text));
+    let headCount = 0;
+    let tailCount = 0;
+    let headBytes = 0;
+    let tailBytes = 0;
+    while (headCount + tailCount < bounded.length) {
+        const nextKeptCount = headCount + tailCount + 1;
+        const omitted = bounded.length - nextKeptCount;
+        if (omitted === 0)
+            break;
+        const headItemBytes = itemBytes[headCount];
+        const tailItemBytes = itemBytes[bounded.length - tailCount - 1];
+        const headFits = subagentTextEntriesProjectionBytes(nextKeptCount, headBytes + headItemBytes + tailBytes, omission(omitted).text) <= maxBytes;
+        const tailFits = subagentTextEntriesProjectionBytes(nextKeptCount, headBytes + tailBytes + tailItemBytes, omission(omitted).text) <= maxBytes;
+        if (!headFits && !tailFits)
+            break;
+        const takeHead = headFits &&
+            (!tailFits ||
+                Math.abs(headBytes + headItemBytes - tailBytes) <=
+                    Math.abs(headBytes - tailBytes - tailItemBytes));
+        if (takeHead) {
+            headCount += 1;
+            headBytes += headItemBytes;
+        }
+        else {
+            tailCount += 1;
+            tailBytes += tailItemBytes;
+        }
+    }
+    const omitted = bounded.length - headCount - tailCount;
+    return [
+        ...bounded.slice(0, headCount),
+        omission(omitted),
+        ...bounded.slice(bounded.length - tailCount),
+    ];
+}
+function subagentTextEntriesProjectionBytes(keptCount, keptBytes, omissionText) {
+    return keptBytes + utf8ByteLength(omissionText) + keptCount;
+}
+function subagentTextEntriesBytes(entries) {
+    if (entries.length === 0)
+        return 0;
+    return (entries.reduce((total, entry) => total + utf8ByteLength(entry.text), 0) + entries.length - 1);
+}
+function truncateUtf8Middle(value, maxBytes) {
+    if (utf8ByteLength(value) <= maxBytes)
+        return value;
+    const marker = "…";
+    const markerBytes = utf8ByteLength(marker);
+    const contentBytes = maxBytes - markerBytes;
+    const headBudget = Math.ceil(contentBytes / 2);
+    const tailBudget = contentBytes - headBudget;
+    const characters = Array.from(value);
+    let headCount = 0;
+    let headBytes = 0;
+    while (headCount < characters.length) {
+        const nextBytes = utf8ByteLength(characters[headCount]);
+        if (headBytes + nextBytes > headBudget)
+            break;
+        headBytes += nextBytes;
+        headCount += 1;
+    }
+    let tailCount = 0;
+    let tailBytes = 0;
+    while (tailCount < characters.length - headCount) {
+        const nextBytes = utf8ByteLength(characters[characters.length - tailCount - 1]);
+        if (tailBytes + nextBytes > tailBudget)
+            break;
+        tailBytes += nextBytes;
+        tailCount += 1;
+    }
+    return `${characters.slice(0, headCount).join("")}${marker}${characters
+        .slice(characters.length - tailCount)
+        .join("")}`;
+}
+function utf8ByteLength(value) {
+    return UTF8_ENCODER.encode(value).byteLength;
+}
 function truncateNoticeText(value, maxChars) {
     if (value.length <= maxChars)
         return value;
@@ -314,6 +465,7 @@ const sessionProtocolOutgoingRoutingSchema = z
         "session.delta",
         "session.ephemeral",
         "session.pendingUserMessages",
+        "session.subagentActivities",
         "session.clientTool.call",
         "session.clientTool.cancel",
         "response",
@@ -1667,6 +1819,97 @@ const sessionProtocolPendingUserMessagesMessageSchema = z
     state: sessionProtocolPendingUserMessagesStateSchema,
 })
     .strip();
+const subagentActivityLineSchema = z
+    .string()
+    .refine((text) => !text.includes("\n") && !text.includes("\r"), "must be one line");
+const subagentActivityShortTextSchema = subagentActivityLineSchema
+    .min(1)
+    .refine((text) => text.trim().length > 0)
+    .refine((text) => utf8ByteLength(text) <= SESSION_PROTOCOL_MAX_SUBAGENT_SHORT_TEXT_BYTES, `must not exceed ${SESSION_PROTOCOL_MAX_SUBAGENT_SHORT_TEXT_BYTES} UTF-8 bytes`);
+const subagentToolPresentationSchema = z
+    .object({
+    action: subagentActivityShortTextSchema,
+    operation: subagentActivityShortTextSchema.optional(),
+    subject: nonEmptyStringSchema.refine((subject) => utf8ByteLength(subject) <= SESSION_PROTOCOL_MAX_SUBAGENT_TOOL_SUBJECT_BYTES, `must not exceed ${SESSION_PROTOCOL_MAX_SUBAGENT_TOOL_SUBJECT_BYTES} UTF-8 bytes`),
+    subjectWrap: z.enum(["word", "character"]),
+    details: z
+        .array(z
+        .object({
+        text: subagentActivityLineSchema,
+        tone: z.enum(["added", "removed"]).optional(),
+        wrap: z.enum(["word", "character"]),
+    })
+        .strip())
+        .refine((details) => subagentTextEntriesBytes(details) <= SESSION_PROTOCOL_MAX_SUBAGENT_TOOL_DETAILS_BYTES, `text must not exceed ${SESSION_PROTOCOL_MAX_SUBAGENT_TOOL_DETAILS_BYTES} UTF-8 bytes`),
+    metadata: z
+        .array(subagentActivityLineSchema)
+        .refine((metadata) => subagentTextEntriesBytes(metadata.map((text) => ({ text }))) <=
+        SESSION_PROTOCOL_MAX_SUBAGENT_TOOL_METADATA_BYTES, `text must not exceed ${SESSION_PROTOCOL_MAX_SUBAGENT_TOOL_METADATA_BYTES} UTF-8 bytes`),
+})
+    .strip();
+const sessionProtocolSubagentActivitySchema = z.discriminatedUnion("type", [
+    z
+        .object({
+        type: z.literal("assistant"),
+        text: nonEmptyStringSchema.refine((text) => utf8ByteLength(text) <= SESSION_PROTOCOL_MAX_SUBAGENT_ASSISTANT_TEXT_BYTES, `must not exceed ${SESSION_PROTOCOL_MAX_SUBAGENT_ASSISTANT_TEXT_BYTES} UTF-8 bytes`),
+    })
+        .strip(),
+    z
+        .object({
+        type: z.literal("tool"),
+        toolName: subagentActivityShortTextSchema,
+        outcome: z.enum(["succeeded", "failed", "blocked", "cancelled"]),
+        presentation: subagentToolPresentationSchema,
+    })
+        .strip(),
+    z
+        .object({
+        type: z.literal("notice"),
+        severity: z.enum(["info", "warn", "error"]),
+        title: subagentActivityShortTextSchema,
+        content: z
+            .array(z.string())
+            .refine((content) => subagentTextEntriesBytes(content.map((text) => ({ text }))) <=
+            SESSION_PROTOCOL_MAX_SUBAGENT_NOTICE_CONTENT_BYTES, `text must not exceed ${SESSION_PROTOCOL_MAX_SUBAGENT_NOTICE_CONTENT_BYTES} UTF-8 bytes`)
+            .optional(),
+    })
+        .strip(),
+]);
+const sessionProtocolSubagentActivitiesAgentStateSchema = z
+    .object({
+    runRevision: z.number().int().positive(),
+    activities: z
+        .array(sessionProtocolSubagentActivitySchema)
+        .max(SESSION_PROTOCOL_MAX_SUBAGENT_ACTIVITIES),
+})
+    .strip();
+const sessionProtocolSubagentActivitiesStateSchema = z
+    .object({
+    revision: z.number().int().positive(),
+    agents: z.record(nonEmptyStringSchema, sessionProtocolSubagentActivitiesAgentStateSchema),
+})
+    .strip();
+const sessionProtocolSubagentActivitiesChangeSchema = z.discriminatedUnion("type", [
+    z
+        .object({
+        type: z.literal("agent.set"),
+        agentId: nonEmptyStringSchema,
+        state: sessionProtocolSubagentActivitiesAgentStateSchema,
+    })
+        .strip(),
+    z.object({ type: z.literal("agent.remove"), agentId: nonEmptyStringSchema }).strip(),
+]);
+const sessionProtocolSubagentActivitiesMessageSchema = z
+    .object({
+    version: z.literal(SESSION_PROTOCOL_VERSION),
+    type: z.literal("session.subagentActivities"),
+    sessionId: nonEmptyStringSchema,
+    revision: z.number().int().positive(),
+    changes: z
+        .array(sessionProtocolSubagentActivitiesChangeSchema)
+        .refine((changes) => new Set(changes.map((change) => change.agentId)).size === changes.length, "must not contain duplicate agent ids"),
+})
+    .strip();
 const sessionProtocolInitializeResultSchema = z
     .object({
     protocolVersion: z.literal(SESSION_PROTOCOL_VERSION),
@@ -1683,6 +1926,7 @@ const sessionProtocolObserveResultSchema = z
     .object({
     snapshot: sessionProtocolSnapshotSchema,
     pendingUserMessages: sessionProtocolPendingUserMessagesStateSchema,
+    subagentActivities: sessionProtocolSubagentActivitiesStateSchema,
 })
     .strip();
 const sessionProtocolListResultSchema = z
@@ -1904,6 +2148,35 @@ export function createSessionProtocolPendingUserMessagesMessage(options) {
     }
     return parsedMessage.data;
 }
+export function applySessionProtocolSubagentActivitiesMessage(state, message) {
+    if (message.revision <= state.revision) {
+        return structuredClone(state);
+    }
+    const agents = { ...state.agents };
+    for (const change of message.changes) {
+        if (change.type === "agent.set") {
+            agents[change.agentId] = structuredClone(change.state);
+        }
+        else {
+            delete agents[change.agentId];
+        }
+    }
+    return { revision: message.revision, agents };
+}
+export function createSessionProtocolSubagentActivitiesMessage(options) {
+    const message = {
+        version: SESSION_PROTOCOL_VERSION,
+        type: "session.subagentActivities",
+        sessionId: options.sessionId,
+        revision: options.revision,
+        changes: options.changes,
+    };
+    const parsedMessage = sessionProtocolSubagentActivitiesMessageSchema.safeParse(message);
+    if (!parsedMessage.success) {
+        throw new Error(`session protocol subagent activities message is invalid: ${formatZodError(parsedMessage.error)}`);
+    }
+    return parsedMessage.data;
+}
 function validateSnapshotResetCause(snapshot, message) {
     if (message.delta.type !== "snapshot.reset") {
         return;
@@ -2445,6 +2718,9 @@ export function parseSessionProtocolOutgoingLine(line) {
     if (routing.data.type === "session.pendingUserMessages") {
         return parseSessionProtocolPendingUserMessagesMessage(parsed);
     }
+    if (routing.data.type === "session.subagentActivities") {
+        return parseSessionProtocolSubagentActivitiesMessage(parsed);
+    }
     if (routing.data.type === "session.clientTool.call" ||
         routing.data.type === "session.clientTool.cancel") {
         return parseSessionProtocolClientToolMessage(parsed);
@@ -3133,6 +3409,26 @@ function parseSessionProtocolPendingUserMessagesMessage(payload) {
         message: message.data,
     };
 }
+function parseSessionProtocolSubagentActivitiesMessage(payload) {
+    const fail = (message) => outgoingParseFailure("session.subagentActivities", null, SESSION_PROTOCOL_ERROR_CODES.invalidRequest, message);
+    const message = sessionProtocolSubagentActivitiesMessageSchema.safeParse(payload);
+    if (!message.success) {
+        if (hasIssue(message.error, ["sessionId"])) {
+            return fail("session.subagentActivities.sessionId must be a non-empty string");
+        }
+        if (hasIssue(message.error, ["revision"])) {
+            return fail("session.subagentActivities.revision is invalid");
+        }
+        if (hasIssue(message.error, ["changes"])) {
+            return fail("session.subagentActivities.changes are invalid");
+        }
+        return fail(`invalid session.subagentActivities message: ${formatZodError(message.error)}`);
+    }
+    return {
+        ok: true,
+        message: message.data,
+    };
+}
 function parseSessionProtocolResponseMessage(payload) {
     const parsedIdField = sessionProtocolIdFieldSchema.safeParse(payload);
     const responseId = parseNullableRequestId(parsedIdField.success ? parsedIdField.data.id : undefined);