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

package/dist/svelte/augmentations/workspaces.composer.svelte

@@ -0,0 +1,180 @@
+<script lang="ts">
+	import { useChatSurface } from '../surface-context.js';
+	const { chatRoomStore, runtimeChatStore } = useChatSurface();
+
+	import { Button } from '@vibesdotdev/kit/components/ui/button';
+	import { Icon } from '@vibesdotdev/kit/components/icon';
+	import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@vibesdotdev/kit/components/ui/select';
+	import { settle, valueFreeFailure } from '@vibesdotdev/kernel';
+
+	import { normalizeChatWorkspaceCatalog, prepareChatWorkspaceSelection, resolveChatWorkspaceSelection, type ChatWorkspaceCatalog, type ChatWorkspaceResolver } from '../workspace-catalog.js';
+	import type { ChatComposerAugmentPresentation } from '../composer-augments.js';
+
+	let {
+		presentation = 'composer',
+		workspaceCatalog = [],
+		onPrepareWorkspace,
+		onCreateWorkspace,
+		creatingWorkspace = false
+	}: {
+		presentation?: ChatComposerAugmentPresentation;
+		workspaceCatalog?: ChatWorkspaceCatalog;
+		onPrepareWorkspace?: ChatWorkspaceResolver;
+		onCreateWorkspace?: () => void;
+		creatingWorkspace?: boolean;
+	} = $props();
+
+	const WORKSPACE_REQUIRED = '__workspace_required__';
+	const normalizedWorkspaceCatalog = $derived(normalizeChatWorkspaceCatalog(workspaceCatalog));
+	const selectedWorkspaceId = $derived(chatRoomStore.effectiveWorkspaceId);
+	const workspaceSelection = $derived(
+		resolveChatWorkspaceSelection(normalizedWorkspaceCatalog, selectedWorkspaceId)
+	);
+	const selectedWorkspace = $derived(
+		workspaceSelection.status === 'ready' ? workspaceSelection.workspace : null
+	);
+	const workspaceSelectionLocked = $derived(Boolean(runtimeChatStore.activeRoom?.id));
+	let workspaceError = $state<string | null>(null);
+	const triggerSize = $derived(presentation === 'setup' ? 'default' : 'compact');
+
+	async function selectWorkspace(workspaceId: string): Promise<void> {
+		if (workspaceId === WORKSPACE_REQUIRED) return;
+		const workspace = normalizedWorkspaceCatalog.find(
+			(candidate) => candidate.id === workspaceId && !candidate.disabled
+		);
+		if (!workspace) {
+			workspaceError = 'That workspace is no longer available.';
+			return;
+		}
+		const settled = await settle(async () => {
+			const prepared = await prepareChatWorkspaceSelection(
+				runtimeChatStore.activeRoom?.id,
+				workspace,
+				onPrepareWorkspace
+			);
+			await runtimeChatStore.setWorkspaceBinding(prepared);
+		});
+		if (settled.ok) {
+			workspaceError = null;
+		} else {
+			const failure = valueFreeFailure(settled.cause);
+			workspaceError = failure.reason ?? 'The workspace could not be selected.';
+		}
+	}
+</script>
+
+<div class="chat-composer-augment" class:chat-composer-augment--setup={presentation === 'setup'}>
+	{#if normalizedWorkspaceCatalog.length > 0 || !onCreateWorkspace}
+		<Select
+			type="single"
+			value={selectedWorkspaceId ?? WORKSPACE_REQUIRED}
+			disabled={workspaceSelectionLocked}
+			onValueChange={(value: string) => void selectWorkspace(value)}
+		>
+			<SelectTrigger
+				size={triggerSize}
+				class={presentation === 'setup' ? 'w-full' : 'max-w-full min-w-0 overflow-hidden'}
+				data-required={workspaceSelection.status !== 'ready'}
+				aria-label={workspaceSelectionLocked
+					? 'Conversation workspace, locked'
+					: 'Conversation workspace'}
+				title={workspaceSelectionLocked
+					? 'Start a new conversation to choose another workspace'
+					: undefined}
+			>
+				<Icon
+					icon={workspaceSelectionLocked
+						? 'lucide:lock-keyhole'
+						: selectedWorkspace?.location === 'cloud'
+							? 'lucide:cloud'
+							: 'lucide:folder-code'}
+					class="h-3.5 w-3.5"
+				/>
+				<SelectValue>
+					<span class="truncate">
+						{selectedWorkspace?.label ??
+							(workspaceSelection.status === 'unavailable'
+								? 'Workspace unavailable'
+								: 'Choose workspace')}
+					</span>
+				</SelectValue>
+			</SelectTrigger>
+			<SelectContent>
+				{#each normalizedWorkspaceCatalog as workspace (workspace.id)}
+					<SelectItem value={workspace.id} disabled={workspace.disabled}>
+						<span class="chat-composer-augment__item">
+							<span>{workspace.label}</span>
+							<small>
+								{workspace.unavailableReason ??
+									workspace.description ??
+									(workspace.location === 'local' ? 'On this device' : 'Cloud workspace')}
+							</small>
+						</span>
+					</SelectItem>
+				{/each}
+				{#if normalizedWorkspaceCatalog.length === 0}
+					<SelectItem value="__workspace_catalog_empty__" disabled>
+						No workspaces available
+					</SelectItem>
+				{/if}
+			</SelectContent>
+		</Select>
+	{/if}
+	{#if onCreateWorkspace}
+		<Button
+			type="button"
+			variant="ghost"
+			size={presentation === 'setup' ? 'default' : 'sm'}
+			class={presentation === 'setup' ? undefined : '!h-[1.625rem] !min-h-[1.625rem] rounded-full px-2 text-xs'}
+			data-required={workspaceSelection.status !== 'ready'}
+			disabled={creatingWorkspace || workspaceSelectionLocked}
+			title={workspaceSelectionLocked
+				? 'Start a new conversation to add another workspace'
+				: undefined}
+			onclick={onCreateWorkspace}
+		>
+			<Icon
+				icon={creatingWorkspace ? 'lucide:loader-circle' : 'lucide:folder-plus'}
+				class={`h-3.5 w-3.5 ${creatingWorkspace ? 'animate-spin' : ''}`}
+			/>
+			<span>{creatingWorkspace ? 'Adding…' : 'Add workspace'}</span>
+		</Button>
+	{/if}
+	{#if workspaceError}
+		<span class="chat-composer-augment__status" role="status">{workspaceError}</span>
+	{/if}
+</div>
+
+<style>
+	.chat-composer-augment {
+		display: flex;
+		width: auto;
+		max-width: 100%;
+		min-width: 0;
+		align-items: center;
+		gap: 0.5rem;
+	}
+
+	.chat-composer-augment--setup {
+		flex-direction: column;
+		align-items: stretch;
+	}
+
+	.chat-composer-augment__item {
+		display: grid;
+		gap: 0.1rem;
+	}
+
+	.chat-composer-augment__item small {
+		max-width: 18rem;
+		overflow: hidden;
+		color: var(--muted-foreground);
+		text-overflow: ellipsis;
+		white-space: nowrap;
+	}
+
+	.chat-composer-augment__status {
+		color: color-mix(in oklab, var(--warning) 70%, var(--foreground));
+		font-size: 0.72rem;
+	}
+</style>

package/dist/svelte/augmentations/workspaces.composer.svelte.d.ts

@@ -0,0 +1,13 @@
+import { type ChatWorkspaceCatalog, type ChatWorkspaceResolver } from '../workspace-catalog.ts';
+import type { ChatComposerAugmentPresentation } from '../composer-augments.ts';
+type $$ComponentProps = {
+    presentation?: ChatComposerAugmentPresentation;
+    workspaceCatalog?: ChatWorkspaceCatalog;
+    onPrepareWorkspace?: ChatWorkspaceResolver;
+    onCreateWorkspace?: () => void;
+    creatingWorkspace?: boolean;
+};
+declare const Workspaces: import("svelte").Component<$$ComponentProps, {}, "">;
+type Workspaces = ReturnType<typeof Workspaces>;
+export default Workspaces;
+//# sourceMappingURL=workspaces.composer.svelte.d.ts.map

package/dist/svelte/augmentations/workspaces.composer.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspaces.composer.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/augmentations/workspaces.composer.svelte.ts"],"names":[],"mappings":"AAUA,OAAO,EAA+F,KAAK,oBAAoB,EAAE,KAAK,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAC7L,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,yBAAyB,CAAC;AAE9E,KAAK,gBAAgB,GAAI;IACxB,YAAY,CAAC,EAAE,+BAA+B,CAAC;IAC/C,gBAAgB,CAAC,EAAE,oBAAoB,CAAC;IACxC,kBAAkB,CAAC,EAAE,qBAAqB,CAAC;IAC3C,iBAAiB,CAAC,EAAE,MAAM,IAAI,CAAC;IAC/B,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAwHH,QAAA,MAAM,UAAU,sDAAwC,CAAC;AACzD,KAAK,UAAU,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC;AAChD,eAAe,UAAU,CAAC"}

package/dist/svelte/augmentations/workspaces.descriptor.d.ts

@@ -0,0 +1,34 @@
+declare const _default: {
+    id: string;
+    kind: "ai/augment";
+    trigger: string;
+    title: string;
+    priority: number;
+    positionRule: "start-only" | "after-whitespace" | "anywhere";
+    eagerCompletions: boolean;
+    maxCompletions: number;
+    debounceMs: number;
+    async: boolean;
+    placement: "command" | "primary" | "overflow";
+    name?: string | undefined;
+    description?: string | undefined;
+    tags?: string[] | undefined;
+    hardware?: string[] | undefined;
+    enabled?: boolean | undefined;
+    capabilityId?: string | undefined;
+    requiredContext?: string[] | undefined;
+    optionalContext?: string[] | undefined;
+    config?: unknown;
+    retention?: string | {
+        reason: string;
+        maxAgeDays?: number | undefined;
+        maxEntries?: number | undefined;
+        maxBytes?: number | undefined;
+        cascadeFrom?: string | undefined;
+        ageField?: string | undefined;
+        enforcedBy?: string | undefined;
+    } | undefined;
+    category?: string | undefined;
+};
+export default _default;
+//# sourceMappingURL=workspaces.descriptor.d.ts.map

package/dist/svelte/augmentations/workspaces.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspaces.descriptor.d.ts","sourceRoot":"","sources":["../../../src/svelte/augmentations/workspaces.descriptor.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,wBAeG"}

package/dist/svelte/augmentations/workspaces.descriptor.js

@@ -0,0 +1,17 @@
+import { AIAugmentDescriptorSchema } from '@vibesdotdev/ai/augmentations/schemas/augment';
+export default AIAugmentDescriptorSchema.parse({
+    id: 'chat.augment.workspaces',
+    name: 'Conversation workspace',
+    title: 'Conversation workspace',
+    description: 'Choose the local or cloud workspace this conversation may use.',
+    category: 'Conversation setup',
+    trigger: '/',
+    positionRule: 'after-whitespace',
+    eagerCompletions: true,
+    maxCompletions: 8,
+    debounceMs: 0,
+    async: false,
+    priority: 92,
+    placement: 'primary',
+    enabled: true
+});

package/dist/svelte/augmentations/workspaces.impl.browser.d.ts

@@ -0,0 +1,4 @@
+import type { AIAugmentImplementation } from '@vibesdotdev/ai/augmentations/schemas/augment-runtime';
+declare const impl: AIAugmentImplementation;
+export default impl;
+//# sourceMappingURL=workspaces.impl.browser.d.ts.map

package/dist/svelte/augmentations/workspaces.impl.browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspaces.impl.browser.d.ts","sourceRoot":"","sources":["../../../src/svelte/augmentations/workspaces.impl.browser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGX,uBAAuB,EAEvB,MAAM,uDAAuD,CAAC;AAiB/D,QAAA,MAAM,IAAI,EAAE,uBA+CX,CAAC;AAEF,eAAe,IAAI,CAAC"}

package/dist/svelte/augmentations/workspaces.impl.browser.js

@@ -0,0 +1,51 @@
+import * as z from 'zod/v4';
+import { settle, valueFreeFailure } from '@vibesdotdev/kernel';
+import { getChatSurface } from "../surface-client.svelte.js";
+import { createChatWorkspaceCompletions, getChatWorkspaceCatalog, prepareChatWorkspaceSelection, resolveChatWorkspace } from "../workspace-catalog.js";
+const workspaceSelectionSchema = z.looseObject({
+    workspaceId: z.string().trim().min(1)
+});
+const workspaceLabelSchema = z.looseObject({
+    workspaceLabel: z.string().optional()
+});
+const impl = {
+    complete(ctx) {
+        return createChatWorkspaceCompletions(getChatWorkspaceCatalog(ctx.runtime), ctx.query);
+    },
+    async execute(ctx) {
+        const surface = getChatSurface(ctx.runtime);
+        const raw = ctx.completion?.data;
+        const parsed = workspaceSelectionSchema.safeParse(raw);
+        if (!parsed.success) {
+            return { type: 'toast', message: 'No workspace selected', level: 'error' };
+        }
+        const workspaceId = parsed.data.workspaceId;
+        const labelParsed = workspaceLabelSchema.safeParse(raw);
+        const workspaceLabel = (labelParsed.success && labelParsed.data.workspaceLabel?.trim())
+            ? labelParsed.data.workspaceLabel.trim()
+            : undefined;
+        const available = getChatWorkspaceCatalog(ctx.runtime).find((workspace) => workspace.id === workspaceId && !workspace.disabled);
+        if (!available) {
+            return {
+                type: 'toast',
+                message: 'That workspace is no longer available',
+                level: 'error'
+            };
+        }
+        const settled = await settle(async () => {
+            const prepared = await prepareChatWorkspaceSelection(surface.runtimeChatStore.activeRoom?.id, available, (workspace) => resolveChatWorkspace(ctx.runtime, workspace));
+            await surface.runtimeChatStore.setWorkspaceBinding(prepared);
+        });
+        if (!settled.ok) {
+            const failure = valueFreeFailure(settled.cause);
+            return {
+                type: 'toast',
+                message: failure.reason ?? 'Failed to update workspace',
+                level: 'error'
+            };
+        }
+        const label = workspaceLabel || available.label;
+        return { type: 'toast', message: `Using ${label}`, level: 'success' };
+    }
+};
+export default impl;

package/dist/svelte/auth-error.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Detect auth-boundary failures from chat client / HTTP error messages so
+ * embedded chat empty states can show a Sign in CTA instead of a no-op
+ * "New conversation" button (work dee9f04c).
+ */
+export declare function isChatAuthError(message: string | null | undefined): boolean;
+/**
+ * Whether the empty-state primary action should be Sign in rather than
+ * New conversation.
+ */
+export declare function chatEmptyStateNeedsSignIn(options: {
+    authenticated?: boolean | null;
+    error?: string | null;
+}): boolean;
+//# sourceMappingURL=auth-error.d.ts.map

package/dist/svelte/auth-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-error.d.ts","sourceRoot":"","sources":["../../src/svelte/auth-error.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAW3E;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE;IAClD,aAAa,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,GAAG,OAAO,CAGV"}

package/dist/svelte/auth-error.js

@@ -0,0 +1,32 @@
+/**
+ * Detect auth-boundary failures from chat client / HTTP error messages so
+ * embedded chat empty states can show a Sign in CTA instead of a no-op
+ * "New conversation" button (work dee9f04c).
+ */
+export function isChatAuthError(message) {
+    if (!message)
+        return false;
+    const text = message.toLowerCase();
+    if (text.includes('401') || text.includes('403'))
+        return true;
+    if (text.includes('unauthorized') || text.includes('unauthenticated'))
+        return true;
+    if (text.includes('forbidden'))
+        return true;
+    if (text.includes('not authenticated') || text.includes('no session'))
+        return true;
+    if (text.includes('please sign in') || text.includes('sign in to') || text.includes('sign-in'))
+        return true;
+    if (text.includes('authentication') || text.includes('authorization required'))
+        return true;
+    return false;
+}
+/**
+ * Whether the empty-state primary action should be Sign in rather than
+ * New conversation.
+ */
+export function chatEmptyStateNeedsSignIn(options) {
+    if (options.authenticated === false)
+        return true;
+    return isChatAuthError(options.error);
+}

package/dist/svelte/chat-modes.d.ts

@@ -0,0 +1,19 @@
+import { type RuntimeRef } from '@vibesdotdev/kernel';
+import { type NormalizedChatMode } from '@vibesdotdev/chat/chat-modes/helpers';
+export type ChatModeOption = {
+    id: string;
+    name?: string;
+    description?: string;
+    icon?: string;
+    order?: number;
+    enabled?: boolean;
+};
+/**
+ * The `chat.modes` config entries the handed runtime declares, normalized.
+ * A host with no config manifests, or no `chat.modes` manifest, declares none.
+ */
+export declare function loadConfiguredChatModes(runtime: RuntimeRef): Promise<Record<string, NormalizedChatMode>>;
+export declare function resolveChatModeOptions(runtime: RuntimeRef, options?: {
+    configTimeoutMs?: number;
+}): Promise<ChatModeOption[]>;
+//# sourceMappingURL=chat-modes.d.ts.map

package/dist/svelte/chat-modes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-modes.d.ts","sourceRoot":"","sources":["../../src/svelte/chat-modes.ts"],"names":[],"mappings":"AACA,OAAO,EAA6C,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAGjG,OAAO,EAIN,KAAK,kBAAkB,EACvB,MAAM,sCAAsC,CAAC;AAM9C,MAAM,MAAM,cAAc,GAAG;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAIF;;;GAGG;AACH,wBAAsB,uBAAuB,CAC5C,OAAO,EAAE,UAAU,GACjB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC,CA4B7C;AAyBD,wBAAsB,sBAAsB,CAC3C,OAAO,EAAE,UAAU,EACnB,OAAO,GAAE;IAAE,eAAe,CAAC,EAAE,MAAM,CAAA;CAAO,GACxC,OAAO,CAAC,cAAc,EAAE,CAAC,CA6B3B"}

package/dist/svelte/chat-modes.js

@@ -0,0 +1,86 @@
+import * as z from 'zod/v4';
+import { CapabilityError, settle, valueFreeFailure } from '@vibesdotdev/kernel';
+import { getLogger } from '@vibesdotdev/logging';
+import { ChatModesConfigSchema } from '@vibesdotdev/chat/chat-modes/schemas/config';
+import { getRuntimeChatModeDescriptors, mergeChatModes, normalizeRuntimeChatModes } from '@vibesdotdev/chat/chat-modes/helpers';
+const ConfigManifestImplSchema = z.object({
+    data: ChatModesConfigSchema.optional()
+});
+const CONFIG_TIMEOUT_MS = 750;
+/**
+ * The `chat.modes` config entries the handed runtime declares, normalized.
+ * A host with no config manifests, or no `chat.modes` manifest, declares none.
+ */
+export async function loadConfiguredChatModes(runtime) {
+    if (!runtime.hasKind('config/manifest'))
+        return {};
+    const selected = await runtime.query('config/manifest').withId('chat.modes').select();
+    if (!selected)
+        return {};
+    const parsed = ConfigManifestImplSchema.safeParse(selected.impl);
+    if (!parsed.success) {
+        throw new CapabilityError('Configured chat modes manifest is invalid', 'UNAVAILABLE', {
+            cause: valueFreeFailure(parsed.error)
+        });
+    }
+    const data = parsed.data.data;
+    if (!data)
+        return {};
+    return Object.fromEntries(Object.entries(data)
+        .filter(([, mode]) => !!mode)
+        .map(([id, mode]) => [
+        id,
+        {
+            id,
+            name: mode.name ?? id,
+            description: mode.description,
+            icon: mode.icon,
+            sourceType: 'database',
+            enabled: mode.enabled !== false,
+            order: mode.order
+        }
+    ]));
+}
+/**
+ * Configured modes, bounded by the runtime's lifecycle. The selector still
+ * offers the runtime's own modes when the config read fails or is slow; the
+ * failure is reported, never silently read as "none configured".
+ */
+async function loadConfiguredChatModesBounded(runtime, timeoutMs) {
+    const settled = await settle(() => runtime.lifecycle.wait(() => loadConfiguredChatModes(runtime), {
+        timeoutMs,
+        reason: 'chat-modes-config'
+    }));
+    if (settled.ok)
+        return settled.value;
+    const failure = valueFreeFailure(settled.cause);
+    getLogger('chat:modes', runtime).warn('configured chat modes unavailable; offering runtime modes only', {
+        error: failure
+    });
+    return {};
+}
+export async function resolveChatModeOptions(runtime, options = {}) {
+    const runtimeModes = normalizeRuntimeChatModes(getRuntimeChatModeDescriptors(runtime));
+    const configuredModes = await loadConfiguredChatModesBounded(runtime, options.configTimeoutMs ?? CONFIG_TIMEOUT_MS);
+    const merged = mergeChatModes(runtimeModes, configuredModes);
+    return Object.values(merged)
+        .filter((mode) => mode.enabled !== false)
+        // Hidden modes (org-scoped, server-bound — e.g. org workflow) are
+        // resolvable by id but never offered in user-facing selectors.
+        .filter((mode) => mode.hidden !== true)
+        .map((mode) => ({
+        id: mode.id,
+        name: mode.name,
+        description: mode.description,
+        icon: mode.icon,
+        order: mode.order,
+        enabled: mode.enabled
+    }))
+        .sort((a, b) => {
+        const orderA = a.order ?? 100;
+        const orderB = b.order ?? 100;
+        if (orderA !== orderB)
+            return orderA - orderB;
+        return (a.name ?? a.id).localeCompare(b.name ?? b.id);
+    });
+}

package/dist/svelte/chat-svelte.plugin.d.ts

@@ -0,0 +1,4 @@
+export declare const chatSurfacePlugin: import("@vibesdotdev/kernel").RuntimePlugin;
+export declare const chatSveltePlugin: import("@vibesdotdev/kernel").RuntimePlugin;
+export default chatSveltePlugin;
+//# sourceMappingURL=chat-svelte.plugin.d.ts.map

package/dist/svelte/chat-svelte.plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-svelte.plugin.d.ts","sourceRoot":"","sources":["../../src/svelte/chat-svelte.plugin.ts"],"names":[],"mappings":"AAiEA,eAAO,MAAM,iBAAiB,6CAa5B,CAAC;AAEH,eAAO,MAAM,gBAAgB,6CAmK3B,CAAC;AAEH,eAAe,gBAAgB,CAAC"}

package/dist/svelte/chat-svelte.plugin.js

@@ -0,0 +1,124 @@
+import { chatWorkspaceCatalogPlugin } from "./workspace-catalog.js";
+/**
+ * Chat Svelte Plugin — registers Svelte-specific UI descriptors.
+ *
+ * This plugin extracts the `ai/context.ui` descriptors that declare
+ * `surfaces: ['svelte']` from the framework-neutral chat plugin, so that
+ * `@vibesdotdev/chat` stays importable from CLI, TUI, bridge, MCP, and
+ * desktop surfaces without pulling Svelte-aware metadata.
+ *
+ * The framework chat package owns chat-domain schemas and descriptors. This
+ * package owns the Svelte/browser implementations and Svelte-only UI descriptors.
+ */
+import { createRuntimePlugin, loader } from '@vibesdotdev/kernel';
+import { getVibesClient, RuntimeClientDescriptorSchema } from '@vibesdotdev/kernel/client';
+import { chatAiDescriptors, chatAiLoaders } from "./ai/contributions.js";
+import { createSvelteToolWidgetDescriptor, createSvelteToolWidgetLoader } from '@vibesdotdev/tools/svelte/tool-widgets';
+import chatMessagesActionDescriptor from "./ui/chat-messages.action.descriptor.js";
+import chatMessagesFormDescriptor from "./ui/chat-messages.form.descriptor.js";
+import chatMessagesBadgeDescriptor from "./ui/chat-messages.badge.descriptor.js";
+import { DEFAULT_CHAT_COMPOSER_ACTION_DESCRIPTORS, chatComposerActionKind } from "./composer-actions.js";
+import { chatDialogWidgetKind } from "./dialog-widgets.js";
+import workspacesAugmentDescriptor from "./augmentations/workspaces.descriptor.js";
+import workspacesComposerDescriptor from "./augmentations/workspaces.composer.descriptor.js";
+import agentComposerDescriptor from "./augmentations/agent.composer.descriptor.js";
+import modesComposerDescriptor from "./augmentations/modes.composer.descriptor.js";
+import permissionsComposerDescriptor from "./augmentations/permissions.composer.descriptor.js";
+import modelsComposerDescriptor from "./augmentations/models.composer.descriptor.js";
+import visibilityComposerDescriptor from "./augmentations/visibility.composer.descriptor.js";
+import foldersComposerDescriptor from "./augmentations/folders.composer.descriptor.js";
+import responseLengthComposerDescriptor from "./augmentations/response-length.composer.descriptor.js";
+import compactionComposerDescriptor from "./augmentations/compaction.composer.descriptor.js";
+import addAgentsDialogWidgetDescriptor from "./augmentations/add-agents.dialog.descriptor.js";
+import manageAgentsDialogWidgetDescriptor from "./augmentations/manage-agents.dialog.descriptor.js";
+import { manageToolsDialogWidgetDescriptor, manageToolsComposerActionDescriptor, manageToolsDialogWidgetLoader } from "./tools/descriptors.js";
+const CHAT_TOOL_WIDGETS = [
+    {
+        toolId: 'chat-session-report',
+        load: () => import('./tool-widgets/ChatSessionReportToolCard.svelte')
+    },
+    { toolId: 'chat-message', load: () => import('./tool-widgets/ChatMessageToolCard.svelte') },
+    { toolId: 'chat-room', load: () => import('./tool-widgets/ChatRoomToolCard.svelte') }
+];
+const chatToolWidgetDescriptors = CHAT_TOOL_WIDGETS.map((widget) => createSvelteToolWidgetDescriptor({ toolId: widget.toolId }));
+const chatSurfaceDescriptor = RuntimeClientDescriptorSchema.parse({
+    kind: 'runtime/client',
+    id: 'chat.surface',
+    name: 'Chat surface state'
+});
+export const chatSurfacePlugin = createRuntimePlugin({
+    id: 'chat-surface-state',
+    dependencies: ['runtime-client'],
+    descriptors: [chatSurfaceDescriptor],
+    loaders: [
+        loader(chatSurfaceDescriptor.id, { kind: 'runtime/client' }, async () => {
+            const { ChatSurfaceClient } = await import("./surface-client.svelte.js");
+            return { impl: ChatSurfaceClient };
+        })
+    ],
+    async onActivate(runtime) {
+        await getVibesClient(chatSurfaceDescriptor.id, runtime);
+    }
+});
+export const chatSveltePlugin = createRuntimePlugin({
+    id: '@vibesdotdev/chat/svelte',
+    name: 'Chat Svelte',
+    description: 'Svelte-specific chat adapter — registers chat composer action and ai/context.ui descriptors for Svelte chat widgets',
+    dependencies: ['chat'],
+    async onRegister(runtime) { await runtime.registerPlugin(chatSurfacePlugin); },
+    async onActivate(runtime) { await runtime.registerPlugin(chatWorkspaceCatalogPlugin); },
+    kinds: [chatComposerActionKind, chatDialogWidgetKind],
+    descriptors: [
+        ...chatAiDescriptors,
+        // Tools owns tools/ui; Runtime queues these when that optional kind arrives later.
+        ...chatToolWidgetDescriptors,
+        ...DEFAULT_CHAT_COMPOSER_ACTION_DESCRIPTORS,
+        chatMessagesActionDescriptor,
+        chatMessagesFormDescriptor,
+        chatMessagesBadgeDescriptor,
+        workspacesAugmentDescriptor,
+        workspacesComposerDescriptor,
+        agentComposerDescriptor,
+        modesComposerDescriptor,
+        permissionsComposerDescriptor,
+        modelsComposerDescriptor,
+        visibilityComposerDescriptor,
+        foldersComposerDescriptor,
+        responseLengthComposerDescriptor,
+        compactionComposerDescriptor,
+        addAgentsDialogWidgetDescriptor,
+        manageAgentsDialogWidgetDescriptor,
+        manageToolsDialogWidgetDescriptor,
+        manageToolsComposerActionDescriptor
+    ],
+    loaders: [
+        ...chatAiLoaders,
+        ...CHAT_TOOL_WIDGETS.map((widget, index) => createSvelteToolWidgetLoader(chatToolWidgetDescriptors[index], widget.load)),
+        loader('chat-messages.action', { kind: 'ai/context.ui', scope: 'browser' }, () => import('./ui/ChatMessagesAction.svelte')),
+        loader('chat-messages.form', { kind: 'ai/context.ui', scope: 'browser' }, () => import('./ui/ChatMessagesForm.svelte')),
+        loader('chat-messages.badge', { kind: 'ai/context.ui', scope: 'browser' }, () => import('./ui/ChatMessagesBadge.svelte')),
+        loader('chat.augment.modes', { kind: 'ai/augment', scope: 'browser' }, () => import("./augmentations/modes.impl.browser.js")),
+        loader('chat.augment.response-length', { kind: 'ai/augment', scope: 'browser' }, () => import("./augmentations/response-length.impl.browser.js")),
+        loader('chat.augment.visibility', { kind: 'ai/augment', scope: 'browser' }, () => import("./augmentations/visibility.impl.browser.js")),
+        loader('chat.augment.folders', { kind: 'ai/augment', scope: 'browser' }, () => import("./augmentations/folders.impl.browser.js")),
+        loader('chat.augment.messages', { kind: 'ai/augment', scope: 'browser' }, () => import("./augmentations/messages.impl.browser.js")),
+        loader('chat.augment.models', { kind: 'ai/augment', scope: 'browser' }, () => import("./augmentations/models.impl.browser.js")),
+        loader('chat.augment.workspaces', { kind: 'ai/augment', scope: 'browser' }, () => import("./augmentations/workspaces.impl.browser.js")),
+        loader('chat.augment.agent', { kind: 'ai/augment', scope: 'browser' }, () => import("./augmentations/agent.impl.browser.js")),
+        loader('chat.augment.permissions', { kind: 'ai/augment', scope: 'browser' }, () => import("./augmentations/permissions.impl.browser.js")),
+        loader('chat.augment.compaction', { kind: 'ai/augment', scope: 'browser' }, () => import("./augmentations/compaction.impl.browser.js")),
+        loader('chat.augment.workspaces.composer', { kind: 'ai/context.ui', scope: 'browser' }, () => import('./augmentations/workspaces.composer.svelte')),
+        loader('chat.augment.agent.composer', { kind: 'ai/context.ui', scope: 'browser' }, () => import('./augmentations/agent.composer.svelte')),
+        loader('chat.augment.modes.composer', { kind: 'ai/context.ui', scope: 'browser' }, () => import('./augmentations/modes.composer.svelte')),
+        loader('chat.augment.permissions.composer', { kind: 'ai/context.ui', scope: 'browser' }, () => import('./augmentations/permissions.composer.svelte')),
+        loader('chat.augment.models.composer', { kind: 'ai/context.ui', scope: 'browser' }, () => import('./augmentations/models.composer.svelte')),
+        loader('chat.augment.visibility.composer', { kind: 'ai/context.ui', scope: 'browser' }, () => import('./augmentations/visibility.composer.svelte')),
+        loader('chat.augment.folders.composer', { kind: 'ai/context.ui', scope: 'browser' }, () => import('./augmentations/folders.composer.svelte')),
+        loader('chat.augment.response-length.composer', { kind: 'ai/context.ui', scope: 'browser' }, () => import('./augmentations/response-length.composer.svelte')),
+        loader('chat.augment.compaction.composer', { kind: 'ai/context.ui', scope: 'browser' }, () => import('./augmentations/compaction.composer.svelte')),
+        loader('chat.dialog-widget.add-agents', { kind: 'chat/dialog.widget', scope: 'browser' }, () => import('./augmentations/AddAgentsDialog.svelte')),
+        loader('chat.dialog-widget.manage-agents', { kind: 'chat/dialog.widget', scope: 'browser' }, () => import('./augmentations/ManageAgentsDialog.svelte')),
+        manageToolsDialogWidgetLoader
+    ]
+});
+export default chatSveltePlugin;