@markusylisiurunen/tau 0.2.128 → 0.3.0

package/dist/protocol/session_protocol.js

@@ -0,0 +1,2117 @@
+import { z } from "zod";
+export const SESSION_PROTOCOL_VERSION = 1;
+export const SESSION_PROTOCOL_METHODS = [
+    "initialize",
+    "session.create",
+    "session.list",
+    "session.observe",
+    "session.unobserve",
+    "session.record",
+    "session.submit",
+    "session.queue",
+    "session.steer",
+    "session.retry",
+    "session.exec",
+    "session.interrupt",
+    "session.snapshot",
+    "session.setRisk",
+    "session.setReasoning",
+    "session.setPersona",
+    "session.resolvePrompt",
+    "session.autocompletePaths",
+    "session.reload",
+    "session.compact",
+    "session.prune",
+    "session.rewind",
+    "session.terminateSubagent",
+    "session.ephemeral.create",
+    "session.ephemeral.submit",
+    "session.ephemeral.close",
+];
+const SESSION_PROTOCOL_METHOD_SET = new Set(SESSION_PROTOCOL_METHODS);
+function formatZodError(error) {
+    return error.issues
+        .map((issue) => {
+        const path = issue.path.length > 0 ? issue.path.join(".") : undefined;
+        return path ? `${path}: ${issue.message}` : issue.message;
+    })
+        .join("; ");
+}
+export const SESSION_PROTOCOL_ERROR_CODES = {
+    parseError: "parse_error",
+    invalidRequest: "invalid_request",
+    methodNotFound: "method_not_found",
+    invalidParams: "invalid_params",
+    notFound: "not_found",
+    busy: "busy",
+    internalError: "internal_error",
+};
+const SESSION_PROTOCOL_ERROR_CODE_VALUES = [
+    SESSION_PROTOCOL_ERROR_CODES.parseError,
+    SESSION_PROTOCOL_ERROR_CODES.invalidRequest,
+    SESSION_PROTOCOL_ERROR_CODES.methodNotFound,
+    SESSION_PROTOCOL_ERROR_CODES.invalidParams,
+    SESSION_PROTOCOL_ERROR_CODES.notFound,
+    SESSION_PROTOCOL_ERROR_CODES.busy,
+    SESSION_PROTOCOL_ERROR_CODES.internalError,
+];
+const sessionProtocolMethodSchema = z.enum(SESSION_PROTOCOL_METHODS);
+const sessionProtocolMethodListSchema = z
+    .array(sessionProtocolMethodSchema)
+    .superRefine((methods, ctx) => {
+    const seen = new Set();
+    for (const method of methods) {
+        if (seen.has(method)) {
+            ctx.addIssue({
+                code: "custom",
+                message: `duplicate session protocol method '${method}'`,
+            });
+        }
+        seen.add(method);
+    }
+});
+const sessionProtocolSessionLifecycleSchema = z.enum(["idle", "running"]);
+const sessionProtocolErrorCodeSchema = z.enum(SESSION_PROTOCOL_ERROR_CODE_VALUES);
+const nonEmptyStringSchema = z
+    .string()
+    .min(1)
+    .refine((value) => value.trim().length > 0);
+const sessionProtocolRequestIdSchema = nonEmptyStringSchema;
+const nullableSessionProtocolRequestIdSchema = sessionProtocolRequestIdSchema.nullable();
+const messageSchema = z.custom(isMessage);
+const sessionProtocolReadyMessageSchema = z
+    .object({
+    version: z.literal(SESSION_PROTOCOL_VERSION),
+    type: z.literal("ready"),
+    methods: sessionProtocolMethodListSchema,
+})
+    .strict();
+const sessionProtocolRequestEnvelopeSchema = z
+    .object({
+    version: z.literal(SESSION_PROTOCOL_VERSION),
+    type: z.literal("request"),
+    id: sessionProtocolRequestIdSchema,
+    method: z.string(),
+    params: z.unknown(),
+})
+    .strict();
+const sessionProtocolOutgoingRoutingSchema = z
+    .object({
+    version: z.literal(SESSION_PROTOCOL_VERSION),
+    type: z.enum(["ready", "session.delta", "session.ephemeral", "response"]),
+})
+    .passthrough();
+const sessionProtocolIdFieldSchema = z.object({ id: z.unknown() }).passthrough();
+const sessionProtocolOkFieldSchema = z.object({ ok: z.unknown() }).passthrough();
+const sessionProtocolVersionFieldSchema = z.object({ version: z.unknown() }).passthrough();
+const sessionProtocolTypeFieldSchema = z.object({ type: z.unknown() }).passthrough();
+const sessionProtocolResponseSuccessSchema = z
+    .object({
+    version: z.literal(SESSION_PROTOCOL_VERSION),
+    type: z.literal("response"),
+    id: sessionProtocolRequestIdSchema,
+    ok: z.literal(true),
+    result: z.unknown(),
+})
+    .strict();
+const sessionProtocolResponseErrorSchema = z
+    .object({
+    version: z.literal(SESSION_PROTOCOL_VERSION),
+    type: z.literal("response"),
+    id: nullableSessionProtocolRequestIdSchema,
+    ok: z.literal(false),
+    error: z
+        .object({
+        code: sessionProtocolErrorCodeSchema,
+        message: z.string(),
+        data: z.unknown().optional(),
+    })
+        .strict(),
+})
+    .strict();
+const sessionProtocolInitializeParamsSchema = z
+    .object({
+    client: z
+        .object({
+        name: nonEmptyStringSchema,
+        version: nonEmptyStringSchema,
+    })
+        .strict(),
+})
+    .strict();
+const sessionProtocolUserMessageParamsSchema = z
+    .object({
+    sessionId: nonEmptyStringSchema,
+    text: z.string(),
+    historyEntryId: nonEmptyStringSchema.optional(),
+})
+    .strict();
+const sessionProtocolRecordParamsSchema = sessionProtocolUserMessageParamsSchema;
+const sessionProtocolExecParamsSchema = z
+    .object({
+    sessionId: nonEmptyStringSchema,
+    command: nonEmptyStringSchema,
+    cwd: nonEmptyStringSchema.optional(),
+    timeoutMs: z.number().int().positive().optional(),
+})
+    .strict();
+const sessionProtocolSessionIdParamsSchema = z
+    .object({
+    sessionId: nonEmptyStringSchema,
+})
+    .strict();
+const sessionProtocolSetRiskParamsSchema = z
+    .object({
+    sessionId: nonEmptyStringSchema,
+    riskLevel: z.enum(["read-only", "read-write"]),
+})
+    .strict();
+const sessionProtocolReasoningEffortSchema = z.enum([
+    "none",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+]);
+const sessionProtocolSetReasoningParamsSchema = z
+    .object({
+    sessionId: nonEmptyStringSchema,
+    reasoning: sessionProtocolReasoningEffortSchema,
+})
+    .strict();
+const sessionProtocolSetPersonaParamsSchema = z
+    .object({
+    sessionId: nonEmptyStringSchema,
+    personaId: nonEmptyStringSchema,
+})
+    .strict();
+const sessionProtocolResolvePromptParamsSchema = z
+    .object({
+    sessionId: nonEmptyStringSchema,
+    promptId: nonEmptyStringSchema,
+})
+    .strict();
+const sessionProtocolAutocompletePathsParamsSchema = z
+    .object({
+    sessionId: nonEmptyStringSchema,
+    query: z.string(),
+    limit: z.number().int().positive().max(100),
+})
+    .strict();
+const sessionProtocolCompactParamsSchema = z
+    .object({
+    sessionId: nonEmptyStringSchema,
+    mode: z.enum(["summary-only", "summary-and-last"]),
+    guidance: z.string().optional(),
+})
+    .strict();
+const sessionProtocolPruneParamsSchema = z
+    .object({
+    sessionId: nonEmptyStringSchema,
+    strategy: z.enum(["earliest", "largest", "smart"]),
+    fraction: z.number().min(0).max(1),
+    guidance: z.string().optional(),
+})
+    .strict();
+const sessionProtocolRewindParamsSchema = z
+    .object({
+    sessionId: nonEmptyStringSchema,
+    historyEntryId: nonEmptyStringSchema,
+})
+    .strict();
+const sessionProtocolTerminateSubagentParamsSchema = z
+    .object({
+    sessionId: nonEmptyStringSchema,
+    subagentId: nonEmptyStringSchema,
+})
+    .strict();
+const sessionProtocolEphemeralAgentToolSchema = z.enum([
+    "bash",
+    "write",
+    "edit",
+    "view_image",
+    "web_search",
+    "web_fetch",
+]);
+const sessionProtocolEphemeralCreateParamsSchema = z
+    .object({
+    sessionId: nonEmptyStringSchema,
+    instructions: nonEmptyStringSchema,
+    tools: z.array(sessionProtocolEphemeralAgentToolSchema),
+    riskLevel: z.enum(["read-only", "read-write"]),
+})
+    .strict();
+const sessionProtocolEphemeralSubmitParamsSchema = z
+    .object({
+    sessionId: nonEmptyStringSchema,
+    contextId: nonEmptyStringSchema,
+    threadId: nonEmptyStringSchema,
+    forkFromThreadId: nonEmptyStringSchema.optional(),
+    message: nonEmptyStringSchema,
+})
+    .strict();
+const sessionProtocolEphemeralCloseParamsSchema = z
+    .object({
+    sessionId: nonEmptyStringSchema,
+    contextId: nonEmptyStringSchema,
+})
+    .strict();
+const absolutePathSchema = nonEmptyStringSchema.refine((value) => value.startsWith("/"));
+const sessionProtocolLocalExecutionEnvironmentInputSchema = z
+    .object({
+    kind: z.literal("local"),
+    cwd: absolutePathSchema,
+})
+    .strict();
+const sessionProtocolCloudflareSandboxExecutionEnvironmentInputSchema = z
+    .object({
+    kind: z.literal("cloudflare-sandbox"),
+    bridgeId: nonEmptyStringSchema,
+    sandboxId: nonEmptyStringSchema,
+    cwd: absolutePathSchema,
+})
+    .strict();
+const sessionProtocolFlySpriteExecutionEnvironmentInputSchema = z
+    .object({
+    kind: z.literal("fly-sprite"),
+    apiId: nonEmptyStringSchema,
+    spriteName: nonEmptyStringSchema,
+    cwd: absolutePathSchema,
+})
+    .strict();
+const sessionProtocolExecutionEnvironmentInputSchema = z.discriminatedUnion("kind", [
+    sessionProtocolLocalExecutionEnvironmentInputSchema,
+    sessionProtocolCloudflareSandboxExecutionEnvironmentInputSchema,
+    sessionProtocolFlySpriteExecutionEnvironmentInputSchema,
+]);
+const sessionProtocolCreateParamsSchema = z
+    .object({
+    executionEnvironment: sessionProtocolExecutionEnvironmentInputSchema,
+    personaId: nonEmptyStringSchema.optional(),
+    riskLevel: z.enum(["read-only", "read-write"]).optional(),
+    reasoning: sessionProtocolReasoningEffortSchema.optional(),
+})
+    .strict();
+const sessionProtocolEmptyParamsSchema = z.object({}).strict();
+const sessionProtocolSessionSummarySchema = z
+    .object({
+    sessionId: nonEmptyStringSchema,
+    lifecycle: sessionProtocolSessionLifecycleSchema,
+})
+    .strict();
+const sessionProtocolServiceTierSchema = z.enum(["priority", "flex"]);
+const sessionProtocolModelSnapshotSchema = z
+    .object({
+    id: nonEmptyStringSchema,
+    name: nonEmptyStringSchema,
+    api: nonEmptyStringSchema,
+    provider: nonEmptyStringSchema,
+    baseUrl: z.string(),
+    reasoning: z.boolean(),
+    thinkingLevelMap: z
+        .partialRecord(z.enum(["off", "minimal", "low", "medium", "high", "xhigh"]), z.string().nullable())
+        .optional(),
+    input: z.array(z.enum(["text", "image"])),
+    cost: z
+        .object({
+        input: z.number().nonnegative(),
+        output: z.number().nonnegative(),
+        cacheRead: z.number().nonnegative(),
+        cacheWrite: z.number().nonnegative(),
+    })
+        .strict(),
+    contextWindow: z.number().int().positive(),
+    maxTokens: z.number().int().positive(),
+    compat: z.unknown().optional(),
+})
+    .strict();
+const sessionProtocolPersonaSettingsSnapshotSchema = z
+    .object({
+    reasoning: sessionProtocolReasoningEffortSchema.optional(),
+    interleavedThinking: z.boolean().optional(),
+    serviceTier: sessionProtocolServiceTierSchema.optional(),
+})
+    .strict();
+const sessionProtocolSubagentSnapshotSchema = z
+    .object({
+    description: z.string().optional(),
+    tools: z.array(nonEmptyStringSchema).optional(),
+    riskLevel: z.enum(["read-only", "read-write"]).optional(),
+    launchModels: z.array(nonEmptyStringSchema).optional(),
+})
+    .strict();
+const sessionProtocolPersonaSnapshotSchema = z
+    .object({
+    id: nonEmptyStringSchema,
+    label: nonEmptyStringSchema,
+    description: z.string().optional(),
+    allowedReasoningLevels: z.array(sessionProtocolReasoningEffortSchema).optional(),
+    subagents: z.record(nonEmptyStringSchema, sessionProtocolSubagentSnapshotSchema).optional(),
+    tools: z.array(nonEmptyStringSchema).optional(),
+    skills: z.union([z.literal("*"), z.array(nonEmptyStringSchema)]),
+    source: z.enum(["builtin", "user", "project"]),
+})
+    .strict();
+const sessionProtocolPromptTemplateSnapshotSchema = z
+    .object({
+    id: nonEmptyStringSchema,
+    label: z.string().optional(),
+    description: z.string().optional(),
+})
+    .strict();
+const sessionProtocolSkillSnapshotSchema = z
+    .object({
+    name: nonEmptyStringSchema,
+    description: nonEmptyStringSchema,
+    path: nonEmptyStringSchema,
+})
+    .strict();
+const sessionProtocolContentCatalogSnapshotSchema = z
+    .object({
+    personas: z.array(sessionProtocolPersonaSnapshotSchema),
+    prompts: z.array(sessionProtocolPromptTemplateSnapshotSchema),
+    skills: z.array(sessionProtocolSkillSnapshotSchema),
+})
+    .strict();
+const sessionProtocolSettingsSnapshotSchema = z
+    .object({
+    personaId: nonEmptyStringSchema,
+    riskLevel: z.enum(["read-only", "read-write"]),
+    reasoning: sessionProtocolReasoningEffortSchema.optional(),
+    serviceTier: sessionProtocolServiceTierSchema.optional(),
+})
+    .strict();
+const sessionProtocolBootstrapSnapshotSchema = z
+    .object({
+    model: sessionProtocolModelSnapshotSchema,
+    prompt: z
+        .object({
+        environmentTag: nonEmptyStringSchema,
+        subagentPrompts: z.record(z.string(), z.string()),
+    })
+        .strict(),
+})
+    .strict();
+const sessionProtocolLocalExecutionEnvironmentSnapshotSchema = z
+    .object({
+    kind: z.literal("local"),
+    cwd: nonEmptyStringSchema,
+    home: nonEmptyStringSchema,
+})
+    .strict();
+const sessionProtocolCloudflareSandboxExecutionEnvironmentSnapshotSchema = z
+    .object({
+    kind: z.literal("cloudflare-sandbox"),
+    bridgeId: nonEmptyStringSchema,
+    sandboxId: nonEmptyStringSchema,
+    cwd: nonEmptyStringSchema,
+    home: nonEmptyStringSchema,
+})
+    .strict();
+const sessionProtocolFlySpriteExecutionEnvironmentSnapshotSchema = z
+    .object({
+    kind: z.literal("fly-sprite"),
+    apiId: nonEmptyStringSchema,
+    spriteName: nonEmptyStringSchema,
+    cwd: nonEmptyStringSchema,
+    home: nonEmptyStringSchema,
+})
+    .strict();
+const sessionProtocolExecutionEnvironmentSnapshotSchema = z.discriminatedUnion("kind", [
+    sessionProtocolLocalExecutionEnvironmentSnapshotSchema,
+    sessionProtocolCloudflareSandboxExecutionEnvironmentSnapshotSchema,
+    sessionProtocolFlySpriteExecutionEnvironmentSnapshotSchema,
+]);
+const sessionProtocolSystemMessageSchema = z
+    .object({
+    role: z.literal("system"),
+    content: z.string(),
+    timestamp: z.number().finite(),
+})
+    .strict();
+const sessionProtocolDraftAssistantMessageSchema = z
+    .object({
+    role: z.literal("assistant"),
+    content: z.array(z.unknown()),
+    timestamp: z.number().finite(),
+})
+    .strict();
+const sessionProtocolMessagePayloadSchema = z.union([
+    sessionProtocolSystemMessageSchema,
+    messageSchema,
+    sessionProtocolDraftAssistantMessageSchema,
+]);
+const sessionProtocolMessageSchema = z
+    .object({
+    id: nonEmptyStringSchema,
+    state: z.enum(["draft", "committed", "interrupted", "discarded"]),
+    modelVisible: z.boolean(),
+    message: sessionProtocolMessagePayloadSchema,
+})
+    .strict();
+const sessionProtocolNoticeSchema = z
+    .object({
+    severity: z.enum(["info", "warn", "error"]),
+    text: z.string(),
+    timestamp: z.number().finite(),
+})
+    .strict();
+const sessionProtocolOperationSchema = z
+    .object({
+    kind: z.enum(["auto-compaction", "manual-compaction", "prune", "reload", "rewind"]),
+    status: z.enum(["running", "succeeded", "failed", "cancelled", "skipped"]),
+    startedAt: z.number().finite(),
+    finishedAt: z.number().finite().optional(),
+    summary: z.string().optional(),
+    error: z.string().optional(),
+    data: z.record(z.string(), z.unknown()).optional(),
+})
+    .strict();
+const sessionProtocolTimelineItemSchema = z.discriminatedUnion("type", [
+    z
+        .object({
+        type: z.literal("message"),
+        id: nonEmptyStringSchema,
+        messageId: nonEmptyStringSchema,
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal("notice"),
+        id: nonEmptyStringSchema,
+        notice: sessionProtocolNoticeSchema,
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal("operation"),
+        id: nonEmptyStringSchema,
+        operation: sessionProtocolOperationSchema,
+    })
+        .strict(),
+]);
+const sessionProtocolToolRunSchema = z
+    .object({
+    id: nonEmptyStringSchema,
+    toolCallId: nonEmptyStringSchema,
+    toolName: nonEmptyStringSchema,
+    call: z
+        .object({
+        messageId: nonEmptyStringSchema,
+        contentIndex: z.number().int().nonnegative(),
+    })
+        .strict(),
+    status: z.enum(["queued", "running", "succeeded", "failed", "blocked", "cancelled"]),
+    startedAt: z.number().finite().optional(),
+    finishedAt: z.number().finite().optional(),
+    resultMessageId: nonEmptyStringSchema.optional(),
+    summary: z.string().optional(),
+    error: z.string().optional(),
+    facetIds: z.array(nonEmptyStringSchema),
+})
+    .strict();
+const sessionProtocolAgentUsageSchema = z
+    .object({
+    input: z.number().finite(),
+    output: z.number().finite(),
+    cacheRead: z.number().finite(),
+    cacheWrite: z.number().finite(),
+    contextWindowUsageTokens: z.number().finite(),
+    contextWindow: z.number().finite(),
+})
+    .strict();
+const sessionProtocolAgentRunSchema = z
+    .object({
+    id: nonEmptyStringSchema,
+    name: nonEmptyStringSchema,
+    title: nonEmptyStringSchema,
+    status: z.enum(["running", "succeeded", "failed", "cancelled"]),
+    originMessageId: nonEmptyStringSchema,
+    modelLabel: z.string().optional(),
+    costTotal: z.number().finite(),
+    turns: z.number().finite(),
+    toolCalls: z.number().finite(),
+    usage: sessionProtocolAgentUsageSchema,
+    startedAt: z.number().finite(),
+    finishedAt: z.number().finite().optional(),
+    abortRequested: z.boolean(),
+    progress: z.string().optional(),
+    finalText: z.string().optional(),
+    error: z.string().optional(),
+})
+    .strict();
+const sessionProtocolFacetSubjectSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("session") }).strict(),
+    z.object({ type: z.literal("message"), id: nonEmptyStringSchema }).strict(),
+    z.object({ type: z.literal("tool"), id: nonEmptyStringSchema }).strict(),
+    z.object({ type: z.literal("agent"), id: nonEmptyStringSchema }).strict(),
+    z.object({ type: z.literal("operation"), id: nonEmptyStringSchema }).strict(),
+]);
+const sessionProtocolFacetSchema = z
+    .object({
+    id: nonEmptyStringSchema,
+    subject: sessionProtocolFacetSubjectSchema,
+    kind: nonEmptyStringSchema,
+    version: z.number().int().positive(),
+    data: z.record(z.string(), z.unknown()),
+})
+    .strict();
+const sessionProtocolSnapshotSchema = z
+    .object({
+    sessionId: nonEmptyStringSchema,
+    revision: z.number().int().positive(),
+    lifecycle: sessionProtocolSessionLifecycleSchema,
+    settings: sessionProtocolSettingsSnapshotSchema,
+    bootstrap: sessionProtocolBootstrapSnapshotSchema,
+    catalog: sessionProtocolContentCatalogSnapshotSchema,
+    executionEnvironment: sessionProtocolExecutionEnvironmentSnapshotSchema,
+    messages: z.array(sessionProtocolMessageSchema),
+    timeline: z.array(sessionProtocolTimelineItemSchema),
+    tools: z.record(nonEmptyStringSchema, sessionProtocolToolRunSchema),
+    agents: z.record(nonEmptyStringSchema, sessionProtocolAgentRunSchema),
+    facets: z.record(nonEmptyStringSchema, sessionProtocolFacetSchema),
+})
+    .strict()
+    .superRefine((snapshot, ctx) => {
+    const messageIds = new Set();
+    for (const message of snapshot.messages) {
+        if (messageIds.has(message.id)) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["messages"],
+                message: `duplicate message id '${message.id}'`,
+            });
+        }
+        messageIds.add(message.id);
+    }
+    const timelineIds = new Set();
+    for (const item of snapshot.timeline) {
+        if (timelineIds.has(item.id)) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["timeline"],
+                message: `duplicate timeline item id '${item.id}'`,
+            });
+        }
+        timelineIds.add(item.id);
+        if (item.type === "message" && !messageIds.has(item.messageId)) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["timeline"],
+                message: `timeline message item '${item.id}' references unknown message '${item.messageId}'`,
+            });
+        }
+    }
+});
+const sessionProtocolDeltaReasonSchema = z.enum([
+    "user-message",
+    "assistant-stream",
+    "assistant-message",
+    "tool-run",
+    "tool-result",
+    "notice",
+    "agent-run",
+    "maintenance",
+    "configuration",
+    "recovery",
+]);
+const sessionProtocolChangeSchema = z.discriminatedUnion("type", [
+    z
+        .object({
+        type: z.literal("lifecycle.set"),
+        lifecycle: sessionProtocolSessionLifecycleSchema,
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal("message.append"),
+        message: sessionProtocolMessageSchema,
+        timelineItem: sessionProtocolTimelineItemSchema.optional(),
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal("message.replace"),
+        message: sessionProtocolMessageSchema,
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal("message.content.append"),
+        messageId: nonEmptyStringSchema,
+        text: z.string().optional(),
+        thinking: z.string().optional(),
+        timestamp: z.number().finite(),
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal("timeline.append"),
+        item: sessionProtocolTimelineItemSchema,
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal("timeline.replace"),
+        item: sessionProtocolTimelineItemSchema,
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal("timeline.remove"),
+        id: nonEmptyStringSchema,
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal("tool.set"),
+        tool: sessionProtocolToolRunSchema,
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal("tool.remove"),
+        id: nonEmptyStringSchema,
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal("agent.set"),
+        agent: sessionProtocolAgentRunSchema,
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal("agent.remove"),
+        id: nonEmptyStringSchema,
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal("facet.set"),
+        facet: sessionProtocolFacetSchema,
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal("facet.remove"),
+        id: nonEmptyStringSchema,
+    })
+        .strict(),
+]);
+const sessionProtocolDeltaSchema = z.discriminatedUnion("type", [
+    z
+        .object({
+        type: z.literal("snapshot.patch"),
+        changes: z.array(sessionProtocolChangeSchema),
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal("snapshot.reset"),
+        snapshot: sessionProtocolSnapshotSchema,
+    })
+        .strict(),
+]);
+const sessionProtocolDeltaMessageSchema = z
+    .object({
+    version: z.literal(SESSION_PROTOCOL_VERSION),
+    type: z.literal("session.delta"),
+    sessionId: nonEmptyStringSchema,
+    fromRevision: z.number().int().positive().nullable(),
+    toRevision: z.number().int().positive(),
+    reason: sessionProtocolDeltaReasonSchema,
+    delta: sessionProtocolDeltaSchema,
+})
+    .strict()
+    .superRefine((message, ctx) => {
+    if (message.delta.type === "snapshot.patch" && message.fromRevision === null) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["fromRevision"],
+            message: "snapshot.patch delta requires fromRevision",
+        });
+    }
+    if (message.delta.type === "snapshot.patch" &&
+        message.fromRevision !== null &&
+        message.toRevision <= message.fromRevision) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["toRevision"],
+            message: "snapshot.patch toRevision must be greater than fromRevision",
+        });
+    }
+    if (message.delta.type === "snapshot.patch") {
+        message.delta.changes.forEach((change, index) => {
+            if (change.type === "message.content.append" &&
+                (change.text === undefined || change.text.length === 0) &&
+                (change.thinking === undefined || change.thinking.length === 0)) {
+                ctx.addIssue({
+                    code: "custom",
+                    path: ["delta", "changes", index],
+                    message: "message.content.append requires text or thinking",
+                });
+            }
+        });
+    }
+    if (message.delta.type === "snapshot.reset" &&
+        message.delta.snapshot.revision !== message.toRevision) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["delta", "snapshot", "revision"],
+            message: "snapshot.reset revision must equal toRevision",
+        });
+    }
+});
+const sessionProtocolEphemeralAgentThreadUpdateEventSchema = z
+    .object({
+    type: z.literal("ephemeral-agent.thread-update"),
+    contextId: nonEmptyStringSchema,
+    threadId: nonEmptyStringSchema,
+    update: z
+        .object({
+        costTotal: z.number().finite(),
+        usage: sessionProtocolAgentUsageSchema,
+        lastActivityText: z.string().optional(),
+    })
+        .strict(),
+})
+    .strict();
+const sessionProtocolEphemeralEventSchema = sessionProtocolEphemeralAgentThreadUpdateEventSchema;
+const sessionProtocolEphemeralMessageSchema = z
+    .object({
+    version: z.literal(SESSION_PROTOCOL_VERSION),
+    type: z.literal("session.ephemeral"),
+    sessionId: nonEmptyStringSchema,
+    event: sessionProtocolEphemeralEventSchema,
+})
+    .strict();
+const sessionProtocolInitializeResultSchema = z
+    .object({
+    protocolVersion: z.literal(SESSION_PROTOCOL_VERSION),
+    methods: sessionProtocolMethodListSchema,
+    alreadyInitialized: z.boolean(),
+})
+    .strict();
+const sessionProtocolListResultSchema = z
+    .object({
+    sessions: z.array(sessionProtocolSessionSummarySchema),
+})
+    .strict();
+const sessionProtocolSubmitResultSchema = z
+    .object({
+    turn: z
+        .object({
+        aborted: z.boolean(),
+        blocked: z
+            .object({
+            reason: z.literal("auto-compaction-failed"),
+            message: z.string(),
+        })
+            .strict()
+            .optional(),
+    })
+        .strict(),
+})
+    .strict();
+const sessionProtocolTurnResultSchema = sessionProtocolSubmitResultSchema;
+const sessionProtocolRetryResultSchema = sessionProtocolTurnResultSchema;
+const sessionProtocolSubmitWithUserResultSchema = sessionProtocolTurnResultSchema
+    .extend({
+    userHistoryEntryId: nonEmptyStringSchema,
+})
+    .strict();
+const sessionProtocolRecordResultSchema = z
+    .object({
+    snapshot: sessionProtocolSnapshotSchema,
+    userHistoryEntryId: nonEmptyStringSchema,
+})
+    .strict();
+const sessionProtocolExecResultSchema = z
+    .object({
+    output: z.string(),
+    stdout: z.string(),
+    stderr: z.string(),
+    exitCode: z.number().int().nullable(),
+    truncated: z.boolean(),
+})
+    .strict();
+const sessionProtocolInterruptResultSchema = z
+    .object({
+    interrupted: z.boolean(),
+    isTurnRunning: z.boolean(),
+})
+    .strict();
+const sessionProtocolCompactResultSchema = z
+    .object({
+    snapshot: sessionProtocolSnapshotSchema,
+    compactionMessage: nonEmptyStringSchema,
+    includedLastAssistant: z.boolean(),
+})
+    .strict();
+const sessionProtocolPruneResultSchema = z
+    .object({
+    snapshot: sessionProtocolSnapshotSchema,
+    message: nonEmptyStringSchema,
+    noop: z.boolean(),
+    bashResultsPruned: z.number().int().nonnegative(),
+    editCallsPruned: z.number().int().nonnegative(),
+    editResultsPruned: z.number().int().nonnegative(),
+    bytesPruned: z.number().int().nonnegative(),
+})
+    .strict();
+const sessionProtocolRewindResultSchema = z
+    .object({
+    snapshot: sessionProtocolSnapshotSchema,
+    historyEntryId: nonEmptyStringSchema,
+    text: z.string(),
+    removedEntryIds: z.array(nonEmptyStringSchema),
+})
+    .strict();
+const sessionProtocolReloadResultSchema = z
+    .object({
+    snapshot: sessionProtocolSnapshotSchema,
+    warnings: z.array(z.string()),
+    counts: z
+        .object({
+        personas: z.number().int().nonnegative(),
+        prompts: z.number().int().nonnegative(),
+        skills: z.number().int().nonnegative(),
+    })
+        .strict(),
+})
+    .strict();
+const sessionProtocolResolvePromptResultSchema = z
+    .object({
+    promptId: nonEmptyStringSchema,
+    text: z.string(),
+})
+    .strict();
+const sessionProtocolAutocompletePathsResultSchema = z
+    .object({
+    paths: z.array(z.string()),
+})
+    .strict();
+const sessionProtocolUnobserveResultSchema = z
+    .object({
+    unobserved: z.literal(true),
+})
+    .strict();
+const sessionProtocolTerminateSubagentResultSchema = z
+    .object({
+    found: z.boolean(),
+})
+    .strict();
+const sessionProtocolEphemeralCreateResultSchema = z
+    .object({
+    contextId: nonEmptyStringSchema,
+})
+    .strict();
+const sessionProtocolEphemeralSubmitResultSchema = z
+    .object({
+    threadId: nonEmptyStringSchema,
+    response: z.string(),
+})
+    .strict();
+const sessionProtocolEphemeralCloseResultSchema = z
+    .object({
+    closed: z.boolean(),
+})
+    .strict();
+export function isSessionProtocolMethod(value) {
+    return typeof value === "string" && SESSION_PROTOCOL_METHOD_SET.has(value);
+}
+export function createSessionProtocolError(code, message, data) {
+    return data === undefined ? { code, message } : { code, message, data };
+}
+export function createSessionProtocolSuccessResponse(id, method, result) {
+    const parsed = validateSessionProtocolResult(method, result);
+    if (!parsed.ok) {
+        throw new Error(parsed.error.message);
+    }
+    const response = {
+        version: SESSION_PROTOCOL_VERSION,
+        type: "response",
+        id,
+        ok: true,
+        result: parsed.value,
+    };
+    const parsedResponse = sessionProtocolResponseSuccessSchema.safeParse(response);
+    if (!parsedResponse.success) {
+        throw new Error(`session protocol success response is invalid: ${formatZodError(parsedResponse.error)}`);
+    }
+    return parsedResponse.data;
+}
+export function createSessionProtocolErrorResponse(id, code, message, data) {
+    const response = {
+        version: SESSION_PROTOCOL_VERSION,
+        type: "response",
+        id,
+        ok: false,
+        error: createSessionProtocolError(code, message, data),
+    };
+    const parsed = sessionProtocolResponseErrorSchema.safeParse(response);
+    if (!parsed.success) {
+        throw new Error(`session protocol error response is invalid: ${formatZodError(parsed.error)}`);
+    }
+    return parsed.data;
+}
+export function createSessionProtocolDeltaMessage(options) {
+    const message = {
+        version: SESSION_PROTOCOL_VERSION,
+        type: "session.delta",
+        sessionId: options.sessionId,
+        fromRevision: options.fromRevision,
+        toRevision: options.toRevision,
+        reason: options.reason,
+        delta: options.delta,
+    };
+    const parsedMessage = sessionProtocolDeltaMessageSchema.safeParse(message);
+    if (!parsedMessage.success) {
+        throw new Error(`session protocol delta message is invalid: ${formatZodError(parsedMessage.error)}`);
+    }
+    return parsedMessage.data;
+}
+export function createSessionProtocolEphemeralMessage(options) {
+    const message = {
+        version: SESSION_PROTOCOL_VERSION,
+        type: "session.ephemeral",
+        sessionId: options.sessionId,
+        event: options.event,
+    };
+    const parsedMessage = sessionProtocolEphemeralMessageSchema.safeParse(message);
+    if (!parsedMessage.success) {
+        throw new Error(`session protocol ephemeral message is invalid: ${formatZodError(parsedMessage.error)}`);
+    }
+    return parsedMessage.data;
+}
+export function applySessionProtocolDelta(snapshot, message) {
+    if (message.sessionId !== snapshot.sessionId) {
+        throw new Error(`session delta targets '${message.sessionId}' but current snapshot is '${snapshot.sessionId}'`);
+    }
+    if (message.delta.type === "snapshot.reset") {
+        return structuredClone(message.delta.snapshot);
+    }
+    if (message.fromRevision !== snapshot.revision) {
+        throw new Error(`session delta revision mismatch: expected ${snapshot.revision}, got ${message.fromRevision}`);
+    }
+    const contentAppendSnapshot = applyContentAppendDelta(snapshot, message);
+    if (contentAppendSnapshot) {
+        return contentAppendSnapshot;
+    }
+    const keyedPatchSnapshot = applyKeyedRecordDelta(snapshot, message);
+    if (keyedPatchSnapshot) {
+        return keyedPatchSnapshot;
+    }
+    const next = structuredClone(snapshot);
+    next.revision = message.toRevision;
+    for (const change of message.delta.changes) {
+        switch (change.type) {
+            case "lifecycle.set":
+                next.lifecycle = change.lifecycle;
+                break;
+            case "message.append":
+                next.messages.push(structuredClone(change.message));
+                if (change.timelineItem) {
+                    next.timeline.push(structuredClone(change.timelineItem));
+                }
+                break;
+            case "message.replace": {
+                const index = next.messages.findIndex((entry) => entry.id === change.message.id);
+                if (index === -1) {
+                    next.messages.push(structuredClone(change.message));
+                }
+                else {
+                    next.messages[index] = structuredClone(change.message);
+                }
+                break;
+            }
+            case "message.content.append": {
+                appendMessageContent(next, change);
+                break;
+            }
+            case "timeline.append":
+                next.timeline.push(structuredClone(change.item));
+                break;
+            case "timeline.replace": {
+                const index = next.timeline.findIndex((item) => item.id === change.item.id);
+                if (index === -1) {
+                    next.timeline.push(structuredClone(change.item));
+                }
+                else {
+                    next.timeline[index] = structuredClone(change.item);
+                }
+                break;
+            }
+            case "timeline.remove":
+                next.timeline = next.timeline.filter((item) => item.id !== change.id);
+                break;
+            case "tool.set":
+                next.tools[change.tool.id] = structuredClone(change.tool);
+                break;
+            case "tool.remove":
+                delete next.tools[change.id];
+                break;
+            case "agent.set":
+                next.agents[change.agent.id] = structuredClone(change.agent);
+                break;
+            case "agent.remove":
+                delete next.agents[change.id];
+                break;
+            case "facet.set":
+                next.facets[change.facet.id] = structuredClone(change.facet);
+                break;
+            case "facet.remove":
+                delete next.facets[change.id];
+                break;
+        }
+    }
+    return next;
+}
+function applyKeyedRecordDelta(snapshot, message) {
+    if (message.delta.type !== "snapshot.patch") {
+        return undefined;
+    }
+    let nextTools;
+    let nextAgents;
+    let nextFacets;
+    const cloneTools = () => {
+        nextTools ??= { ...snapshot.tools };
+        return nextTools;
+    };
+    const cloneAgents = () => {
+        nextAgents ??= { ...snapshot.agents };
+        return nextAgents;
+    };
+    const cloneFacets = () => {
+        nextFacets ??= { ...snapshot.facets };
+        return nextFacets;
+    };
+    for (const change of message.delta.changes) {
+        switch (change.type) {
+            case "tool.set":
+                cloneTools()[change.tool.id] = structuredClone(change.tool);
+                break;
+            case "tool.remove":
+                delete cloneTools()[change.id];
+                break;
+            case "agent.set":
+                cloneAgents()[change.agent.id] = structuredClone(change.agent);
+                break;
+            case "agent.remove":
+                delete cloneAgents()[change.id];
+                break;
+            case "facet.set":
+                cloneFacets()[change.facet.id] = structuredClone(change.facet);
+                break;
+            case "facet.remove":
+                delete cloneFacets()[change.id];
+                break;
+            default:
+                return undefined;
+        }
+    }
+    return {
+        ...snapshot,
+        revision: message.toRevision,
+        ...(nextTools ? { tools: nextTools } : {}),
+        ...(nextAgents ? { agents: nextAgents } : {}),
+        ...(nextFacets ? { facets: nextFacets } : {}),
+    };
+}
+function applyContentAppendDelta(snapshot, message) {
+    if (message.delta.type !== "snapshot.patch" ||
+        message.delta.changes.length !== 1 ||
+        message.delta.changes[0]?.type !== "message.content.append") {
+        return undefined;
+    }
+    const change = message.delta.changes[0];
+    const messageIndex = snapshot.messages.findIndex((entry) => entry.id === change.messageId);
+    if (messageIndex === -1) {
+        throw new Error(`message.content.append targets unknown message '${change.messageId}'`);
+    }
+    const target = snapshot.messages[messageIndex];
+    if (target.message.role !== "assistant" || !Array.isArray(target.message.content)) {
+        throw new Error(`message.content.append targets non-assistant message '${change.messageId}'`);
+    }
+    if (target.state !== "draft") {
+        throw new Error(`message.content.append targets non-draft message '${change.messageId}'`);
+    }
+    const nextMessages = [...snapshot.messages];
+    const nextTarget = {
+        ...target,
+        message: {
+            ...target.message,
+            content: target.message.content.map((item) => ({ ...item })),
+        },
+    };
+    nextMessages[messageIndex] = nextTarget;
+    const next = {
+        ...snapshot,
+        revision: message.toRevision,
+        messages: nextMessages,
+    };
+    appendMessageContent(next, change);
+    return next;
+}
+function appendMessageContent(snapshot, change) {
+    const entry = snapshot.messages.find((message) => message.id === change.messageId);
+    if (!entry) {
+        throw new Error(`message.content.append targets unknown message '${change.messageId}'`);
+    }
+    const message = entry.message;
+    if (message.role !== "assistant" || !Array.isArray(message.content)) {
+        throw new Error(`message.content.append targets non-assistant message '${change.messageId}'`);
+    }
+    if (entry.state !== "draft") {
+        throw new Error(`message.content.append targets non-draft message '${change.messageId}'`);
+    }
+    if (change.thinking) {
+        appendAssistantTextBlock(message.content, "thinking", change.thinking);
+    }
+    if (change.text) {
+        appendAssistantTextBlock(message.content, "text", change.text);
+    }
+    message.timestamp = change.timestamp;
+}
+function appendAssistantTextBlock(content, type, value) {
+    if (type === "text") {
+        const existing = content.find((item) => item.type === "text");
+        if (existing) {
+            existing.text += value;
+            return;
+        }
+        content.push({ type: "text", text: value });
+        return;
+    }
+    const existing = content.find((item) => item.type === "thinking");
+    if (existing) {
+        existing.thinking += value;
+        return;
+    }
+    const textIndex = content.findIndex((item) => item.type === "text");
+    if (textIndex === -1) {
+        content.push({ type: "thinking", thinking: value });
+        return;
+    }
+    content.splice(textIndex, 0, { type: "thinking", thinking: value });
+}
+export function createSessionProtocolReadyMessage() {
+    return {
+        version: SESSION_PROTOCOL_VERSION,
+        type: "ready",
+        methods: [...SESSION_PROTOCOL_METHODS],
+    };
+}
+export function serializeSessionProtocolMessage(message) {
+    return JSON.stringify(message);
+}
+export function parseSessionProtocolRequestLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+        return {
+            ok: false,
+            id: null,
+            error: createSessionProtocolError(SESSION_PROTOCOL_ERROR_CODES.invalidRequest, "request line cannot be empty"),
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            id: null,
+            error: createSessionProtocolError(SESSION_PROTOCOL_ERROR_CODES.parseError, "failed to parse JSON request line", {
+                cause: error instanceof Error ? error.message : String(error),
+            }),
+        };
+    }
+    const parsedIdField = sessionProtocolIdFieldSchema.safeParse(parsed);
+    const requestIdCandidate = parsedIdField.success
+        ? parseNullableRequestId(parsedIdField.data.id)
+        : null;
+    const requestId = requestIdCandidate?.ok ? requestIdCandidate.id : null;
+    const requestEnvelope = sessionProtocolRequestEnvelopeSchema.safeParse(parsed);
+    if (!requestEnvelope.success) {
+        if (hasIssue(requestEnvelope.error, [], "invalid_type")) {
+            return {
+                ok: false,
+                id: null,
+                error: createSessionProtocolError(SESSION_PROTOCOL_ERROR_CODES.invalidRequest, "request must be a JSON object"),
+            };
+        }
+        if (hasIssue(requestEnvelope.error, ["id"])) {
+            return {
+                ok: false,
+                id: null,
+                error: createSessionProtocolError(SESSION_PROTOCOL_ERROR_CODES.invalidRequest, "request id must be a non-empty string"),
+            };
+        }
+        if (hasIssue(requestEnvelope.error, [], "unrecognized_keys")) {
+            return {
+                ok: false,
+                id: requestId,
+                error: createSessionProtocolError(SESSION_PROTOCOL_ERROR_CODES.invalidRequest, "request contains unsupported top-level fields"),
+            };
+        }
+        if (hasIssue(requestEnvelope.error, ["version"])) {
+            const parsedVersionField = sessionProtocolVersionFieldSchema.safeParse(parsed);
+            const version = parsedVersionField.success ? parsedVersionField.data.version : undefined;
+            return {
+                ok: false,
+                id: requestId,
+                error: createSessionProtocolError(SESSION_PROTOCOL_ERROR_CODES.invalidRequest, `unsupported session protocol version: ${String(version)}`),
+            };
+        }
+        if (hasIssue(requestEnvelope.error, ["type"])) {
+            return {
+                ok: false,
+                id: requestId,
+                error: createSessionProtocolError(SESSION_PROTOCOL_ERROR_CODES.invalidRequest, 'request.type must be "request"'),
+            };
+        }
+        if (hasIssue(requestEnvelope.error, ["method"])) {
+            return {
+                ok: false,
+                id: requestId,
+                error: createSessionProtocolError(SESSION_PROTOCOL_ERROR_CODES.invalidRequest, "request.method must be a string"),
+            };
+        }
+        if (hasIssue(requestEnvelope.error, ["params"])) {
+            return {
+                ok: false,
+                id: requestId,
+                error: createSessionProtocolError(SESSION_PROTOCOL_ERROR_CODES.invalidRequest, "request.params is required"),
+            };
+        }
+        return {
+            ok: false,
+            id: requestId,
+            error: createSessionProtocolError(SESSION_PROTOCOL_ERROR_CODES.invalidRequest, `request is invalid: ${formatZodError(requestEnvelope.error)}`),
+        };
+    }
+    const method = requestEnvelope.data.method;
+    if (!isSessionProtocolMethod(method)) {
+        return {
+            ok: false,
+            id: requestEnvelope.data.id,
+            error: createSessionProtocolError(SESSION_PROTOCOL_ERROR_CODES.methodNotFound, `unsupported method: ${method}`),
+        };
+    }
+    const request = createSessionProtocolRequest(requestEnvelope.data.id, method, requestEnvelope.data.params);
+    if (!request.ok) {
+        return {
+            ok: false,
+            id: requestEnvelope.data.id,
+            error: request.error,
+        };
+    }
+    return {
+        ok: true,
+        request: request.value,
+    };
+}
+export function createSessionProtocolRequest(id, method, params) {
+    const parsedId = sessionProtocolRequestIdSchema.safeParse(id);
+    if (!parsedId.success) {
+        return {
+            ok: false,
+            error: createSessionProtocolError(SESSION_PROTOCOL_ERROR_CODES.invalidRequest, "request id must be a non-empty string"),
+        };
+    }
+    const parsed = validateSessionProtocolParams(method, params);
+    if (!parsed.ok) {
+        return parsed;
+    }
+    return {
+        ok: true,
+        value: {
+            ...requestEnvelope(parsedId.data),
+            method,
+            params: parsed.value,
+        },
+    };
+}
+function requestEnvelope(id) {
+    return {
+        version: SESSION_PROTOCOL_VERSION,
+        type: "request",
+        id,
+    };
+}
+export function parseSessionProtocolOutgoingLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+        return outgoingParseFailure(null, null, SESSION_PROTOCOL_ERROR_CODES.invalidRequest, "session protocol line cannot be empty", undefined, "empty_line");
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch (error) {
+        return outgoingParseFailure(null, null, SESSION_PROTOCOL_ERROR_CODES.parseError, "failed to parse JSON session protocol line", {
+            cause: error instanceof Error ? error.message : String(error),
+        }, "parse_error");
+    }
+    const routing = sessionProtocolOutgoingRoutingSchema.safeParse(parsed);
+    if (!routing.success) {
+        if (hasIssue(routing.error, [], "invalid_type")) {
+            return outgoingParseFailure(null, null, SESSION_PROTOCOL_ERROR_CODES.invalidRequest, "session protocol payload must be a JSON object");
+        }
+        if (hasIssue(routing.error, ["version"])) {
+            const parsedVersionField = sessionProtocolVersionFieldSchema.safeParse(parsed);
+            const version = parsedVersionField.success ? parsedVersionField.data.version : undefined;
+            return outgoingParseFailure(null, null, SESSION_PROTOCOL_ERROR_CODES.invalidRequest, `unsupported session protocol version: ${String(version)}`, undefined, "unsupported_version");
+        }
+        const parsedTypeField = sessionProtocolTypeFieldSchema.safeParse(parsed);
+        const messageType = parsedTypeField.success ? parsedTypeField.data.type : undefined;
+        return outgoingParseFailure(null, null, SESSION_PROTOCOL_ERROR_CODES.invalidRequest, `unsupported session protocol message type: ${String(messageType)}`, undefined, "unsupported_message_type");
+    }
+    if (routing.data.type === "ready") {
+        return parseSessionProtocolReadyMessage(parsed);
+    }
+    if (routing.data.type === "session.delta") {
+        return parseSessionProtocolDeltaMessage(parsed);
+    }
+    if (routing.data.type === "session.ephemeral") {
+        return parseSessionProtocolEphemeralMessage(parsed);
+    }
+    return parseSessionProtocolResponseMessage(parsed);
+}
+export function validateSessionProtocolParams(method, params) {
+    switch (method) {
+        case "initialize":
+            return validateInitializeParams(params);
+        case "session.create":
+            return validateCreateParams(params);
+        case "session.observe":
+            return validateSessionIdParams("session.observe", params);
+        case "session.unobserve":
+            return validateSessionIdParams("session.unobserve", params);
+        case "session.record":
+            return validateRecordParams(params);
+        case "session.submit":
+        case "session.queue":
+        case "session.steer":
+            return validateUserMessageParams(method, params);
+        case "session.exec":
+            return validateExecParams(params);
+        case "session.list":
+            return validateNoParams(method, params);
+        case "session.retry":
+        case "session.interrupt":
+        case "session.snapshot":
+        case "session.reload":
+            return validateSessionIdParams(method, params);
+        case "session.setRisk":
+            return validateSetRiskParams(params);
+        case "session.setReasoning":
+            return validateSetReasoningParams(params);
+        case "session.setPersona":
+            return validateSetPersonaParams(params);
+        case "session.resolvePrompt":
+            return validateResolvePromptParams(params);
+        case "session.autocompletePaths":
+            return validateAutocompletePathsParams(params);
+        case "session.compact":
+            return validateCompactParams(params);
+        case "session.prune":
+            return validatePruneParams(params);
+        case "session.rewind":
+            return validateRewindParams(params);
+        case "session.terminateSubagent":
+            return validateTerminateSubagentParams(params);
+        case "session.ephemeral.create":
+            return validateEphemeralCreateParams(params);
+        case "session.ephemeral.submit":
+            return validateEphemeralSubmitParams(params);
+        case "session.ephemeral.close":
+            return validateEphemeralCloseParams(params);
+    }
+}
+export function validateSessionProtocolResult(method, result) {
+    switch (method) {
+        case "initialize":
+            return validateResult(method, result, sessionProtocolInitializeResultSchema);
+        case "session.create":
+        case "session.observe":
+        case "session.snapshot":
+        case "session.setRisk":
+        case "session.setReasoning":
+        case "session.setPersona":
+            return validateResult(method, result, sessionProtocolSnapshotSchema);
+        case "session.resolvePrompt":
+            return validateResult(method, result, sessionProtocolResolvePromptResultSchema);
+        case "session.autocompletePaths":
+            return validateResult(method, result, sessionProtocolAutocompletePathsResultSchema);
+        case "session.unobserve":
+            return validateResult(method, result, sessionProtocolUnobserveResultSchema);
+        case "session.reload":
+            return validateResult(method, result, sessionProtocolReloadResultSchema);
+        case "session.compact":
+            return validateResult(method, result, sessionProtocolCompactResultSchema);
+        case "session.prune":
+            return validateResult(method, result, sessionProtocolPruneResultSchema);
+        case "session.rewind":
+            return validateResult(method, result, sessionProtocolRewindResultSchema);
+        case "session.terminateSubagent":
+            return validateResult(method, result, sessionProtocolTerminateSubagentResultSchema);
+        case "session.ephemeral.create":
+            return validateResult(method, result, sessionProtocolEphemeralCreateResultSchema);
+        case "session.ephemeral.submit":
+            return validateResult(method, result, sessionProtocolEphemeralSubmitResultSchema);
+        case "session.ephemeral.close":
+            return validateResult(method, result, sessionProtocolEphemeralCloseResultSchema);
+        case "session.list":
+            return validateResult(method, result, sessionProtocolListResultSchema);
+        case "session.submit":
+        case "session.queue":
+        case "session.steer":
+            return validateResult(method, result, sessionProtocolSubmitWithUserResultSchema);
+        case "session.record":
+            return validateResult(method, result, sessionProtocolRecordResultSchema);
+        case "session.retry":
+            return validateResult(method, result, sessionProtocolRetryResultSchema);
+        case "session.exec":
+            return validateResult(method, result, sessionProtocolExecResultSchema);
+        case "session.interrupt":
+            return validateResult(method, result, sessionProtocolInterruptResultSchema);
+    }
+}
+function validateSessionIdParams(method, params) {
+    const parsed = sessionProtocolSessionIdParamsSchema.safeParse(params);
+    if (!parsed.success) {
+        const message = hasIssue(parsed.error, [], "invalid_type")
+            ? `${method} params must be an object`
+            : hasIssue(parsed.error, [], "unrecognized_keys")
+                ? `${method} params only support sessionId`
+                : hasIssue(parsed.error, ["sessionId"])
+                    ? `${method} params.sessionId must be a non-empty string`
+                    : `${method} params are invalid: ${formatZodError(parsed.error)}`;
+        return invalidParams(message);
+    }
+    return {
+        ok: true,
+        value: {
+            sessionId: parsed.data.sessionId,
+        },
+    };
+}
+function validateInitializeParams(params) {
+    const parsed = sessionProtocolInitializeParamsSchema.safeParse(params);
+    if (!parsed.success) {
+        const message = hasIssue(parsed.error, [], "invalid_type")
+            ? "initialize params must be an object with client metadata"
+            : hasIssue(parsed.error, ["client"]) || hasIssue(parsed.error, [], "unrecognized_keys")
+                ? "initialize.client must be an object with name/version strings"
+                : hasIssue(parsed.error, ["client", "name"])
+                    ? "initialize.client.name must be a non-empty string"
+                    : hasIssue(parsed.error, ["client", "version"])
+                        ? "initialize.client.version must be a non-empty string"
+                        : `initialize params are invalid: ${formatZodError(parsed.error)}`;
+        return invalidParams(message);
+    }
+    return {
+        ok: true,
+        value: {
+            client: {
+                name: parsed.data.client.name,
+                version: parsed.data.client.version,
+            },
+        },
+    };
+}
+function validateUserMessageParams(method, params) {
+    const parsed = sessionProtocolUserMessageParamsSchema.safeParse(params);
+    if (!parsed.success) {
+        const message = hasIssue(parsed.error, [], "invalid_type")
+            ? `${method} params must be an object`
+            : hasIssue(parsed.error, [], "unrecognized_keys")
+                ? `${method} params only support sessionId, text, and optional historyEntryId`
+                : hasIssue(parsed.error, ["sessionId"])
+                    ? `${method} params.sessionId must be a non-empty string`
+                    : hasIssue(parsed.error, ["text"])
+                        ? `${method} params.text must be a string`
+                        : hasIssue(parsed.error, ["historyEntryId"])
+                            ? `${method} params.historyEntryId must be a non-empty string when provided`
+                            : `${method} params are invalid: ${formatZodError(parsed.error)}`;
+        return invalidParams(message);
+    }
+    return {
+        ok: true,
+        value: {
+            sessionId: parsed.data.sessionId,
+            text: parsed.data.text,
+            ...(parsed.data.historyEntryId !== undefined
+                ? { historyEntryId: parsed.data.historyEntryId }
+                : {}),
+        },
+    };
+}
+function validateRecordParams(params) {
+    const parsed = sessionProtocolRecordParamsSchema.safeParse(params);
+    if (!parsed.success) {
+        const message = hasIssue(parsed.error, [], "invalid_type")
+            ? "session.record params must be an object"
+            : hasIssue(parsed.error, [], "unrecognized_keys")
+                ? "session.record params only support sessionId, text, and optional historyEntryId"
+                : hasIssue(parsed.error, ["sessionId"])
+                    ? "session.record params.sessionId must be a non-empty string"
+                    : hasIssue(parsed.error, ["text"])
+                        ? "session.record params.text must be a string"
+                        : hasIssue(parsed.error, ["historyEntryId"])
+                            ? "session.record params.historyEntryId must be a non-empty string when provided"
+                            : `session.record params are invalid: ${formatZodError(parsed.error)}`;
+        return invalidParams(message);
+    }
+    return {
+        ok: true,
+        value: {
+            sessionId: parsed.data.sessionId,
+            text: parsed.data.text,
+            ...(parsed.data.historyEntryId !== undefined
+                ? { historyEntryId: parsed.data.historyEntryId }
+                : {}),
+        },
+    };
+}
+function validateExecParams(params) {
+    const parsed = sessionProtocolExecParamsSchema.safeParse(params);
+    if (!parsed.success) {
+        const message = hasIssue(parsed.error, [], "invalid_type")
+            ? "session.exec params must be an object"
+            : hasIssue(parsed.error, [], "unrecognized_keys")
+                ? "session.exec params only support sessionId, command, optional cwd, and optional timeoutMs"
+                : hasIssue(parsed.error, ["sessionId"])
+                    ? "session.exec params.sessionId must be a non-empty string"
+                    : hasIssue(parsed.error, ["command"])
+                        ? "session.exec params.command must be a non-empty string"
+                        : hasIssue(parsed.error, ["cwd"])
+                            ? "session.exec params.cwd must be a non-empty string when provided"
+                            : hasIssue(parsed.error, ["timeoutMs"])
+                                ? "session.exec params.timeoutMs must be a positive integer when provided"
+                                : `session.exec params are invalid: ${formatZodError(parsed.error)}`;
+        return invalidParams(message);
+    }
+    return {
+        ok: true,
+        value: {
+            sessionId: parsed.data.sessionId,
+            command: parsed.data.command,
+            ...(parsed.data.cwd !== undefined ? { cwd: parsed.data.cwd } : {}),
+            ...(parsed.data.timeoutMs !== undefined ? { timeoutMs: parsed.data.timeoutMs } : {}),
+        },
+    };
+}
+function validateSetRiskParams(params) {
+    const parsed = sessionProtocolSetRiskParamsSchema.safeParse(params);
+    if (!parsed.success) {
+        const message = hasIssue(parsed.error, [], "invalid_type")
+            ? "session.setRisk params must be an object"
+            : hasIssue(parsed.error, [], "unrecognized_keys")
+                ? "session.setRisk params only support sessionId and riskLevel"
+                : hasIssue(parsed.error, ["sessionId"])
+                    ? "session.setRisk params.sessionId must be a non-empty string"
+                    : hasIssue(parsed.error, ["riskLevel"])
+                        ? "session.setRisk params.riskLevel must be 'read-only' or 'read-write'"
+                        : `session.setRisk params are invalid: ${formatZodError(parsed.error)}`;
+        return invalidParams(message);
+    }
+    return {
+        ok: true,
+        value: {
+            sessionId: parsed.data.sessionId,
+            riskLevel: parsed.data.riskLevel,
+        },
+    };
+}
+function validateSetReasoningParams(params) {
+    const parsed = sessionProtocolSetReasoningParamsSchema.safeParse(params);
+    if (!parsed.success) {
+        const message = hasIssue(parsed.error, [], "invalid_type")
+            ? "session.setReasoning params must be an object"
+            : hasIssue(parsed.error, [], "unrecognized_keys")
+                ? "session.setReasoning params only support sessionId and reasoning"
+                : hasIssue(parsed.error, ["sessionId"])
+                    ? "session.setReasoning params.sessionId must be a non-empty string"
+                    : hasIssue(parsed.error, ["reasoning"])
+                        ? "session.setReasoning params.reasoning must be one of none, minimal, low, medium, high, or xhigh"
+                        : `session.setReasoning params are invalid: ${formatZodError(parsed.error)}`;
+        return invalidParams(message);
+    }
+    return {
+        ok: true,
+        value: {
+            sessionId: parsed.data.sessionId,
+            reasoning: parsed.data.reasoning,
+        },
+    };
+}
+function validateSetPersonaParams(params) {
+    const parsed = sessionProtocolSetPersonaParamsSchema.safeParse(params);
+    if (!parsed.success) {
+        const message = hasIssue(parsed.error, [], "invalid_type")
+            ? "session.setPersona params must be an object"
+            : hasIssue(parsed.error, [], "unrecognized_keys")
+                ? "session.setPersona params only support sessionId and personaId"
+                : hasIssue(parsed.error, ["sessionId"])
+                    ? "session.setPersona params.sessionId must be a non-empty string"
+                    : hasIssue(parsed.error, ["personaId"])
+                        ? "session.setPersona params.personaId must be a non-empty string"
+                        : `session.setPersona params are invalid: ${formatZodError(parsed.error)}`;
+        return invalidParams(message);
+    }
+    return {
+        ok: true,
+        value: {
+            sessionId: parsed.data.sessionId,
+            personaId: parsed.data.personaId,
+        },
+    };
+}
+function validateResolvePromptParams(params) {
+    const parsed = sessionProtocolResolvePromptParamsSchema.safeParse(params);
+    if (!parsed.success) {
+        const message = hasIssue(parsed.error, [], "invalid_type")
+            ? "session.resolvePrompt params must be an object"
+            : hasIssue(parsed.error, [], "unrecognized_keys")
+                ? "session.resolvePrompt params only support sessionId and promptId"
+                : hasIssue(parsed.error, ["sessionId"])
+                    ? "session.resolvePrompt params.sessionId must be a non-empty string"
+                    : hasIssue(parsed.error, ["promptId"])
+                        ? "session.resolvePrompt params.promptId must be a non-empty string"
+                        : `session.resolvePrompt params are invalid: ${formatZodError(parsed.error)}`;
+        return invalidParams(message);
+    }
+    return {
+        ok: true,
+        value: {
+            sessionId: parsed.data.sessionId,
+            promptId: parsed.data.promptId,
+        },
+    };
+}
+function validateAutocompletePathsParams(params) {
+    const parsed = sessionProtocolAutocompletePathsParamsSchema.safeParse(params);
+    if (!parsed.success) {
+        const message = hasIssue(parsed.error, [], "invalid_type")
+            ? "session.autocompletePaths params must be an object"
+            : hasIssue(parsed.error, [], "unrecognized_keys")
+                ? "session.autocompletePaths params only support sessionId, query, and limit"
+                : hasIssue(parsed.error, ["sessionId"])
+                    ? "session.autocompletePaths params.sessionId must be a non-empty string"
+                    : hasIssue(parsed.error, ["query"])
+                        ? "session.autocompletePaths params.query must be a string"
+                        : hasIssue(parsed.error, ["limit"])
+                            ? "session.autocompletePaths params.limit must be a positive integer up to 100"
+                            : `session.autocompletePaths params are invalid: ${formatZodError(parsed.error)}`;
+        return invalidParams(message);
+    }
+    return {
+        ok: true,
+        value: {
+            sessionId: parsed.data.sessionId,
+            query: parsed.data.query,
+            limit: parsed.data.limit,
+        },
+    };
+}
+function validateCompactParams(params) {
+    const parsed = sessionProtocolCompactParamsSchema.safeParse(params);
+    if (!parsed.success) {
+        const message = hasIssue(parsed.error, [], "invalid_type")
+            ? "session.compact params must be an object"
+            : hasIssue(parsed.error, [], "unrecognized_keys")
+                ? "session.compact params only support sessionId, mode, and optional guidance"
+                : hasIssue(parsed.error, ["sessionId"])
+                    ? "session.compact params.sessionId must be a non-empty string"
+                    : hasIssue(parsed.error, ["mode"])
+                        ? "session.compact params.mode must be 'summary-only' or 'summary-and-last'"
+                        : hasIssue(parsed.error, ["guidance"])
+                            ? "session.compact params.guidance must be a string when provided"
+                            : `session.compact params are invalid: ${formatZodError(parsed.error)}`;
+        return invalidParams(message);
+    }
+    return {
+        ok: true,
+        value: {
+            sessionId: parsed.data.sessionId,
+            mode: parsed.data.mode,
+            ...(parsed.data.guidance !== undefined ? { guidance: parsed.data.guidance } : {}),
+        },
+    };
+}
+function validatePruneParams(params) {
+    const parsed = sessionProtocolPruneParamsSchema.safeParse(params);
+    if (!parsed.success) {
+        const message = hasIssue(parsed.error, [], "invalid_type")
+            ? "session.prune params must be an object"
+            : hasIssue(parsed.error, [], "unrecognized_keys")
+                ? "session.prune params only support sessionId, strategy, fraction, and optional guidance"
+                : hasIssue(parsed.error, ["sessionId"])
+                    ? "session.prune params.sessionId must be a non-empty string"
+                    : hasIssue(parsed.error, ["strategy"])
+                        ? "session.prune params.strategy must be 'earliest', 'largest', or 'smart'"
+                        : hasIssue(parsed.error, ["fraction"])
+                            ? "session.prune params.fraction must be a number between 0 and 1"
+                            : hasIssue(parsed.error, ["guidance"])
+                                ? "session.prune params.guidance must be a string when provided"
+                                : `session.prune params are invalid: ${formatZodError(parsed.error)}`;
+        return invalidParams(message);
+    }
+    return {
+        ok: true,
+        value: {
+            sessionId: parsed.data.sessionId,
+            strategy: parsed.data.strategy,
+            fraction: parsed.data.fraction,
+            ...(parsed.data.guidance !== undefined ? { guidance: parsed.data.guidance } : {}),
+        },
+    };
+}
+function validateRewindParams(params) {
+    const parsed = sessionProtocolRewindParamsSchema.safeParse(params);
+    if (!parsed.success) {
+        const message = hasIssue(parsed.error, [], "invalid_type")
+            ? "session.rewind params must be an object"
+            : hasIssue(parsed.error, [], "unrecognized_keys")
+                ? "session.rewind params only support sessionId and historyEntryId"
+                : hasIssue(parsed.error, ["sessionId"])
+                    ? "session.rewind params.sessionId must be a non-empty string"
+                    : hasIssue(parsed.error, ["historyEntryId"])
+                        ? "session.rewind params.historyEntryId must be a non-empty string"
+                        : `session.rewind params are invalid: ${formatZodError(parsed.error)}`;
+        return invalidParams(message);
+    }
+    return {
+        ok: true,
+        value: {
+            sessionId: parsed.data.sessionId,
+            historyEntryId: parsed.data.historyEntryId,
+        },
+    };
+}
+function validateTerminateSubagentParams(params) {
+    const parsed = sessionProtocolTerminateSubagentParamsSchema.safeParse(params);
+    if (!parsed.success) {
+        const message = hasIssue(parsed.error, [], "invalid_type")
+            ? "session.terminateSubagent params must be an object"
+            : hasIssue(parsed.error, [], "unrecognized_keys")
+                ? "session.terminateSubagent params only support sessionId and subagentId"
+                : hasIssue(parsed.error, ["sessionId"])
+                    ? "session.terminateSubagent params.sessionId must be a non-empty string"
+                    : hasIssue(parsed.error, ["subagentId"])
+                        ? "session.terminateSubagent params.subagentId must be a non-empty string"
+                        : `session.terminateSubagent params are invalid: ${formatZodError(parsed.error)}`;
+        return invalidParams(message);
+    }
+    return {
+        ok: true,
+        value: {
+            sessionId: parsed.data.sessionId,
+            subagentId: parsed.data.subagentId,
+        },
+    };
+}
+function validateEphemeralCreateParams(params) {
+    const parsed = sessionProtocolEphemeralCreateParamsSchema.safeParse(params);
+    if (!parsed.success) {
+        const message = hasIssue(parsed.error, [], "invalid_type")
+            ? "session.ephemeral.create params must be an object"
+            : hasIssue(parsed.error, [], "unrecognized_keys")
+                ? "session.ephemeral.create params only support sessionId, instructions, tools, and riskLevel"
+                : hasIssue(parsed.error, ["sessionId"])
+                    ? "session.ephemeral.create params.sessionId must be a non-empty string"
+                    : hasIssue(parsed.error, ["instructions"])
+                        ? "session.ephemeral.create params.instructions must be a non-empty string"
+                        : hasIssue(parsed.error, ["tools"])
+                            ? "session.ephemeral.create params.tools are invalid"
+                            : hasIssue(parsed.error, ["riskLevel"])
+                                ? "session.ephemeral.create params.riskLevel must be read-only or read-write"
+                                : `session.ephemeral.create params are invalid: ${formatZodError(parsed.error)}`;
+        return invalidParams(message);
+    }
+    return { ok: true, value: parsed.data };
+}
+function validateEphemeralSubmitParams(params) {
+    const parsed = sessionProtocolEphemeralSubmitParamsSchema.safeParse(params);
+    if (!parsed.success) {
+        const message = hasIssue(parsed.error, [], "invalid_type")
+            ? "session.ephemeral.submit params must be an object"
+            : hasIssue(parsed.error, [], "unrecognized_keys")
+                ? "session.ephemeral.submit params only support sessionId, contextId, threadId, optional forkFromThreadId, and message"
+                : hasIssue(parsed.error, ["sessionId"])
+                    ? "session.ephemeral.submit params.sessionId must be a non-empty string"
+                    : hasIssue(parsed.error, ["contextId"])
+                        ? "session.ephemeral.submit params.contextId must be a non-empty string"
+                        : hasIssue(parsed.error, ["threadId"])
+                            ? "session.ephemeral.submit params.threadId must be a non-empty string"
+                            : hasIssue(parsed.error, ["forkFromThreadId"])
+                                ? "session.ephemeral.submit params.forkFromThreadId must be a non-empty string when provided"
+                                : hasIssue(parsed.error, ["message"])
+                                    ? "session.ephemeral.submit params.message must be a non-empty string"
+                                    : `session.ephemeral.submit params are invalid: ${formatZodError(parsed.error)}`;
+        return invalidParams(message);
+    }
+    return {
+        ok: true,
+        value: {
+            sessionId: parsed.data.sessionId,
+            contextId: parsed.data.contextId,
+            threadId: parsed.data.threadId,
+            ...(parsed.data.forkFromThreadId !== undefined
+                ? { forkFromThreadId: parsed.data.forkFromThreadId }
+                : {}),
+            message: parsed.data.message,
+        },
+    };
+}
+function validateEphemeralCloseParams(params) {
+    const parsed = sessionProtocolEphemeralCloseParamsSchema.safeParse(params);
+    if (!parsed.success) {
+        const message = hasIssue(parsed.error, [], "invalid_type")
+            ? "session.ephemeral.close params must be an object"
+            : hasIssue(parsed.error, [], "unrecognized_keys")
+                ? "session.ephemeral.close params only support sessionId and contextId"
+                : hasIssue(parsed.error, ["sessionId"])
+                    ? "session.ephemeral.close params.sessionId must be a non-empty string"
+                    : hasIssue(parsed.error, ["contextId"])
+                        ? "session.ephemeral.close params.contextId must be a non-empty string"
+                        : `session.ephemeral.close params are invalid: ${formatZodError(parsed.error)}`;
+        return invalidParams(message);
+    }
+    return { ok: true, value: parsed.data };
+}
+function validateCreateParams(params) {
+    const parsed = sessionProtocolCreateParamsSchema.safeParse(params);
+    if (!parsed.success) {
+        const message = hasIssue(parsed.error, [], "invalid_type")
+            ? "session.create params must be an object"
+            : hasIssue(parsed.error, [], "unrecognized_keys")
+                ? "session.create params only support executionEnvironment, personaId, riskLevel, and reasoning"
+                : hasIssue(parsed.error, ["executionEnvironment"])
+                    ? "session.create params.executionEnvironment must be an object"
+                    : hasIssue(parsed.error, ["executionEnvironment", "kind"])
+                        ? "session.create params.executionEnvironment.kind must be 'local', 'cloudflare-sandbox', or 'fly-sprite'"
+                        : hasIssue(parsed.error, ["executionEnvironment", "cwd"])
+                            ? "session.create params.executionEnvironment.cwd must be an absolute path"
+                            : hasIssue(parsed.error, ["personaId"])
+                                ? "session.create params.personaId must be a non-empty string"
+                                : hasIssue(parsed.error, ["riskLevel"])
+                                    ? "session.create params.riskLevel must be 'read-only' or 'read-write'"
+                                    : hasIssue(parsed.error, ["reasoning"])
+                                        ? "session.create params.reasoning must be one of none, minimal, low, medium, high, or xhigh"
+                                        : `session.create params are invalid: ${formatZodError(parsed.error)}`;
+        return invalidParams(message);
+    }
+    return {
+        ok: true,
+        value: parsed.data,
+    };
+}
+function validateNoParams(method, params) {
+    const parsed = sessionProtocolEmptyParamsSchema.safeParse(params);
+    if (!parsed.success) {
+        return invalidParams(`${method} params must be an empty object`);
+    }
+    return { ok: true, value: {} };
+}
+function validateResult(method, result, schema) {
+    const parsed = schema.safeParse(result);
+    if (!parsed.success) {
+        return {
+            ok: false,
+            error: createSessionProtocolError(SESSION_PROTOCOL_ERROR_CODES.invalidRequest, `${method} result is invalid: ${formatZodError(parsed.error)}`),
+        };
+    }
+    return {
+        ok: true,
+        value: parsed.data,
+    };
+}
+function parseSessionProtocolReadyMessage(payload) {
+    const ready = sessionProtocolReadyMessageSchema.safeParse(payload);
+    if (!ready.success) {
+        return outgoingParseFailure("ready", null, SESSION_PROTOCOL_ERROR_CODES.invalidRequest, `invalid ready message: ${formatZodError(ready.error)}`);
+    }
+    return {
+        ok: true,
+        message: {
+            version: SESSION_PROTOCOL_VERSION,
+            type: "ready",
+            methods: [...ready.data.methods],
+        },
+    };
+}
+function parseSessionProtocolDeltaMessage(payload) {
+    const fail = (message) => outgoingParseFailure("session.delta", null, SESSION_PROTOCOL_ERROR_CODES.invalidRequest, message);
+    const deltaMessage = sessionProtocolDeltaMessageSchema.safeParse(payload);
+    if (!deltaMessage.success) {
+        if (hasIssue(deltaMessage.error, [], "unrecognized_keys")) {
+            return fail("session.delta message contains unsupported fields");
+        }
+        if (hasIssue(deltaMessage.error, ["sessionId"])) {
+            return fail("session.delta.sessionId must be a non-empty string");
+        }
+        if (hasIssue(deltaMessage.error, ["fromRevision"])) {
+            return fail("session.delta.fromRevision must be a positive integer or null");
+        }
+        if (hasIssue(deltaMessage.error, ["toRevision"])) {
+            return fail("session.delta.toRevision must be a positive integer");
+        }
+        if (hasIssue(deltaMessage.error, ["reason"])) {
+            return fail("session.delta.reason is invalid");
+        }
+        if (hasIssue(deltaMessage.error, ["delta"])) {
+            return fail("session.delta.delta is invalid");
+        }
+        return fail(`invalid session.delta message: ${formatZodError(deltaMessage.error)}`);
+    }
+    return {
+        ok: true,
+        message: {
+            version: SESSION_PROTOCOL_VERSION,
+            type: "session.delta",
+            sessionId: deltaMessage.data.sessionId,
+            fromRevision: deltaMessage.data.fromRevision,
+            toRevision: deltaMessage.data.toRevision,
+            reason: deltaMessage.data.reason,
+            delta: deltaMessage.data.delta,
+        },
+    };
+}
+function parseSessionProtocolEphemeralMessage(payload) {
+    const fail = (message) => outgoingParseFailure("session.ephemeral", null, SESSION_PROTOCOL_ERROR_CODES.invalidRequest, message);
+    const ephemeralMessage = sessionProtocolEphemeralMessageSchema.safeParse(payload);
+    if (!ephemeralMessage.success) {
+        if (hasIssue(ephemeralMessage.error, [], "unrecognized_keys")) {
+            return fail("session.ephemeral message contains unsupported fields");
+        }
+        if (hasIssue(ephemeralMessage.error, ["sessionId"])) {
+            return fail("session.ephemeral.sessionId must be a non-empty string");
+        }
+        if (hasIssue(ephemeralMessage.error, ["event"])) {
+            return fail("session.ephemeral.event is invalid");
+        }
+        return fail(`invalid session.ephemeral message: ${formatZodError(ephemeralMessage.error)}`);
+    }
+    return {
+        ok: true,
+        message: ephemeralMessage.data,
+    };
+}
+function parseSessionProtocolResponseMessage(payload) {
+    const parsedIdField = sessionProtocolIdFieldSchema.safeParse(payload);
+    const responseId = parseNullableRequestId(parsedIdField.success ? parsedIdField.data.id : undefined);
+    const requestId = responseId.ok ? responseId.id : null;
+    const fail = (message, reason = "invalid_payload", id = requestId) => outgoingParseFailure("response", id, SESSION_PROTOCOL_ERROR_CODES.invalidRequest, message, undefined, reason);
+    if (!responseId.ok) {
+        return fail("response.id must be a non-empty string or null", "response_invalid_id", null);
+    }
+    const parsedOkField = sessionProtocolOkFieldSchema.safeParse(payload);
+    const ok = parsedOkField.success ? parsedOkField.data.ok : undefined;
+    if (ok === true) {
+        const successResponse = sessionProtocolResponseSuccessSchema.safeParse(payload);
+        if (!successResponse.success) {
+            if (hasIssue(successResponse.error, [], "unrecognized_keys")) {
+                return fail("successful response must only include result payload");
+            }
+            if (hasIssue(successResponse.error, ["result"], "invalid_type")) {
+                return fail("successful response must include result");
+            }
+            if (hasIssue(successResponse.error, ["id"])) {
+                return fail("successful response.id must be a non-empty string", "response_invalid_id");
+            }
+            return fail(`invalid successful response: ${formatZodError(successResponse.error)}`);
+        }
+        return {
+            ok: true,
+            message: {
+                version: SESSION_PROTOCOL_VERSION,
+                type: "response",
+                id: successResponse.data.id,
+                ok: true,
+                result: successResponse.data.result,
+            },
+        };
+    }
+    if (ok !== false) {
+        return fail("response.ok must be true or false");
+    }
+    const errorResponse = sessionProtocolResponseErrorSchema.safeParse(payload);
+    if (!errorResponse.success) {
+        if (hasIssue(errorResponse.error, [], "unrecognized_keys")) {
+            return fail("error response must only include error payload");
+        }
+        if (hasIssue(errorResponse.error, ["error"])) {
+            return fail("error response.error must be an object");
+        }
+        if (hasIssue(errorResponse.error, ["error", "code"]) ||
+            hasIssue(errorResponse.error, ["error", "message"])) {
+            return fail("error response.error must include a valid code and string message");
+        }
+        return fail(`invalid error response: ${formatZodError(errorResponse.error)}`);
+    }
+    return {
+        ok: true,
+        message: {
+            version: SESSION_PROTOCOL_VERSION,
+            type: "response",
+            id: errorResponse.data.id,
+            ok: false,
+            error: errorResponse.data.error,
+        },
+    };
+}
+function parseNullableRequestId(value) {
+    if (value === null) {
+        return { ok: true, id: null };
+    }
+    const parsed = sessionProtocolRequestIdSchema.safeParse(value);
+    return parsed.success ? { ok: true, id: parsed.data } : { ok: false };
+}
+function outgoingParseFailure(messageType, id, code, message, data, reason = "invalid_payload") {
+    return {
+        ok: false,
+        reason,
+        messageType,
+        id,
+        error: createSessionProtocolError(code, message, data),
+    };
+}
+function hasIssue(error, path = [], code) {
+    return error.issues.some((issue) => (code === undefined || issue.code === code) &&
+        issue.path.length === path.length &&
+        issue.path.every((segment, i) => segment === path[i]));
+}
+function invalidParams(message) {
+    return {
+        ok: false,
+        error: createSessionProtocolError(SESSION_PROTOCOL_ERROR_CODES.invalidParams, message),
+    };
+}
+function isMessage(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    switch (value.role) {
+        case "user":
+            return typeof value.content === "string" || Array.isArray(value.content);
+        case "assistant":
+            return Array.isArray(value.content);
+        case "toolResult":
+            return (typeof value.toolCallId === "string" &&
+                typeof value.toolName === "string" &&
+                typeof value.isError === "boolean" &&
+                Array.isArray(value.content));
+        default:
+            return false;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=session_protocol.js.map