@mcp-b/react-components 0.48.0 → 0.49.0

package/dist/ThinkChat-CwMdEum8.d.ts

@@ -1,185 +0,0 @@
-import { i as AgentMessageRenderPartContext } from "./AgentMessageParts-C7L-Mv9U.js";
-import { K as PromptInputMessage } from "./PromptInput-DtJHyp0S.js";
-import { r as AgentChatProps } from "./AgentChat-BLmQghkt.js";
-import { n as AgentToolEventsValue } from "./AgentToolRunsContext-jtmveaRE.js";
-import { o as UseSessionCompactionResult } from "./SessionCompaction-CmTJFpzj.js";
-import { o as createThinkChatActivityRenderer, r as ThinkChatActivityRendererOptions, t as ThinkChatActivity } from "./ThinkChatActivity-B3lGVS-6.js";
-import { i as ThinkChatValue } from "./ThinkChatContext-COIgzkYp.js";
-import { t as ThinkRecoveryNotice } from "./ThinkRecoveryNotice-DGWr94rk.js";
-import { n as WorkspaceFileRenderer } from "./WorkspaceMessageResponse-kJYU8Onj.js";
-import * as React from "react";
-import { UIMessage } from "ai";
-import { UseAgentOptions } from "agents/react";
-import { DataTag, UndefinedInitialDataOptions } from "@tanstack/react-query";
-import { PendingApproval, Think } from "@cloudflare/think";
-import { AgentStub } from "agents/client";
-
-//#region src/components/agents-sdk/ThinkChat.d.ts
-type ThinkPendingExecutionApprovalsQueryKey = readonly ["think", sourceKey: string, "pending-approvals"];
-type ThinkPendingExecutionApprovalsQueryOptions = UndefinedInitialDataOptions<readonly PendingApproval[], Error, readonly PendingApproval[], ThinkPendingExecutionApprovalsQueryKey> & {
-  queryKey: DataTag<ThinkPendingExecutionApprovalsQueryKey, readonly PendingApproval[], Error>;
-};
-interface ThinkChatProviderProps<State = unknown, MessageT extends UIMessage = UIMessage> {
-  /** The `useAgentChat` value from `@cloudflare/think/react` that descendants read. */
-  chat: ThinkChatValue<State, MessageT>;
-  /** Optional whole `useAgentToolEvents` result when the app owns the parent connection. */
-  agentTools?: AgentToolEventsValue<MessageT["parts"][number]>;
-  children: React.ReactNode;
-}
-interface ThinkChatRootProps<State = unknown> {
-  /** Agent to connect to: a kebab-case class name, or full `useAgent` options. */
-  agent: string | UseAgentOptions<State>;
-  /** Disable durable pending-approval discovery. Also disable it on `ThinkChat.Messages`. */
-  approvalsEnabled?: boolean;
-  /** Instance name (e.g. a session or room id). Wins over `agent.name`. */
-  name?: string;
-  /**
-   * Stable, non-secret identity for the remote Think agent. Include endpoint,
-   * account or tenant scope, and agent path so sources cannot share cached data.
-   */
-  sourceKey: string;
-  children: React.ReactNode;
-}
-/**
- * The first-turn surface with no conversation behind it. Supply this instead of
- * a chat provider when the composer's submission is what creates the
- * conversation: connecting early is what leaves empty threads behind.
- */
-interface ThinkChatDraft<MessageT extends UIMessage = UIMessage> {
-  /** Client-only transcript rows, such as a locally rendered guide. */
-  messages?: readonly MessageT[];
-  /** Receives the first message, normalized the same way a live thread's is. */
-  onSubmit: (message: {
-    text: string;
-    files: PromptInputMessage["files"];
-  }) => void | Promise<void>;
-  /** Set while the app is creating the conversation, so the composer reads busy. */
-  status?: AgentChatProps<MessageT>["status"];
-}
-type ThinkChatManagedAgentChatProp = "messages" | "onApprovalResponse" | "onRegenerate" | "onStop" | "onSubmit" | "status";
-/**
- * The AgentChat composition surface, minus the live values ThinkChat supplies
- * from `useAgentChat`. Think-specific activity and draft/session inputs extend
- * that owner instead of mirroring every AgentChat prop here.
- */
-type ThinkChatMessagesProps<MessageT extends UIMessage = UIMessage> = Omit<AgentChatProps<MessageT>, ThinkChatManagedAgentChatProp> & ThinkChatActivityRendererOptions<MessageT> & {
-  /**
-   * Renders without a chat provider, for the first turn of a conversation
-   * that does not exist yet.
-   */
-  draft?: ThinkChatDraft<MessageT>; /** Whole `useSessionCompaction` result for built-in progress and error notices. */
-  sessionCompaction?: UseSessionCompactionResult;
-  /**
-   * Promotes one standalone assistant workspace file link through a host
-   * callback. Return a node to replace the link, or `null` to keep it.
-   */
-  renderWorkspaceFile?: WorkspaceFileRenderer;
-};
-/** Shared pending-approval options for components and TanStack Router loaders. */
-declare function thinkPendingExecutionApprovalsQueryOptions(stub: AgentStub<Think>, sourceKey: string): ThinkPendingExecutionApprovalsQueryOptions;
-declare function useThinkPendingExecutionApprovals(stub: AgentStub<Think>, sourceKey: string, refreshSignal?: unknown, enabled?: boolean): {
-  pendingApprovals: readonly PendingApproval[];
-  refreshPendingApprovals: () => Promise<void>;
-};
-/**
- * Chat UI for Cloudflare Think agents. Provide a `useAgentChat` value (or let
- * `ThinkChat.Root` create one) and `ThinkChat.Messages` renders the message
- * stream with agent work folded into collapsed Activity blocks.
- */
-declare function ThinkChatProvider<State = unknown, MessageT extends UIMessage = UIMessage>({
-  agentTools,
-  chat,
-  children
-}: ThinkChatProviderProps<State, MessageT>): React.JSX.Element;
-/**
- * Batteries-included root: connects to the named Think agent (upstream's
- * `useAgent` + `useAgentChat`) and provides the live chat to everything
- * inside. Render it beneath the app's `QueryClientProvider`. If the app
- * already owns the chat hook, use `ThinkChat.Provider`.
- *
- * @example
- * ```tsx
- * <QueryClientProvider client={queryClient}>
- *   <ThinkChat.Root
- *     agent="my-agent"
- *     name="session-1"
- *     sourceKey="api.example.com:account:acme:agent:session-1"
- *   >
- *     <ThinkChat.Messages />
- *   </ThinkChat.Root>
- * </QueryClientProvider>
- * ```
- */
-declare function ThinkChatRoot<State = unknown, MessageT extends UIMessage = UIMessage>({
-  agent: agentOption,
-  approvalsEnabled,
-  name,
-  sourceKey,
-  children
-}: ThinkChatRootProps<State>): React.JSX.Element;
-/**
- * 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. 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.
- */
-declare function ThinkChatMessages<State = unknown, MessageT extends UIMessage = UIMessage>({
-  draft,
-  loading,
-  renderPart,
-  excludeTools,
-  renderAgentToolRunLink,
-  renderWorkspaceFile,
-  toolRenderers,
-  thinkStub,
-  onExecutionSettled,
-  pendingApprovals,
-  notice,
-  sessionCompaction,
-  ...props
-}: ThinkChatMessagesProps<MessageT>): React.JSX.Element;
-/**
- * The ambient chat value from `ThinkChat.Root`/`Provider` — for custom tool
- * panels, cards, or composer actions that need `messages`, `status`, or
- * `sendMessage`. Throws outside a provider.
- */
-declare function useThinkChat<State = unknown, MessageT extends UIMessage = UIMessage>(): Omit<import("@ai-sdk/react").UseChatHelpers<MessageT>, "addToolOutput"> & {
-  clearHistory: () => void;
-  addToolOutput: (opts: {
-    toolCallId: string;
-    toolName?: string;
-    output?: unknown;
-    state?: "output-available" | "output-error";
-    errorText?: string;
-  }) => void;
-  isServerStreaming: boolean;
-  isStreaming: boolean;
-  isRecovering: boolean;
-  isToolContinuation: boolean;
-  connectionError: (Error & {
-    code: number;
-    reason: string;
-    wasClean: boolean;
-  }) | null;
-};
-/**
- * Namespace entry point. `Root` + `Messages` is the standard surface;
- * `Provider` + `useThinkChat` when the app owns the chat hook; `Activity`,
- * `renderActivityPart`, and `createActivityRenderer` for custom layouts and
- * app-specific tools.
- */
-declare const ThinkChat: {
-  Provider: typeof ThinkChatProvider;
-  Root: typeof ThinkChatRoot;
-  Messages: typeof ThinkChatMessages;
-  Activity: typeof ThinkChatActivity;
-  RecoveryNotice: typeof ThinkRecoveryNotice;
-  renderActivityPart: (context: AgentMessageRenderPartContext<UIMessage<unknown, import("ai").UIDataTypes, import("ai").UITools>>) => React.ReactNode | undefined;
-  createActivityRenderer: typeof createThinkChatActivityRenderer;
-};
-//#endregion
-export { ThinkChatProvider as a, ThinkChatRootProps as c, thinkPendingExecutionApprovalsQueryOptions as d, useThinkChat as f, ThinkChatMessagesProps as i, ThinkPendingExecutionApprovalsQueryKey as l, ThinkChatDraft as n, ThinkChatProviderProps as o, useThinkPendingExecutionApprovals as p, ThinkChatMessages as r, ThinkChatRoot as s, ThinkChat as t, ThinkPendingExecutionApprovalsQueryOptions as u };

