@mcp-b/react-components 0.14.1 → 0.16.0

package/dist/{Select-Dl_vF_Bt.d.ts → Select-BeEsefzh.d.ts}

@@ -3,6 +3,9 @@ import { Select } from "@base-ui/react/select";
 
 //#region src/components/Select.d.ts
 type SelectProps<Value = unknown> = Select.Root.Props<Value>;
+interface SelectLabelProps extends Omit<Select.Label.Props, "className"> {
+  className?: string;
+}
 interface SelectTriggerProps extends Omit<Select.Trigger.Props, "className"> {
   className?: string;
   /**
@@ -80,6 +83,13 @@ interface SelectScrollDownArrowProps extends Omit<Select.ScrollDownArrow.Props,
  * @see {@link https://base-ui.com/react/components/select | Base UI Select}
  */
 declare function SelectRoot<Value>(props: SelectProps<Value>): React.JSX.Element;
+declare function SelectLabel({
+  className,
+  ref,
+  ...props
+}: SelectLabelProps & {
+  ref?: React.Ref<HTMLDivElement>;
+}): React.JSX.Element;
 declare function SelectTrigger({
   size,
   className,
@@ -190,7 +200,7 @@ declare function SelectScrollDownArrow({
 }): React.JSX.Element;
 declare const Select$1: {
   Root: typeof SelectRoot;
-  Label: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").SelectLabelProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+  Label: typeof SelectLabel;
   Trigger: typeof SelectTrigger;
   Value: typeof SelectValue;
   Icon: typeof SelectIcon;
@@ -210,4 +220,4 @@ declare const Select$1: {
   ScrollDownArrow: typeof SelectScrollDownArrow;
 };
 //#endregion
-export { SelectTriggerProps as _, SelectIconProps as a, SelectItemTextProps as c, SelectPortalProps as d, SelectPositionerProps as f, SelectSeparatorProps as g, SelectScrollUpArrowProps as h, SelectGroupProps as i, SelectListProps as l, SelectScrollDownArrowProps as m, SelectBackdropProps as n, SelectItemIndicatorProps as o, SelectProps as p, SelectGroupLabelProps as r, SelectItemProps as s, Select$1 as t, SelectPopupProps as u, SelectValueProps as v };
+export { SelectSeparatorProps as _, SelectIconProps as a, SelectItemTextProps as c, SelectPopupProps as d, SelectPortalProps as f, SelectScrollUpArrowProps as g, SelectScrollDownArrowProps as h, SelectGroupProps as i, SelectLabelProps as l, SelectProps as m, SelectBackdropProps as n, SelectItemIndicatorProps as o, SelectPositionerProps as p, SelectGroupLabelProps as r, SelectItemProps as s, Select$1 as t, SelectListProps as u, SelectTriggerProps as v, SelectValueProps as y };

package/dist/{ThinkChat-7DQ2CogF.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";
@@ -119,7 +119,9 @@ const ThinkChatApprovalsContext = React.createContext(null);
 * The full conversation surface — message list plus composer — with the
 * activity renderer as the default `renderPart`: runs of reasoning/tool parts
 * fold into one collapsed Activity block with derived labels and per-tool
-* panels. Extend for app-specific tools with `toolRenderers` (label/panel
+* panels. Session-generated context/load/search tools are recognized from
+* their upstream runtime schemas and keep their recorded inputs and outputs
+* inspectable. Extend for app-specific tools with `toolRenderers` (label/panel
 * inside the log) or `excludeTools` + your own `renderPart` (standalone
 * card) — see README "App-specific tools" and the Custom Tool Panel story.
 */
@@ -140,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,
@@ -187,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-m9orbdeI.d.ts → ThinkChatActivity-BFQnb2ct.d.ts}

@@ -1,5 +1,5 @@
-import { a as AgentChatRenderPartContext, r as AgentChatProps } from "./AgentChat-Cgb1xuT7.js";
-import { s as ThinkChatPart } from "./ThinkChatToolParts-Cv4o7j6F.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-Cv4o7j6F.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;
@@ -39,6 +49,55 @@ type SkillUITools = {
 };
 type SkillToolPart = ToolUIPart<SkillUITools>;
 declare function isSkillToolPart(part: ThinkChatPart): part is SkillToolPart;
+type SetContextInput = {
+  label: string;
+  content: string;
+  action?: "replace" | "append";
+  metadata?: {
+    title?: string;
+    description?: string;
+  };
+};
+type SessionContextUITools = {
+  set_context: {
+    input: SetContextInput;
+    output: string;
+  };
+  load_context: {
+    input: {
+      label: string;
+      key: string;
+    };
+    output: string;
+  };
+  unload_context: {
+    input: {
+      label: string;
+      key: string;
+    };
+    output: string;
+  };
+  search_context: {
+    input: {
+      label: string;
+      query: string;
+    };
+    output: string;
+  };
+  session_search: {
+    input: {
+      query: string;
+    };
+    output: string;
+  };
+};
+type SessionContextToolPart = ToolUIPart<SessionContextUITools>;
+type SessionContextToolName = keyof SessionContextUITools;
+declare function isSessionContextToolPart(part: ThinkChatPart): part is SessionContextToolPart;
+/** Session tools report provider failures as successful string outputs so the
+    model can recover. Treat that upstream `Error:` envelope as failed UI while
+    preserving the recorded tool state and output verbatim. */
+declare function isSessionContextToolFailure(part: SessionContextToolPart): boolean;
 type FetchToolInput = {
   url: string;
   path?: never;
@@ -82,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 { isThinkChatActivityPart as _, ThinkBashToolOutput as a, ThinkWorkspaceToolName as c, isBrowserToolPart as d, isExecuteToolPart as f, isSkillToolPart as g, isPartWorking as h, SkillToolPart as i, WorkspaceToolPart as l, isPartFailed as m, ExecuteToolPart as n, ThinkBashToolPart as o, isFetchToolPart as p, FetchToolPart as r, ThinkChatPart as s, BrowserToolPart as t, displayUrl as u, isWorkspaceToolPart as v };
+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 };