camox 0.62.0 → 0.65.1

package/dist/features/runtime/runtime.js

@@ -2,7 +2,7 @@ import { serializeJsonForHtml } from "../../lib/html.js";
 import { createRequestContext } from "../../core/requestContext.js";
 import { UNNAMED_DEFAULT_LOCALE, localizedPath, parseLocalePath } from "../../lib/locale-path.js";
 import { draftNamedBy } from "../../lib/draft-scope.js";
-import { buildClearServerAuthCookieHeader, buildServerAuthCookieHeader, getServerAuthCookieHeader } from "../../lib/server-auth-cookie.js";
+import { buildClearServerAuthCookieHeader, buildServerAuthCookieHeader, getLookToken, getServerAuthCookieHeader } from "../../lib/server-auth-cookie.js";
 import { getCookie, getSetCookie } from "../../lib/stored-auth-cookies.js";
 import { ARTIFACTS_PATH_PREFIX, RUNTIME_ROUTE_PATHS, matchRuntimeOwnedRoute } from "./runtimeRoutes.js";
 import { reads } from "../../lib/studio-reads.js";
@@ -13,7 +13,7 @@ import { STUDIO_THEME_SCRIPT } from "../studio/studioTheme.js";
 import { DefaultPageImage, renderPageImage } from "../og/pageImage.js";
 import { discoverLayoutPages, matchDerivedLayout } from "../../core/derivedRoutes.js";
 import { buildLayoutContext, curatedLayoutContext } from "../../core/layoutContext.js";
-import { buildCamoxPageHead, buildFaviconUrl, buildPageHead, buildPageMeta, createServerApiClient, createServerStudioCache, curatedMarkdownResponse, declarePage, isNotFoundError, loadCamoxPageForRequest, parseMarkdownPath, prefersMarkdown, readDraftOrLive, readPageMarkdown, readScopeLocales, renderedHref, resolveMemberProject, withFrontMatter } from "../routes/pageRuntime.js";
+import { buildCamoxPageHead, buildCamoxPageLoaderData, buildFaviconUrl, buildPageHead, buildPageMeta, createServerApiClient, createServerStudioCache, curatedMarkdownResponse, declarePage, isAuthSessionError, isNotFoundError, loadCamoxPage, loadCamoxPageForRequest, parseMarkdownPath, prefersMarkdown, readDraftOrLive, readPageMarkdown, readScopeLocales, renderedHref, resolveMemberProject, withFrontMatter } from "../routes/pageRuntime.js";
 import { assetPrefix } from "./assetPrefix.js";
 import { documentGoogleFonts } from "../og/documentFonts.js";
 import { alternatesByPage, findAlternates, hreflangLinks } from "./alternates.js";
@@ -27,7 +27,7 @@ import { getPageBlockTypes } from "./pageBlockTypes.js";
 import { withPageUrls } from "./structuredData.js";
 import { curatedPageDescription, pageRecords, placedBlockNodes, withStructuredData } from "./pageGraph.js";
 import { createProjectLogoResponse, projectLogo } from "./projectLogo.js";
-import { LOCALE_HEADER } from "@camox/api-contract/drafts";
+import { DRAFT_SEARCH_PARAM, LOCALE_HEADER, LOOK_BLOCK_DEFINITION_PARAM, LOOK_CONTENT_PARAM, LOOK_LOCALE_PARAM, LOOK_PATH_PARAM, LOOK_SETTINGS_PARAM, UNPLACED_BLOCK_ID } from "@camox/api-contract/drafts";
 import { QueryClient, dehydrate } from "@tanstack/react-query";
 import { createHead, renderSSRHead } from "@unhead/react/server";
 
@@ -503,6 +503,314 @@ function createRendererDocumentResponse(options) {
 		"X-Robots-Tag": "noindex"
 	} });
 }
