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

package/dist/svelte/stores/chatRoomStore.svelte.d.ts

@@ -0,0 +1,214 @@
+import type { ChatSurfaceClient } from '../surface-client.svelte.ts';
+import { SvelteMap } from 'svelte/reactivity';
+import type { ChatRoomSurfaceMode } from '@vibesdotdev/chat/schemas/common';
+import type { RepositoryOption } from '@vibesdotdev/platform/svelte/runtime';
+type PendingBuildTargetKind = 'cloud' | 'host';
+type PendingBuildRepository = Pick<RepositoryOption, 'id' | 'name' | 'defaultBranch' | 'provider' | 'cloneUrl' | 'externalId'>;
+/**
+ * Store for managing the active conversation state.
+ * Per R-STORES-001, this store is state-only. All logic is in ChatRoomService.
+ */
+export declare class ChatRoomStore {
+    private readonly stores;
+    constructor(stores: ChatSurfaceClient);
+    roomId: string | null;
+    room: {
+        id: string;
+        ownerId: string;
+        slug: string;
+        type: "agent" | "system" | "direct" | "public" | "private" | "group" | "archived" | "feed";
+        visibility: "public" | "private" | "project";
+        title: string;
+        titleLocked: boolean;
+        projectId?: string | null | undefined;
+        titleGeneratedAt?: string | null | undefined;
+        description?: string | null | undefined;
+        icon?: string | null | undefined;
+        color?: string | null | undefined;
+        archivedAt?: string | null | undefined;
+        archivedBy?: string | null | undefined;
+        archivedReason?: string | null | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        createdAt?: string | undefined;
+        updatedAt?: string | undefined;
+    } | null;
+    roomMode: "standard" | "multi";
+    pendingRoomMode: "standard" | "multi";
+    pendingModeId: string | null;
+    pendingVisibility: "public" | "private" | "project";
+    pendingFolderId: string | null;
+    pendingModelId: string | null;
+    pendingMaxTokens: number | null;
+    pendingCompaction: {
+        enabled: boolean;
+        triggerThreshold: number;
+        modelId: string | null;
+        promptId: string | null;
+    } | null;
+    pendingWorkspaceId: string | null;
+    pendingWorkspaceLabel: string | null;
+    pendingWorkspaceLocation: "local" | "cloud" | null;
+    pendingCodeSessionId: string | null;
+    pendingCodeSessionHostKind: "cloud" | "host" | null;
+    isLoading: boolean;
+    loadError: string | null;
+    pendingBuildRepository: PendingBuildRepository | null;
+    pendingBuildRepositoryId: string | undefined;
+    pendingBuildCheckoutRef: string;
+    pendingBuildTargetKind: PendingBuildTargetKind;
+    pendingBuildHostId: string | undefined;
+    pendingBuildEnvironmentName: string;
+    pendingBuildNodeVersion: string;
+    pendingBuildBunVersion: string;
+    pendingBuildSetupScriptRaw: string;
+    pendingBuildExposedPortsRaw: string;
+    pendingBuildEnvRaw: string;
+    pendingBuildEphemeral: boolean;
+    optimisticSends: {
+        optimisticId: string;
+        content: string;
+        status: "sending" | "sent" | "failed";
+        realMessageId?: string;
+        error?: string;
+        timestamp: number;
+        agentIds: string[];
+    }[];
+    attachedContext: {
+        id: string;
+        type: string;
+        title?: string;
+    }[];
+    pendingUsers: string[];
+    pendingAgents: SvelteMap<string, {
+        responseMode: "always" | "tagged" | "auto";
+        alias: string;
+    }>;
+    pendingPrompts: {
+        id?: string;
+        title?: string;
+        content: string;
+    }[];
+    pendingMedia: SvelteMap<string, {
+        type: "image_url" | "video_url";
+        url: string;
+        title?: string;
+    }>;
+    pendingAttachments: {
+        id: string;
+        name: string;
+        type: string;
+        size: number;
+        url: string;
+        status: "uploading" | "ready" | "failed";
+        source?: "chat-upload" | "platform-storage" | "inline";
+        ref?: string;
+        error?: string;
+    }[];
+    replyToMessageId: string | null;
+    editingMessageId: string | null;
+    selectedMessageId: string | null;
+    get replyingToMessage(): {
+        id: string;
+        chatRoomId: string;
+        status: "failed" | "queued" | "streaming" | "sending" | "sent" | "pending" | "declined" | "processing" | "completed";
+        messageType: "error" | "text" | "image" | "image_url" | "video_url" | "tool_request" | "tool_response" | "knowledge_result";
+        senderType: "user" | "agent" | "system";
+        userId?: string | undefined;
+        agentId?: string | undefined;
+        replyToId?: string | undefined;
+        content?: string | undefined;
+        attachments?: {
+            id: string;
+            fileName: string;
+            contentType: string;
+            size: number;
+            url: string;
+            createdAt: string;
+        }[] | undefined;
+        metadata?: {
+            [x: string]: unknown;
+            contentBlocks?: {
+                thinking: string;
+                message: string;
+            } | undefined;
+            segments?: ({
+                kind: "text";
+                text: string;
+            } | {
+                kind: "thinking";
+                text: string;
+                startedAt?: string | undefined;
+                durationMs?: number | undefined;
+            } | {
+                kind: "tool";
+                toolCallId: string;
+            })[] | undefined;
+            toolCalls?: {
+                [x: string]: unknown;
+                toolId: string;
+                toolName: string;
+                input: unknown;
+                timestamp: string;
+                output?: unknown;
+                error?: string | undefined;
+                status?: "denied" | "cancelled" | "failed" | "pending" | "completed" | "awaiting_approval" | "running" | "interrupted" | undefined;
+                toolCallId?: string | undefined;
+                approval?: {
+                    [x: string]: unknown;
+                    required?: boolean | undefined;
+                    requestId?: string | undefined;
+                    expiresAt?: string | undefined;
+                    respondedAt?: string | undefined;
+                    decision?: "denied" | "timeout" | "pending" | "approved" | undefined;
+                    reason?: string | undefined;
+                    approverId?: string | undefined;
+                } | undefined;
+            }[] | undefined;
+            reasoningSteps?: {
+                thought: string;
+                timestamp: string;
+                action?: string | undefined;
+                observation?: string | undefined;
+            }[] | undefined;
+            error?: string | undefined;
+        } | undefined;
+        createdAt?: string | undefined;
+        updatedAt?: string | undefined;
+    } | null;
+    get isReady(): boolean;
+    get canType(): boolean;
+    get effectiveRoomMode(): ChatRoomSurfaceMode;
+    get effectiveWorkspaceId(): string | null;
+    get isMultiMode(): boolean;
+    get pendingAgentsArray(): {
+        agentId: string;
+        responseMode: "always" | "tagged" | "auto";
+        alias: string;
+    }[];
+    get pendingBuildRepositoryName(): string | null;
+    resetPendingBuildConfig(): void;
+}
+export declare const chatRoomStore: ChatRoomStore;
+/**
+ * Store for managing real-time SSE connection state.
+ *
+ * `typingUsers` is populated from the `chat.typing` SSE channel and
+ * read by `RuntimeChatMessages` to render the typing indicator strip.
+ * `onlineUsers` is populated from the `chat.presence` channel and read by
+ * the participant sidebar to render each member's online/away/offline dot.
+ * Both are replaced wholesale (new Set/Map) by the stream-event handler so
+ * $state reactivity fires; the stream wiring owns the auth-oritative state
+ * (typing auto-expiry, presence offline) and pushes the full snapshot.
+ */
+export declare class ChatRealtimeStore {
+    currentRoomId: string | null;
+    connectionStatus: "error" | "connected" | "disconnected" | "connecting" | "reconnecting";
+    lastError: string | null;
+    typingUsers: Set<string>;
+    onlineUsers: Map<string, {
+        lastActivity: number;
+    }>;
+}
+export declare const chatRealtimeStore: ChatRealtimeStore;
+export {};
+//# sourceMappingURL=chatRoomStore.svelte.d.ts.map

