@markusylisiurunen/tau 0.2.128 → 0.3.0

package/dist/protocol/session_protocol.d.ts

@@ -0,0 +1,691 @@
+import type { Message, TextContent, ThinkingContent, ToolCall } from "@earendil-works/pi-ai";
+export declare const SESSION_PROTOCOL_VERSION: 1;
+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.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"];
+export type SessionProtocolMethod = (typeof SESSION_PROTOCOL_METHODS)[number];
+export declare const SESSION_PROTOCOL_ERROR_CODES: {
+    readonly parseError: "parse_error";
+    readonly invalidRequest: "invalid_request";
+    readonly methodNotFound: "method_not_found";
+    readonly invalidParams: "invalid_params";
+    readonly notFound: "not_found";
+    readonly busy: "busy";
+    readonly internalError: "internal_error";
+};
+export type SessionProtocolErrorCode = (typeof SESSION_PROTOCOL_ERROR_CODES)[keyof typeof SESSION_PROTOCOL_ERROR_CODES];
+export type SessionProtocolRequestId = string;
+export type SessionProtocolInitializeParams = {
+    client: {
+        name: string;
+        version: string;
+    };
+};
+export type SessionProtocolLocalExecutionEnvironmentInput = {
+    kind: "local";
+    cwd: string;
+};
+export type SessionProtocolCloudflareSandboxExecutionEnvironmentInput = {
+    kind: "cloudflare-sandbox";
+    bridgeId: string;
+    sandboxId: string;
+    cwd: string;
+};
+export type SessionProtocolFlySpriteExecutionEnvironmentInput = {
+    kind: "fly-sprite";
+    apiId: string;
+    spriteName: string;
+    cwd: string;
+};
+export type SessionProtocolExecutionEnvironmentInput = SessionProtocolLocalExecutionEnvironmentInput | SessionProtocolCloudflareSandboxExecutionEnvironmentInput | SessionProtocolFlySpriteExecutionEnvironmentInput;
+export type SessionProtocolCreateParams = {
+    executionEnvironment: SessionProtocolExecutionEnvironmentInput;
+    personaId?: string;
+    riskLevel?: "read-only" | "read-write";
+    reasoning?: SessionProtocolReasoningEffort;
+};
+export type SessionProtocolListParams = Record<string, never>;
+export type SessionProtocolSessionIdParams = {
+    sessionId: string;
+};
+export type SessionProtocolUnobserveParams = SessionProtocolSessionIdParams;
+export type SessionProtocolUserMessageParams = {
+    sessionId: string;
+    text: string;
+    historyEntryId?: string;
+};
+export type SessionProtocolSubmitParams = SessionProtocolUserMessageParams;
+export type SessionProtocolQueueParams = SessionProtocolUserMessageParams;
+export type SessionProtocolSteerParams = SessionProtocolUserMessageParams;
+export type SessionProtocolRecordParams = SessionProtocolSessionIdParams & {
+    text: string;
+    historyEntryId?: string;
+};
+export type SessionProtocolRetryParams = SessionProtocolSessionIdParams;
+export type SessionProtocolExecParams = SessionProtocolSessionIdParams & {
+    command: string;
+    cwd?: string;
+    timeoutMs?: number;
+};
+export type SessionProtocolSetRiskParams = SessionProtocolSessionIdParams & {
+    riskLevel: "read-only" | "read-write";
+};
+export type SessionProtocolSetReasoningParams = SessionProtocolSessionIdParams & {
+    reasoning: SessionProtocolReasoningEffort;
+};
+export type SessionProtocolSetPersonaParams = SessionProtocolSessionIdParams & {
+    personaId: string;
+};
+export type SessionProtocolResolvePromptParams = SessionProtocolSessionIdParams & {
+    promptId: string;
+};
+export type SessionProtocolAutocompletePathsParams = SessionProtocolSessionIdParams & {
+    query: string;
+    limit: number;
+};
+export type SessionProtocolReloadParams = SessionProtocolSessionIdParams;
+export type SessionProtocolCompactParams = SessionProtocolSessionIdParams & {
+    mode: "summary-only" | "summary-and-last";
+    guidance?: string;
+};
+export type SessionProtocolPruneParams = SessionProtocolSessionIdParams & {
+    strategy: "earliest" | "largest" | "smart";
+    fraction: number;
+    guidance?: string;
+};
+export type SessionProtocolRewindParams = SessionProtocolSessionIdParams & {
+    historyEntryId: string;
+};
+export type SessionProtocolTerminateSubagentParams = SessionProtocolSessionIdParams & {
+    subagentId: string;
+};
+export type SessionProtocolEphemeralAgentTool = "bash" | "write" | "edit" | "view_image" | "web_search" | "web_fetch";
+export type SessionProtocolEphemeralCreateParams = SessionProtocolSessionIdParams & {
+    instructions: string;
+    tools: SessionProtocolEphemeralAgentTool[];
+    riskLevel: "read-only" | "read-write";
+};
+export type SessionProtocolEphemeralSubmitParams = SessionProtocolSessionIdParams & {
+    contextId: string;
+    threadId: string;
+    forkFromThreadId?: string;
+    message: string;
+};
+export type SessionProtocolEphemeralCloseParams = SessionProtocolSessionIdParams & {
+    contextId: string;
+};
+export type SessionProtocolParamsByMethod = {
+    initialize: SessionProtocolInitializeParams;
+    "session.create": SessionProtocolCreateParams;
+    "session.list": SessionProtocolListParams;
+    "session.observe": SessionProtocolSessionIdParams;
+    "session.unobserve": SessionProtocolUnobserveParams;
+    "session.record": SessionProtocolRecordParams;
+    "session.submit": SessionProtocolSubmitParams;
+    "session.queue": SessionProtocolQueueParams;
+    "session.steer": SessionProtocolSteerParams;
+    "session.retry": SessionProtocolRetryParams;
+    "session.exec": SessionProtocolExecParams;
+    "session.interrupt": SessionProtocolSessionIdParams;
+    "session.snapshot": SessionProtocolSessionIdParams;
+    "session.setRisk": SessionProtocolSetRiskParams;
+    "session.setReasoning": SessionProtocolSetReasoningParams;
+    "session.setPersona": SessionProtocolSetPersonaParams;
+    "session.resolvePrompt": SessionProtocolResolvePromptParams;
+    "session.autocompletePaths": SessionProtocolAutocompletePathsParams;
+    "session.reload": SessionProtocolReloadParams;
+    "session.compact": SessionProtocolCompactParams;
+    "session.prune": SessionProtocolPruneParams;
+    "session.rewind": SessionProtocolRewindParams;
+    "session.terminateSubagent": SessionProtocolTerminateSubagentParams;
+    "session.ephemeral.create": SessionProtocolEphemeralCreateParams;
+    "session.ephemeral.submit": SessionProtocolEphemeralSubmitParams;
+    "session.ephemeral.close": SessionProtocolEphemeralCloseParams;
+};
+export type SessionProtocolInitializeResult = {
+    protocolVersion: typeof SESSION_PROTOCOL_VERSION;
+    methods: SessionProtocolMethod[];
+    alreadyInitialized: boolean;
+};
+export type SessionProtocolTurnResult = {
+    turn: {
+        aborted: boolean;
+        blocked?: {
+            reason: "auto-compaction-failed";
+            message: string;
+        };
+    };
+};
+export type SessionProtocolUserMessageTurnResult = SessionProtocolTurnResult & {
+    userHistoryEntryId: string;
+};
+export type SessionProtocolSubmitResult = SessionProtocolUserMessageTurnResult;
+export type SessionProtocolQueueResult = SessionProtocolUserMessageTurnResult;
+export type SessionProtocolSteerResult = SessionProtocolUserMessageTurnResult;
+export type SessionProtocolRecordResult = {
+    snapshot: SessionProtocolSnapshot;
+    userHistoryEntryId: string;
+};
+export type SessionProtocolRetryResult = SessionProtocolTurnResult;
+export type SessionProtocolExecResult = {
+    output: string;
+    stdout: string;
+    stderr: string;
+    exitCode: number | null;
+    truncated: boolean;
+};
+export type SessionProtocolSessionLifecycle = "idle" | "running";
+export type SessionProtocolSessionSummary = {
+    sessionId: string;
+    lifecycle: SessionProtocolSessionLifecycle;
+};
+export type SessionProtocolListResult = {
+    sessions: SessionProtocolSessionSummary[];
+};
+export type SessionProtocolSystemMessage = {
+    role: "system";
+    content: string;
+    timestamp: number;
+};
+export type SessionProtocolDraftAssistantMessage = {
+    role: "assistant";
+    content: (TextContent | ThinkingContent | ToolCall)[];
+    timestamp: number;
+};
+export type SessionProtocolMessagePayload = SessionProtocolSystemMessage | Message | SessionProtocolDraftAssistantMessage;
+export type SessionProtocolMessageState = "draft" | "committed" | "interrupted" | "discarded";
+export type SessionProtocolMessage = {
+    id: string;
+    state: SessionProtocolMessageState;
+    modelVisible: boolean;
+    message: SessionProtocolMessagePayload;
+};
+export type SessionProtocolTimelineItem = {
+    type: "message";
+    id: string;
+    messageId: string;
+} | {
+    type: "notice";
+    id: string;
+    notice: SessionProtocolNotice;
+} | {
+    type: "operation";
+    id: string;
+    operation: SessionProtocolOperation;
+};
+export type SessionProtocolNotice = {
+    severity: "info" | "warn" | "error";
+    text: string;
+    timestamp: number;
+};
+export type SessionProtocolOperation = {
+    kind: "auto-compaction" | "manual-compaction" | "prune" | "reload" | "rewind";
+    status: "running" | "succeeded" | "failed" | "cancelled" | "skipped";
+    startedAt: number;
+    finishedAt?: number;
+    summary?: string;
+    error?: string;
+    data?: Record<string, unknown>;
+};
+export type SessionProtocolPromptCompositionSnapshot = {
+    environmentTag: string;
+    subagentPrompts: Record<string, string>;
+};
+export type SessionProtocolReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
+export type SessionProtocolThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+export type SessionProtocolServiceTier = "priority" | "flex";
+export type SessionProtocolModelSnapshot = {
+    id: string;
+    name: string;
+    api: string;
+    provider: string;
+    baseUrl: string;
+    reasoning: boolean;
+    thinkingLevelMap?: Partial<Record<SessionProtocolThinkingLevel, string | null>>;
+    input: ("text" | "image")[];
+    cost: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+    };
+    contextWindow: number;
+    maxTokens: number;
+    compat?: unknown;
+};
+export type SessionProtocolPersonaSettingsSnapshot = {
+    reasoning?: SessionProtocolReasoningEffort;
+    interleavedThinking?: boolean;
+    serviceTier?: SessionProtocolServiceTier;
+};
+export type SessionProtocolSubagentSnapshot = {
+    description?: string;
+    tools?: string[];
+    riskLevel?: "read-only" | "read-write";
+    launchModels?: string[];
+};
+export type SessionProtocolPersonaSnapshot = {
+    id: string;
+    label: string;
+    description?: string;
+    allowedReasoningLevels?: SessionProtocolReasoningEffort[];
+    subagents?: Record<string, SessionProtocolSubagentSnapshot>;
+    tools?: string[];
+    skills: string[] | "*";
+    source: "builtin" | "user" | "project";
+};
+export type SessionProtocolBootstrapSnapshot = {
+    model: SessionProtocolModelSnapshot;
+    prompt: SessionProtocolPromptCompositionSnapshot;
+};
+export type SessionProtocolPromptTemplateSnapshot = {
+    id: string;
+    label?: string;
+    description?: string;
+};
+export type SessionProtocolSkillSnapshot = {
+    name: string;
+    description: string;
+    path: string;
+};
+export type SessionProtocolContentCatalogSnapshot = {
+    personas: SessionProtocolPersonaSnapshot[];
+    prompts: SessionProtocolPromptTemplateSnapshot[];
+    skills: SessionProtocolSkillSnapshot[];
+};
+export type SessionProtocolSettingsSnapshot = {
+    personaId: string;
+    riskLevel: "read-only" | "read-write";
+    reasoning?: SessionProtocolReasoningEffort;
+    serviceTier?: SessionProtocolServiceTier;
+};
+export type SessionProtocolLocalExecutionEnvironmentSnapshot = {
+    kind: "local";
+    cwd: string;
+    home: string;
+};
+export type SessionProtocolCloudflareSandboxExecutionEnvironmentSnapshot = {
+    kind: "cloudflare-sandbox";
+    bridgeId: string;
+    sandboxId: string;
+    cwd: string;
+    home: string;
+};
+export type SessionProtocolFlySpriteExecutionEnvironmentSnapshot = {
+    kind: "fly-sprite";
+    apiId: string;
+    spriteName: string;
+    cwd: string;
+    home: string;
+};
+export type SessionProtocolExecutionEnvironmentSnapshot = SessionProtocolLocalExecutionEnvironmentSnapshot | SessionProtocolCloudflareSandboxExecutionEnvironmentSnapshot | SessionProtocolFlySpriteExecutionEnvironmentSnapshot;
+export type SessionProtocolSnapshot = {
+    sessionId: string;
+    revision: number;
+    lifecycle: SessionProtocolSessionLifecycle;
+    settings: SessionProtocolSettingsSnapshot;
+    bootstrap: SessionProtocolBootstrapSnapshot;
+    catalog: SessionProtocolContentCatalogSnapshot;
+    executionEnvironment: SessionProtocolExecutionEnvironmentSnapshot;
+    messages: SessionProtocolMessage[];
+    timeline: SessionProtocolTimelineItem[];
+    tools: Record<string, SessionProtocolToolRun>;
+    agents: Record<string, SessionProtocolAgentRun>;
+    facets: Record<string, SessionProtocolFacet>;
+};
+export type SessionProtocolToolRun = {
+    id: string;
+    toolCallId: string;
+    toolName: string;
+    call: {
+        messageId: string;
+        contentIndex: number;
+    };
+    status: "queued" | "running" | "succeeded" | "failed" | "blocked" | "cancelled";
+    startedAt?: number;
+    finishedAt?: number;
+    resultMessageId?: string;
+    summary?: string;
+    error?: string;
+    facetIds: string[];
+};
+export type SessionProtocolAgentRun = {
+    id: string;
+    name: string;
+    title: string;
+    status: "running" | "succeeded" | "failed" | "cancelled";
+    originMessageId: string;
+    modelLabel?: string;
+    costTotal: number;
+    turns: number;
+    toolCalls: number;
+    usage: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+        contextWindowUsageTokens: number;
+        contextWindow: number;
+    };
+    startedAt: number;
+    finishedAt?: number;
+    abortRequested: boolean;
+    progress?: string;
+    finalText?: string;
+    error?: string;
+};
+export type SessionProtocolFacetSubject = {
+    type: "session";
+} | {
+    type: "message";
+    id: string;
+} | {
+    type: "tool";
+    id: string;
+} | {
+    type: "agent";
+    id: string;
+} | {
+    type: "operation";
+    id: string;
+};
+export type SessionProtocolFacet = {
+    id: string;
+    subject: SessionProtocolFacetSubject;
+    kind: string;
+    version: number;
+    data: Record<string, unknown>;
+};
+export type SessionProtocolInterruptResult = {
+    interrupted: boolean;
+    isTurnRunning: boolean;
+};
+export type SessionProtocolCompactResult = {
+    snapshot: SessionProtocolSnapshot;
+    compactionMessage: string;
+    includedLastAssistant: boolean;
+};
+export type SessionProtocolPruneResult = {
+    snapshot: SessionProtocolSnapshot;
+    message: string;
+    noop: boolean;
+    bashResultsPruned: number;
+    editCallsPruned: number;
+    editResultsPruned: number;
+    bytesPruned: number;
+};
+export type SessionProtocolRewindResult = {
+    snapshot: SessionProtocolSnapshot;
+    historyEntryId: string;
+    text: string;
+    removedEntryIds: string[];
+};
+export type SessionProtocolReloadResult = {
+    snapshot: SessionProtocolSnapshot;
+    warnings: string[];
+    counts: {
+        personas: number;
+        prompts: number;
+        skills: number;
+    };
+};
+export type SessionProtocolResolvePromptResult = {
+    promptId: string;
+    text: string;
+};
+export type SessionProtocolAutocompletePathsResult = {
+    paths: string[];
+};
+export type SessionProtocolUnobserveResult = {
+    unobserved: true;
+};
+export type SessionProtocolTerminateSubagentResult = {
+    found: boolean;
+};
+export type SessionProtocolEphemeralCreateResult = {
+    contextId: string;
+};
+export type SessionProtocolEphemeralSubmitResult = {
+    threadId: string;
+    response: string;
+};
+export type SessionProtocolEphemeralCloseResult = {
+    closed: boolean;
+};
+export type SessionProtocolResultByMethod = {
+    initialize: SessionProtocolInitializeResult;
+    "session.create": SessionProtocolSnapshot;
+    "session.list": SessionProtocolListResult;
+    "session.observe": SessionProtocolSnapshot;
+    "session.unobserve": SessionProtocolUnobserveResult;
+    "session.record": SessionProtocolRecordResult;
+    "session.submit": SessionProtocolSubmitResult;
+    "session.queue": SessionProtocolQueueResult;
+    "session.steer": SessionProtocolSteerResult;
+    "session.retry": SessionProtocolRetryResult;
+    "session.exec": SessionProtocolExecResult;
+    "session.interrupt": SessionProtocolInterruptResult;
+    "session.snapshot": SessionProtocolSnapshot;
+    "session.setRisk": SessionProtocolSnapshot;
+    "session.setReasoning": SessionProtocolSnapshot;
+    "session.setPersona": SessionProtocolSnapshot;
+    "session.resolvePrompt": SessionProtocolResolvePromptResult;
+    "session.autocompletePaths": SessionProtocolAutocompletePathsResult;
+    "session.reload": SessionProtocolReloadResult;
+    "session.compact": SessionProtocolCompactResult;
+    "session.prune": SessionProtocolPruneResult;
+    "session.rewind": SessionProtocolRewindResult;
+    "session.terminateSubagent": SessionProtocolTerminateSubagentResult;
+    "session.ephemeral.create": SessionProtocolEphemeralCreateResult;
+    "session.ephemeral.submit": SessionProtocolEphemeralSubmitResult;
+    "session.ephemeral.close": SessionProtocolEphemeralCloseResult;
+};
+export type SessionProtocolRequestMessage = {
+    [M in SessionProtocolMethod]: {
+        version: typeof SESSION_PROTOCOL_VERSION;
+        type: "request";
+        id: SessionProtocolRequestId;
+        method: M;
+        params: SessionProtocolParamsByMethod[M];
+    };
+}[SessionProtocolMethod];
+export type SessionProtocolSuccessResponseMessage = {
+    version: typeof SESSION_PROTOCOL_VERSION;
+    type: "response";
+    id: SessionProtocolRequestId;
+    ok: true;
+    result: SessionProtocolResultByMethod[SessionProtocolMethod];
+};
+export type SessionProtocolError = {
+    code: SessionProtocolErrorCode;
+    message: string;
+    data?: unknown;
+};
+export type SessionProtocolErrorResponseMessage = {
+    version: typeof SESSION_PROTOCOL_VERSION;
+    type: "response";
+    id: SessionProtocolRequestId | null;
+    ok: false;
+    error: SessionProtocolError;
+};
+export type SessionProtocolResponseMessage = SessionProtocolSuccessResponseMessage | SessionProtocolErrorResponseMessage;
+export type SessionProtocolParsedSuccessResponseMessage = Omit<SessionProtocolSuccessResponseMessage, "result"> & {
+    result: unknown;
+};
+export type SessionProtocolParsedResponseMessage = SessionProtocolParsedSuccessResponseMessage | SessionProtocolErrorResponseMessage;
+export type SessionProtocolDeltaReason = "user-message" | "assistant-stream" | "assistant-message" | "tool-run" | "tool-result" | "notice" | "agent-run" | "maintenance" | "configuration" | "recovery";
+export type SessionProtocolChange = {
+    type: "lifecycle.set";
+    lifecycle: SessionProtocolSessionLifecycle;
+} | {
+    type: "message.append";
+    message: SessionProtocolMessage;
+    timelineItem?: SessionProtocolTimelineItem;
+} | {
+    type: "message.replace";
+    message: SessionProtocolMessage;
+} | {
+    type: "message.content.append";
+    messageId: string;
+    text?: string;
+    thinking?: string;
+    timestamp: number;
+} | {
+    type: "timeline.append";
+    item: SessionProtocolTimelineItem;
+} | {
+    type: "timeline.replace";
+    item: SessionProtocolTimelineItem;
+} | {
+    type: "timeline.remove";
+    id: string;
+} | {
+    type: "tool.set";
+    tool: SessionProtocolToolRun;
+} | {
+    type: "tool.remove";
+    id: string;
+} | {
+    type: "agent.set";
+    agent: SessionProtocolAgentRun;
+} | {
+    type: "agent.remove";
+    id: string;
+} | {
+    type: "facet.set";
+    facet: SessionProtocolFacet;
+} | {
+    type: "facet.remove";
+    id: string;
+};
+export type SessionProtocolDelta = {
+    type: "snapshot.patch";
+    changes: SessionProtocolChange[];
+} | {
+    type: "snapshot.reset";
+    snapshot: SessionProtocolSnapshot;
+};
+export type SessionProtocolDeltaMessage = {
+    version: typeof SESSION_PROTOCOL_VERSION;
+    type: "session.delta";
+    sessionId: string;
+    fromRevision: number | null;
+    toRevision: number;
+    reason: SessionProtocolDeltaReason;
+    delta: SessionProtocolDelta;
+};
+export type SessionProtocolReadyMessage = {
+    version: typeof SESSION_PROTOCOL_VERSION;
+    type: "ready";
+    methods: SessionProtocolMethod[];
+};
+export type SessionProtocolEphemeralAgentThreadUpdateEvent = {
+    type: "ephemeral-agent.thread-update";
+    contextId: string;
+    threadId: string;
+    update: {
+        costTotal: number;
+        usage: {
+            input: number;
+            output: number;
+            cacheRead: number;
+            cacheWrite: number;
+            contextWindowUsageTokens: number;
+            contextWindow: number;
+        };
+        lastActivityText?: string;
+    };
+};
+export type SessionProtocolEphemeralEvent = SessionProtocolEphemeralAgentThreadUpdateEvent;
+export type SessionProtocolEphemeralMessage = {
+    version: typeof SESSION_PROTOCOL_VERSION;
+    type: "session.ephemeral";
+    sessionId: string;
+    event: SessionProtocolEphemeralEvent;
+};
+export type SessionProtocolOutgoingMessage = SessionProtocolResponseMessage | SessionProtocolDeltaMessage | SessionProtocolEphemeralMessage | SessionProtocolReadyMessage;
+export type SessionProtocolParsedOutgoingMessage = SessionProtocolParsedResponseMessage | SessionProtocolDeltaMessage | SessionProtocolEphemeralMessage | SessionProtocolReadyMessage;
+export type SessionProtocolOutgoingParseFailureReason = "invalid_payload" | "empty_line" | "parse_error" | "unsupported_version" | "unsupported_message_type" | "response_invalid_id";
+export type SessionProtocolOutgoingParseFailure = {
+    ok: false;
+    reason: SessionProtocolOutgoingParseFailureReason;
+    messageType: SessionProtocolOutgoingMessage["type"] | null;
+    id: SessionProtocolRequestId | null;
+    error: SessionProtocolError;
+};
+export type SessionProtocolOutgoingParseSuccess = {
+    ok: true;
+    message: SessionProtocolParsedOutgoingMessage;
+};
+export type SessionProtocolOutgoingParseResult = SessionProtocolOutgoingParseFailure | SessionProtocolOutgoingParseSuccess;
+export type SessionProtocolParseFailure = {
+    ok: false;
+    id: SessionProtocolRequestId | null;
+    error: SessionProtocolError;
+};
+export type SessionProtocolParseSuccess = {
+    ok: true;
+    request: SessionProtocolRequestMessage;
+};
+export type SessionProtocolParseResult = SessionProtocolParseFailure | SessionProtocolParseSuccess;
+export type SessionProtocolParamsValidationResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: SessionProtocolError;
+};
+export type SessionProtocolResultValidationResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: SessionProtocolError;
+};
+export declare function isSessionProtocolMethod(value: unknown): value is SessionProtocolMethod;
+export declare function createSessionProtocolError(code: SessionProtocolErrorCode, message: string, data?: unknown): SessionProtocolError;
+export declare function createSessionProtocolSuccessResponse<M extends SessionProtocolMethod>(id: SessionProtocolRequestId, method: M, result: SessionProtocolResultByMethod[M]): SessionProtocolSuccessResponseMessage;
+export declare function createSessionProtocolErrorResponse(id: SessionProtocolRequestId | null, code: SessionProtocolErrorCode, message: string, data?: unknown): SessionProtocolErrorResponseMessage;
+export declare function createSessionProtocolDeltaMessage(options: {
+    sessionId: string;
+    fromRevision: number | null;
+    toRevision: number;
+    reason: SessionProtocolDeltaReason;
+    delta: SessionProtocolDelta;
+}): SessionProtocolDeltaMessage;
+export declare function createSessionProtocolEphemeralMessage(options: {
+    sessionId: string;
+    event: SessionProtocolEphemeralEvent;
+}): SessionProtocolEphemeralMessage;
+export declare function applySessionProtocolDelta(snapshot: SessionProtocolSnapshot, message: SessionProtocolDeltaMessage): SessionProtocolSnapshot;
+export declare function createSessionProtocolReadyMessage(): SessionProtocolReadyMessage;
+export declare function serializeSessionProtocolMessage(message: SessionProtocolOutgoingMessage): string;
+export declare function parseSessionProtocolRequestLine(line: string): SessionProtocolParseResult;
+export declare function createSessionProtocolRequest(id: SessionProtocolRequestId, method: SessionProtocolMethod, params: unknown): SessionProtocolParamsValidationResult<SessionProtocolRequestMessage>;
+export declare function parseSessionProtocolOutgoingLine(line: string): SessionProtocolOutgoingParseResult;
+export declare function validateSessionProtocolParams(method: "initialize", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolInitializeParams>;
+export declare function validateSessionProtocolParams(method: "session.create", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolCreateParams>;
+export declare function validateSessionProtocolParams(method: "session.list", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolListParams>;
+export declare function validateSessionProtocolParams(method: "session.observe", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolSessionIdParams>;
+export declare function validateSessionProtocolParams(method: "session.unobserve", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolUnobserveParams>;
+export declare function validateSessionProtocolParams(method: "session.record", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolRecordParams>;
+export declare function validateSessionProtocolParams(method: "session.submit", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolSubmitParams>;
+export declare function validateSessionProtocolParams(method: "session.queue", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolQueueParams>;
+export declare function validateSessionProtocolParams(method: "session.steer", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolSteerParams>;
+export declare function validateSessionProtocolParams(method: "session.retry", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolRetryParams>;
+export declare function validateSessionProtocolParams(method: "session.exec", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolExecParams>;
+export declare function validateSessionProtocolParams(method: "session.interrupt", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolSessionIdParams>;
+export declare function validateSessionProtocolParams(method: "session.snapshot", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolSessionIdParams>;
+export declare function validateSessionProtocolParams(method: "session.reload", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolReloadParams>;
+export declare function validateSessionProtocolParams(method: "session.setRisk", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolSetRiskParams>;
+export declare function validateSessionProtocolParams(method: "session.setReasoning", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolSetReasoningParams>;
+export declare function validateSessionProtocolParams(method: "session.setPersona", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolSetPersonaParams>;
+export declare function validateSessionProtocolParams(method: "session.resolvePrompt", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolResolvePromptParams>;
+export declare function validateSessionProtocolParams(method: "session.autocompletePaths", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolAutocompletePathsParams>;
+export declare function validateSessionProtocolParams(method: "session.compact", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolCompactParams>;
+export declare function validateSessionProtocolParams(method: "session.prune", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolPruneParams>;
+export declare function validateSessionProtocolParams(method: "session.rewind", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolRewindParams>;
+export declare function validateSessionProtocolParams(method: "session.terminateSubagent", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolTerminateSubagentParams>;
+export declare function validateSessionProtocolParams(method: "session.ephemeral.create", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolEphemeralCreateParams>;
+export declare function validateSessionProtocolParams(method: "session.ephemeral.submit", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolEphemeralSubmitParams>;
+export declare function validateSessionProtocolParams(method: "session.ephemeral.close", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolEphemeralCloseParams>;
+export declare function validateSessionProtocolParams(method: SessionProtocolMethod, params: unknown): SessionProtocolParamsValidationResult<SessionProtocolParamsByMethod[SessionProtocolMethod]>;
+export declare function validateSessionProtocolResult<M extends SessionProtocolMethod>(method: M, result: unknown): SessionProtocolResultValidationResult<SessionProtocolResultByMethod[M]>;