+/**
+* Marks the look document ready (`data-camox-ready` on its root element) for the browser to wait
+* on, once the page's client hydrated it (`camox:hydrated`), the window loaded, and every frame
+* on the page, its Artifacts' included, loaded or failed to, then a frame later, once painted.
+* Artifacts' frames load lazily, and their documents may fetch libraries as they start, so the
+* window's `load` alone comes before them: the frames are made eager once hydrated, so those
+* below the first screen load too, and each frame's own `load` is awaited. A frame that never
+* loads leaves the document unready, and the capture waiting on it times out.
+*/
+const LOOK_READY_SCRIPT = `(()=>{const loaded=new WeakSet();let hydrated=false,marked=false;const mark=()=>{if(marked||!hydrated||document.readyState!=="complete")return;const frames=[...document.querySelectorAll("iframe")];for(const frame of frames)if(frame.getAttribute("loading")==="lazy")frame.setAttribute("loading","eager");if(!frames.every((frame)=>loaded.has(frame)))return;marked=true;requestAnimationFrame(()=>requestAnimationFrame(()=>document.documentElement.setAttribute("data-camox-ready","")))};const settle=(event)=>{if(event.target&&event.target.tagName==="IFRAME")loaded.add(event.target);mark()};document.addEventListener("load",settle,true);document.addEventListener("error",settle,true);addEventListener("load",mark,{once:true});addEventListener("camox:hydrated",()=>{hydrated=true;mark()},{once:true})})()`;
+/** The headers every look document answer carries: private, never cached, never indexed. */
+const LOOK_HEADERS = {
+	"Cache-Control": "private, no-store",
+	"X-Robots-Tag": "noindex"
+};
+/** What the look document answers when it shows nothing: no token, or one the API refused. */
+function lookNotFound() {
+	return new Response("Not found", {
+		status: 404,
+		headers: LOOK_HEADERS
+	});
+}
+/** What the look document answers when the API refuses what it was asked to show, and why. */
+function lookRefused(message) {
+	return new Response(message, {
+		status: 422,
+		headers: {
+			...LOOK_HEADERS,
+			"Content-Type": "text/plain; charset=utf-8"
+		}
+	});
+}
+function overrideParam(searchParams, name) {
+	const raw = searchParams.get(name);
+	if (raw === null) return {
+		ok: true,
+		value: void 0
+	};
+	try {
+		return {
+			ok: true,
+			value: JSON.parse(raw)
+		};
+	} catch {
+		return {
+			ok: false,
+			error: `The ${name} override isn't JSON.`
+		};
+	}
+}
+/**
+* The lightweight document the agent's `look` tool captures (ADR 0032), for the draft
+* `camox-draft` names, read with the look token the request's cookie carries, in the Locale
+* `locale` names by its tag (the Default Locale without one). It shows the page at `path` as a
+* visitor would, or in its Block Definition mode the block of the Block Definition
+* `blockDefinition` names, placed nowhere, alone in the site's shell, with the `content` and
+* `settings` overrides merged on. Either way it has the site's head and stylesheets and the
+* page's client to hydrate its blocks, but nothing of the studio. It answers nothing without a
+* token the API accepts.
+*/
+async function createLookDocumentResponse(request, options) {
+	const { apiUrl, authenticationUrl, projectUuid, renderPage } = options;
+	const { searchParams } = new URL(request.url);
+	const lookToken = getLookToken(request.headers);
+	const draftId = searchParams.get(DRAFT_SEARCH_PARAM) ?? void 0;
+	if (!lookToken || !draftId || !apiUrl || !authenticationUrl || !projectUuid || !renderPage) return lookNotFound();
+	const tag = searchParams.get(LOOK_LOCALE_PARAM)?.toLowerCase();
+	const blockDefinition = searchParams.get(LOOK_BLOCK_DEFINITION_PARAM);
+	const queryClient = new QueryClient();
+	let locales;
+	let locale;
+	let shown;
+	try {
+		locales = await createServerApiClient(apiUrl, {
+			lookToken,
+			draftId
+		}).locales.list({ projectUuid });
+		locale = locales.find((each) => tag ? each.tag.toLowerCase() === tag : each.isDefault);
+		if (!locale) return lookNotFound();
+		const reading = {
+			apiUrl,
+			lookToken,
+			draftId,
+			locale,
+			projectUuid,
+			queryClient
+		};
+		shown = blockDefinition ? await lookAtBlockDefinition(request, options, reading, blockDefinition) : await lookAtPage(request, options, reading);
+	} catch (error) {
+		if (isAuthSessionError(error) || isNotFoundError(error)) return lookNotFound();
+		throw error;
+	}
+	if (shown instanceof Response) return shown;
+	const document = await options.getDocument?.() ?? {};
+	const dehydratedState = dehydrate(queryClient);
+	const input = {
+		...shown,
+		look: true,
+		presentation: "public",
+		apiUrl,
+		authenticationUrl,
+		dehydratedState,
+		draftId,
+		projectUuid,
+		runtimeBasePath: normalizeRuntimeBasePath(options.runtimeBasePath),
+		locale,
+		locales
+	};
+	const appHtml = await renderPage(input);
+	const renderedHead = renderHead(document, createPageHeadInput(shown.head), options.stylesheetUrl, void 0, locale);
+	return new Response(`<!doctype html>
+<html${renderedHead.htmlAttrs}>
+<head>
+${renderedHead.headTags}
+<meta name="robots" content="noindex">
+<script>${LOOK_READY_SCRIPT}<\/script>
+${renderBlockPreloads(options, dehydratedState)}
+<script id="__CAMOX_DATA__" type="application/json">${serializeJsonForHtml(hydrationInputFor(input, appHtml))}<\/script>
+</head>
+<body${renderedHead.bodyAttrs}>
+${renderedHead.bodyTagsOpen}
+<div id="root">${appHtml}</div>
+${renderedHead.bodyTags}
+${renderClientEntryScript(options.pageClientEntryUrl)}
+</body>
+</html>`, { headers: {
+		...LOOK_HEADERS,
+		"Content-Type": "text/html; charset=utf-8",
+		"Referrer-Policy": "no-referrer"
+	} });
+}
+/** Where the look document's client believes it is: `path` of the draft, in its Locale. */
+function lookHref(request, options, pathname, draftId) {
+	const href = new URL(withRuntimeBasePath(pathname, options.runtimeBasePath), request.url);
+	href.searchParams.set(DRAFT_SEARCH_PARAM, draftId);
+	return href;
+}
+/**
+* The look document's page at `path`, with its head, as a visitor would see it. A path is
+* matched as the website serves it: a singleton layout's route first, then a curated page, then a
+* derived layout's route.
+*/
+async function lookAtPage(request, options, reading) {
+	const { apiUrl, draftId, locale } = reading;
+	const path = normalizePagePath(new URL(request.url).searchParams.get(LOOK_PATH_PARAM));
+	const camoxApp = await options.getCamoxApp?.();
+	const match = camoxApp && matchDerivedLayout(camoxApp.getLayouts(), path);
+	if (match?.layout._internal.kind === "singleton") return lookAtLayoutPage(request, options, reading, path, match);
+	let page;
+	try {
+		page = await loadCamoxPage({
+			...reading,
+			pathname: path
+		});
+	} catch (error) {
+		if (match && isNotFoundError(error)) return lookAtLayoutPage(request, options, reading, path, match);
+		throw error;
+	}
+	const pathname = localizedPath(path, locale);
+	const href = lookHref(request, options, pathname, draftId);
+	const loaderData = buildCamoxPageLoaderData(apiUrl, page, href.origin);
+	return {
+		head: camoxApp ? buildCamoxPageHead(camoxApp, loaderData, locale) : {},
+		href: href.href,
+		layoutIdentity: getLayoutIdentity(page.layout),
+		loaderData,
+		pathname
+	};
+}
+/**
+* The look document's page of a singleton or derived layout at `path`: the layout's blocks, read
+* with the look token, around what its loader returns, its records read from the draft. A loader
+* that finds nothing answers why.
+*/
+async function lookAtLayoutPage(request, options, reading, path, match) {
+	const { apiUrl, lookToken, draftId, locale, projectUuid, queryClient } = reading;
+	const app = await options.getCamoxApp?.();
+	const layout = match.layout._internal;
+	const pathname = localizedPath(path, locale);
+	let result;
+	let shared;
+	try {
+		[result, shared] = await Promise.all([loadLayoutResult(app, match, createLayoutRequestContext(options, "draft", {
+			lookToken,
+			draftId,
+			locale
+		}), locale), createServerApiClient(apiUrl, {
+			lookToken,
+			draftId,
+			locale
+		}).layouts.get({
+			projectUuid,
+			layoutId: layout.id
+		})]);
+	} catch (error) {
+		if (!isNotFoundError(error)) throw error;
+		return new Response(`The draft has no page at ${path}: the ${layout.id} layout's loader found nothing to show.`, {
+			status: 404,
+			headers: {
+				...LOOK_HEADERS,
+				"Content-Type": "text/plain; charset=utf-8"
+			}
+		});
+	}
+	const studioCache = createServerStudioCache(queryClient, {
+		apiUrl,
+		lookToken,
+		locale
+	});
+	const inDraft = { in: draftId };
+	const runtimeBasePath = normalizeRuntimeBasePath(options.runtimeBasePath);
+	studioCache.land(reads.layoutStructure({
+		projectUuid,
+		layoutId: layout.id
+	}), shared, inDraft);
+	studioCache.set(reads.derivedPageData({
+		projectUuid,
+		runtimeBasePath,
+		pathname
+	}), result ?? null, inDraft);
+	const href = lookHref(request, options, pathname, draftId);
+	const record = asCollectionItem(result);
+	const collection = record && app?.getCollectionById(record.collectionId);
+	const context = buildLayoutContext(layout, {
+		path: pathname,
+		locale: locale.tag,
+		projectName: shared.projectName,
+		data: result?.data,
+		params: match.params,
+		record: record && collection ? recordPageValues(collection, record) : void 0
+	});
+	return {
+		head: buildPageHead({
+			layout,
+			context,
+			origin: href.origin,
+			faviconUrl: buildFaviconUrl(apiUrl, shared.project),
+			hasMarkdown: layout.toMarkdown !== void 0,
+			recordType: record?.structuredData?.node?.["@type"]
+		}),
+		href: href.href,
+		layoutIdentity: getLayoutIdentity(shared.layout),
+		loaderData: null,
+		pathname,
+		derived: {
+			layoutId: layout.id,
+			page: {
+				params: match.params,
+				path: pathname,
+				projectName: shared.projectName
+			},
+			result,
+			layout: shared.layout
+		}
+	};
+}
+/**
+* The look document's Block Definition mode: the block of the Block Definition `type` as the
+* draft would show it placed, with its default content and Block Settings and the overrides the
+* URL gives merged on, by the API, which checks them against its schemas. An override it refuses
+* answers its message. The block is read as a page reads its blocks, so it renders and hydrates
+* as a page's block does; its page is the Locale's home, which links resolve against.
+*/
+async function lookAtBlockDefinition(request, options, reading, type) {
+	const { apiUrl, lookToken, draftId, locale, projectUuid, queryClient } = reading;
+	const { searchParams } = new URL(request.url);
+	const content = overrideParam(searchParams, LOOK_CONTENT_PARAM);
+	const settings = overrideParam(searchParams, LOOK_SETTINGS_PARAM);
+	if (!content.ok) return lookRefused(content.error);
+	if (!settings.ok) return lookRefused(settings.error);
+	const studioCache = createServerStudioCache(queryClient, {
+		apiUrl,
+		lookToken,
+		locale
+	});
+	const inDraft = { in: draftId };
+	let bundle;
+	try {
+		[bundle] = await Promise.all([createServerApiClient(apiUrl, {
+			lookToken,
+			draftId,
+			locale
+		}).blocks.getUnplaced({
+			projectUuid,
+			type,
+			content: content.value,
+			settings: settings.value
+		}), studioCache.ensure(reads.pageList({ projectUuid }), inDraft).catch(() => null)]);
+	} catch (error) {
+		if (isBadRequestError(error)) return lookRefused(error.message);
+		throw error;
+	}
+	studioCache.set(reads.blockBundle(UNPLACED_BLOCK_ID), bundle, inDraft);
+	const pathname = localizedPath("/", locale);
+	return {
+		head: {},
+		href: lookHref(request, options, pathname, draftId).href,
+		layoutIdentity: null,
+		loaderData: null,
+		pathname,
+		lookBlock: UNPLACED_BLOCK_ID
+	};
+}
+/** Whether an API error refused the request's input, such as an override its schema refuses. */
+function isBadRequestError(error) {
+	const { code, status } = error ?? {};
+	return code === "BAD_REQUEST" || status === 400;
+}
 function renderClientEntryScript(src) {
 	if (!src) return "";
 	return `<script type="module" src="${escapeXml(src)}"><\/script>`;
@@ -959,11 +1267,12 @@ function createLayoutRequestContext(options, source, reading) {
 * Reads the records `loader` and `routes` ask for, in `locale` or the default locale; none
 * without an API.
 */
-function createRecordLookup(options, source, { authCookieHeader, draftId, locale } = {}) {
+function createRecordLookup(options, source, { authCookieHeader, lookToken, draftId, locale } = {}) {
 	const { apiUrl, projectUuid } = options;
 	if (!apiUrl || !projectUuid) return void 0;
 	const api = createServerApiClient(apiUrl, {
 		authCookieHeader: source === "draft" ? authCookieHeader : void 0,
+		lookToken: source === "draft" ? lookToken : void 0,
 		draftId,
 		locale
 	});
@@ -1460,6 +1769,7 @@ async function handleCamoxRequest(request, options = {}) {
 	if (match.kind === "artifact") return createArtifactDocumentResponse(pathname, options);
 	if (match.kind === "og") return createOgResponse(request, options);
 	if (match.kind === "renderer") return createRendererDocumentResponse(options);
+	if (match.kind === "look") return createLookDocumentResponse(request, options);
 	if (match.kind === "logo") return createProjectLogoResponse(request, options);
 	if (match.kind === "sitemap") return createSitemapResponse(request, options);
 	if (match.kind === "llms-txt") return createLlmsTxtResponse(request, options);

package/dist/features/runtime/runtimeRoutes.d.ts

@@ -10,6 +10,11 @@
 export declare const RUNTIME_ROUTE_PATHS: {
   readonly data: "/_camox/data";
   readonly health: "/_camox/health";
+  /**
+   * The lightweight document the agent's `look` tool captures (ADR 0032): one page of a draft,
+   * read with a look token, without the studio.
+   */
+  readonly look: "/_camox/look";
   readonly registry: "/_camox/registry";
   /** The renderer frame's document (ADR 0023), which the studio loads to render its pages. */
   readonly renderer: "/_camox/renderer";

package/dist/features/runtime/runtimeRoutes.js

@@ -10,6 +10,11 @@
 const RUNTIME_ROUTE_PATHS = {
 	data: "/_camox/data",
 	health: "/_camox/health",
+	/**
+	* The lightweight document the agent's `look` tool captures (ADR 0032): one page of a draft,
+	* read with a look token, without the studio.
+	*/
+	look: "/_camox/look",
 	registry: "/_camox/registry",
 	/** The renderer frame's document (ADR 0023), which the studio loads to render its pages. */
 	renderer: "/_camox/renderer",

package/dist/features/studio/components/ChatWidget.js

@@ -4,15 +4,18 @@ import { AuthContext } from "../../../lib/auth.js";
 import { reads, useReadQuery } from "../../../lib/studio-reads.js";
 import { cn } from "../../../lib/utils.js";
 import { BOTTOM_CARD_EDGES, CARD_BODY_EDGES } from "../../preview/components/SidebarStack.js";
+import { studioStore } from "../studioStore.js";
 import { FollowAgentContext } from "../followAgentContext.js";
 import { useThread } from "../../../lib/use-thread.js";
 import { EditorWhereContext } from "../editorWhereContext.js";
 import { useEditorSelection } from "../useEditorSelection.js";
+import { ConnectAgent } from "./ConnectAgent.js";
 import { ThreadComposer } from "./ThreadComposer.js";
 import { ThreadMessages } from "./ThreadMessages.js";
 import { c } from "react/compiler-runtime";
 import * as React from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useSelector } from "@xstate/store-react";
 import { EMPTY_THREAD_VIEW } from "@camox/api-contract/threads";
 
 //#region src/features/studio/components/ChatWidget.tsx
@@ -23,7 +26,8 @@ import { EMPTY_THREAD_VIEW } from "@camox/api-contract/threads";
 * When the agent on Live hands the editor's request off to a draft, the studio that asked enters
 * it, if it still shows Live; the card the Live turn ends on opens it too. Each message tells the
 * agent where the editor is: the page they look at, with what they selected on it unless they
-* cleared it from the composer, or the Canvas with no page selected.
+* cleared it from the composer, or the Canvas with no page selected. "Ask the agent" elsewhere in
+* the studio fills its composer. Under the composer, it invites the editor to connect their own AI.
 */
 function ChatWidget(t0) {
 	const $ = c(6);
@@ -44,9 +48,9 @@ function ChatWidget(t0) {
 				children: "Agent"
 			})
 		});
-		t3 = /* @__PURE__ */ jsx("div", {
+		t3 = /* @__PURE__ */ jsxs("div", {
 			className: cn("bg-background flex min-h-0 flex-1 flex-col", CARD_BODY_EDGES),
-			children: /* @__PURE__ */ jsx(CurrentThread, {})
+			children: [/* @__PURE__ */ jsx(CurrentThread, {}), /* @__PURE__ */ jsx(ConnectAgent, {})]
 		});
 		$[2] = t2;
 		$[3] = t3;
@@ -126,7 +130,7 @@ function CurrentThread() {
 	return t4;
 }
 function Thread(t0) {
-	const $ = c(36);
+	const $ = c(40);
 	const { apiUrl, projectId, draftId, onEnterDraft, onOpenDraft } = t0;
 	let t1;
 	if ($[0] !== onEnterDraft) {
@@ -176,85 +180,107 @@ function Thread(t0) {
 	const [cleared, setCleared] = React.useState(null);
 	if (cleared !== null && selectionKey !== cleared) setCleared(null);
 	const carried = selection && selectionKey !== cleared ? selection : void 0;
+	const asked = useSelector(studioStore, _temp);
 	let t6;
-	if ($[11] !== carried || $[12] !== follow || $[13] !== send || $[14] !== where) {
-		t6 = (text) => {
+	let t7;
+	if ($[11] !== asked) {
+		t6 = () => {
+			if (asked) studioStore.trigger.takeAgentAsk();
+		};
+		t7 = [asked];
+		$[11] = asked;
+		$[12] = t6;
+		$[13] = t7;
+	} else {
+		t6 = $[12];
+		t7 = $[13];
+	}
+	React.useEffect(t6, t7);
+	let t8;
+	if ($[14] !== carried || $[15] !== follow || $[16] !== send || $[17] !== where) {
+		t8 = (text) => {
 			follow?.resume();
 			send(text, where?.on === "page" && carried ? {
 				...where,
 				selection: carried
 			} : where);
 		};
-		$[11] = carried;
-		$[12] = follow;
-		$[13] = send;
-		$[14] = where;
-		$[15] = t6;
-	} else t6 = $[15];
-	const sendFollowing = t6;
-	let t7;
-	if ($[16] !== onOpenDraft || $[17] !== sending || $[18] !== view) {
-		t7 = /* @__PURE__ */ jsx(ThreadMessages, {
+		$[14] = carried;
+		$[15] = follow;
+		$[16] = send;
+		$[17] = where;
+		$[18] = t8;
+	} else t8 = $[18];
+	const sendFollowing = t8;
+	let t9;
+	if ($[19] !== onOpenDraft || $[20] !== sending || $[21] !== view) {
+		t9 = /* @__PURE__ */ jsx(ThreadMessages, {
 			view,
 			sending,
 			onOpenDraft
 		});
-		$[16] = onOpenDraft;
-		$[17] = sending;
-		$[18] = view;
-		$[19] = t7;
-	} else t7 = $[19];
-	let t8;
-	if ($[20] !== error) {
-		t8 = error && /* @__PURE__ */ jsx("p", {
+		$[19] = onOpenDraft;
+		$[20] = sending;
+		$[21] = view;
+		$[22] = t9;
+	} else t9 = $[22];
+	let t10;
+	if ($[23] !== error) {
+		t10 = error && /* @__PURE__ */ jsx("p", {
 			role: "alert",
 			className: "text-destructive px-2 pt-2 text-sm",
 			children: error
 		});
-		$[20] = error;
-		$[21] = t8;
-	} else t8 = $[21];
-	let t9;
-	if ($[22] !== carried?.path) {
-		t9 = carried?.path.at(-1);
-		$[22] = carried?.path;
-		$[23] = t9;
-	} else t9 = $[23];
-	let t10;
-	if ($[24] !== selectionKey) {
-		t10 = () => selectionKey !== null && setCleared(selectionKey);
-		$[24] = selectionKey;
-		$[25] = t10;
-	} else t10 = $[25];
+		$[23] = error;
+		$[24] = t10;
+	} else t10 = $[24];
 	let t11;
-	if ($[26] !== sendFollowing || $[27] !== stop || $[28] !== t10 || $[29] !== t9 || $[30] !== view.running) {
-		t11 = /* @__PURE__ */ jsx(ThreadComposer, {
+	if ($[25] !== carried?.path) {
+		t11 = carried?.path.at(-1);
+		$[25] = carried?.path;
+		$[26] = t11;
+	} else t11 = $[26];
+	let t12;
+	if ($[27] !== selectionKey) {
+		t12 = () => selectionKey !== null && setCleared(selectionKey);
+		$[27] = selectionKey;
+		$[28] = t12;
+	} else t12 = $[28];
+	const t13 = asked ?? void 0;
+	let t14;
+	if ($[29] !== sendFollowing || $[30] !== stop || $[31] !== t11 || $[32] !== t12 || $[33] !== t13 || $[34] !== view.running) {
+		t14 = /* @__PURE__ */ jsx(ThreadComposer, {
 			onSend: sendFollowing,
 			onStop: stop,
-			selection: t9,
-			onClearSelection: t10,
-			running: view.running
+			selection: t11,
+			onClearSelection: t12,
+			running: view.running,
+			filled: t13
 		});
-		$[26] = sendFollowing;
-		$[27] = stop;
-		$[28] = t10;
-		$[29] = t9;
-		$[30] = view.running;
+		$[29] = sendFollowing;
+		$[30] = stop;
 		$[31] = t11;
-	} else t11 = $[31];
-	let t12;
-	if ($[32] !== t11 || $[33] !== t7 || $[34] !== t8) {
-		t12 = /* @__PURE__ */ jsxs(Fragment, { children: [
-			t7,
-			t8,
-			t11
+		$[32] = t12;
+		$[33] = t13;
+		$[34] = view.running;
+		$[35] = t14;
+	} else t14 = $[35];
+	let t15;
+	if ($[36] !== t10 || $[37] !== t14 || $[38] !== t9) {
+		t15 = /* @__PURE__ */ jsxs(Fragment, { children: [
+			t9,
+			t10,
+			t14
 		] });
-		$[32] = t11;
-		$[33] = t7;
-		$[34] = t8;
-		$[35] = t12;
-	} else t12 = $[35];
-	return t12;
+		$[36] = t10;
+		$[37] = t14;
+		$[38] = t9;
+		$[39] = t15;
+	} else t15 = $[39];
+	return t15;
+}
+function _temp(state) {
+	return state.context.agentAsk;
 }
 
 //#endregion