package/dist/svelte/stores/chatRoomStore.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chatRoomStore.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/stores/chatRoomStore.svelte.ts"],"names":[],"mappings":"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"}

package/dist/svelte/stores/chatRoomStore.svelte.js

@@ -0,0 +1,130 @@
+import { contextualChatStore } from "../surface-context.js";
+import * as z from 'zod/v4';
+import { SvelteMap } from 'svelte/reactivity';
+/**
+ * Store for managing the active conversation state.
+ * Per R-STORES-001, this store is state-only. All logic is in ChatRoomService.
+ */
+export class ChatRoomStore {
+    stores;
+    constructor(stores) {
+        this.stores = stores;
+    }
+    // Core room state
+    roomId = $state(null);
+    room = $state(null);
+    roomMode = $state('standard');
+    pendingRoomMode = $state('standard');
+    pendingModeId = $state('chat');
+    pendingVisibility = $state('private');
+    pendingFolderId = $state(null);
+    pendingModelId = $state(null);
+    pendingMaxTokens = $state(null);
+    pendingCompaction = $state(null);
+    pendingWorkspaceId = $state(null);
+    pendingWorkspaceLabel = $state(null);
+    pendingWorkspaceLocation = $state(null);
+    pendingCodeSessionId = $state(null);
+    pendingCodeSessionHostKind = $state(null);
+    isLoading = $state(false);
+    loadError = $state(null);
+    // Draft Code-mode configuration, used before a room exists and mirrored by
+    // the build session panel once a room is opened.
+    pendingBuildRepository = $state(null);
+    pendingBuildRepositoryId = $state(undefined);
+    pendingBuildCheckoutRef = $state('');
+    pendingBuildTargetKind = $state('cloud');
+    pendingBuildHostId = $state(undefined);
+    pendingBuildEnvironmentName = $state('Development');
+    pendingBuildNodeVersion = $state('');
+    pendingBuildBunVersion = $state('');
+    pendingBuildSetupScriptRaw = $state('');
+    pendingBuildExposedPortsRaw = $state('5173');
+    pendingBuildEnvRaw = $state('');
+    pendingBuildEphemeral = $state(false);
+    // Optimistic messages (synced from optimisticMessageManager by chat-room-service)
+    optimisticSends = $state([]);
+    // Staged items for the next message
+    attachedContext = $state([]);
+    pendingUsers = $state([]);
+    pendingAgents = $state(new SvelteMap());
+    pendingPrompts = $state([]);
+    pendingMedia = $state(new SvelteMap());
+    pendingAttachments = $state([]);
+    // UI interaction state
+    replyToMessageId = $state(null);
+    editingMessageId = $state(null);
+    selectedMessageId = $state(null);
+    get replyingToMessage() {
+        if (!this.replyToMessageId)
+            return null;
+        return this.stores.chatMessagesStore.data.get(this.replyToMessageId) ?? null;
+    }
+    get isReady() {
+        return !!this.roomId && !!this.room;
+    }
+    get canType() {
+        return !this.roomId || this.isReady;
+    }
+    get effectiveRoomMode() {
+        const mode = this.room?.metadata?.roomMode;
+        if (mode === 'multi' || mode === 'standard')
+            return mode;
+        if (!this.roomId)
+            return this.pendingRoomMode;
+        return this.roomMode;
+    }
+    get effectiveWorkspaceId() {
+        if (!this.roomId)
+            return this.pendingWorkspaceId;
+        const parsed = z.string().trim().min(1).safeParse(this.room?.metadata?.workspaceId);
+        return parsed.success ? parsed.data : null;
+    }
+    get isMultiMode() {
+        return this.effectiveRoomMode === 'multi';
+    }
+    get pendingAgentsArray() {
+        return Array.from(this.pendingAgents.entries()).map(([agentId, v]) => ({
+            agentId,
+            responseMode: v.responseMode,
+            alias: v.alias
+        }));
+    }
+    get pendingBuildRepositoryName() {
+        return this.pendingBuildRepository?.name ?? null;
+    }
+    resetPendingBuildConfig() {
+        this.pendingBuildRepository = null;
+        this.pendingBuildRepositoryId = undefined;
+        this.pendingBuildCheckoutRef = '';
+        this.pendingBuildTargetKind = 'cloud';
+        this.pendingBuildHostId = undefined;
+        this.pendingBuildEnvironmentName = 'Development';
+        this.pendingBuildNodeVersion = '';
+        this.pendingBuildBunVersion = '';
+        this.pendingBuildSetupScriptRaw = '';
+        this.pendingBuildExposedPortsRaw = '5173';
+        this.pendingBuildEnvRaw = '';
+        this.pendingBuildEphemeral = false;
+    }
+}
+export const chatRoomStore = contextualChatStore('chatRoomStore');
+/**
+ * Store for managing real-time SSE connection state.
+ *
+ * `typingUsers` is populated from the `chat.typing` SSE channel and
+ * read by `RuntimeChatMessages` to render the typing indicator strip.
+ * `onlineUsers` is populated from the `chat.presence` channel and read by
+ * the participant sidebar to render each member's online/away/offline dot.
+ * Both are replaced wholesale (new Set/Map) by the stream-event handler so
+ * $state reactivity fires; the stream wiring owns the auth-oritative state
+ * (typing auto-expiry, presence offline) and pushes the full snapshot.
+ */
+export class ChatRealtimeStore {
+    currentRoomId = $state(null);
+    connectionStatus = $state('disconnected');
+    lastError = $state(null);
+    typingUsers = $state(new Set());
+    onlineUsers = $state(new Map());
+}
+export const chatRealtimeStore = contextualChatStore('chatRealtimeStore');