package/dist/ThinkChat-DiI6hhDP.js

@@ -1,332 +0,0 @@
-import { composerDraftToPrompt, parseComposerLinks } from "./utils/composer-link.js";
-import { TransitionSurface } from "./components/foundations/TransitionSurface.js";
-import { AgentToolRunsProvider, useSourceScopedAgentToolEvents } from "./components/agents-sdk/AgentToolRunsContext.js";
-import { AgentChat, compactingNotice } from "./components/agents-sdk/AgentChat.js";
-import { ThinkChatContext, ThinkChatLiveContext, useOptionalThinkChatContext, useThinkChatContext } from "./components/agents-sdk/ThinkChatContext.js";
-import { ThinkChatActivity, createThinkChatActivityRenderer, renderThinkChatActivityPart } from "./components/agents-sdk/ThinkChatActivity.js";
-import { ThinkRecoveryNotice } from "./components/agents-sdk/ThinkRecoveryNotice.js";
-import { n as WorkspaceMessageResponse, t as WorkspaceFileRendererProvider } from "./WorkspaceMessageResponse-BqOezptB.js";
-import * as React from "react";
-import { jsx, jsxs } from "react/jsx-runtime";
-import { isTextUIPart } from "ai";
-import { useAgentChat } from "@cloudflare/think/react";
-import { useAgent } from "agents/react";
-import { queryOptions, useQuery, useQueryClient } from "@tanstack/react-query";
-//#region src/components/_internal/think-approvals.ts
-/**
-* Ambient approvals belong to their stub. An explicit different stub may only
-* use approval state and settlement handlers supplied alongside that override.
-*/
-function resolveThinkApprovalProps(overrides, ambient) {
-	const inheritsAmbient = overrides.thinkStub === void 0 || overrides.thinkStub === ambient?.thinkStub;
-	return {
-		thinkStub: overrides.thinkStub ?? ambient?.thinkStub,
-		pendingApprovals: overrides.pendingApprovals ?? (inheritsAmbient ? ambient?.pendingApprovals : void 0),
-		onExecutionSettled: overrides.onExecutionSettled ?? (inheritsAmbient ? ambient?.onExecutionSettled : void 0)
-	};
-}
-//#endregion
-//#region src/components/agents-sdk/ThinkChat.tsx
-const EMPTY_PENDING_APPROVALS = [];
-const STREAMED_TEXT_ANIMATION = {
-	animation: "fadeIn",
-	duration: 150,
-	easing: "cubic-bezier(0.37, 0.55, 0.86, 0.88)",
-	sep: "word",
-	stagger: 0
-};
-/**
-* Acknowledgement copy for a landed compaction. Both numbers are Session's own
-* estimates, so the text is hedged ("about", rounded to thousands) and falls
-* back to the plain sentence when the difference is not a positive size —
-* estimator noise must never render as "0 tokens freed".
-*/
-function compactionSizeText({ tokensAfter, tokensBefore }) {
-	const freed = Math.round((tokensBefore - tokensAfter) / 1e3) * 1e3;
-	return freed > 0 ? `Context compacted — about ${freed.toLocaleString()} tokens freed.` : "Context compacted.";
-}
-function toAgentChatStatus(chat) {
-	if (chat.status === "submitted") return "submitted";
-	if (chat.isStreaming || chat.isRecovering) return "streaming";
-	return chat.status ?? "ready";
-}
-function thinkPendingExecutionApprovalsQueryKey(sourceKey) {
-	return [
-		"think",
-		sourceKey,
-		"pending-approvals"
-	];
-}
-/** Shared pending-approval options for components and TanStack Router loaders. */
-function thinkPendingExecutionApprovalsQueryOptions(stub, sourceKey) {
-	return queryOptions({
-		queryKey: thinkPendingExecutionApprovalsQueryKey(sourceKey),
-		queryFn: () => stub.pendingApprovals(),
-		staleTime: 5e3
-	});
-}
-function useThinkPendingExecutionApprovals(stub, sourceKey, refreshSignal, enabled = true) {
-	const queryClient = useQueryClient();
-	const approvalsQuery = useQuery({
-		...thinkPendingExecutionApprovalsQueryOptions(stub, sourceKey),
-		enabled
-	});
-	const refreshState = React.useRef({
-		sourceKey,
-		observedSignal: refreshSignal,
-		pending: false
-	});
-	const refetch = React.useEffectEvent(() => approvalsQuery.refetch());
-	const refreshPendingApprovals = React.useCallback(async () => {
-		if (!enabled) return;
-		const filters = {
-			queryKey: thinkPendingExecutionApprovalsQueryKey(sourceKey),
-			exact: true
-		};
-		await queryClient.cancelQueries(filters);
-		await queryClient.invalidateQueries(filters);
-	}, [
-		enabled,
-		queryClient,
-		sourceKey
-	]);
-	React.useEffect(() => {
-		if (!enabled || refreshState.current.sourceKey !== sourceKey) {
-			refreshState.current = {
-				sourceKey,
-				observedSignal: refreshSignal,
-				pending: false
-			};
-			return;
-		}
-		if (!Object.is(refreshState.current.observedSignal, refreshSignal)) {
-			refreshState.current.observedSignal = refreshSignal;
-			refreshState.current.pending = true;
-		}
-		if (approvalsQuery.isFetching || !refreshState.current.pending) return;
-		refreshState.current.pending = false;
-		refetch();
-	}, [
-		approvalsQuery.isFetching,
-		enabled,
-		refreshSignal,
-		sourceKey
-	]);
-	return React.useMemo(() => ({
-		pendingApprovals: approvalsQuery.data ?? EMPTY_PENDING_APPROVALS,
-		refreshPendingApprovals
-	}), [approvalsQuery.data, refreshPendingApprovals]);
-}
-/**
-* Chat UI for Cloudflare Think agents. Provide a `useAgentChat` value (or let
-* `ThinkChat.Root` create one) and `ThinkChat.Messages` renders the message
-* stream with agent work folded into collapsed Activity blocks.
-*/
-function ThinkChatProvider({ agentTools, chat, children }) {
-	const isStreaming = Boolean(chat.isStreaming);
-	const lastMessageId = chat.messages.at(-1)?.id;
-	const live = React.useMemo(() => ({
-		isStreaming,
-		lastMessageId
-	}), [isStreaming, lastMessageId]);
-	const chatProvider = /* @__PURE__ */ jsx(ThinkChatContext.Provider, {
-		value: chat,
-		children: /* @__PURE__ */ jsx(ThinkChatLiveContext.Provider, {
-			value: live,
-			children
-		})
-	});
-	return agentTools ? /* @__PURE__ */ jsx(AgentToolRunsProvider, {
-		agentTools,
-		children: chatProvider
-	}) : chatProvider;
-}
-/**
-* Batteries-included root: connects to the named Think agent (upstream's
-* `useAgent` + `useAgentChat`) and provides the live chat to everything
-* inside. Render it beneath the app's `QueryClientProvider`. If the app
-* already owns the chat hook, use `ThinkChat.Provider`.
-*
-* @example
-* ```tsx
-* <QueryClientProvider client={queryClient}>
-*   <ThinkChat.Root
-*     agent="my-agent"
-*     name="session-1"
-*     sourceKey="api.example.com:account:acme:agent:session-1"
-*   >
-*     <ThinkChat.Messages />
-*   </ThinkChat.Root>
-* </QueryClientProvider>
-* ```
-*/
-function ThinkChatRoot({ agent: agentOption, approvalsEnabled = true, name, sourceKey, children }) {
-	const agent = useAgent(typeof agentOption === "string" ? {
-		agent: agentOption,
-		name
-	} : {
-		...agentOption,
-		name: name ?? agentOption.name
-	});
-	const chat = useAgentChat({ agent });
-	const agentTools = useSourceScopedAgentToolEvents(agent);
-	const approvals = useThinkPendingExecutionApprovals(agent.stub, sourceKey, `${chat.messages.length}:${chat.status}`, approvalsEnabled);
-	const approvalsContext = React.useMemo(() => ({
-		...approvals,
-		thinkStub: agent.stub
-	}), [agent.stub, approvals]);
-	return /* @__PURE__ */ jsx(ThinkChatProvider, {
-		chat,
-		agentTools,
-		children: /* @__PURE__ */ jsx(ThinkChatApprovalsContext.Provider, {
-			value: approvalsContext,
-			children
-		})
-	});
-}
-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. 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.
-*/
-function ThinkChatMessages({ draft, loading, renderPart, excludeTools, renderAgentToolRunLink, renderWorkspaceFile, toolRenderers, thinkStub, onExecutionSettled, pendingApprovals, notice, sessionCompaction, ...props }) {
-	const chat = useOptionalThinkChatContext();
-	const approvals = React.useContext(ThinkChatApprovalsContext);
-	const resolvedApprovals = resolveThinkApprovalProps({
-		thinkStub,
-		pendingApprovals,
-		onExecutionSettled
-	}, approvals && {
-		thinkStub: approvals.thinkStub,
-		pendingApprovals: approvals.pendingApprovals,
-		onExecutionSettled: approvals.refreshPendingApprovals
-	});
-	const activityRenderPart = React.useMemo(() => createThinkChatActivityRenderer({
-		excludeTools,
-		renderAgentToolRunLink,
-		toolRenderers
-	}), [
-		excludeTools,
-		renderAgentToolRunLink,
-		toolRenderers
-	]);
-	const streamingMessageId = (chat ? chat.isStreaming : draft?.status === "streaming") ? (chat?.messages ?? draft?.messages)?.at(-1)?.id : void 0;
-	const defaultRenderPart = React.useCallback((context) => {
-		const activity = activityRenderPart(context);
-		if (activity !== void 0) return activity;
-		return isTextUIPart(context.part) && context.part.text ? /* @__PURE__ */ jsx(WorkspaceMessageResponse, {
-			animated: STREAMED_TEXT_ANIMATION,
-			isAnimating: context.message.role === "assistant" && context.message.id === streamingMessageId && context.part.state === "streaming",
-			promoteWorkspaceFiles: context.message.role === "assistant",
-			children: context.part.text
-		}) : void 0;
-	}, [activityRenderPart, streamingMessageId]);
-	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 defaultNotice = chat ? /* @__PURE__ */ jsx(ThinkRecoveryNotice, { chat }) : null;
-	const [dismissedCompaction, setDismissedCompaction] = React.useState(null);
-	const landedCompaction = sessionCompaction?.lastCompaction && sessionCompaction.lastCompaction !== dismissedCompaction ? sessionCompaction.lastCompaction : null;
-	const sessionCompactionNotice = sessionCompaction?.compacting ? compactingNotice : sessionCompaction?.sessionError ? /* @__PURE__ */ jsxs(TransitionSurface, {
-		className: "think-recovery-notice",
-		"data-tone": "danger",
-		children: ["Compaction failed: ", sessionCompaction.sessionError]
-	}) : sessionCompaction?.reloadError ? /* @__PURE__ */ jsx(TransitionSurface, {
-		className: "think-recovery-notice",
-		"data-tone": "danger",
-		children: "Transcript may be out of date. The next completed turn will retry the refresh."
-	}) : landedCompaction ? /* @__PURE__ */ jsxs(TransitionSurface, {
-		className: "think-recovery-notice",
-		children: [compactionSizeText(landedCompaction), " Context usage updates after your next message."]
-	}) : null;
-	const recoveryActive = chat && (chat.isRecovering || chat.connectionError || chat.error);
-	const submit = ({ text, files, references }, send) => {
-		setDismissedCompaction(sessionCompaction?.lastCompaction ?? null);
-		const fromLinks = composerDraftToPrompt(text);
-		const referenceTokens = references?.map(({ trigger, value }) => trigger ? `${trigger}${value}` : value) ?? [];
-		const prompt = parseComposerLinks(text).length ? fromLinks : [...referenceTokens, text.trim()].filter(Boolean).join(" ");
-		if (!prompt && !files.length) return;
-		return send({
-			text: prompt,
-			files
-		});
-	};
-	const withWorkspaceFileRenderer = (lane) => /* @__PURE__ */ jsx(WorkspaceFileRendererProvider, {
-		renderWorkspaceFile,
-		children: lane
-	});
-	if (loading) return withWorkspaceFileRenderer(/* @__PURE__ */ jsx(AgentChat, {
-		showComposer: true,
-		...props,
-		renderPart: resolvedRenderPart,
-		messages: EMPTY_DRAFT_MESSAGES,
-		status: "ready",
-		notice,
-		loading: true
-	}));
-	if (!chat) {
-		if (!draft) throw new Error("ThinkChat.Messages must be used inside <ThinkChat.Provider> or <ThinkChat.Root>, or given a `draft`, or set `loading` while one hydrates.");
-		return withWorkspaceFileRenderer(/* @__PURE__ */ jsx(AgentChat, {
-			...props,
-			renderPart: resolvedRenderPart,
-			messages: draft.messages ?? EMPTY_DRAFT_MESSAGES,
-			status: draft.status ?? "ready",
-			notice: notice ?? sessionCompactionNotice,
-			onSubmit: (message) => submit(message, draft.onSubmit)
-		}));
-	}
-	return withWorkspaceFileRenderer(/* @__PURE__ */ jsx(AgentChat, {
-		...props,
-		renderPart: resolvedRenderPart,
-		messages: chat.messages,
-		status: toAgentChatStatus(chat),
-		onStop: chat.stop,
-		onApprovalResponse: chat.addToolApprovalResponse,
-		thinkStub: resolvedApprovals.thinkStub,
-		onExecutionSettled: resolvedApprovals.onExecutionSettled,
-		pendingApprovals: resolvedApprovals.pendingApprovals,
-		notice: notice ?? (recoveryActive ? defaultNotice : sessionCompactionNotice),
-		onRegenerate: (messageId) => void chat.regenerate({ messageId }),
-		onSubmit: (message) => submit(message, chat.sendMessage)
-	}));
-}
-const EMPTY_DRAFT_MESSAGES = [];
-/**
-* The ambient chat value from `ThinkChat.Root`/`Provider` — for custom tool
-* panels, cards, or composer actions that need `messages`, `status`, or
-* `sendMessage`. Throws outside a provider.
-*/
-function useThinkChat() {
-	return useThinkChatContext("useThinkChat");
-}
-/**
-* Namespace entry point. `Root` + `Messages` is the standard surface;
-* `Provider` + `useThinkChat` when the app owns the chat hook; `Activity`,
-* `renderActivityPart`, and `createActivityRenderer` for custom layouts and
-* app-specific tools.
-*/
-const ThinkChat = {
-	Provider: ThinkChatProvider,
-	Root: ThinkChatRoot,
-	Messages: ThinkChatMessages,
-	Activity: ThinkChatActivity,
-	RecoveryNotice: ThinkRecoveryNotice,
-	renderActivityPart: renderThinkChatActivityPart,
-	createActivityRenderer: createThinkChatActivityRenderer
-};
-//#endregion
-export { thinkPendingExecutionApprovalsQueryOptions as a, resolveThinkApprovalProps as c, ThinkChatRoot as i, ThinkChatMessages as n, useThinkChat as o, ThinkChatProvider as r, useThinkPendingExecutionApprovals as s, ThinkChat as t };

