@mcp-b/react-components 0.14.2 → 0.16.0

package/dist/{ThinkChat-BPcehdbP.js → ThinkChat-CzC-zNGA.js}

@@ -1,5 +1,5 @@
-import { Button } from "./components/Button.js";
 import { AgentChat } from "./components/AgentChat.js";
+import { AgentChatTurnError } from "./components/AgentChatTurnError.js";
 import { ThinkChatContext, useThinkChatContext } from "./components/ThinkChatContext.js";
 import { ThinkChatActivity, createThinkChatActivityRenderer, renderThinkChatActivityPart } from "./components/ThinkChatActivity.js";
 import * as React from "react";
@@ -142,44 +142,32 @@ function ThinkChatMessages({ renderPart, excludeTools, toolRenderers, thinkStub,
 		excludeTools,
 		toolRenderers
 	}), [excludeTools, toolRenderers]);
+	const resolvedRenderPart = React.useMemo(() => renderPart ? (context) => {
+		const renderBuiltIn = () => {
+			const builtIn = defaultRenderPart(context);
+			return builtIn === void 0 ? context.defaultRender() : builtIn;
+		};
+		const custom = renderPart({
+			...context,
+			defaultRender: renderBuiltIn
+		});
+		return custom === void 0 ? renderBuiltIn() : custom;
+	} : defaultRenderPart, [defaultRenderPart, renderPart]);
 	const retryMessageId = chat.error ? chat.messages.findLast((message) => message.role !== "system")?.id : void 0;
 	const defaultNotice = chat.isRecovering ? /* @__PURE__ */ jsx(Fragment, { children: "Reconnecting to the agent…" }) : chat.connectionError ? /* @__PURE__ */ jsxs("span", {
 		"data-tone": "danger",
 		children: ["Connection lost", chat.connectionError.reason ? ` — ${chat.connectionError.reason}` : ""]
-	}) : chat.error ? /* @__PURE__ */ jsxs("div", {
-		className: "agent-chat__turn-error",
-		"data-tone": "danger",
-		children: [/* @__PURE__ */ jsxs("p", {
-			className: "agent-chat__turn-error-message",
-			children: [
-				/* @__PURE__ */ jsx("strong", { children: "Response failed." }),
-				" ",
-				chat.error.message.trim() || "The response could not be completed."
-			]
-		}), /* @__PURE__ */ jsxs("div", {
-			className: "agent-chat__turn-error-actions",
-			children: [/* @__PURE__ */ jsx(Button, {
-				type: "button",
-				variant: "ghost",
-				color: "neutral",
-				size: "lg",
-				onClick: chat.clearError,
-				children: "Dismiss"
-			}), retryMessageId ? /* @__PURE__ */ jsx(Button, {
-				type: "button",
-				color: "primary",
-				size: "lg",
-				onClick: () => {
-					chat.clearError();
-					chat.regenerate({ messageId: retryMessageId });
-				},
-				children: "Try again"
-			}) : null]
-		})]
+	}) : chat.error ? /* @__PURE__ */ jsx(AgentChatTurnError, {
+		error: chat.error,
+		onDismiss: chat.clearError,
+		onRetry: retryMessageId ? () => {
+			chat.clearError();
+			chat.regenerate({ messageId: retryMessageId });
+		} : void 0
 	}) : void 0;
 	return /* @__PURE__ */ jsx(AgentChat, {
 		...props,
-		renderPart: renderPart ?? defaultRenderPart,
+		renderPart: resolvedRenderPart,
 		messages: chat.messages,
 		status,
 		onStop: chat.stop,
@@ -189,10 +177,10 @@ function ThinkChatMessages({ renderPart, excludeTools, toolRenderers, thinkStub,
 		pendingApprovals: resolvedApprovals.pendingApprovals,
 		notice: notice ?? defaultNotice,
 		onRegenerate: (messageId) => void chat.regenerate({ messageId }),
-		onSubmit: ({ text, files }) => {
-			const trimmed = text.trim();
-			if (trimmed || files.length) chat.sendMessage({
-				text: trimmed,
+		onSubmit: ({ text, files, references }) => {
+			const prompt = [...references?.map(({ trigger, value }) => trigger ? `${trigger}${value}` : value) ?? [], text.trim()].filter(Boolean).join(" ");
+			if (prompt || files.length) return chat.sendMessage({
+				text: prompt,
 				files
 			});
 		}

package/dist/{ThinkChatActivity-BmwuIigx.d.ts → ThinkChatActivity-BFQnb2ct.d.ts}

@@ -1,5 +1,5 @@
-import { a as AgentChatRenderPartContext, r as AgentChatProps } from "./AgentChat-DQkqt82e.js";
-import { l as ThinkChatPart } from "./ThinkChatToolParts-CDEjqS6A.js";
+import { i as AgentChatProps, o as AgentChatRenderPartContext } from "./AgentChat-CrlpbvQJ.js";
+import { l as ThinkChatPart } from "./ThinkChatToolParts-CSzVwMXf.js";
 import * as React from "react";
 import { DynamicToolUIPart, ToolUIPart, UIMessage } from "ai";
 
@@ -27,13 +27,6 @@ interface ThinkChatActivityRendererOptions {
   /** Per-tool label/panel overrides inside the activity log, keyed by tool name. */
   toolRenderers?: ThinkChatToolRenderers;
 }
-/**
- * One-line natural-language label for an activity part ("Ran vp test",
- * "Fetched developers.cloudflare.com/agents/"); `null` for boundaries that
- * aren't steps (step-start). Exported so a custom `renderPart` can reuse the
- * built-in labels for tools it doesn't override.
- */
-declare function describeThinkChatActivityPart(part: ThinkChatPart, toolRenderers?: ThinkChatToolRenderers): string | null;
 interface ThinkChatActivityProps {
   /** Render with the log expanded. */
   defaultOpen?: boolean;
@@ -70,4 +63,4 @@ declare function createThinkChatActivityRenderer<MessageT extends UIMessage = UI
 /** Default activity renderer — `createThinkChatActivityRenderer()` with no overrides. */
 declare const renderThinkChatActivityPart: (context: AgentChatRenderPartContext<UIMessage<unknown, import("ai").UIDataTypes, import("ai").UITools>>) => React.ReactNode | undefined;
 //#endregion
-export { ThinkChatToolRenderers as a, renderThinkChatActivityPart as c, ThinkChatToolRenderer as i, ThinkChatActivityProps as n, createThinkChatActivityRenderer as o, ThinkChatActivityRendererOptions as r, describeThinkChatActivityPart as s, ThinkChatActivity as t };
+export { ThinkChatToolRenderers as a, ThinkChatToolRenderer as i, ThinkChatActivityProps as n, createThinkChatActivityRenderer as o, ThinkChatActivityRendererOptions as r, renderThinkChatActivityPart as s, ThinkChatActivity as t };

package/dist/ThinkChatActivitySummary-BPmu9a-c.d.ts

@@ -0,0 +1,39 @@
+import { i as AgentActivityIconKind, s as AgentActivitySummary } from "./AgentActivity-BNUNrP9O.js";
+import { l as ThinkChatPart } from "./ThinkChatToolParts-CSzVwMXf.js";
+import { DynamicToolUIPart, ToolUIPart } from "ai";
+
+//#region src/components/ThinkChatActivitySummary.d.ts
+interface ThinkChatToolDescriber {
+  describe?: (part: ToolUIPart | DynamicToolUIPart) => string | null | undefined;
+}
+type ThinkChatToolDescribers = Record<string, ThinkChatToolDescriber>;
+type ThinkChatActivityHeader = Omit<AgentActivitySummary, "mode">;
+declare function activityPartUrl(part: ThinkChatPart): string | null;
+declare function activityPartIconKind(part: ThinkChatPart): AgentActivityIconKind;
+/**
+ * One-line natural-language label for an activity part ("Ran vp test",
+ * "Fetched developers.cloudflare.com/agents/"); `null` for boundaries that
+ * aren't steps (step-start). Exported so a custom `renderPart` can reuse the
+ * built-in labels for tools it doesn't override.
+ */
+declare function describeThinkChatActivityPart(part: ThinkChatPart, toolRenderers?: ThinkChatToolDescribers): string | null;
+declare function summarizeActivitySteps(parts: readonly ThinkChatPart[]): string;
+interface ThinkChatToolLifecycleSnapshot {
+  toolName: string;
+  input?: unknown;
+  state: "working" | "succeeded" | "failed" | "approval-required";
+  output?: unknown;
+  error?: unknown;
+}
+/** Derive the serializable collapsed header from persisted AI SDK message parts. */
+declare function deriveThinkChatActivityHeader(parts: readonly ThinkChatPart[], options?: {
+  isStreaming?: boolean;
+  toolDescribers?: ThinkChatToolDescribers;
+}): ThinkChatActivityHeader | null;
+/**
+ * Derive the same live header from a host lifecycle event without making the
+ * host manufacture an AI SDK UI message part.
+ */
+declare function deriveThinkChatToolLifecycleHeader(snapshot: ThinkChatToolLifecycleSnapshot): ThinkChatActivityHeader;
+//#endregion
+export { activityPartIconKind as a, deriveThinkChatToolLifecycleHeader as c, ThinkChatToolLifecycleSnapshot as i, describeThinkChatActivityPart as l, ThinkChatToolDescriber as n, activityPartUrl as o, ThinkChatToolDescribers as r, deriveThinkChatActivityHeader as s, ThinkChatActivityHeader as t, summarizeActivitySteps as u };

package/dist/{ThinkChatToolParts-CDEjqS6A.d.ts → ThinkChatToolParts-CSzVwMXf.d.ts}

@@ -1,4 +1,4 @@
-import { InferUITools, ToolUIPart, UIMessage } from "ai";
+import { DynamicToolUIPart, InferUITools, ToolUIPart, UIMessage } from "ai";
 import { ProxyToolInput, ProxyToolOutput } from "@cloudflare/codemode";
 import { QuickActionExtractInput, QuickActionPage, QuickActionScrapeInput, QuickActionToolName } from "@cloudflare/think/tools/browser";
 import { FetchResponseMode, FetchResult } from "@cloudflare/think/tools/fetch";
@@ -6,6 +6,16 @@ import { WorkspaceTools } from "@cloudflare/think/tools/workspace";
 
 //#region src/components/ThinkChatToolParts.d.ts
 type ThinkChatPart = UIMessage["parts"][number];
+type AnyToolUIPart = ToolUIPart | DynamicToolUIPart;
+/** Prefer AI SDK's provider/tool-authored title over its transport-facing key. */
+declare function getToolDisplayName(part: AnyToolUIPart): string;
+/**
+ * Whole-part supplement to Think's simplified state mapping. Think maps every
+ * `output-available` part to complete, while AI SDK preliminary outputs remain
+ * in flight until a non-preliminary result arrives.
+ */
+declare function isToolPartWorking(part: AnyToolUIPart): boolean;
+declare function isToolPartFailed(part: AnyToolUIPart): boolean;
 type WorkspaceUITools = InferUITools<Required<WorkspaceTools>>;
 type WorkspaceToolPart = ToolUIPart<WorkspaceUITools>;
 type ThinkWorkspaceToolName = keyof WorkspaceUITools;
@@ -131,10 +141,10 @@ type ExecuteToolPart = ToolUIPart<{
 declare function isExecuteToolPart(part: ThinkChatPart): part is ExecuteToolPart;
 /** Agent work (reasoning, tool calls, step boundaries) vs. content shown to the user. */
 declare function isThinkChatActivityPart(part: ThinkChatPart | undefined, excludeTools?: ReadonlySet<string>): boolean;
-/** In-flight: the stream opened this part but hasn't delivered its result yet. */
+/** In-flight: awaiting input, approval continuation, or a final tool result. */
 declare function isPartWorking(part: ThinkChatPart): boolean;
 /** Errored or denied — upstream's simplified tool-part state vocabulary. */
 declare function isPartFailed(part: ThinkChatPart): boolean;
 declare function displayUrl(url: string | undefined): string;
 //#endregion
-export { isWorkspaceToolPart as S, isPartWorking as _, SessionContextToolPart as a, isSkillToolPart as b, ThinkBashToolPart as c, WorkspaceToolPart as d, displayUrl as f, isPartFailed as g, isFetchToolPart as h, SessionContextToolName as i, ThinkChatPart as l, isExecuteToolPart as m, ExecuteToolPart as n, SkillToolPart as o, isBrowserToolPart as p, FetchToolPart as r, ThinkBashToolOutput as s, BrowserToolPart as t, ThinkWorkspaceToolName as u, isSessionContextToolFailure as v, isThinkChatActivityPart as x, isSessionContextToolPart as y };
+export { isToolPartFailed as C, isThinkChatActivityPart as S, isWorkspaceToolPart as T, isPartFailed as _, SessionContextToolPart as a, isSessionContextToolPart as b, ThinkBashToolPart as c, WorkspaceToolPart as d, displayUrl as f, isFetchToolPart as g, isExecuteToolPart as h, SessionContextToolName as i, ThinkChatPart as l, isBrowserToolPart as m, ExecuteToolPart as n, SkillToolPart as o, getToolDisplayName as p, FetchToolPart as r, ThinkBashToolOutput as s, BrowserToolPart as t, ThinkWorkspaceToolName as u, isPartWorking as v, isToolPartWorking as w, isSkillToolPart as x, isSessionContextToolFailure as y };

package/dist/ThinkExecutionRun-ChhWhOoU.d.ts

@@ -0,0 +1,30 @@
+import { ThinkSubmissionInspection } from "@cloudflare/think";
+import { WorkflowInfo } from "agents/workflows";
+
+//#region src/components/ThinkExecutionRun.d.ts
+/** Whole upstream execution records displayed by Think routine and execution surfaces. */
+type ThinkExecutionRun = ThinkSubmissionInspection | WorkflowInfo;
+/** Narrows the direct upstream execution union without wrapping either record. */
+declare function isThinkSubmissionRun(run: ThinkExecutionRun): run is ThinkSubmissionInspection;
+type ThinkExecutionStatusTone = "success" | "danger" | "warning" | "primary" | "neutral";
+declare function getThinkExecutionRunId(run: ThinkExecutionRun): string;
+declare function getThinkExecutionRunTitle(run: ThinkExecutionRun): string;
+declare function getThinkExecutionRunSubtitle(run: ThinkExecutionRun): string | undefined;
+declare function getThinkExecutionRunProgressedAt(run: ThinkExecutionRun): number | Date | undefined;
+declare function getThinkExecutionRunProgressedLabel(run: ThinkExecutionRun): "Started" | "Updated";
+/**
+ * WorkflowInfo.status resolves through the Workers-only InstanceStatus ambient
+ * type, so browser consumers format the whole upstream record's runtime value
+ * instead of exporting a local mirror of that union.
+ */
+declare function getThinkExecutionRunStatus(run: ThinkExecutionRun): string;
+declare function getThinkExecutionRunStatusTone(run: ThinkExecutionRun): ThinkExecutionStatusTone;
+declare function formatThinkExecutionStatus(status: string): string;
+declare function formatThinkExecutionTimestamp(value: Date | number | null | undefined, fallback?: string): string;
+declare function formatThinkExecutionShortTimestamp(value: Date | number | null | undefined, fallback?: string): string;
+declare function formatThinkExecutionRunProgress(run: ThinkExecutionRun): string;
+declare function getThinkExecutionRunAccessibleName(run: ThinkExecutionRun): string;
+declare function getThinkExecutionRunError(run: ThinkExecutionRun): string | undefined;
+declare function isSameThinkExecutionRun(first: ThinkExecutionRun | null, second: ThinkExecutionRun): boolean;
+//#endregion
+export { isThinkSubmissionRun as _, formatThinkExecutionStatus as a, getThinkExecutionRunError as c, getThinkExecutionRunProgressedLabel as d, getThinkExecutionRunStatus as f, isSameThinkExecutionRun as g, getThinkExecutionRunTitle as h, formatThinkExecutionShortTimestamp as i, getThinkExecutionRunId as l, getThinkExecutionRunSubtitle as m, ThinkExecutionStatusTone as n, formatThinkExecutionTimestamp as o, getThinkExecutionRunStatusTone as p, formatThinkExecutionRunProgress as r, getThinkExecutionRunAccessibleName as s, ThinkExecutionRun as t, getThinkExecutionRunProgressedAt as u };

package/dist/Toggle-CAAlNl-M.d.ts

@@ -0,0 +1,69 @@
+import * as React from "react";
+import { Toggle } from "@base-ui/react/toggle";
+
+//#region src/components/Toggle.d.ts
+interface ToggleVariantsOptions {
+  variant?: "default" | "outline" | null;
+  size?: "default" | "sm" | "lg" | null;
+  className?: string;
+}
+/**
+ * Props for the Toggle component.
+ */
+interface ToggleProps extends Omit<React.ComponentPropsWithoutRef<typeof Toggle>, "className">, ToggleVariantsOptions {}
+declare function toggleVariants({
+  variant,
+  size,
+  className
+}?: ToggleVariantsOptions): string;
+/**
+ * A two-state button that can be on (pressed) or off.
+ * Useful for toggling a setting or mode.
+ *
+ * @example
+ * ```tsx
+ * // Basic toggle
+ * <Toggle>
+ *   Bold
+ * </Toggle>
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Controlled toggle
+ * const [pressed, setPressed] = useState(false);
+ *
+ * <Toggle pressed={pressed} onPressedChange={setPressed}>
+ *   {pressed ? 'On' : 'Off'}
+ * </Toggle>
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With icons
+ * <Toggle>
+ *   {({ pressed }) => pressed ? <BoldIcon filled /> : <BoldIcon />}
+ * </Toggle>
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Default pressed state
+ * <Toggle defaultPressed>
+ *   Enabled
+ * </Toggle>
+ * ```
+ *
+ * @see {@link https://base-ui.com/react/components/toggle | Base UI Toggle}
+ */
+declare function Toggle$1({
+  className,
+  variant,
+  size,
+  ref,
+  ...props
+}: ToggleProps & {
+  ref?: React.Ref<HTMLButtonElement>;
+}): React.JSX.Element;
+//#endregion
+export { toggleVariants as i, ToggleProps as n, ToggleVariantsOptions as r, Toggle$1 as t };

package/dist/ToggleGroup-8hPv-b69.d.ts

@@ -0,0 +1,73 @@
+import { r as ToggleVariantsOptions } from "./Toggle-CAAlNl-M.js";
+import * as React from "react";
+import { ToggleGroup } from "@base-ui/react/toggle-group";
+import { Toggle } from "@base-ui/react/toggle";
+
+//#region src/components/ToggleGroup.d.ts
+type ToggleGroupSize = ToggleVariantsOptions["size"] | "md";
+interface ToggleGroupProps extends Omit<React.ComponentPropsWithRef<typeof ToggleGroup>, "className"> {
+  className?: string;
+  variant?: ToggleVariantsOptions["variant"];
+  /**
+   * The size of the toggle group.
+   * @default 'md'
+   */
+  size?: ToggleGroupSize;
+  spacing?: number;
+}
+interface ToggleGroupItemProps extends Omit<React.ComponentPropsWithRef<typeof Toggle>, "className">, ToggleVariantsOptions {}
+/**
+ * A toggle group component for selecting one or multiple options.
+ *
+ * @example
+ * ```tsx
+ * // Single selection (defaultValue is an array)
+ * <ToggleGroup defaultValue={["center"]}>
+ *   <ToggleGroupItem value="left">Left</ToggleGroupItem>
+ *   <ToggleGroupItem value="center">Center</ToggleGroupItem>
+ *   <ToggleGroupItem value="right">Right</ToggleGroupItem>
+ * </ToggleGroup>
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Multiple selection
+ * <ToggleGroup multiple defaultValue={["bold", "italic"]}>
+ *   <ToggleGroupItem value="bold">Bold</ToggleGroupItem>
+ *   <ToggleGroupItem value="italic">Italic</ToggleGroupItem>
+ *   <ToggleGroupItem value="underline">Underline</ToggleGroupItem>
+ * </ToggleGroup>
+ * ```
+ *
+ * @see {@link https://base-ui.com/react/components/toggle-group | Base UI Toggle Group}
+ */
+declare function ToggleGroupRoot({
+  size,
+  spacing,
+  variant,
+  className,
+  children,
+  style,
+  ref,
+  ...props
+}: ToggleGroupProps & {
+  ref?: React.Ref<HTMLDivElement>;
+}): React.JSX.Element;
+/**
+ * A single toggle item within a ToggleGroup.
+ */
+declare function ToggleGroupItem({
+  className,
+  variant,
+  size,
+  ref,
+  ...props
+}: ToggleGroupItemProps & {
+  ref?: React.Ref<HTMLButtonElement>;
+}): React.JSX.Element;
+declare const ToggleGroup$1: {
+  Root: typeof ToggleGroupRoot;
+  Item: typeof ToggleGroupItem;
+};
+//#endregion
+export { ToggleGroupItemProps as n, ToggleGroupProps as r, ToggleGroup$1 as t };

package/dist/Workspace-D39LxGvP.d.ts

@@ -0,0 +1,62 @@
+import { i as WorkspaceFileState, r as WorkspaceFileAssetResolver } from "./WorkspaceFile-DOZkPwzu.js";
+import { WorkspaceLike } from "@cloudflare/think";
+import { FileInfo, Workspace } from "@cloudflare/shell";
+
+//#region src/components/Workspace.d.ts
+/** Workspace summary, as returned by `Workspace.getWorkspaceInfo()` upstream. */
+type WorkspaceInfo = Awaited<ReturnType<Workspace["getWorkspaceInfo"]>>;
+/** Whole upstream workspace shapes, accepted without narrowing or mirroring. */
+type WorkspaceSource = Workspace | WorkspaceLike;
+interface UseWorkspaceOptions {
+  /** Must be referentially stable (memoize in the app) — a new source resets the workspace. */
+  source: WorkspaceSource;
+  /** Root directory to list first. Defaults to "/". */
+  root?: string;
+  /**
+   * Optional host adapter called before text/binary reads. Return `null` for
+   * ordinary text files and prefer signed/range-friendly URLs for large media.
+   * The configured root scopes navigation; hosts must enforce authorization
+   * atomically when resolving assets across a trust boundary.
+   */
+  resolveFileAsset?: WorkspaceFileAssetResolver;
+  /** Maximum size for the built-in buffered-byte fallback. Defaults to 32 MiB. */
+  maxInlineAssetBytes?: number;
+}
+interface WorkspaceState {
+  root: string;
+  /** Loaded directory listings, keyed by directory path. */
+  entriesByDirectory: Readonly<Record<string, readonly FileInfo[]>>;
+  /** Every loaded entry, keyed by its path. */
+  entryByPath: ReadonlyMap<string, FileInfo>;
+  expandedPaths: ReadonlySet<string>;
+  /** Update expansion; newly expanded directories load lazily. */
+  setExpandedPaths: (next: Set<string>) => void;
+  selectedPath: string | null;
+  /** Select a file and load it. Text is cached; binary assets remain active-file only. */
+  selectFile: (path: string | null) => void;
+  /** The selected file once its read settles; null while loading. */
+  selectedFile: WorkspaceFileState | null;
+  /** Root listing in flight. */
+  isLoading: boolean;
+  /** Directory and file paths with a request in flight. */
+  loadingPaths: ReadonlySet<string>;
+  /** Root/directory listing failure. Per-file read errors live on the file state. */
+  error: string | null;
+  /** Workspace summary, when the source provides `getWorkspaceInfo`. */
+  info: WorkspaceInfo | null;
+  /** Reload the root, every expanded directory, and the selected file. */
+  refresh: () => void;
+}
+/**
+ * Headless state for browsing a Think workspace: lazy directory loading,
+ * cached file reads, expansion/selection, and refresh. Feed the result to
+ * `WorkspaceExplorer`, or compose `WorkspaceBrowser` and `WorkspaceFileView`.
+ */
+declare function useWorkspace({
+  source,
+  root,
+  resolveFileAsset,
+  maxInlineAssetBytes
+}: UseWorkspaceOptions): WorkspaceState;
+//#endregion
+export { useWorkspace as a, WorkspaceState as i, WorkspaceInfo as n, WorkspaceSource as r, UseWorkspaceOptions as t };

package/dist/WorkspaceFile-DOZkPwzu.d.ts

@@ -0,0 +1,106 @@
+import { A as CodeBlockLanguage } from "./CodeBlock-BRajW4QU.js";
+import { SkillParseResult } from "agent-skills-ts-sdk";
+import { FileInfo } from "@cloudflare/shell";
+
+//#region src/components/WorkspaceFile.d.ts
+type WorkspaceMediaKind = "image" | "pdf" | "audio" | "video";
+interface WorkspaceMediaInfo {
+  kind: WorkspaceMediaKind;
+  mimeType: string;
+}
+type WorkspaceMediaTrackKind = "subtitles" | "captions" | "descriptions" | "chapters" | "metadata";
+/** Optional timed text supplied by a host alongside an audio or video asset. */
+interface WorkspaceMediaTrack {
+  src: string;
+  kind: WorkspaceMediaTrackKind;
+  srcLang: string;
+  label: string;
+  default?: boolean;
+}
+interface WorkspaceFileAssetMetadata {
+  mimeType?: string;
+  size?: number;
+  /** Meaningful image alternative. Empty or omitted values fall back to the file name. */
+  alt?: string;
+  /** Optional video poster URL. */
+  posterUrl?: string;
+  /** CORS mode for audio/video and cross-origin timed-text tracks. */
+  crossOrigin?: "anonymous" | "use-credentials";
+  /** Optional caption, subtitle, description, chapter, or metadata tracks. */
+  tracks?: readonly WorkspaceMediaTrack[];
+  /** Optional transcript destination shown alongside audio and video previews. */
+  transcriptUrl?: string;
+}
+/** A host-owned URL or component-owned buffered data for the active workspace file. */
+type WorkspaceFileAsset = (WorkspaceFileAssetMetadata & {
+  kind: "url";
+  /**
+   * HTTP(S), relative, or blob URL owned by the host. The component never
+   * revokes it, so it must remain valid for the preview lifetime. PDF URLs
+   * must serve `application/pdf` with `X-Content-Type-Options: nosniff`.
+   */
+  url: string;
+  /**
+   * Optional host-owned download destination. Cross-origin endpoints must
+   * use `Content-Disposition: attachment`; SVG also requires attachment
+   * semantics or an isolated asset origin.
+   */
+  downloadUrl?: string;
+}) | (WorkspaceFileAssetMetadata & {
+  kind: "data"; /** Buffered data whose component-created object URL is revoked on replacement/unmount. */
+  data: Blob | ArrayBuffer | Uint8Array;
+});
+interface WorkspaceFileAssetRequest {
+  /**
+   * Canonical path reported by `source.stat()`. Use this path, not
+   * `requestedPath`, when issuing a host-owned asset URL.
+   */
+  path: string;
+  /** Path selected in the explorer. This can name a symlink. */
+  requestedPath: string;
+  /** Normalized navigation root configured on `useWorkspace`. */
+  root: string;
+  /** Fresh metadata from `source.stat()`. The resolver is never called without it. */
+  info: FileInfo;
+  signal: AbortSignal;
+}
+/**
+ * Host adapter for signed/range-friendly URLs or custom binary loading.
+ * `useWorkspace` performs defense-in-depth path checks, but its `stat()` and
+ * read calls are not atomic. Hosts that treat `root` as an authorization
+ * boundary must authorize and resolve the asset atomically in this callback
+ * (preferably by immutable file identity), then return its URL or bytes.
+ */
+type WorkspaceFileAssetResolver = (request: WorkspaceFileAssetRequest) => WorkspaceFileAsset | null | Promise<WorkspaceFileAsset | null>;
+interface WorkspaceFileState {
+  path: string;
+  name: string;
+  /** Text content. Media previews leave this `null` and populate `asset`. */
+  content: string | null;
+  /** Binary asset for a supported image, PDF, audio, or video file. */
+  asset?: WorkspaceFileAsset | null;
+  /** Upstream metadata when the file was present in a loaded directory. */
+  info?: FileInfo | null;
+  error: string | null;
+}
+/** Agent Skills SDK result attached to a workspace `SKILL.md` preview. */
+interface WorkspaceSkillDocument {
+  parsed: SkillParseResult | null;
+  validationErrors: readonly string[];
+}
+declare function getWorkspaceBasename(path: string): string;
+declare function isWorkspaceMarkdownPath(path: string): boolean;
+declare function isWorkspaceSkillPath(path: string): boolean;
+/**
+ * Identify supported browser-native media before reading a file as text.
+ * A precise supported MIME wins; extensions provide the fallback for stores
+ * that report generic values such as `application/octet-stream`.
+ */
+declare function inferWorkspaceMedia(path: string, mimeType?: string | null): WorkspaceMediaInfo | null;
+declare function isWorkspaceMediaPath(path: string, mimeType?: string | null): boolean;
+/** Parse and validate a workspace skill with the canonical Agent Skills SDK. */
+declare function parseWorkspaceSkill(content: string): WorkspaceSkillDocument;
+/** Best-effort syntax-highlighting language from a file path; unknown extensions render as plain text. */
+declare function inferWorkspaceLanguage(path: string): CodeBlockLanguage;
+//#endregion
+export { WorkspaceMediaInfo as a, WorkspaceMediaTrackKind as c, inferWorkspaceLanguage as d, inferWorkspaceMedia as f, parseWorkspaceSkill as g, isWorkspaceSkillPath as h, WorkspaceFileState as i, WorkspaceSkillDocument as l, isWorkspaceMediaPath as m, WorkspaceFileAssetRequest as n, WorkspaceMediaKind as o, isWorkspaceMarkdownPath as p, WorkspaceFileAssetResolver as r, WorkspaceMediaTrack as s, WorkspaceFileAsset as t, getWorkspaceBasename as u };