package/dist/svelte/stores/chatRouteStore.svelte.d.ts

@@ -0,0 +1,36 @@
+import type { ChatSurfaceClient } from '../surface-client.svelte.ts';
+import type { ChatRoomParticipant, UnifiedChatMessage, UnifiedChatRoom } from '@vibesdotdev/chat';
+export interface ChatRouteUser {
+    id: string;
+    email?: string | null;
+    name?: string | null;
+    displayName?: string | null;
+    image?: string | null;
+    avatarUrl?: string | null;
+    role?: 'owner' | 'admin' | 'member' | 'viewer' | 'guest' | 'banned';
+}
+export interface ChatRouteInitialData {
+    roomId?: string | null;
+    room?: UnifiedChatRoom | null;
+    messages?: UnifiedChatMessage[];
+    participants?: ChatRoomParticipant[];
+    currentUser?: ChatRouteUser | null;
+}
+export interface OpenChatRouteOptions extends ChatRouteInitialData {
+    mode?: 'new' | 'room';
+}
+export declare class ChatRouteStore {
+    private readonly stores;
+    constructor(stores: ChatSurfaceClient);
+    mode: "room" | "new";
+    routeRoomId: string | null;
+    loading: boolean;
+    ready: boolean;
+    error: string | null;
+    hydrate(data?: ChatRouteInitialData): void;
+    setCurrentUser(user: ChatRouteUser): void;
+    open(options?: OpenChatRouteOptions): Promise<void>;
+    close(): Promise<void>;
+}
+export declare const chatRouteStore: ChatRouteStore;
+//# sourceMappingURL=chatRouteStore.svelte.d.ts.map

