@vibesdotdev/chat 0.0.0-stage → 1.0.0-rc.0

package/dist/client/consumer-session-capability.d.ts

@@ -0,0 +1,1020 @@
+/**
+ * Renderer-safe access to the consumer daemon's real local Chat session.
+ *
+ * This is deliberately a Chat-owned capability, not a Desktop command tunnel.
+ * Long-running turns are started and then polled in bounded records so the CEF
+ * renderer never receives a daemon endpoint, storage handle, runtime object, or
+ * unbounded RPC request.
+ */
+import { type RuntimeDescriptor } from '@vibesdotdev/kernel';
+import * as z from 'zod/v4';
+import { type ChatTurnReceipt } from '../storage/chat-rooms.storage.schema.ts';
+import { type ToolCallRecord, type UnifiedChatMessage, type UnifiedChatRoom } from '../schemas/unified.ts';
+import type { ChatApprovalDecision, ChatComposerOptions, ChatFolderListResult, ChatFolder, ChatFolderCreateInput, ChatFolderBatchMoveInput, ChatFolderUpdateInput, ChatFolderMoveInput, ChatMessageSearchRoomResult, ChatRoomCreateInput, ChatRoomSettingsPatch, ChatRunInput } from './schemas/contracts.ts';
+export declare const CHAT_CONSUMER_SESSION_KIND = "chat/consumer-session";
+export declare const CHAT_CONSUMER_SESSION_ID = "chat.local-session";
+/**
+ * Room summary — everything the sidebar, routing, and execution-state
+ * derivation need, minus message content. `items` holds ~all of the bytes
+ * (full tool payloads), so it stays server-side until messages page in via
+ * `listMessages`. Declared first: result schemas below reference it.
+ */
+export declare const ChatConsumerRoomSummarySchema: z.ZodObject<{
+    type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    id: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    agentId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodOptional<z.ZodISODateTime>;
+    visibility: z.ZodOptional<z.ZodEnum<{
+        public: "public";
+        private: "private";
+        project: "project";
+    }>>;
+    agents: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        alias: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$loose>>>;
+    users: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        userId: z.ZodOptional<z.ZodString>;
+        id: z.ZodOptional<z.ZodString>;
+        role: z.ZodOptional<z.ZodEnum<{
+            owner: "owner";
+            member: "member";
+            applicant: "applicant";
+            admin: "admin";
+            moderator: "moderator";
+            guest: "guest";
+            banned: "banned";
+        }>>;
+    }, z.core.$loose>>>;
+    lastMessageAt: z.ZodISODateTime;
+    unreadCount: z.ZodOptional<z.ZodNumber>;
+    modeId: z.ZodOptional<z.ZodString>;
+    roomMode: z.ZodDefault<z.ZodEnum<{
+        standard: "standard";
+        multi: "multi";
+    }>>;
+    inputHistory: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    draft: z.ZodOptional<z.ZodString>;
+    participants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            agent: "agent";
+            friend: "friend";
+        }>;
+        name: z.ZodDefault<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        modelHint: z.ZodOptional<z.ZodString>;
+        responseStyle: z.ZodDefault<z.ZodEnum<{
+            never: "never";
+            always: "always";
+            auto: "auto";
+            reply: "reply";
+        }>>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        order: z.ZodOptional<z.ZodNumber>;
+        source: z.ZodOptional<z.ZodEnum<{
+            config: "config";
+            runtime: "runtime";
+            pairing: "pairing";
+            history: "history";
+        }>>;
+    }, z.core.$strip>>>;
+    cloudSyncEnabled: z.ZodOptional<z.ZodBoolean>;
+    lastMessage: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ChatConsumerRoomSummary = z.infer<typeof ChatConsumerRoomSummarySchema>;
+export declare const ChatConsumerSnapshotSchema: z.ZodObject<{
+    rooms: z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        id: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodOptional<z.ZodISODateTime>;
+        visibility: z.ZodOptional<z.ZodEnum<{
+            public: "public";
+            private: "private";
+            project: "project";
+        }>>;
+        agents: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            agentId: z.ZodString;
+            alias: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$loose>>>;
+        users: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            userId: z.ZodOptional<z.ZodString>;
+            id: z.ZodOptional<z.ZodString>;
+            role: z.ZodOptional<z.ZodEnum<{
+                owner: "owner";
+                member: "member";
+                applicant: "applicant";
+                admin: "admin";
+                moderator: "moderator";
+                guest: "guest";
+                banned: "banned";
+            }>>;
+        }, z.core.$loose>>>;
+        lastMessageAt: z.ZodISODateTime;
+        unreadCount: z.ZodOptional<z.ZodNumber>;
+        modeId: z.ZodOptional<z.ZodString>;
+        roomMode: z.ZodDefault<z.ZodEnum<{
+            standard: "standard";
+            multi: "multi";
+        }>>;
+        inputHistory: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        draft: z.ZodOptional<z.ZodString>;
+        participants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodEnum<{
+                agent: "agent";
+                friend: "friend";
+            }>;
+            name: z.ZodDefault<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            modelHint: z.ZodOptional<z.ZodString>;
+            responseStyle: z.ZodDefault<z.ZodEnum<{
+                never: "never";
+                always: "always";
+                auto: "auto";
+                reply: "reply";
+            }>>;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            order: z.ZodOptional<z.ZodNumber>;
+            source: z.ZodOptional<z.ZodEnum<{
+                config: "config";
+                runtime: "runtime";
+                pairing: "pairing";
+                history: "history";
+            }>>;
+        }, z.core.$strip>>>;
+        cloudSyncEnabled: z.ZodOptional<z.ZodBoolean>;
+        lastMessage: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    activeRoomId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ChatConsumerSnapshot = z.infer<typeof ChatConsumerSnapshotSchema>;
+export declare const ChatConsumerActiveRoomSchema: z.ZodObject<{
+    activeRoomId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ChatConsumerActiveRoom = z.infer<typeof ChatConsumerActiveRoomSchema>;
+/**
+ * Message-page policy. A page fills to the count limit AND the byte budget,
+ * whichever binds first, so a window of fat tool payloads can never blow the
+ * transport cap. Every message is projected first (tool-call history collapses
+ * to a bounded tail), so the budget measures wire bytes, not storage bytes. A
+ * single projected message over the budget still returns alone (the page must
+ * make progress). A single projected message over the transport cap throws
+ * `CHAT_MESSAGE_TOO_LARGE:<id>` instead of dying anonymously downstream —
+ * raw content that large has never been observed (the observed fat is always
+ * accumulated tool history, now bounded), and the named id is repairable.
+ */
+export declare const CONSUMER_MESSAGE_PAGE_DEFAULT_LIMIT = 50;
+export declare const CONSUMER_MESSAGE_PAGE_MAX_LIMIT = 200;
+export declare const CONSUMER_MESSAGE_PAGE_BUDGET_BYTES: number;
+/**
+ * Transport result cap every consumer verb is exposed under. Single source:
+ * the exposure default below and the projector guard share it, so the wire
+ * can never carry a message the projection layer would reject anonymously.
+ */
+export declare const CONSUMER_TRANSPORT_RESULT_CAP_BYTES: number;
+/**
+ * Tool-call tail policy. A turn accumulates every tool call onto its assistant
+ * message's metadata (123 calls ≈ 1MB observed live); the consumer projection
+ * keeps the recent tail and marks the omission explicitly, so pages and polls
+ * stay bounded while full history stays one paged verb away.
+ */
+export declare const CONSUMER_TOOLCALL_TAIL_LIMIT = 25;
+export declare const CONSUMER_TOOLCALL_TAIL_BUDGET_BYTES: number;
+/** Catch-up polls keep the trailing events; message state converges through touched messages. */
+export declare const CONSUMER_POLL_MAX_EVENTS = 1000;
+export declare const ChatConsumerToolCallHistorySchema: z.ZodObject<{
+    total: z.ZodNumber;
+    omitted: z.ZodNumber;
+}, z.core.$strip>;
+export type ChatConsumerToolCallHistory = z.infer<typeof ChatConsumerToolCallHistorySchema>;
+/**
+ * Trim one message for the consumer wire: collapse `metadata.toolCalls` to the
+ * recent tail when it exceeds the tail policy, and record the omission in
+ * `metadata.toolCallHistory` so the cut is explicit, never silent. Messages
+ * that fit pass through untouched (same reference, zero behavior change).
+ */
+export declare function trimConsumerMessage(message: UnifiedChatMessage): UnifiedChatMessage;
+/**
+ * Project one message for the consumer wire: trim, then enforce the transport
+ * guard. A single projected message still over the result cap throws with its
+ * id instead of dying anonymously at the projection layer. Repair is
+ * `removeMessage`/`updateMessage` on the named id.
+ */
+export declare function projectConsumerMessage(message: UnifiedChatMessage): UnifiedChatMessage;
+/**
+ * Read the projection marker `projectConsumerMessage` leaves when it trims
+ * tool-call history. Null when the message carries its full history.
+ */
+export declare function readToolCallHistory(message: UnifiedChatMessage): ChatConsumerToolCallHistory | null;
+export declare const ChatConsumerMessagePageInputSchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    direction: z.ZodOptional<z.ZodEnum<{
+        before: "before";
+        after: "after";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    messageId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ChatConsumerMessagePageInput = z.infer<typeof ChatConsumerMessagePageInputSchema>;
+export declare const ChatConsumerMessagePageSchema: z.ZodObject<{
+    messages: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        roomId: z.ZodString;
+        senderType: z.ZodEnum<{
+            user: "user";
+            agent: "agent";
+            system: "system";
+        }>;
+        messageType: z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            text: "text";
+            image: "image";
+            image_url: "image_url";
+            video_url: "video_url";
+            tool_request: "tool_request";
+            tool_response: "tool_response";
+            knowledge_result: "knowledge_result";
+        }>>;
+        userId: z.ZodOptional<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodString>;
+        role: z.ZodEnum<{
+            user: "user";
+            system: "system";
+            assistant: "assistant";
+        }>;
+        content: z.ZodString;
+        attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            fileName: z.ZodString;
+            contentType: z.ZodString;
+            size: z.ZodNumber;
+            url: z.ZodString;
+            createdAt: z.ZodISODateTime;
+        }, z.core.$strip>>>;
+        status: z.ZodDefault<z.ZodEnum<{
+            cancelled: "cancelled";
+            failed: "failed";
+            queued: "queued";
+            streaming: "streaming";
+            sending: "sending";
+            sent: "sent";
+            pending: "pending";
+            declined: "declined";
+            processing: "processing";
+            completed: "completed";
+        }>>;
+        streaming: z.ZodOptional<z.ZodBoolean>;
+        cancelled: z.ZodOptional<z.ZodBoolean>;
+        replyToId: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodObject<{
+            segments: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"thinking">;
+                text: z.ZodString;
+                startedAt: z.ZodOptional<z.ZodISODateTime>;
+                durationMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"tool">;
+                toolCallId: z.ZodString;
+            }, z.core.$strip>], "kind">>>;
+            contentBlocks: z.ZodOptional<z.ZodObject<{
+                thinking: z.ZodDefault<z.ZodString>;
+                message: z.ZodDefault<z.ZodString>;
+            }, z.core.$strip>>;
+            toolCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                toolCallId: z.ZodString;
+                toolId: z.ZodString;
+                toolName: z.ZodString;
+                rewrittenFrom: z.ZodOptional<z.ZodObject<{
+                    toolId: z.ZodString;
+                    command: z.ZodString;
+                }, z.core.$strip>>;
+                input: z.ZodOptional<z.ZodUnknown>;
+                output: z.ZodOptional<z.ZodUnknown>;
+                error: z.ZodOptional<z.ZodString>;
+                status: z.ZodEnum<{
+                    denied: "denied";
+                    cancelled: "cancelled";
+                    failed: "failed";
+                    timeout: "timeout";
+                    pending: "pending";
+                    completed: "completed";
+                    awaiting_approval: "awaiting_approval";
+                    running: "running";
+                    interrupted: "interrupted";
+                }>;
+                startedAt: z.ZodISODateTime;
+                completedAt: z.ZodOptional<z.ZodISODateTime>;
+                durationMs: z.ZodOptional<z.ZodNumber>;
+                approval: z.ZodOptional<z.ZodObject<{
+                    required: z.ZodOptional<z.ZodBoolean>;
+                    requestId: z.ZodOptional<z.ZodString>;
+                    expiresAt: z.ZodOptional<z.ZodISODateTime>;
+                    respondedAt: z.ZodOptional<z.ZodISODateTime>;
+                    decision: z.ZodOptional<z.ZodEnum<{
+                        denied: "denied";
+                        timeout: "timeout";
+                        pending: "pending";
+                        approved: "approved";
+                    }>>;
+                    reason: z.ZodOptional<z.ZodString>;
+                    approverId: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                events: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    type: z.ZodString;
+                    toolCallId: z.ZodString;
+                    toolName: z.ZodString;
+                    status: z.ZodOptional<z.ZodString>;
+                    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    output: z.ZodOptional<z.ZodUnknown>;
+                    error: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        message: z.ZodOptional<z.ZodString>;
+                        code: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>]>>;
+                    approvalMode: z.ZodOptional<z.ZodString>;
+                    timestamp: z.ZodISODateTime;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>>;
+            reasoningSteps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                thought: z.ZodString;
+                action: z.ZodOptional<z.ZodString>;
+                observation: z.ZodOptional<z.ZodString>;
+                timestamp: z.ZodISODateTime;
+            }, z.core.$strip>>>;
+            messageParts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                messageId: z.ZodString;
+                sequence: z.ZodNumber;
+                content: z.ZodString;
+                timestamp: z.ZodISODateTime;
+                streaming: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>;
+            error: z.ZodOptional<z.ZodString>;
+            usage: z.ZodOptional<z.ZodObject<{
+                promptTokens: z.ZodOptional<z.ZodNumber>;
+                completionTokens: z.ZodOptional<z.ZodNumber>;
+                totalTokens: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            durationMs: z.ZodOptional<z.ZodNumber>;
+            generationId: z.ZodOptional<z.ZodString>;
+            agentName: z.ZodOptional<z.ZodString>;
+            agentAlias: z.ZodOptional<z.ZodString>;
+            generating: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$loose>>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodOptional<z.ZodISODateTime>;
+    }, z.core.$strip>>;
+    hasMore: z.ZodBoolean;
+}, z.core.$strip>;
+export type ChatConsumerMessagePage = z.infer<typeof ChatConsumerMessagePageSchema>;
+export declare const ChatConsumerMessageCreateSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    role: z.ZodEnum<{
+        user: "user";
+        system: "system";
+        assistant: "assistant";
+    }>;
+    content: z.ZodString;
+    senderType: z.ZodOptional<z.ZodEnum<{
+        user: "user";
+        agent: "agent";
+        system: "system";
+    }>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        cancelled: "cancelled";
+        failed: "failed";
+        queued: "queued";
+        streaming: "streaming";
+        sending: "sending";
+        sent: "sent";
+        pending: "pending";
+        declined: "declined";
+        processing: "processing";
+        completed: "completed";
+    }>>;
+    agentId: z.ZodOptional<z.ZodString>;
+    userId: z.ZodOptional<z.ZodString>;
+    replyToId: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type ChatConsumerMessageCreate = z.infer<typeof ChatConsumerMessageCreateSchema>;
+export declare const ChatConsumerMessagePatchSchema: z.ZodObject<{
+    content: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        cancelled: "cancelled";
+        failed: "failed";
+        queued: "queued";
+        streaming: "streaming";
+        sending: "sending";
+        sent: "sent";
+        pending: "pending";
+        declined: "declined";
+        processing: "processing";
+        completed: "completed";
+    }>>;
+    cancelled: z.ZodOptional<z.ZodBoolean>;
+    streaming: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type ChatConsumerMessagePatch = z.infer<typeof ChatConsumerMessagePatchSchema>;
+/**
+ * Cut one message page out of a room's chronological messages. Shared by the
+ * owner impl and test fakes so both enforce identical paging semantics:
+ * `messageId` fetches one message; otherwise the window fills from the cursor
+ * (tail by default) to the count limit AND the byte budget, whichever first.
+ * Every candidate is projected first, so the budget measures wire bytes.
+ */
+export declare function pageConsumerMessages(ordered: readonly UnifiedChatMessage[], input?: ChatConsumerMessagePageInput): ChatConsumerMessagePage;
+/**
+ * Tool-call page policy. Same shape as message paging (cursor over
+ * `toolCallId`, count limit AND the shared page byte budget): the full history
+ * a projection trimmed stays reachable in bounded pages.
+ */
+export declare const ChatConsumerToolCallPageInputSchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    direction: z.ZodOptional<z.ZodEnum<{
+        before: "before";
+        after: "after";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ChatConsumerToolCallPageInput = z.infer<typeof ChatConsumerToolCallPageInputSchema>;
+export declare const ChatConsumerToolCallPageSchema: z.ZodObject<{
+    toolCalls: z.ZodArray<z.ZodObject<{
+        toolCallId: z.ZodString;
+        toolId: z.ZodString;
+        toolName: z.ZodString;
+        rewrittenFrom: z.ZodOptional<z.ZodObject<{
+            toolId: z.ZodString;
+            command: z.ZodString;
+        }, z.core.$strip>>;
+        input: z.ZodOptional<z.ZodUnknown>;
+        output: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            denied: "denied";
+            cancelled: "cancelled";
+            failed: "failed";
+            timeout: "timeout";
+            pending: "pending";
+            completed: "completed";
+            awaiting_approval: "awaiting_approval";
+            running: "running";
+            interrupted: "interrupted";
+        }>;
+        startedAt: z.ZodISODateTime;
+        completedAt: z.ZodOptional<z.ZodISODateTime>;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        approval: z.ZodOptional<z.ZodObject<{
+            required: z.ZodOptional<z.ZodBoolean>;
+            requestId: z.ZodOptional<z.ZodString>;
+            expiresAt: z.ZodOptional<z.ZodISODateTime>;
+            respondedAt: z.ZodOptional<z.ZodISODateTime>;
+            decision: z.ZodOptional<z.ZodEnum<{
+                denied: "denied";
+                timeout: "timeout";
+                pending: "pending";
+                approved: "approved";
+            }>>;
+            reason: z.ZodOptional<z.ZodString>;
+            approverId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        events: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodString;
+            toolCallId: z.ZodString;
+            toolName: z.ZodString;
+            status: z.ZodOptional<z.ZodString>;
+            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            output: z.ZodOptional<z.ZodUnknown>;
+            error: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                message: z.ZodOptional<z.ZodString>;
+                code: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>]>>;
+            approvalMode: z.ZodOptional<z.ZodString>;
+            timestamp: z.ZodISODateTime;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    hasMore: z.ZodBoolean;
+}, z.core.$strip>;
+export type ChatConsumerToolCallPage = z.infer<typeof ChatConsumerToolCallPageSchema>;
+/**
+ * Cut one tool-call page out of a message's chronological tool history.
+ * Mirrors `pageConsumerMessages`: tail by default, count limit AND byte
+ * budget, progress guaranteed (one over-budget call still returns alone).
+ */
+export declare function pageConsumerToolCalls(ordered: readonly ToolCallRecord[], input?: ChatConsumerToolCallPageInput): ChatConsumerToolCallPage;
+export declare const ChatConsumerRunPollSchema: z.ZodObject<{
+    runId: z.ZodString;
+    cursor: z.ZodNumber;
+    events: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+    }, z.core.$loose>>;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        failed: "failed";
+        completed: "completed";
+        running: "running";
+        "awaiting-approval": "awaiting-approval";
+    }>;
+    approval: z.ZodNullable<z.ZodObject<{
+        requestId: z.ZodString;
+        toolId: z.ZodString;
+        toolName: z.ZodString;
+        args: z.ZodRecord<z.ZodString, z.ZodType<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue>>>;
+        toolCallId: z.ZodOptional<z.ZodString>;
+        commandPrefixes: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>;
+    result: z.ZodNullable<z.ZodObject<{
+        status: z.ZodOptional<z.ZodEnum<{
+            cancelled: "cancelled";
+            failed: "failed";
+            completed: "completed";
+            "dispatch-failed": "dispatch-failed";
+            "waiting-for-user": "waiting-for-user";
+        }>>;
+        attention: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                message: "message";
+                approval: "approval";
+            }>;
+            requestId: z.ZodOptional<z.ZodString>;
+            summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        userMessageId: z.ZodString;
+        assistantMessageId: z.ZodString;
+        content: z.ZodString;
+        toolCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            toolCallId: z.ZodString;
+            toolId: z.ZodString;
+            toolName: z.ZodString;
+            rewrittenFrom: z.ZodOptional<z.ZodObject<{
+                toolId: z.ZodString;
+                command: z.ZodString;
+            }, z.core.$strip>>;
+            input: z.ZodOptional<z.ZodUnknown>;
+            output: z.ZodOptional<z.ZodUnknown>;
+            error: z.ZodOptional<z.ZodString>;
+            status: z.ZodEnum<{
+                denied: "denied";
+                cancelled: "cancelled";
+                failed: "failed";
+                timeout: "timeout";
+                pending: "pending";
+                completed: "completed";
+                awaiting_approval: "awaiting_approval";
+                running: "running";
+                interrupted: "interrupted";
+            }>;
+            startedAt: z.ZodISODateTime;
+            completedAt: z.ZodOptional<z.ZodISODateTime>;
+            durationMs: z.ZodOptional<z.ZodNumber>;
+            approval: z.ZodOptional<z.ZodObject<{
+                required: z.ZodOptional<z.ZodBoolean>;
+                requestId: z.ZodOptional<z.ZodString>;
+                expiresAt: z.ZodOptional<z.ZodISODateTime>;
+                respondedAt: z.ZodOptional<z.ZodISODateTime>;
+                decision: z.ZodOptional<z.ZodEnum<{
+                    denied: "denied";
+                    timeout: "timeout";
+                    pending: "pending";
+                    approved: "approved";
+                }>>;
+                reason: z.ZodOptional<z.ZodString>;
+                approverId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            events: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodString;
+                toolCallId: z.ZodString;
+                toolName: z.ZodString;
+                status: z.ZodOptional<z.ZodString>;
+                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                output: z.ZodOptional<z.ZodUnknown>;
+                error: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    message: z.ZodOptional<z.ZodString>;
+                    code: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>]>>;
+                approvalMode: z.ZodOptional<z.ZodString>;
+                timestamp: z.ZodISODateTime;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+        reasoningSteps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            thought: z.ZodString;
+            action: z.ZodOptional<z.ZodString>;
+            observation: z.ZodOptional<z.ZodString>;
+            timestamp: z.ZodISODateTime;
+        }, z.core.$strip>>>;
+        usage: z.ZodOptional<z.ZodObject<{
+            promptTokens: z.ZodOptional<z.ZodNumber>;
+            completionTokens: z.ZodOptional<z.ZodNumber>;
+            totalTokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        durationMs: z.ZodNumber;
+        modelId: z.ZodOptional<z.ZodString>;
+        cancellationFailure: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            code: z.ZodOptional<z.ZodString>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$loose>>;
+    error: z.ZodNullable<z.ZodString>;
+    room: z.ZodObject<{
+        type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        id: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodOptional<z.ZodISODateTime>;
+        visibility: z.ZodOptional<z.ZodEnum<{
+            public: "public";
+            private: "private";
+            project: "project";
+        }>>;
+        agents: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            agentId: z.ZodString;
+            alias: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$loose>>>;
+        users: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            userId: z.ZodOptional<z.ZodString>;
+            id: z.ZodOptional<z.ZodString>;
+            role: z.ZodOptional<z.ZodEnum<{
+                owner: "owner";
+                member: "member";
+                applicant: "applicant";
+                admin: "admin";
+                moderator: "moderator";
+                guest: "guest";
+                banned: "banned";
+            }>>;
+        }, z.core.$loose>>>;
+        lastMessageAt: z.ZodISODateTime;
+        unreadCount: z.ZodOptional<z.ZodNumber>;
+        modeId: z.ZodOptional<z.ZodString>;
+        roomMode: z.ZodDefault<z.ZodEnum<{
+            standard: "standard";
+            multi: "multi";
+        }>>;
+        inputHistory: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        draft: z.ZodOptional<z.ZodString>;
+        participants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodEnum<{
+                agent: "agent";
+                friend: "friend";
+            }>;
+            name: z.ZodDefault<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            modelHint: z.ZodOptional<z.ZodString>;
+            responseStyle: z.ZodDefault<z.ZodEnum<{
+                never: "never";
+                always: "always";
+                auto: "auto";
+                reply: "reply";
+            }>>;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            order: z.ZodOptional<z.ZodNumber>;
+            source: z.ZodOptional<z.ZodEnum<{
+                config: "config";
+                runtime: "runtime";
+                pairing: "pairing";
+                history: "history";
+            }>>;
+        }, z.core.$strip>>>;
+        cloudSyncEnabled: z.ZodOptional<z.ZodBoolean>;
+        lastMessage: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    messages: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        roomId: z.ZodString;
+        senderType: z.ZodEnum<{
+            user: "user";
+            agent: "agent";
+            system: "system";
+        }>;
+        messageType: z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            text: "text";
+            image: "image";
+            image_url: "image_url";
+            video_url: "video_url";
+            tool_request: "tool_request";
+            tool_response: "tool_response";
+            knowledge_result: "knowledge_result";
+        }>>;
+        userId: z.ZodOptional<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodString>;
+        role: z.ZodEnum<{
+            user: "user";
+            system: "system";
+            assistant: "assistant";
+        }>;
+        content: z.ZodString;
+        attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            fileName: z.ZodString;
+            contentType: z.ZodString;
+            size: z.ZodNumber;
+            url: z.ZodString;
+            createdAt: z.ZodISODateTime;
+        }, z.core.$strip>>>;
+        status: z.ZodDefault<z.ZodEnum<{
+            cancelled: "cancelled";
+            failed: "failed";
+            queued: "queued";
+            streaming: "streaming";
+            sending: "sending";
+            sent: "sent";
+            pending: "pending";
+            declined: "declined";
+            processing: "processing";
+            completed: "completed";
+        }>>;
+        streaming: z.ZodOptional<z.ZodBoolean>;
+        cancelled: z.ZodOptional<z.ZodBoolean>;
+        replyToId: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodObject<{
+            segments: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"thinking">;
+                text: z.ZodString;
+                startedAt: z.ZodOptional<z.ZodISODateTime>;
+                durationMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"tool">;
+                toolCallId: z.ZodString;
+            }, z.core.$strip>], "kind">>>;
+            contentBlocks: z.ZodOptional<z.ZodObject<{
+                thinking: z.ZodDefault<z.ZodString>;
+                message: z.ZodDefault<z.ZodString>;
+            }, z.core.$strip>>;
+            toolCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                toolCallId: z.ZodString;
+                toolId: z.ZodString;
+                toolName: z.ZodString;
+                rewrittenFrom: z.ZodOptional<z.ZodObject<{
+                    toolId: z.ZodString;
+                    command: z.ZodString;
+                }, z.core.$strip>>;
+                input: z.ZodOptional<z.ZodUnknown>;
+                output: z.ZodOptional<z.ZodUnknown>;
+                error: z.ZodOptional<z.ZodString>;
+                status: z.ZodEnum<{
+                    denied: "denied";
+                    cancelled: "cancelled";
+                    failed: "failed";
+                    timeout: "timeout";
+                    pending: "pending";
+                    completed: "completed";
+                    awaiting_approval: "awaiting_approval";
+                    running: "running";
+                    interrupted: "interrupted";
+                }>;
+                startedAt: z.ZodISODateTime;
+                completedAt: z.ZodOptional<z.ZodISODateTime>;
+                durationMs: z.ZodOptional<z.ZodNumber>;
+                approval: z.ZodOptional<z.ZodObject<{
+                    required: z.ZodOptional<z.ZodBoolean>;
+                    requestId: z.ZodOptional<z.ZodString>;
+                    expiresAt: z.ZodOptional<z.ZodISODateTime>;
+                    respondedAt: z.ZodOptional<z.ZodISODateTime>;
+                    decision: z.ZodOptional<z.ZodEnum<{
+                        denied: "denied";
+                        timeout: "timeout";
+                        pending: "pending";
+                        approved: "approved";
+                    }>>;
+                    reason: z.ZodOptional<z.ZodString>;
+                    approverId: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                events: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    type: z.ZodString;
+                    toolCallId: z.ZodString;
+                    toolName: z.ZodString;
+                    status: z.ZodOptional<z.ZodString>;
+                    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    output: z.ZodOptional<z.ZodUnknown>;
+                    error: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        message: z.ZodOptional<z.ZodString>;
+                        code: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>]>>;
+                    approvalMode: z.ZodOptional<z.ZodString>;
+                    timestamp: z.ZodISODateTime;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>>;
+            reasoningSteps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                thought: z.ZodString;
+                action: z.ZodOptional<z.ZodString>;
+                observation: z.ZodOptional<z.ZodString>;
+                timestamp: z.ZodISODateTime;
+            }, z.core.$strip>>>;
+            messageParts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                messageId: z.ZodString;
+                sequence: z.ZodNumber;
+                content: z.ZodString;
+                timestamp: z.ZodISODateTime;
+                streaming: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>;
+            error: z.ZodOptional<z.ZodString>;
+            usage: z.ZodOptional<z.ZodObject<{
+                promptTokens: z.ZodOptional<z.ZodNumber>;
+                completionTokens: z.ZodOptional<z.ZodNumber>;
+                totalTokens: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            durationMs: z.ZodOptional<z.ZodNumber>;
+            generationId: z.ZodOptional<z.ZodString>;
+            agentName: z.ZodOptional<z.ZodString>;
+            agentAlias: z.ZodOptional<z.ZodString>;
+            generating: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$loose>>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodOptional<z.ZodISODateTime>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ChatConsumerRunPoll = z.infer<typeof ChatConsumerRunPollSchema>;
+/**
+ * Session id stamped on run-command artifacts for unbound execution (no code
+ * session). Must match the `sessionId` the run-command tool uses on that path:
+ * the consumer impl routes it to the `runtime/execution` lane instead of a
+ * code session. Tool outputs carrying this sessionId + a procId are stoppable
+ * through the same verbs as session-bound background processes.
+ */
+export declare const CONSUMER_UNBOUND_EXECUTION_SESSION_ID = "runtime/execution";
+/** One background process, as shown in tool cards and the processes panel. */
+export declare const ChatBackgroundProcessSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    procId: z.ZodString;
+    command: z.ZodArray<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    running: z.ZodNullable<z.ZodBoolean>;
+    startedAt: z.ZodString;
+    pid: z.ZodOptional<z.ZodNumber>;
+    exitCode: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+export type ChatBackgroundProcess = z.infer<typeof ChatBackgroundProcessSchema>;
+/** A room's background process, linked to the tool call that launched it. */
+export declare const ChatRoomBackgroundProcessSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    procId: z.ZodString;
+    command: z.ZodArray<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    running: z.ZodNullable<z.ZodBoolean>;
+    startedAt: z.ZodString;
+    pid: z.ZodOptional<z.ZodNumber>;
+    exitCode: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    messageId: z.ZodOptional<z.ZodString>;
+    toolCallId: z.ZodOptional<z.ZodString>;
+    toolName: z.ZodOptional<z.ZodString>;
+    stale: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ChatRoomBackgroundProcess = z.infer<typeof ChatRoomBackgroundProcessSchema>;
+export declare const ChatRoomBackgroundProcessesSchema: z.ZodObject<{
+    processes: z.ZodArray<z.ZodObject<{
+        sessionId: z.ZodString;
+        procId: z.ZodString;
+        command: z.ZodArray<z.ZodString>;
+        cwd: z.ZodOptional<z.ZodString>;
+        running: z.ZodNullable<z.ZodBoolean>;
+        startedAt: z.ZodString;
+        pid: z.ZodOptional<z.ZodNumber>;
+        exitCode: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        messageId: z.ZodOptional<z.ZodString>;
+        toolCallId: z.ZodOptional<z.ZodString>;
+        toolName: z.ZodOptional<z.ZodString>;
+        stale: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    errors: z.ZodArray<z.ZodObject<{
+        sessionId: z.ZodString;
+        error: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ChatRoomBackgroundProcesses = z.infer<typeof ChatRoomBackgroundProcessesSchema>;
+export interface ChatConsumerSessionCapability {
+    /** Room summaries for every room plus the active id. Message content pages in via `listMessages`. */
+    snapshot(): Promise<ChatConsumerSnapshot>;
+    /** One bounded page of a room's messages (count limit AND byte budget; `hasMore` for paging). */
+    listMessages(roomId: string, page?: ChatConsumerMessagePageInput): Promise<ChatConsumerMessagePage>;
+    /** One bounded page of a message's full tool-call history (the projection keeps only the tail). */
+    listMessageToolCalls(roomId: string, messageId: string, page?: ChatConsumerToolCallPageInput): Promise<ChatConsumerToolCallPage>;
+    createMessage(roomId: string, input: ChatConsumerMessageCreate): Promise<UnifiedChatMessage>;
+    updateMessage(roomId: string, id: string, patch: ChatConsumerMessagePatch): Promise<UnifiedChatMessage | null>;
+    removeMessage(roomId: string, id: string): Promise<boolean>;
+    clearMessages(roomId: string): Promise<ChatConsumerRoomSummary>;
+    getComposerOptions(): Promise<ChatComposerOptions>;
+    createRoom(input?: ChatRoomCreateInput): Promise<ChatConsumerRoomSummary>;
+    createOrGetRoom(input: ChatRoomCreateInput & {
+        id: string;
+    }): Promise<{
+        room: ChatConsumerRoomSummary;
+        created: boolean;
+    }>;
+    readTurnReceipt(roomId: string, messageId: string): Promise<ChatTurnReceipt | null>;
+    removeRoom(roomId: string): Promise<boolean>;
+    forkRoom(roomId: string, upToMessageId?: string): Promise<ChatConsumerRoomSummary>;
+    /** Sets the active room pointer. Returns only the pointer — room data flows through `snapshot`. */
+    setActiveRoom(roomId: string | null): Promise<ChatConsumerActiveRoom>;
+    saveRoom(roomId: string, patch: Partial<UnifiedChatRoom>): Promise<ChatConsumerRoomSummary>;
+    updateRoomSettings(roomId: string, patch: ChatRoomSettingsPatch): Promise<ChatConsumerRoomSummary>;
+    clearRoom(roomId: string): Promise<ChatConsumerRoomSummary>;
+    listFolders(): Promise<ChatFolderListResult>;
+    createFolder(input: ChatFolderCreateInput): Promise<ChatFolder>;
+    updateFolder(id: string, input: ChatFolderUpdateInput): Promise<ChatFolder>;
+    removeFolder(id: string): Promise<void>;
+    moveRooms(input: ChatFolderBatchMoveInput): Promise<void>;
+    moveRoom(input: ChatFolderMoveInput): Promise<void>;
+    searchMessages(input: Omit<Parameters<import('./schemas/contracts.ts').ChatSearchCollection['messages']>[0], 'signal'>): Promise<ChatMessageSearchRoomResult[]>;
+    beginRun(roomId: string, input: Omit<ChatRunInput, 'signal'>): Promise<{
+        runId: string;
+    }>;
+    pollRun(runId: string, cursor: number): Promise<ChatConsumerRunPoll>;
+    decideApproval(runId: string, requestId: string, decision: ChatApprovalDecision): Promise<boolean>;
+    cancelRun(runId: string): Promise<boolean>;
+    /** Background processes spawned in one session (code session or unbound execution). */
+    listBackgroundProcesses(sessionId: string): Promise<ChatBackgroundProcess[]>;
+    /**
+     * Stop one background process. False only when the procId is unknown —
+     * session-owned procs stay known after exit (true), while unbound procs
+     * are reaped on exit (a second stop reports false).
+     */
+    stopBackgroundProcess(sessionId: string, procId: string, signal?: string): Promise<boolean>;
+    /**
+     * Every background process behind one room: session-reported status merged
+     * with transcript linkage. Transcript-known procs no live session tracks
+     * return as `stale` (e.g. the host restarted and dropped its handles).
+     */
+    listRoomBackgroundProcesses(roomId: string): Promise<ChatRoomBackgroundProcesses>;
+}
+export declare const chatConsumerSessionKind: import("@vibesdotdev/kernel").RuntimeKindDescriptorRecord<ChatConsumerSessionCapability>;
+export declare const chatConsumerSessionDescriptor: RuntimeDescriptor;
+export declare const chatConsumerSessionExposure: {
+    protocolVersion: 1;
+    discoverable: boolean;
+    audiences: ("service" | "operator" | "consumer-renderer" | "consumer-cli" | "consumer-agent")[];
+    methods: Record<string, {
+        request: {
+            id: string;
+            version: number;
+            schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        };
+        result: {
+            id: string;
+            version: number;
+            schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        };
+        dataClassification: "user" | "secret" | "public" | "sensitive";
+        rendererView: "denied" | "raw" | "redacted";
+        retry: {
+            mode: "read";
+            retry: "safe";
+        } | {
+            mode: "idempotent";
+            operationIdRequired: true;
+            reconciliationMethod: string;
+        } | {
+            mode: "non-idempotent";
+            retry: "never";
+        };
+        cancellation: {
+            mode: "required" | "none" | "cooperative";
+            defaultDeadlineMs: number;
+            maxDeadlineMs: number;
+        };
+        maxRequestBytes: number;
+        maxResultBytes: number;
+        projectRenderer?: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
+        stream?: {
+            event: {
+                id: string;
+                version: number;
+                schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            };
+            maxEventBytes: number;
+            initialCredits: number;
+            maxCredits: number;
+            projectRenderer?: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
+        } | undefined;
+    }>;
+};
+//# sourceMappingURL=consumer-session-capability.d.ts.map