@mcp-b/react-components 0.14.2 → 0.16.1

package/dist/components/ThinkChatActivitySummary.js

@@ -0,0 +1,421 @@
+import { displayUrl, getToolDisplayName, isBrowserToolPart, isExecuteToolPart, isFetchToolPart, isPartFailed, isPartWorking, isSessionContextToolFailure, isSessionContextToolPart, isSkillToolPart, isWorkspaceToolPart } from "./ThinkChatToolParts.js";
+import { t as summarizeToolInput } from "../summarize-tool-input-BUJsENSn.js";
+import { getToolName, isReasoningUIPart, isToolUIPart } from "ai";
+//#region src/components/ThinkChatActivitySummary.ts
+const ACTIVITY_HEADER_LABEL_MAX_LENGTH = 240;
+function boundedActivityHeader(header) {
+	if (header.label.length <= ACTIVITY_HEADER_LABEL_MAX_LENGTH) return header;
+	return {
+		...header,
+		label: `${header.label.slice(0, ACTIVITY_HEADER_LABEL_MAX_LENGTH - 1).trimEnd()}…`
+	};
+}
+function getToolInput(part) {
+	return part.input;
+}
+function getToolOutput(part) {
+	return part.state === "output-available" ? part.output : void 0;
+}
+const HTTP_URL_PATTERN = /https?:\/\/[^\s"'<>)}\]]+/i;
+function firstHttpUrl(value) {
+	let text;
+	if (typeof value === "string") text = value;
+	else try {
+		text = JSON.stringify(value) ?? "";
+	} catch {
+		text = "";
+	}
+	const raw = HTTP_URL_PATTERN.exec(text)?.[0]?.replace(/[.,;:!?]+$/, "");
+	if (!raw) return null;
+	try {
+		return new URL(raw).origin;
+	} catch {
+		return null;
+	}
+}
+function genericToolLabels(name, hasUrl) {
+	const normalized = name.toLowerCase();
+	if (normalized.includes("grep") || normalized.includes("find") || normalized.includes("code")) return {
+		working: "Searching code",
+		done: "Searched code",
+		failed: "Code search failed",
+		summary: "searched code",
+		icon: "search"
+	};
+	if (normalized.includes("search") || normalized.includes("web") || normalized.includes("browser") || normalized.includes("google")) return {
+		working: "Searching the web",
+		done: "Searched the web",
+		failed: "Web search failed",
+		summary: "searched the web",
+		icon: "web"
+	};
+	if (hasUrl || normalized.includes("fetch") || normalized.includes("http") || normalized.includes("url")) return {
+		working: "Reading a URL",
+		done: "Read a URL",
+		failed: "URL read failed",
+		summary: "read a URL",
+		icon: "web"
+	};
+	if (normalized.includes("edit") || normalized.includes("write") || normalized.includes("delete") || normalized.includes("patch") || normalized.includes("apply") || normalized.includes("create") || normalized.includes("update")) return {
+		working: "Editing files",
+		done: "Edited files",
+		failed: "Edit failed",
+		summary: "edited files",
+		icon: "edit"
+	};
+	if (normalized.includes("exec") || normalized.includes("bash") || normalized.includes("shell") || normalized.includes("terminal") || normalized.includes("command")) return {
+		working: "Running a command",
+		done: "Ran a command",
+		failed: "Command failed",
+		summary: "ran a command",
+		icon: "command"
+	};
+	if (normalized.includes("read") || normalized.includes("open") || normalized.includes("list") || normalized.includes("file")) return {
+		working: "Reading files",
+		done: "Read files",
+		failed: "Read failed",
+		summary: "read files",
+		icon: "read"
+	};
+	return {
+		working: "Using a tool",
+		done: "Used a tool",
+		failed: "Tool failed",
+		summary: "used a tool",
+		icon: "tool"
+	};
+}
+function genericToolPresentation(part, hasUrl) {
+	const labels = genericToolLabels(getToolName(part), hasUrl);
+	if (part.title === void 0 && labels.summary !== "used a tool") return labels;
+	const displayName = getToolDisplayName(part);
+	return {
+		...labels,
+		working: `Running ${displayName}`,
+		done: `Ran ${displayName}`,
+		failed: `${displayName} failed`,
+		summary: `ran ${displayName}`
+	};
+}
+function describeGenericToolPart(part) {
+	const labels = genericToolPresentation(part, activityPartUrl(part) !== null);
+	const label = isPartFailed(part) ? labels.failed : isPartWorking(part) ? labels.working : labels.done;
+	const detail = summarizeToolInput(getToolInput(part));
+	return detail ? `${label} · ${detail}` : label;
+}
+function activityPartUrl(part) {
+	if (isFetchToolPart(part)) return firstHttpUrl(part.input?.url ?? part.input?.path);
+	if (isBrowserToolPart(part) && part.type !== "tool-browser_execute") return firstHttpUrl(part.input?.url);
+	if (isToolUIPart(part) && !isExecuteToolPart(part)) return firstHttpUrl(getToolInput(part)) ?? (part.state === "output-available" ? firstHttpUrl(getToolOutput(part)) : null);
+	return null;
+}
+function activityPartIconKind(part) {
+	if (isReasoningUIPart(part)) return "thought";
+	if (isWorkspaceToolPart(part)) switch (part.type) {
+		case "tool-read":
+		case "tool-list": return "read";
+		case "tool-write":
+		case "tool-edit":
+		case "tool-delete": return "edit";
+		case "tool-find":
+		case "tool-grep": return "search";
+		case "tool-bash": return "command";
+	}
+	if (isSkillToolPart(part)) return "tool";
+	if (isSessionContextToolPart(part)) return part.type === "tool-search_context" || part.type === "tool-session_search" ? "search" : "tool";
+	if (isFetchToolPart(part)) return "web";
+	if (isBrowserToolPart(part)) return part.type === "tool-browser_execute" ? "browser" : "web";
+	if (isExecuteToolPart(part)) return "command";
+	if (isToolUIPart(part)) return genericToolLabels(getToolName(part), activityPartUrl(part) !== null).icon;
+	return "tool";
+}
+function activityPartWorkspaceDestination(part) {
+	if (!isWorkspaceToolPart(part)) return null;
+	switch (part.type) {
+		case "tool-read":
+		case "tool-write":
+		case "tool-edit":
+		case "tool-delete": {
+			const path = part.input?.path;
+			return typeof path === "string" && path.length > 0 ? {
+				kind: "file",
+				path,
+				fragment: null
+			} : null;
+		}
+		case "tool-list":
+		case "tool-find":
+		case "tool-grep":
+		case "tool-bash": return null;
+	}
+}
+/**
+* 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.
+*/
+function describeThinkChatActivityPart(part, toolRenderers) {
+	if (isToolUIPart(part)) {
+		const custom = toolRenderers?.[getToolName(part)]?.describe?.(part);
+		if (custom !== void 0) return custom;
+	}
+	if (isReasoningUIPart(part)) {
+		const snippet = summarizeToolInput({ text: part.text });
+		const label = part.state === "streaming" ? "Thinking…" : "Thought";
+		return snippet ? `${label} · ${snippet}` : label;
+	}
+	if (isWorkspaceToolPart(part)) return describeWorkspaceToolPart(part);
+	if (isSkillToolPart(part)) return describeSkillToolPart(part);
+	if (isSessionContextToolPart(part)) return describeSessionContextToolPart(part);
+	if (isFetchToolPart(part)) return describeFetchToolPart(part);
+	if (isBrowserToolPart(part)) return describeBrowserToolPart(part);
+	if (isExecuteToolPart(part)) return describeExecuteToolPart(part);
+	if (isToolUIPart(part)) return describeGenericToolPart(part);
+	return null;
+}
+function basename(path) {
+	return path?.split("/").filter(Boolean).at(-1) ?? null;
+}
+function describeWorkspaceToolPart(part) {
+	const working = isPartWorking(part);
+	const failed = isPartFailed(part);
+	if (part.type === "tool-bash") {
+		const command = part.input?.script?.trim() ?? "";
+		if (failed) return command ? `Command failed · ${command}` : "Command failed";
+		const verb = working ? "Running" : "Ran";
+		return command ? `${verb} ${command}` : `${verb} a command`;
+	}
+	const label = (() => {
+		switch (part.type) {
+			case "tool-read": return `${working ? "Reading" : "Read"} ${basename(part.input?.path) ?? "a file"}`;
+			case "tool-write": return `${working ? "Writing" : "Wrote"} ${basename(part.input?.path) ?? "a file"}`;
+			case "tool-edit": return `${working ? "Editing" : "Edited"} ${basename(part.input?.path) ?? "a file"}`;
+			case "tool-delete": return `${working ? "Deleting" : "Deleted"} ${part.input?.path || "a file"}`;
+			case "tool-list": {
+				const path = part.input?.path;
+				return `${working ? "Listing" : "Listed"} ${path && path !== "/" ? path : "files"}`;
+			}
+			case "tool-find": return `${working ? "Searching" : "Searched"} for ${part.input?.pattern || "files"}`;
+			case "tool-grep": return `${working ? "Searching" : "Searched"} for ${part.input?.query || "text"}`;
+		}
+	})();
+	return failed ? `${label} · failed` : label;
+}
+function describeSkillToolPart(part) {
+	const working = isPartWorking(part);
+	const failed = isPartFailed(part);
+	const label = (() => {
+		switch (part.type) {
+			case "tool-activate_skill": {
+				const name = part.input?.name;
+				return `${working ? "Using" : "Used"} ${name ? `the ${name} skill` : "a skill"}`;
+			}
+			case "tool-read_skill_resource": return `${working ? "Reading" : "Read"} ${part.input?.path ?? "a skill resource"}`;
+			case "tool-run_skill_script": return `${working ? "Running" : "Ran"} ${part.input?.path ?? "a skill script"}`;
+		}
+	})();
+	return failed ? `${label} · failed` : label;
+}
+function describeSessionContextToolPart(part) {
+	const working = isPartWorking(part);
+	const failed = isSessionContextToolFailure(part);
+	const label = (() => {
+		switch (part.type) {
+			case "tool-set_context": {
+				const target = part.input?.label ? ` ${part.input.label}` : " context";
+				return `${working ? "Updating" : "Updated"}${target}`;
+			}
+			case "tool-load_context": return `${working ? "Loading" : "Loaded"} ${part.input?.key ?? "context"}`;
+			case "tool-unload_context": return `${working ? "Unloading" : "Unloaded"} ${part.input?.key ?? "context"}`;
+			case "tool-search_context": return `${working ? "Searching" : "Searched"} ${part.input?.label ?? "context"}`;
+			case "tool-session_search": return `${working ? "Searching" : "Searched"} conversations`;
+		}
+	})();
+	return failed ? `${label} · failed` : label;
+}
+function describeBrowserToolPart(part) {
+	const working = isPartWorking(part);
+	const failed = isPartFailed(part);
+	if (part.type === "tool-browser_execute") {
+		const output = part.state === "output-available" ? part.output : void 0;
+		if (failed || output?.status === "error") return "Browser automation failed";
+		if (output?.status === "paused") return "Browser waiting for approval";
+		return working ? "Using the browser" : "Used the browser";
+	}
+	const page = displayUrl(part.input?.url) || "a page";
+	const label = (() => {
+		switch (part.type) {
+			case "tool-browser_extract": return `${working ? "Extracting" : "Extracted"} data from ${page}`;
+			case "tool-browser_links": return `${working ? "Listing" : "Listed"} links on ${page}`;
+			case "tool-browser_scrape": return `${working ? "Scraping" : "Scraped"} ${page}`;
+			default: return `${working ? "Browsing" : "Browsed"} ${page}`;
+		}
+	})();
+	return failed ? `${label} · failed` : label;
+}
+function describeExecuteToolPart(part) {
+	const output = part.state === "output-available" ? part.output : void 0;
+	if (isPartFailed(part) || output?.status === "error") return "Code failed";
+	if (output?.status === "paused") return "Code waiting for approval";
+	const label = isPartWorking(part) ? "Running code" : "Ran code";
+	const snippet = summarizeToolInput(part.input);
+	return snippet ? `${label} · ${snippet}` : label;
+}
+function describeFetchToolPart(part) {
+	const target = part.input?.url ?? part.input?.path ?? "";
+	const output = part.state === "output-available" ? part.output : void 0;
+	if (isPartFailed(part) || output?.ok === false) return target ? `Fetch failed · ${target}` : "Fetch failed";
+	const verb = isPartWorking(part) ? "Fetching" : "Fetched";
+	return target ? `${verb} ${target}` : `${verb} a URL`;
+}
+function summarizeActivitySteps(parts) {
+	const byTool = /* @__PURE__ */ new Map();
+	const genericSegments = /* @__PURE__ */ new Set();
+	const skillNames = /* @__PURE__ */ new Set();
+	let thoughts = 0;
+	let skillParts = 0;
+	const sessionSegments = /* @__PURE__ */ new Set();
+	let fetches = 0;
+	let browses = 0;
+	let codeRuns = 0;
+	for (const part of parts) if (isReasoningUIPart(part)) thoughts++;
+	else if (isWorkspaceToolPart(part)) {
+		const name = getToolName(part);
+		byTool.set(name, (byTool.get(name) ?? 0) + 1);
+	} else if (isSkillToolPart(part)) {
+		skillParts++;
+		if (typeof part.input?.name === "string") skillNames.add(part.input.name);
+	} else if (isSessionContextToolPart(part)) sessionSegments.add(part.type === "tool-search_context" || part.type === "tool-session_search" ? "searched context" : "updated context");
+	else if (isFetchToolPart(part)) fetches++;
+	else if (isBrowserToolPart(part)) browses++;
+	else if (isExecuteToolPart(part)) codeRuns++;
+	else if (isToolUIPart(part)) genericSegments.add(genericToolPresentation(part, activityPartUrl(part) !== null).summary);
+	const count = (name) => byTool.get(name) ?? 0;
+	const files = (n) => n === 1 ? "a file" : `${n} files`;
+	const reads = count("read");
+	const edits = count("edit") + count("write");
+	const deletes = count("delete");
+	const commands = count("bash");
+	const segments = [];
+	if (thoughts > 0) segments.push("thought");
+	if (skillParts > 0) segments.push(skillNames.size === 1 ? `used the ${[...skillNames][0]} skill` : skillNames.size > 1 ? `used ${skillNames.size} skills` : "used a skill");
+	for (const segment of ["updated context", "searched context"]) if (sessionSegments.has(segment)) segments.push(segment);
+	if (reads > 0) segments.push(`read ${files(reads)}`);
+	if (edits > 0) segments.push(`edited ${files(edits)}`);
+	if (deletes > 0) segments.push(`deleted ${files(deletes)}`);
+	if (count("find") + count("grep") > 0) segments.push("searched code");
+	if (count("list") > 0) segments.push("listed files");
+	if (fetches > 0) segments.push(fetches === 1 ? "fetched a URL" : `fetched ${fetches} URLs`);
+	if (browses > 0) segments.push("used the browser");
+	if (codeRuns > 0) segments.push("ran code");
+	if (commands > 0) segments.push(commands === 1 ? "ran a command" : `ran ${commands} commands`);
+	for (const segment of [
+		"edited files",
+		"searched code",
+		"searched the web",
+		"read a URL",
+		"ran a command",
+		"read files",
+		"used a tool"
+	]) if (genericSegments.has(segment)) segments.push(segment);
+	for (const segment of genericSegments) if (!segments.includes(segment)) segments.push(segment);
+	if (segments.length === 0) return "Worked";
+	const top = segments.slice(0, 3);
+	const joined = top.length === 1 ? top[0] : `${top.slice(0, -1).join(", ")} and ${top.at(-1)}`;
+	return joined.charAt(0).toUpperCase() + joined.slice(1);
+}
+/** Derive the serializable collapsed header from persisted AI SDK message parts. */
+function deriveThinkChatActivityHeader(parts, options = {}) {
+	const described = parts.flatMap((part) => {
+		const label = describeThinkChatActivityPart(part, options.toolDescribers);
+		return label ? [{
+			label,
+			part
+		}] : [];
+	});
+	if (described.length === 0) return null;
+	if (options.isStreaming ?? parts.some(isPartWorking)) {
+		const latest = described.at(-1);
+		const workspaceDestination = activityPartWorkspaceDestination(latest.part);
+		return boundedActivityHeader({
+			label: latest.label,
+			iconKind: activityPartIconKind(latest.part),
+			...activityPartUrl(latest.part) ? { url: activityPartUrl(latest.part) } : {},
+			...workspaceDestination ? { workspaceDestination } : {}
+		});
+	}
+	if (parts.some((part) => isToolUIPart(part) && isPartFailed(part))) return boundedActivityHeader({
+		label: summarizeActivitySteps(parts),
+		iconKind: "approval"
+	});
+	const workspaceRepresentative = parts.find((part) => activityPartIconKind(part) === "edit" && activityPartWorkspaceDestination(part)) ?? parts.find((part) => activityPartWorkspaceDestination(part));
+	const workspaceDestination = workspaceRepresentative ? activityPartWorkspaceDestination(workspaceRepresentative) : null;
+	const representative = parts.find((part) => activityPartIconKind(part) === "edit") ?? parts.find((part) => activityPartUrl(part)) ?? parts.find((part) => describeThinkChatActivityPart(part));
+	if (!representative) return boundedActivityHeader({
+		label: summarizeActivitySteps(parts),
+		iconKind: "tool"
+	});
+	const url = activityPartUrl(representative);
+	return boundedActivityHeader({
+		label: summarizeActivitySteps(parts),
+		iconKind: activityPartIconKind(representative),
+		...url ? { url } : {},
+		...workspaceDestination ? { workspaceDestination } : {}
+	});
+}
+/**
+* Derive the same live header from a host lifecycle event without making the
+* host manufacture an AI SDK UI message part.
+*/
+function deriveThinkChatToolLifecycleHeader(snapshot) {
+	if (snapshot.state === "approval-required") return boundedActivityHeader({
+		label: "Approval needed",
+		iconKind: "approval"
+	});
+	const part = lifecycleSnapshotToToolPart(snapshot);
+	const url = activityPartUrl(part);
+	const workspaceDestination = activityPartWorkspaceDestination(part);
+	return boundedActivityHeader({
+		label: describeThinkChatActivityPart(part) ?? "Used a tool",
+		iconKind: activityPartIconKind(part),
+		...url ? { url } : {},
+		...workspaceDestination ? { workspaceDestination } : {}
+	});
+}
+/** Internal adapter only: callers stay on the small semantic lifecycle API. */
+function lifecycleSnapshotToToolPart(snapshot) {
+	const base = {
+		type: `tool-${snapshot.toolName}`,
+		toolCallId: "activity-summary",
+		input: snapshot.input
+	};
+	switch (snapshot.state) {
+		case "working": return {
+			...base,
+			state: "input-available"
+		};
+		case "succeeded": return {
+			...base,
+			state: "output-available",
+			output: snapshot.output
+		};
+		case "failed": return {
+			...base,
+			state: "output-error",
+			errorText: lifecycleErrorText(snapshot.error)
+		};
+		case "approval-required": throw new Error("Approval snapshots are handled before UI-part adaptation");
+	}
+}
+function lifecycleErrorText(error) {
+	if (typeof error === "string") return error;
+	if (error instanceof Error) return error.message;
+	try {
+		return error === void 0 ? "Tool failed" : String(error);
+	} catch {
+		return "Tool failed";
+	}
+}
+//#endregion
+export { activityPartIconKind, activityPartUrl, deriveThinkChatActivityHeader, deriveThinkChatToolLifecycleHeader, describeThinkChatActivityPart, summarizeActivitySteps };

package/dist/components/ThinkChatToolPanels.d.ts

@@ -1,4 +1,4 @@
-import { a as SessionContextToolPart, d as WorkspaceToolPart, n as ExecuteToolPart, o as SkillToolPart, r as FetchToolPart, t as BrowserToolPart } from "../ThinkChatToolParts-CDEjqS6A.js";
+import { a as SessionContextToolPart, d as WorkspaceToolPart, n as ExecuteToolPart, o as SkillToolPart, r as FetchToolPart, t as BrowserToolPart } from "../ThinkChatToolParts-CSzVwMXf.js";
 import * as React from "react";
 
 //#region src/components/ThinkChatToolPanels.d.ts
@@ -31,17 +31,19 @@ declare function ThinkChatFetchPanel({
 }: {
   part: FetchToolPart;
 }): React.JSX.Element;
+interface ThinkChatExecutePanelProps {
+  /** Whole upstream Think execute-tool part, including its current output lifecycle. */
+  part: ExecuteToolPart;
+}
 /** The codemode execute tool as an activity panel: highlighted TypeScript
     plus logs, result, and the paused pending-approval list. */
 declare function ThinkChatExecutePanel({
   part
-}: {
-  part: ExecuteToolPart;
-}): React.JSX.Element;
+}: ThinkChatExecutePanelProps): React.JSX.Element;
 declare function ThinkChatBrowserPanel({
   part
 }: {
   part: BrowserToolPart;
 }): React.JSX.Element;
 //#endregion