package/dist/svelte/stores/chatRouteStore.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chatRouteStore.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/stores/chatRouteStore.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAErE,OAAO,KAAK,EACX,mBAAmB,EACnB,kBAAkB,EAClB,eAAe,EACf,MAAM,mBAAmB,CAAC;AAE3B,MAAM,WAAW,aAAa;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,IAAI,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAC;CACpE;AASD,MAAM,WAAW,oBAAoB;IACpC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,IAAI,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,EAAE,kBAAkB,EAAE,CAAC;IAChC,YAAY,CAAC,EAAE,mBAAmB,EAAE,CAAC;IACrC,WAAW,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;CACnC;AAED,MAAM,WAAW,oBAAqB,SAAQ,oBAAoB;IACjE,IAAI,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;CACtB;AAED,qBAAa,cAAc;IACd,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,iBAAiB;IAEtD,IAAI,iBAAiC;IACrC,WAAW,gBAA+B;IAC1C,OAAO,UAAiB;IACxB,KAAK,UAAiB;IACtB,KAAK,gBAA+B;IAEpC,OAAO,CAAC,IAAI,GAAE,oBAAyB,GAAG,IAAI;IAgB9C,cAAc,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI;IAcnC,IAAI,CAAC,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBvD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAM5B;AAED,eAAO,MAAM,cAAc,gBAAwC,CAAC"}

package/dist/svelte/stores/chatRouteStore.svelte.js