package/dist/ThinkChatActivity-B3lGVS-6.d.ts

@@ -1,77 +0,0 @@
-import { i as AgentMessageRenderPartContext } from "./AgentMessageParts-C7L-Mv9U.js";
-import { r as AgentChatProps } from "./AgentChat-BLmQghkt.js";
-import { l as ThinkChatPart } from "./ThinkChatToolParts-D4qcnnxt.js";
-import { t as ThinkChatActivityDescription } from "./ThinkChatActivitySummary-BtBQgMg6.js";
-import * as React from "react";
-import { DynamicToolUIPart, ToolUIPart, UIMessage } from "ai";
-import { AgentToolRunState } from "agents/agent-tools";
-
-//#region src/components/agents-sdk/ThinkChatActivity.d.ts
-/**
- * Bespoke rendering for one tool inside the activity log. Both hooks fall
- * through to the built-in families when they return `undefined`, so an
- * override can adjust just the action or just the panel.
- */
-interface ThinkChatToolRenderer {
-  /** One-line step action. `null` hides the step from the log. */
-  describe?: (part: ToolUIPart | DynamicToolUIPart) => ThinkChatActivityDescription | null | undefined;
-  /** Expanded detail under the step. `null` keeps the step a plain row. */
-  panel?: (part: ToolUIPart | DynamicToolUIPart) => React.ReactNode;
-}
-type ThinkChatToolRenderers = Record<string, ThinkChatToolRenderer>;
-interface ThinkChatActivityRendererOptions<MessageT extends UIMessage = UIMessage> {
-  /**
-   * Tool names to keep out of activity folding entirely — the run splits
-   * around them and they fall through to your own renderPart / AgentChat's
-   * generic standalone activity row. For tools that should stay in the log
-   * with custom UI, use `toolRenderers` instead.
-   */
-  excludeTools?: readonly string[];
-  /** Per-tool action/panel overrides inside the activity log, keyed by tool name. */
-  toolRenderers?: ThinkChatToolRenderers;
-  /** App-authored TanStack Router Link for each retained child destination. */
-  renderAgentToolRunLink?: (run: AgentToolRunState<MessageT["parts"][number]>) => React.ReactElement;
-}
-interface ThinkChatActivityProps {
-  /** Render with the log expanded. */
-  defaultOpen?: boolean;
-  parts: readonly ThinkChatPart[];
-  /** Defaults to deriving from part states (reasoning streaming, tool awaiting output). */
-  isStreaming?: boolean;
-  /** Per-tool action/panel overrides, keyed by tool name. */
-  toolRenderers?: ThinkChatToolRenderers;
-  /** Replaces the summary action after the activity settles. */
-  settledAction?: string;
-  /**
-   * Uniquely identifies this run across the whole transcript for persisted
-   * disclosure state (the activity renderer passes `${message.id}:${runStart}`).
-   * Required because any derivable fallback collides for reasoning-led runs
-   * in different messages, bleeding open/closed state across virtualization
-   * remounts.
-   */
-  stateKey: string;
-}
-declare function ThinkChatActivity({
-  parts,
-  defaultOpen,
-  isStreaming,
-  toolRenderers,
-  settledAction,
-  stateKey
-}: ThinkChatActivityProps): React.JSX.Element | null;
-/**
- * Builds a renderPart handler that folds every run of consecutive activity
- * parts (reasoning + tool calls) into one collapsed Activity box. Everything
- * is derived from the UIMessage stream: part order, tool states, reasoning
- * state. Excluded tools split the run and return undefined so your own
- * renderPart (or AgentChat's generic activity row) takes over for them.
- */
-declare function createThinkChatActivityRenderer<MessageT extends UIMessage = UIMessage>({
-  excludeTools,
-  renderAgentToolRunLink,
-  toolRenderers
-}?: ThinkChatActivityRendererOptions<MessageT>): NonNullable<AgentChatProps<MessageT>["renderPart"]>;
-/** Default activity renderer — `createThinkChatActivityRenderer()` with no overrides. */
-declare const renderThinkChatActivityPart: (context: AgentMessageRenderPartContext<UIMessage<unknown, import("ai").UIDataTypes, import("ai").UITools>>) => React.ReactNode | undefined;
-//#endregion
-export { ThinkChatToolRenderers as a, ThinkChatToolRenderer as i, ThinkChatActivityProps as n, createThinkChatActivityRenderer as o, ThinkChatActivityRendererOptions as r, renderThinkChatActivityPart as s, ThinkChatActivity as t };