-export { ThinkChatBrowserPanel, ThinkChatExecutePanel, ThinkChatFetchPanel, ThinkChatSessionContextPanel, ThinkChatSkillPanel, ThinkChatWorkspacePanel };
+export { ThinkChatBrowserPanel, ThinkChatExecutePanel, ThinkChatExecutePanelProps, ThinkChatFetchPanel, ThinkChatSessionContextPanel, ThinkChatSkillPanel, ThinkChatWorkspacePanel };

package/dist/components/ThinkChatToolPanels.js

@@ -1,8 +1,8 @@
 import { ActivityOutput, ActivityPanel } from "./Activity.js";
 import { Tabs } from "./Tabs.js";
-import { t as CodeBlock } from "../CodeBlock-BUFXG8HW.js";
-import { BrowserLiveView } from "./BrowserLiveView.js";
 import { displayUrl, isSessionContextToolFailure } from "./ThinkChatToolParts.js";
+import { t as CodeBlock } from "../CodeBlock-BmB4Xaqq.js";
+import { BrowserLiveView } from "./BrowserLiveView.js";
 import * as React from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { getToolName } from "ai";
@@ -256,17 +256,79 @@ function findBrowserResultMedia(value, depth = 0) {
 	return media;
 }
 function ExecuteCodeView({ code, output, hideResult }) {
+	const calls = output && "calls" in output ? output.calls : void 0;
 	const sections = [
 		output && "logs" in output && output.logs?.length ? output.logs.join("\n") : "",
 		output?.status === "error" ? output.error : "",
-		output?.status === "paused" ? formatPendingActions(output.pending) : "",
+		output?.status === "paused" && !calls?.length ? formatPendingActions(output.pending) : "",
 		output?.status === "completed" && output.result !== void 0 && !hideResult ? typeof output.result === "string" ? output.result : JSON.stringify(output.result, null, 2) : ""
 	].filter(Boolean);
-	return /* @__PURE__ */ jsxs(Fragment, { children: [code ? /* @__PURE__ */ jsx(CodeBlock, {
-		className: "activity__code-block",
-		code,
-		language: "ts"
-	}) : null, sections.length ? /* @__PURE__ */ jsx(ActivityOutput, { children: sections.join("\n\n") }) : null] });
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		code ? /* @__PURE__ */ jsx(CodeBlock, {
+			className: "activity__code-block",
+			code,
+			language: "ts"
+		}) : null,
+		calls?.length ? /* @__PURE__ */ jsx(ToolCallAudit, { calls }) : null,
+		sections.length ? /* @__PURE__ */ jsx(ActivityOutput, { children: sections.join("\n\n") }) : null
+	] });
+}
+/** Durable connector calls emitted by Codemode 0.4.3. The ordered list keeps
+execution order and state available to assistive technology without adding
+another host-side activity protocol. */
+function ToolCallAudit({ calls }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: "activity__call-audit",
+		children: [/* @__PURE__ */ jsx("span", {
+			className: "activity__call-audit-label",
+			children: "Calls"
+		}), /* @__PURE__ */ jsx("ol", {
+			className: "activity__call-audit-list",
+			children: calls.map((call) => /* @__PURE__ */ jsxs("li", {
+				className: "activity__call-audit-item",
+				"data-state": call.state,
+				children: [
+					/* @__PURE__ */ jsx("code", {
+						className: "activity__call-audit-code",
+						children: formatToolCall(call)
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: "activity__call-audit-state",
+						children: toolCallStateLabel(call)
+					}),
+					call.result !== void 0 ? /* @__PURE__ */ jsxs("code", {
+						className: "activity__call-audit-result",
+						children: [
+							" ",
+							"→ ",
+							formatAuditValue(call.result)
+						]
+					}) : null
+				]
+			}, call.seq))
+		})]
+	});
+}
+function formatToolCall(call) {
+	const target = call.connector === "__step" ? `codemode.step(${JSON.stringify(call.method)})` : `${call.connector}.${call.method}`;
+	if (call.connector === "__step") return target;
+	return `${target}(${formatAuditValue(call.args)})`;
+}
+function formatAuditValue(value) {
+	let formatted;
+	if (typeof value === "string") formatted = value;
+	else try {
+		formatted = JSON.stringify(value, (_, item) => typeof item === "bigint" ? `${item}n` : item) ?? String(value);
+	} catch {
+		formatted = String(value);
+	}
+	const maxLength = 240;
+	return formatted.length > maxLength ? `${formatted.slice(0, maxLength - 1)}…` : formatted;
+}
+function toolCallStateLabel(call) {
+	const state = call.state === "pending" ? "awaiting approval" : call.state === "applied" ? "applied" : call.state;
+	const qualifiers = [call.requiresApproval && call.state !== "pending" ? "approval required" : "", call.ephemeral ? "re-executes on replay" : ""].filter(Boolean);
+	return qualifiers.length ? `${state} · ${qualifiers.join(" · ")}` : state;
 }
 function formatPendingActions(pending) {
 	return pending.map((action) => {

package/dist/components/ThinkChatToolParts.d.ts

@@ -1,2 +1,2 @@
-import { S as isWorkspaceToolPart, _ as isPartWorking, a as SessionContextToolPart, b as isSkillToolPart, c as ThinkBashToolPart, d as WorkspaceToolPart, f as displayUrl, g as isPartFailed, h as isFetchToolPart, i as SessionContextToolName, l as ThinkChatPart, m as isExecuteToolPart, n as ExecuteToolPart, o as SkillToolPart, p as isBrowserToolPart, r as FetchToolPart, s as ThinkBashToolOutput, t as BrowserToolPart, u as ThinkWorkspaceToolName, v as isSessionContextToolFailure, x as isThinkChatActivityPart, y as isSessionContextToolPart } from "../ThinkChatToolParts-CDEjqS6A.js";
-export { BrowserToolPart, ExecuteToolPart, FetchToolPart, SessionContextToolName, SessionContextToolPart, SkillToolPart, ThinkBashToolOutput, ThinkBashToolPart, ThinkChatPart, ThinkWorkspaceToolName, WorkspaceToolPart, displayUrl, isBrowserToolPart, isExecuteToolPart, isFetchToolPart, isPartFailed, isPartWorking, isSessionContextToolFailure, isSessionContextToolPart, isSkillToolPart, isThinkChatActivityPart, isWorkspaceToolPart };
+import { C as isToolPartFailed, S as isThinkChatActivityPart, T as isWorkspaceToolPart, _ as isPartFailed, a as SessionContextToolPart, b as isSessionContextToolPart, c as ThinkBashToolPart, d as WorkspaceToolPart, f as displayUrl, g as isFetchToolPart, h as isExecuteToolPart, i as SessionContextToolName, l as ThinkChatPart, m as isBrowserToolPart, n as ExecuteToolPart, o as SkillToolPart, p as getToolDisplayName, r as FetchToolPart, s as ThinkBashToolOutput, t as BrowserToolPart, u as ThinkWorkspaceToolName, v as isPartWorking, w as isToolPartWorking, x as isSkillToolPart, y as isSessionContextToolFailure } from "../ThinkChatToolParts-CSzVwMXf.js";
+export { BrowserToolPart, ExecuteToolPart, FetchToolPart, SessionContextToolName, SessionContextToolPart, SkillToolPart, ThinkBashToolOutput, ThinkBashToolPart, ThinkChatPart, ThinkWorkspaceToolName, WorkspaceToolPart, displayUrl, getToolDisplayName, isBrowserToolPart, isExecuteToolPart, isFetchToolPart, isPartFailed, isPartWorking, isSessionContextToolFailure, isSessionContextToolPart, isSkillToolPart, isThinkChatActivityPart, isToolPartFailed, isToolPartWorking, isWorkspaceToolPart };

package/dist/components/ThinkChatToolParts.js

@@ -1,6 +1,36 @@
-import { getToolPartState } from "@cloudflare/think/react";
 import { getStaticToolName, getToolName, isReasoningUIPart, isStaticToolUIPart, isToolUIPart } from "ai";
 //#region src/components/ThinkChatToolParts.ts
+/** React-free equivalent of Think's UI-state mapping. Kept local so activity
+* summaries can run in workers and extension background contexts. */
+function getToolPartState(part) {
+	if (!("state" in part)) return "loading";
+	switch (part.state) {
+		case "input-streaming": return "streaming";
+		case "approval-requested": return "waiting-approval";
+		case "approval-responded": return "approved";
+		case "output-available": return "complete";
+		case "output-error": return "error";
+		case "output-denied": return "denied";
+		default: return "loading";
+	}
+}
+/** Prefer AI SDK's provider/tool-authored title over its transport-facing key. */
+function getToolDisplayName(part) {
+	return part.title ?? getToolName(part);
+}
+/**
+* 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.
+*/
+function isToolPartWorking(part) {
+	const state = getToolPartState(part);
+	return state === "loading" || state === "streaming" || state === "waiting-approval" || state === "approved" || part.state === "output-available" && part.preliminary === true;
+}
+function isToolPartFailed(part) {
+	const state = getToolPartState(part);
+	return state === "error" || state === "denied";
+}
 const WORKSPACE_TOOL_NAMES = /* @__PURE__ */ new Set([
 	"read",
 	"write",
@@ -36,7 +66,7 @@ function isSessionContextToolPart(part) {
 model can recover. Treat that upstream `Error:` envelope as failed UI while
 preserving the recorded tool state and output verbatim. */
 function isSessionContextToolFailure(part) {
-	return isPartFailed(part) || part.state === "output-available" && part.output.startsWith("Error:");
+	return isPartFailed(part) || part.state === "output-available" && typeof part.output === "string" && part.output.startsWith("Error:");
 }
 function isFetchToolPart(part) {
 	return isStaticToolUIPart(part) && getStaticToolName(part).startsWith("fetch_");
@@ -61,22 +91,18 @@ function isThinkChatActivityPart(part, excludeTools) {
 	if (isToolUIPart(part) && excludeTools?.has(getToolName(part))) return false;
 	return part.type === "step-start" || isReasoningUIPart(part) || isToolUIPart(part);
 }
-/** 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. */
 function isPartWorking(part) {
 	if (isReasoningUIPart(part)) return part.state === "streaming";
-	if (isToolUIPart(part)) {
-		const state = getToolPartState(part);
-		return state === "loading" || state === "streaming" || state === "waiting-approval";
-	}
+	if (isToolUIPart(part)) return isToolPartWorking(part);
 	return false;
 }
 /** Errored or denied — upstream's simplified tool-part state vocabulary. */
 function isPartFailed(part) {
-	const state = getToolPartState(part);
-	return state === "error" || state === "denied";
+	return isToolUIPart(part) && isToolPartFailed(part);
 }
 function displayUrl(url) {
 	return url ? url.replace(/^https?:\/\//, "") : "";
 }
 //#endregion
-export { displayUrl, isBrowserToolPart, isExecuteToolPart, isFetchToolPart, isPartFailed, isPartWorking, isSessionContextToolFailure, isSessionContextToolPart, isSkillToolPart, isThinkChatActivityPart, isWorkspaceToolPart };
+export { displayUrl, getToolDisplayName, isBrowserToolPart, isExecuteToolPart, isFetchToolPart, isPartFailed, isPartWorking, isSessionContextToolFailure, isSessionContextToolPart, isSkillToolPart, isThinkChatActivityPart, isToolPartFailed, isToolPartWorking, isWorkspaceToolPart };

package/dist/components/ThinkExecutionDetail.d.ts

@@ -0,0 +1,20 @@
+import { t as ThinkExecutionRun } from "../ThinkExecutionRun-ChhWhOoU.js";
+import * as React from "react";
+
+//#region src/components/ThinkExecutionDetail.d.ts
+interface ThinkExecutionDetailProps extends React.HTMLAttributes<HTMLElement> {
+  run: ThinkExecutionRun | null;
+  emptyState?: React.ReactNode;
+}
+/** Native Think submission or Agents Workflow detail, reusable outside the execution workbench. */
+declare function ThinkExecutionDetail({
+  className,
+  emptyState,
+  ref,
+  run,
+  ...props
+}: ThinkExecutionDetailProps & {
+  ref?: React.Ref<HTMLElement>;
+}): React.JSX.Element;
+//#endregion
+export { ThinkExecutionDetail, ThinkExecutionDetailProps };