@@ -0,0 +1,75 @@
+import { contextualChatStore } from "../surface-context.js";
+function normalizeParticipantRole(role) {
+    if (role === 'viewer')
+        return 'guest';
+    return role ?? 'owner';
+}
+export class ChatRouteStore {
+    stores;
+    constructor(stores) {
+        this.stores = stores;
+    }
+    mode = $state('new');
+    routeRoomId = $state(null);
+    loading = $state(false);
+    ready = $state(false);
+    error = $state(null);
+    hydrate(data = {}) {
+        if (data.currentUser)
+            this.setCurrentUser(data.currentUser);
+        if (data.roomId !== undefined)
+            this.routeRoomId = data.roomId;
+        if (data.room) {
+            this.stores.sync.syncRoom(data.room, this.stores.chatParticipantsStore.currentUserId);
+        }
+        else if (data.roomId === null) {
+            this.stores.sync.clearActiveRoomState();
+        }
+        if (data.messages && data.roomId) {
+            this.stores.sync.syncMessages(data.roomId, data.messages);
+        }
+        if (data.participants && data.roomId) {
+            this.stores.sync.syncParticipants(data.roomId, data.participants);
+        }
+    }
+    setCurrentUser(user) {
+        this.stores.chatParticipantsStore.currentUserId = user.id;
+        if (this.stores.chatParticipantsStore.users.has(user.id))
+            return;
+        const email = user.email ?? null;
+        const displayName = user.displayName ?? user.name ?? email ?? 'You';
+        this.stores.chatParticipantsStore.users.set(user.id, {
+            id: user.id,
+            email,
+            displayName,
+            avatarUrl: user.avatarUrl ?? user.image ?? null,
+            role: normalizeParticipantRole(user.role)
+        });
+    }
+    async open(options = {}) {
+        this.mode = options.mode ?? (options.roomId ? 'room' : 'new');
+        this.routeRoomId = options.roomId ?? null;
+        this.loading = true;
+        this.error = null;
+        this.hydrate(options);
+        try {
+            await this.stores.runtimeChatStore.load();
+            await this.stores.runtimeChatStore.openRoom(this.routeRoomId);
+            this.ready = true;
+        }
+        catch (error) {
+            this.error = error instanceof Error ? error.message : String(error);
+            throw error;
+        }
+        finally {
+            this.loading = false;
+        }
+    }
+    async close() {
+        this.routeRoomId = null;
+        this.mode = 'new';
+        await this.stores.runtimeChatStore.openRoom(null);
+        this.stores.sync.clearActiveRoomState();
+    }
+}
+export const chatRouteStore = contextualChatStore('chatRouteStore');

package/dist/svelte/stores/chatSessionStore.svelte.d.ts

@@ -0,0 +1,132 @@
+import { type VibesRuntime } from '@vibesdotdev/kernel';
+import type { ChatSessionHandle, ChatSessionSnapshot } from '../../client/schemas/contracts.ts';
+/** Reactive projection of one configured Chat session for any product surface. */
+export declare class ChatSessionStore {
+    snapshot: {
+        id: string;
+        roomId: string;
+        configuration: {
+            version: 1;
+            agentId: string;
+            goal: string;
+            dispatch: "consumer" | "server";
+            userAttachment: "headless" | "attached";
+            interaction: {
+                approvalMode: "always-approve" | "auto-approve-safe" | "always-ask" | "batch-approve";
+                requestTarget: "chat" | "hq";
+                messageChannels: string[];
+            };
+            context: Record<string, unknown>;
+            providerExecution?: {
+                version: 1;
+                providerConnectionId: string;
+                connectionSourceType: "user" | "system";
+                providerType: string;
+                modelId: string;
+                authMethod: string;
+                variantId: string;
+                specId: string;
+                transportId: string;
+                generationLocation: "consumer" | "server";
+                workspaceLocation: "consumer" | "cloud";
+                credentialCustody: "consumer" | "server";
+                billingOwner: "user" | "organization" | "platform";
+                headless: boolean;
+            } | undefined;
+            execution?: {
+                apiSessionIds: string[];
+                codeSessionId?: string | undefined;
+                workspaceId?: string | undefined;
+                workspaceRoot?: string | undefined;
+                repositoryId?: string | undefined;
+                allowedToolIds?: string[] | undefined;
+                hostTarget?: {
+                    kind: "cloud";
+                } | {
+                    kind: "host";
+                    hostId: string;
+                } | undefined;
+                browserSessionId?: string | undefined;
+                desktopSessionId?: string | undefined;
+                pullRequest?: {
+                    repositoryId: string;
+                    pullRequestNumber: number;
+                    expectedHeadSha: string;
+                    sourceRef: string;
+                    allowedActions: ("merge" | "review" | "fix")[];
+                    allowEnvironmentExecution: boolean;
+                } | undefined;
+            } | undefined;
+            outcome?: {
+                kind: "conversation";
+            } | {
+                kind: "pull-request";
+                required: boolean;
+                createRepositoryIfMissing: boolean;
+                repositoryId?: string | undefined;
+            } | {
+                kind: "artifact";
+                artifactKind: string;
+            } | {
+                kind: "verification";
+                failureProjectId?: string | undefined;
+            } | undefined;
+            source?: {
+                kind: string;
+                id: string;
+                href?: string | undefined;
+            } | undefined;
+        };
+        status: "cancelled" | "failed" | "queued" | "completed" | "running" | "starting" | "paused" | "waiting_for_user" | "awaiting_delivery";
+        updatedAt: string;
+        statusMessage?: string | undefined;
+        attention?: {
+            kind: "message" | "approval";
+            requestId?: string | undefined;
+            summary?: string | undefined;
+        } | undefined;
+        delivery?: {
+            kind: "pull-request";
+            id: string;
+            href: string;
+            repositoryId: string;
+            state: "open" | "merged";
+            deliveredAt: string;
+            headSha?: string | undefined;
+        } | {
+            kind: "artifact";
+            id: string;
+            deliveredAt: string;
+            href?: string | undefined;
+            report?: {
+                artifactKind: string;
+                summary: string;
+                artifactIds: string[];
+            } | undefined;
+        } | {
+            kind: "verification";
+            id: string;
+            deliveredAt: string;
+            href?: string | undefined;
+            report?: {
+                summary: string;
+                checks: {
+                    name: string;
+                    status: "failed" | "passed" | "blocked";
+                    evidence: string;
+                }[];
+                workItemIds: string[];
+            } | undefined;
+        } | undefined;
+    } | null;
+    loading: boolean;
+    error: string | null;
+    private handle;
+    private unsubscribe;
+    load(runtime: VibesRuntime, roomId: string): Promise<ChatSessionSnapshot | null>;
+    attach(handle: ChatSessionHandle): void;
+    refresh(): Promise<ChatSessionSnapshot | null>;
+    detach(): void;
+}
+export declare function createChatSessionStore(): ChatSessionStore;
+//# sourceMappingURL=chatSessionStore.svelte.d.ts.map

