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

package/dist/svelte/components/ChatWorkspaceContent.svelte

@@ -0,0 +1,654 @@
+<script lang="ts">
+	import { useChatSurface } from '../surface-context.js';
+	const { chatRoomStore, chatParticipantsStore, runtimeChatStore } = useChatSurface();
+
+	import { onMount, type Snippet } from 'svelte';
+	import { settle } from '@vibesdotdev/kernel';
+	import { RuntimeProvider } from '@vibesdotdev/surface-sveltekit/svelte';
+	import { Button } from '@vibesdotdev/kit/components/ui/button';
+	import { Icon } from '@vibesdotdev/kit/components/icon';
+	import { ChatConversationPane, ChatConversationSidebar, ChatComposerAugmentBar, ChatParticipantsPanel, ChatRuntimeLoader, ChatSurfaceSkeleton, ChatWorkspaceFrame, type ChatSurfaceUser } from './surface/index.js';
+
+	import { chatErrorNotice, chatFailureMessage } from '../../error-notice.js';
+	import type {
+		ChatClient,
+		ChatComposerOptions,
+		ChatRoomCreateInput
+	} from '@vibesdotdev/chat/client/contracts';
+	import { readChatRoomExecutionState } from '@vibesdotdev/chat/client';
+	import { assertChatWorkspaceSelectionMutable, normalizeChatWorkspaceCatalog, prepareChatWorkspaceSelection, resolveChatWorkspaceSelection, type ChatWorkspaceCatalog, type ChatWorkspaceCatalogEntry, type ChatWorkspaceResolver } from '../workspace-catalog.js';
+
+	let {
+		title = 'Workspace Assistant',
+		description = 'Ask about files and Terminal commands in this browser.',
+		user = null,
+		workspaceCatalog = [],
+		initialWorkspaceId = null,
+		startNew = false,
+		onCreateWorkspace,
+		onPrepareWorkspace,
+		clientFactory,
+		clientOwnership = 'owned',
+		preferConsumerSession = false,
+		disposeOnDestroy = true,
+		showWorkspaceShortcuts = true,
+		participantsEnabled = true,
+		inviteEnabled = false,
+		manageToolsEnabled = false,
+		onInvite,
+		onManageTools,
+		framed = true,
+		showSidebarIntro = true,
+		conversationSidebarTitle = 'Conversations',
+		autoSaveId = 'chat:workspace',
+		statusExtras,
+		defaultModeId = 'chat',
+		class: className = ''
+	}: {
+		title?: string;
+		description?: string;
+		user?: ChatSurfaceUser | null;
+		/** Local and cloud workspaces projected by the host/runtime. */
+		workspaceCatalog?: ChatWorkspaceCatalog;
+		/** Optional opaque workspace identity selected by a trusted host route. */
+		initialWorkspaceId?: string | null;
+		/** Open the shared workspace at a fresh conversation instead of the last active room. */
+		startNew?: boolean;
+		/** Optional trusted host action (for example, a native folder picker). */
+		onCreateWorkspace?: () => Promise<ChatWorkspaceCatalog[number] | null>;
+		/** Bind only the workspace the user selects to its local or cloud execution session. */
+		onPrepareWorkspace?: ChatWorkspaceResolver;
+		/** Optional package-owned client variant selected by a trusted host. */
+		clientFactory?: () => ChatClient | Promise<ChatClient>;
+		/** Whether this workspace owns a custom factory's client lifecycle. */
+		clientOwnership?: 'borrowed' | 'owned';
+		/** Resolve the daemon-owned local-first Chat client through runtime federation. */
+		preferConsumerSession?: boolean;
+		/** A workspace owns its account-scoped singleton unless an outer host retains it. */
+		disposeOnDestroy?: boolean;
+		showWorkspaceShortcuts?: boolean;
+		participantsEnabled?: boolean;
+		/** Render the invite action only when the host supplies a real implementation. */
+		inviteEnabled?: boolean;
+		/** Render the tool-management action only when the host supplies a real implementation. */
+		manageToolsEnabled?: boolean;
+		onInvite?: () => void | Promise<void>;
+		onManageTools?: () => void | Promise<void>;
+		/** Add a rounded border when the workspace is embedded inside another canvas. */
+		framed?: boolean;
+		/** Show product introduction above conversation history in standalone hosts. */
+		showSidebarIntro?: boolean;
+		/** Compact label for the conversation history pane. */
+		conversationSidebarTitle?: string;
+		autoSaveId?: string;
+		/** Host-owned status presented above the shared composer. */
+		statusExtras?: Snippet;
+		/** Mode for a new conversation. Editor Code-and-Chat passes `build`. */
+		defaultModeId?: string;
+		class?: string;
+	} = $props();
+
+	let noticeState = $state<{ level: 'info' | 'error'; message: string } | null>(null);
+	// A failure before the chat store starts (no runtime, registration) never
+	// reaches runtimeChatStore.error; without this the surface skeletons forever.
+	let loaderError = $state<Error | null>(null);
+	let addedWorkspaces = $state<ChatWorkspaceCatalog>([]);
+	let preparedWorkspaces = $state<ChatWorkspaceCatalog>([]);
+	let creatingWorkspace = $state(false);
+	let composerOptions = $state<ChatComposerOptions>({
+		models: [],
+		agents: [],
+		folders: [],
+		degraded: []
+	});
+	let composerOptionsLoading = $state(false);
+	let composerOptionsError = $state<string | null>(null);
+	let composerOptionsLoaded = false;
+	let initialWorkspaceApplied = $state(false);
+	let startNewApplied = $state(false);
+	let setupComplete = $state(false);
+	let workspaceWasReady = false;
+	let preferredAgentId = $state<string | undefined>();
+
+	const activeRoomId = $derived(chatRoomStore.roomId);
+	const isNewChat = $derived(!activeRoomId);
+	const activeTitle = $derived(chatRoomStore.room?.title ?? title);
+	const normalizedWorkspaceCatalog = $derived.by(() => {
+		const byId = new Map<string, ChatWorkspaceCatalogEntry>();
+		for (const workspace of workspaceCatalog) byId.set(workspace.id, workspace);
+		for (const workspace of addedWorkspaces) byId.set(workspace.id, workspace);
+		for (const workspace of preparedWorkspaces) byId.set(workspace.id, workspace);
+		// One derivation of "is this room a code session", shared with every other
+		// surface. Re-reading the three metadata keys here is how a half-bound room
+		// gets treated as executable on one surface and not another.
+		const execution = readChatRoomExecutionState(chatRoomStore.room?.metadata);
+		if (execution.kind === 'code-session') {
+			const { binding } = execution;
+			const activeWorkspace = byId.get(binding.workspaceId);
+			if (
+				activeWorkspace &&
+				!activeWorkspace.disabled &&
+				binding.codeSessionHostKind ===
+					(activeWorkspace.location === 'cloud' ? 'cloud' : 'host')
+			) {
+				byId.set(activeWorkspace.id, {
+					...activeWorkspace,
+					codeSessionId: binding.codeSessionId,
+					codeSessionHostKind: binding.codeSessionHostKind
+				});
+			}
+		}
+		return normalizeChatWorkspaceCatalog([...byId.values()]);
+	});
+	const workspaceSelection = $derived(
+		resolveChatWorkspaceSelection(normalizedWorkspaceCatalog, chatRoomStore.effectiveWorkspaceId)
+	);
+	const workspaceReady = $derived(workspaceSelection.status === 'ready');
+	const hostWorkspace = $derived(normalizedWorkspaceCatalog.find((workspace) => workspace.id === initialWorkspaceId));
+	const workspaceMismatch = $derived(Boolean(
+		activeRoomId && initialWorkspaceId && chatRoomStore.effectiveWorkspaceId &&
+		chatRoomStore.effectiveWorkspaceId !== initialWorkspaceId
+	));
+	const requiresSetup = $derived(isNewChat && !setupComplete);
+	const emptyTitle = $derived(requiresSetup ? 'Set up this conversation' : activeTitle);
+	const emptyDescription = $derived(
+		requiresSetup
+			? normalizedWorkspaceCatalog.length === 0
+				? 'Add a workspace below. Vibes will keep every file and tool action inside that explicit boundary.'
+				: 'Choose its workspace, teammate, and model before you begin.'
+			: description
+	);
+	const createRoomInput = $derived.by((): ChatRoomCreateInput => {
+		const base: ChatRoomCreateInput = {
+			title,
+			description,
+			roomMode: 'standard',
+			visibility: 'private',
+			participants: [],
+			modeId: defaultModeId
+		};
+		if (preferConsumerSession) {
+			base.metadata = { approvalMode: runtimeChatStore.pendingApprovalMode };
+		}
+		return base;
+	});
+
+	async function startNewConversation() {
+		preferredAgentId =
+			chatParticipantsStore.agents.keys().next().value ??
+			chatRoomStore.pendingAgents.keys().next().value;
+		noticeState = null;
+		setupComplete = false;
+		// Do not seed the host workspace until the previous room has finished clearing.
+		initialWorkspaceApplied = true;
+		runtimeChatStore.pendingApprovalMode = 'auto-approve-safe';
+		const settled = await settle(async () => {
+			await runtimeChatStore.openRoom(null);
+			await runtimeChatStore.setChatModeId(defaultModeId);
+		});
+		if (!settled.ok) {
+			showNotice('error', chatFailureMessage(settled.cause, 'The conversation could not open.'));
+		}
+		initialWorkspaceApplied = false;
+	}
+
+	function finishConversationSetup() {
+		if (!workspaceReady) {
+			showNotice('error', workspaceRequiredMessage());
+			return;
+		}
+		setupComplete = true;
+		noticeState = null;
+		queueMicrotask(() => {
+			window.dispatchEvent(new CustomEvent('chat:focus-composer'));
+		});
+	}
+
+	function showNotice(level: 'info' | 'error', message: string) {
+		noticeState = { level, message };
+	}
+
+	function sendSuggestion(text: string) {
+		if (!workspaceReady) {
+			showNotice('error', workspaceRequiredMessage());
+			return;
+		}
+		window.dispatchEvent(new CustomEvent('vibes:chat-suggest', { detail: { text } }));
+	}
+
+	function workspaceRequiredMessage(): string {
+		if (normalizedWorkspaceCatalog.length === 0) {
+			return 'Open or connect a workspace before starting this conversation.';
+		}
+		if (workspaceSelection.status === 'unavailable') {
+			return 'This conversation’s workspace is unavailable. Choose another workspace to continue.';
+		}
+		return 'Choose a workspace before sending your first message.';
+	}
+
+	async function prepareWorkspace(
+		workspace: ChatWorkspaceCatalogEntry
+	): Promise<ChatWorkspaceCatalogEntry> {
+		const prepared = await prepareChatWorkspaceSelection(
+			runtimeChatStore.activeRoom?.id,
+			workspace,
+			onPrepareWorkspace
+		);
+		if (prepared.id !== workspace.id) {
+			throw new Error('The workspace runtime returned a different workspace.');
+		}
+		const normalized = normalizeChatWorkspaceCatalog([prepared])[0];
+		if (
+			!normalized ||
+			resolveChatWorkspaceSelection([normalized], normalized.id).status !== 'ready'
+		) {
+			throw new Error('The selected workspace could not be prepared for conversation.');
+		}
+		preparedWorkspaces = [
+			...preparedWorkspaces.filter((entry) => entry.id !== normalized.id),
+			normalized
+		];
+		return normalized;
+	}
+
+	async function createWorkspace(): Promise<void> {
+		if (!onCreateWorkspace || creatingWorkspace) return;
+		creatingWorkspace = true;
+		const settled = await settle(async () => {
+			assertChatWorkspaceSelectionMutable(runtimeChatStore.activeRoom?.id);
+			const workspace = await onCreateWorkspace();
+			if (!workspace) return;
+			addedWorkspaces = [
+				...addedWorkspaces.filter((entry) => entry.id !== workspace.id),
+				workspace
+			];
+			const prepared = await prepareWorkspace(workspace);
+			await runtimeChatStore.setWorkspaceBinding(prepared);
+			showNotice('info', `${workspace.label} is ready for this conversation.`);
+		});
+		creatingWorkspace = false;
+		if (!settled.ok) {
+			showNotice('error', chatFailureMessage(settled.cause, 'The workspace could not be created.'));
+		}
+	}
+
+	async function applyInitialWorkspace(workspace: ChatWorkspaceCatalogEntry): Promise<void> {
+		const settled = await settle(async () => {
+			if (runtimeChatStore.activeRoom) return;
+			const prepared = await prepareWorkspace(workspace);
+			// Restoring the last conversation races the asynchronous host seed.
+			// Never rebind that existing room or leave a stale setup warning on it.
+			if (runtimeChatStore.activeRoom) return;
+			await runtimeChatStore.setWorkspaceBinding(prepared);
+		});
+		if (!settled.ok) {
+			if (runtimeChatStore.activeRoom) return;
+			showNotice('error', chatFailureMessage(settled.cause, 'The requested workspace could not be opened.'));
+		}
+	}
+
+	async function loadComposerOptions() {
+		composerOptionsLoading = true;
+		composerOptionsError = null;
+		const settled = await settle(() => runtimeChatStore.getComposerOptions());
+		composerOptionsLoading = false;
+		if (settled.ok) {
+			composerOptions = settled.value;
+		} else {
+			composerOptions = {
+				models: [],
+				agents: [],
+				folders: [],
+				degraded: ['models', 'agents', 'folders']
+			};
+			composerOptionsError = chatFailureMessage(settled.cause, 'Account options could not be loaded.');
+		}
+	}
+
+	$effect(() => {
+		if (!runtimeChatStore.ready || composerOptionsLoaded) return;
+		composerOptionsLoaded = true;
+		void loadComposerOptions();
+	});
+
+	$effect(() => {
+		if (!startNew || startNewApplied || !runtimeChatStore.ready) return;
+		startNewApplied = true;
+		startNewConversation();
+	});
+
+	$effect(() => {
+		const requestedId = initialWorkspaceId?.trim();
+		const requestedWorkspace = requestedId
+			? normalizedWorkspaceCatalog.find((workspace) => workspace.id === requestedId)
+			: undefined;
+		if (
+			initialWorkspaceApplied ||
+			!runtimeChatStore.ready ||
+			runtimeChatStore.activeRoom?.id ||
+			!requestedWorkspace
+		) {
+			return;
+		}
+		initialWorkspaceApplied = true;
+		void applyInitialWorkspace(requestedWorkspace);
+	});
+
+	$effect(() => {
+		const ready = workspaceReady;
+		if (ready && setupComplete && !workspaceWasReady) {
+			queueMicrotask(() => {
+				window.dispatchEvent(new CustomEvent('chat:focus-composer'));
+			});
+		}
+		workspaceWasReady = ready;
+	});
+
+	onMount(() => {
+		// A desktop Chat app is a history workspace, not a blank composer. Keep
+		// account conversations visible on first open; users can still collapse
+		// the pane and that preference remains owned by the shared Chat UI store.
+		runtimeChatStore.setSidebarLeftOpen(true);
+		if (!chatRoomStore.roomId) {
+			void runtimeChatStore.setChatModeId(defaultModeId);
+		}
+	});
+</script>
+
+<RuntimeProvider>
+	<div
+		class={`chat-workspace ${framed ? '' : 'chat-workspace--unframed'} ${className}`.trim()}
+		data-chat-workspace
+	>
+		<ChatRuntimeLoader
+			roomId={activeRoomId}
+			currentUser={user}
+			{clientFactory}
+			{clientOwnership}
+			{disposeOnDestroy}
+			onError={(error) => {
+				loaderError = error;
+				showNotice('error', 'Chat could not open. Try again in a moment.');
+			}}
+		/>
+
+		<ChatWorkspaceFrame title={activeTitle} {participantsEnabled} {autoSaveId}>
+			{#snippet sidebar({ close })}
+				<div class="chat-workspace__sidebar">
+					{#if showSidebarIntro}
+						<section class="chat-workspace__intro">
+							<p class="chat-workspace__eyebrow">Assistant</p>
+							<h2>{title}</h2>
+							<p>{description}</p>
+						</section>
+					{/if}
+
+					{#if showWorkspaceShortcuts}
+						<section class="chat-workspace__shortcuts" aria-label="Start a message">
+							<Button
+								type="button"
+								variant="ghost"
+								class="chat-workspace__shortcut"
+								disabled={!workspaceReady}
+								onclick={() => sendSuggestion('list files')}
+							>
+								<Icon icon="lucide:folder-open" class="h-4 w-4" />
+								<span>List files</span>
+							</Button>
+							<Button
+								type="button"
+								variant="ghost"
+								class="chat-workspace__shortcut"
+								disabled={!workspaceReady}
+								onclick={() => sendSuggestion('how do I create a file from Terminal?')}
+							>
+								<Icon icon="lucide:terminal" class="h-4 w-4" />
+								<span>Terminal help</span>
+							</Button>
+						</section>
+					{/if}
+
+					<ChatConversationSidebar
+						title={conversationSidebarTitle}
+						{activeRoomId}
+						onClose={close}
+						onNew={startNewConversation}
+					/>
+				</div>
+			{/snippet}
+			{#snippet participants({ close })}
+				<ChatParticipantsPanel onClose={close} />
+			{/snippet}
+
+			{#if runtimeChatStore.ready}
+				<ChatConversationPane
+					{activeRoomId}
+					{isNewChat}
+					title={activeRoomId ? activeTitle : emptyTitle}
+					description={activeRoomId ? description : emptyDescription}
+					placeholder="Ask about a file or Terminal command..."
+					{createRoomInput}
+					requireWorkspace
+					agents={composerOptions.agents}
+					dialogMode="event"
+					requireImplementedDialogs={true}
+					includeEmptyRuntimeActions={workspaceReady && !requiresSetup}
+					showEmptyFocusAction={workspaceReady && !requiresSetup}
+					includeRuntimeActions={true}
+					sendDisabled={!workspaceReady}
+					showComposer={!requiresSetup && (workspaceReady || Boolean(activeRoomId))}
+					{inviteEnabled}
+					{manageToolsEnabled}
+					{onInvite}
+					{onManageTools}
+					onRoomCreated={() => {
+						noticeState = null;
+					}}
+					onSendStart={() => {
+						// A new send supersedes the last failure's notice.
+						noticeState = null;
+					}}
+					onSent={({ room }) => {
+						if (room.id === activeRoomId) noticeState = null;
+					}}
+					onNotice={(message) => showNotice('info', message)}
+					onError={(message) => showNotice('error', chatErrorNotice(message))}
+					onSendBlocked={({ reason }) => {
+						if (reason === 'disabled' && !workspaceReady) {
+							showNotice('error', workspaceRequiredMessage());
+						}
+					}}
+					{statusExtras}
+				>
+					{#snippet notice()}
+						{#if workspaceMismatch}
+							<div class="chat-workspace__notice flex flex-wrap items-center gap-2" role="status" data-testid="chat-workspace-mismatch">
+								<span>This conversation uses {workspaceSelection.workspace?.label ?? 'another workspace'}. The editor is on {hostWorkspace?.label ?? 'a different workspace'}.</span>
+								<Button size="sm" variant="outline" onclick={startNewConversation}>New chat in {hostWorkspace?.label ?? 'editor workspace'}</Button>
+							</div>
+						{/if}
+						{#if noticeState}
+							<div class="chat-workspace__notice" data-level={noticeState.level}>
+								{noticeState.message}
+							</div>
+						{/if}
+					{/snippet}
+					{#snippet emptyActions()}
+						{#if !requiresSetup}
+							<div class="chat-workspace__empty-actions">
+								<Button
+									type="button"
+									variant="secondary"
+									size="sm"
+									onclick={() => sendSuggestion('list files')}
+								>
+									List files
+								</Button>
+								<Button
+									type="button"
+									variant="outline"
+									size="sm"
+									onclick={() => sendSuggestion('how do I create a file from Terminal?')}
+								>
+									Terminal help
+								</Button>
+							</div>
+						{:else}
+							<div class="w-full space-y-6 text-left">
+								<ChatComposerAugmentBar
+									permissionsEnabled={preferConsumerSession}
+									options={composerOptions}
+									workspaceCatalog={normalizedWorkspaceCatalog}
+									onPrepareWorkspace={prepareWorkspace}
+									onCreateWorkspace={onCreateWorkspace ? createWorkspace : undefined}
+									{creatingWorkspace}
+									loading={composerOptionsLoading}
+									error={composerOptionsError}
+									presentation="setup"
+									{preferredAgentId}
+									{defaultModeId}
+									onRetry={() => void loadComposerOptions()}
+								/>
+								<Button
+									type="button"
+									class="w-full"
+									variant={workspaceReady ? 'default' : 'secondary'}
+									disabled={!workspaceReady}
+									onclick={finishConversationSetup}
+								>
+									Start conversation
+									<Icon icon="lucide:arrow-right" class="h-4 w-4" />
+								</Button>
+							</div>
+						{/if}
+					{/snippet}
+					{#snippet composerPrefix()}
+						<ChatComposerAugmentBar
+							permissionsEnabled={preferConsumerSession}
+							options={composerOptions}
+							workspaceCatalog={normalizedWorkspaceCatalog}
+							onPrepareWorkspace={prepareWorkspace}
+							onCreateWorkspace={onCreateWorkspace ? createWorkspace : undefined}
+							{creatingWorkspace}
+							loading={composerOptionsLoading}
+							error={composerOptionsError}
+							{defaultModeId}
+							onRetry={() => void loadComposerOptions()}
+						/>
+					{/snippet}
+				</ChatConversationPane>
+			{:else if runtimeChatStore.error || loaderError}
+				<div class="chat-workspace__error" role="alert">
+					<Icon icon="lucide:message-square-warning" class="h-5 w-5" />
+					<span>Chat could not open. Try again in a moment.</span>
+				</div>
+			{:else}
+				<ChatSurfaceSkeleton />
+			{/if}
+		</ChatWorkspaceFrame>
+	</div>
+</RuntimeProvider>
+
+<style>
+	.chat-workspace {
+		width: 100%;
+		height: 100%;
+		min-width: 0;
+		min-height: 0;
+		overflow: hidden;
+		border: 1px solid var(--border, rgba(0, 0, 0, 0.1));
+		border-radius: 0.5rem;
+		background: var(--background, #fff);
+	}
+
+	.chat-workspace--unframed {
+		border: 0;
+		border-radius: 0;
+	}
+
+	.chat-workspace__sidebar {
+		display: flex;
+		height: 100%;
+		min-height: 0;
+		flex-direction: column;
+		background: var(--background, #fff);
+	}
+
+	.chat-workspace__intro,
+	.chat-workspace__shortcuts {
+		display: grid;
+		gap: 0.7rem;
+		border-bottom: 1px solid var(--border, rgba(0, 0, 0, 0.1));
+		padding: 0.9rem;
+	}
+
+	.chat-workspace__eyebrow {
+		margin: 0;
+		color: var(--muted-foreground, #6b7280);
+		font-size: 0.72rem;
+		font-weight: 700;
+		letter-spacing: 0;
+		text-transform: uppercase;
+	}
+
+	.chat-workspace__intro h2 {
+		margin: 0;
+		font-size: 1rem;
+		font-weight: 800;
+		line-height: 1.2;
+	}
+
+	.chat-workspace__intro p {
+		margin: 0;
+		color: var(--muted-foreground, #6b7280);
+		font-size: 0.85rem;
+		line-height: 1.45;
+	}
+
+	:global(.chat-workspace__shortcut) {
+		justify-content: flex-start;
+		gap: 0.5rem;
+		border-radius: 0.4rem;
+	}
+
+	.chat-workspace__notice {
+		margin: 0.75rem 0.75rem 0;
+		border: 1px solid var(--border, rgba(0, 0, 0, 0.1));
+		border-radius: 0.5rem;
+		background: var(--muted, rgba(0, 0, 0, 0.05));
+		color: var(--foreground, inherit);
+		padding: 0.65rem 0.75rem;
+		font-size: 0.85rem;
+	}
+
+	.chat-workspace__notice[data-level='error'],
+	.chat-workspace__error {
+		border-color: color-mix(in srgb, var(--destructive, #dc2626) 45%, transparent);
+		background: color-mix(in srgb, var(--destructive, #dc2626) 10%, transparent);
+		color: var(--destructive, #dc2626);
+	}
+
+	.chat-workspace__empty-actions {
+		display: flex;
+		flex-wrap: wrap;
+		justify-content: center;
+		gap: 0.5rem;
+	}
+
+
+	.chat-workspace__error {
+		display: flex;
+		height: 100%;
+		min-height: 15rem;
+		align-items: center;
+		justify-content: center;
+		gap: 0.5rem;
+		border: 0;
+		padding: 1rem;
+		text-align: center;
+	}
+
+	:global(.chat-workspace .runtime-chat-input__marshal) {
+		display: none;
+	}
+</style>

package/dist/svelte/components/ChatWorkspaceContent.svelte.d.ts

@@ -0,0 +1,51 @@
+import { type Snippet } from 'svelte';
+import { type ChatSurfaceUser } from './surface/index.ts';
+import type { ChatClient } from '@vibesdotdev/chat/client/contracts';
+import { type ChatWorkspaceCatalog, type ChatWorkspaceResolver } from '../workspace-catalog.ts';
+type $$ComponentProps = {
+    title?: string;
+    description?: string;
+    user?: ChatSurfaceUser | null;
+    /** Local and cloud workspaces projected by the host/runtime. */
+    workspaceCatalog?: ChatWorkspaceCatalog;
+    /** Optional opaque workspace identity selected by a trusted host route. */
+    initialWorkspaceId?: string | null;
+    /** Open the shared workspace at a fresh conversation instead of the last active room. */
+    startNew?: boolean;
+    /** Optional trusted host action (for example, a native folder picker). */
+    onCreateWorkspace?: () => Promise<ChatWorkspaceCatalog[number] | null>;
+    /** Bind only the workspace the user selects to its local or cloud execution session. */
+    onPrepareWorkspace?: ChatWorkspaceResolver;
+    /** Optional package-owned client variant selected by a trusted host. */
+    clientFactory?: () => ChatClient | Promise<ChatClient>;
+    /** Whether this workspace owns a custom factory's client lifecycle. */
+    clientOwnership?: 'borrowed' | 'owned';
+    /** Resolve the daemon-owned local-first Chat client through runtime federation. */
+    preferConsumerSession?: boolean;
+    /** A workspace owns its account-scoped singleton unless an outer host retains it. */
+    disposeOnDestroy?: boolean;
+    showWorkspaceShortcuts?: boolean;
+    participantsEnabled?: boolean;
+    /** Render the invite action only when the host supplies a real implementation. */
+    inviteEnabled?: boolean;
+    /** Render the tool-management action only when the host supplies a real implementation. */
+    manageToolsEnabled?: boolean;
+    onInvite?: () => void | Promise<void>;
+    onManageTools?: () => void | Promise<void>;
+    /** Add a rounded border when the workspace is embedded inside another canvas. */
+    framed?: boolean;
+    /** Show product introduction above conversation history in standalone hosts. */
+    showSidebarIntro?: boolean;
+    /** Compact label for the conversation history pane. */
+    conversationSidebarTitle?: string;
+    autoSaveId?: string;
+    /** Host-owned status presented above the shared composer. */
+    statusExtras?: Snippet;
+    /** Mode for a new conversation. Editor Code-and-Chat passes `build`. */
+    defaultModeId?: string;
+    class?: string;
+};
+declare const ChatWorkspaceContent: import("svelte").Component<$$ComponentProps, {}, "">;
+type ChatWorkspaceContent = ReturnType<typeof ChatWorkspaceContent>;
+export default ChatWorkspaceContent;
+//# sourceMappingURL=ChatWorkspaceContent.svelte.d.ts.map