package/dist/ThinkChatContext-COIgzkYp.d.ts

@@ -1,28 +0,0 @@
-import * as React from "react";
-import { UIMessage } from "ai";
-import { useAgentChat } from "@cloudflare/think/react";
-
-//#region src/components/agents-sdk/ThinkChatContext.d.ts
-/** The complete upstream Think chat hook value, preserving app state and message extensions. */
-type ThinkChatValue<State = unknown, MessageT extends UIMessage = UIMessage> = ReturnType<typeof useAgentChat<State, MessageT>>;
-/**
- * React contexts cannot bind provider-specific generics. Keep the stored value
- * opaque and restore the complete upstream hook type through the typed accessors.
- */
-declare const ThinkChatContext: React.Context<unknown>;
-declare function useOptionalThinkChatContext<State = unknown, MessageT extends UIMessage = UIMessage>(): ThinkChatValue<State, MessageT> | null;
-declare function useThinkChatContext<State = unknown, MessageT extends UIMessage = UIMessage>(component: string): ThinkChatValue<State, MessageT>;
-/**
- * The two live-chat facts transcript rows actually need. Kept separate from
- * the full chat value (whose identity changes every stream delta) so memoized
- * rows subscribed here only re-render when the run starts, ends, or moves to
- * a new message.
- */
-interface ThinkChatLiveValue {
-  isStreaming: boolean;
-  lastMessageId: string | undefined;
-}
-declare const ThinkChatLiveContext: React.Context<ThinkChatLiveValue | null>;
-declare function useOptionalThinkChatLive(): ThinkChatLiveValue | null;
-//#endregion
-export { useOptionalThinkChatContext as a, ThinkChatValue as i, ThinkChatLiveContext as n, useOptionalThinkChatLive as o, ThinkChatLiveValue as r, useThinkChatContext as s, ThinkChatContext as t };

package/dist/ThinkRecoveryNotice-DGWr94rk.d.ts

@@ -1,19 +0,0 @@
-import { i as ThinkChatValue } from "./ThinkChatContext-COIgzkYp.js";
-import { UIMessage } from "ai";
-
-//#region src/components/agents-sdk/ThinkRecoveryNotice.d.ts
-interface ThinkRecoveryNoticeProps<State = unknown, MessageT extends UIMessage = UIMessage> {
-  /** The complete `useAgentChat` value from `@cloudflare/think/react`. */
-  chat: ThinkChatValue<State, MessageT>;
-}
-/**
- * Native Think recovery, connection, and turn-error content for AgentChat's
- * persistent polite notice region. Think exposes no recovery phase, progress,
- * checkpoint, attempt count, or timeline to the browser, so this adapter does
- * not claim those details.
- */
-declare function ThinkRecoveryNotice<State = unknown, MessageT extends UIMessage = UIMessage>({
-  chat
-}: ThinkRecoveryNoticeProps<State, MessageT>): import("react").JSX.Element | null;
-//#endregion
-export { ThinkRecoveryNoticeProps as n, ThinkRecoveryNotice as t };