package/dist/svelte/stores/chatSessionStore.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chatSessionStore.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/stores/chatSessionStore.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAElF,OAAO,KAAK,EACX,iBAAiB,EACjB,mBAAmB,EAEnB,MAAM,mCAAmC,CAAC;AAE3C,kFAAkF;AAClF,qBAAa,gBAAgB;IAC5B,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAA4C;IACpD,OAAO,UAAiB;IACxB,KAAK,gBAA+B;IAEpC,OAAO,CAAC,MAAM,CAAkC;IAChD,OAAO,CAAC,WAAW,CAA4B;IAEzC,IAAI,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;IAqBtF,MAAM,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI;IAQjC,OAAO,IAAI,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;IAWpD,MAAM,IAAI,IAAI;CAMd;AAED,wBAAgB,sBAAsB,IAAI,gBAAgB,CAEzD"}

package/dist/svelte/stores/chatSessionStore.svelte.js

@@ -0,0 +1,59 @@
+import { settle, valueFreeFailure } from '@vibesdotdev/kernel';
+import { getVibesChatClient } from "../../client/helper.js";
+/** Reactive projection of one configured Chat session for any product surface. */
+export class ChatSessionStore {
+    snapshot = $state(null);
+    loading = $state(false);
+    error = $state(null);
+    handle = null;
+    unsubscribe = null;
+    async load(runtime, roomId) {
+        this.loading = true;
+        this.error = null;
+        const settled = await settle(async () => {
+            const client = await getVibesChatClient(runtime);
+            const handle = await client.sessions.get(roomId);
+            if (!handle) {
+                this.detach();
+                this.error = 'Chat session not found.';
+                return null;
+            }
+            this.attach(handle);
+            return this.snapshot;
+        });
+        this.loading = false;
+        if (settled.ok)
+            return settled.value;
+        const failure = valueFreeFailure(settled.cause);
+        this.error = failure.reason ?? 'Chat session load failed.';
+        return null;
+    }
+    attach(handle) {
+        this.detach();
+        this.handle = handle;
+        this.unsubscribe = handle.subscribe((snapshot) => {
+            this.snapshot = snapshot;
+        });
+    }
+    async refresh() {
+        if (!this.handle)
+            return this.snapshot;
+        this.error = null;
+        const handle = this.handle;
+        const settled = await settle(() => handle.refresh());
+        if (settled.ok)
+            return settled.value;
+        const failure = valueFreeFailure(settled.cause);
+        this.error = failure.reason ?? 'Chat session refresh failed.';
+        return null;
+    }
+    detach() {
+        this.unsubscribe?.();
+        this.unsubscribe = null;
+        this.handle = null;
+        this.snapshot = null;
+    }
+}
+export function createChatSessionStore() {
+    return new ChatSessionStore();
+}