@fragno-dev/pi-fragment 0.0.1 → 0.0.3

package/dist/browser/{factory-DKoO_lRA.js → clients-BscY_HVe.js}

@@ -1,9 +1,6 @@
+import { atom, batched, computed, map, onMount, onStart, onStop, startTask, task } from "nanostores";
 import { defineFragment, defineRoutes } from "@fragno-dev/core";
 import { z } from "zod";
-import { Agent } from "@mariozechner/pi-agent-core";
-import { createAssistantMessageEventStream } from "@mariozechner/pi-ai";
-import { NonRetryableError, defineWorkflow } from "@fragno-dev/workflows";
-import { column, idColumn, schema } from "@fragno-dev/db/schema";
 
 //#region ../fragno/dist/api/route.js
 /**
@@ -19,6 +16,80 @@ function resolveRouteFactories(context, routesOrFactories) {
 	return routes;
 }
 
+//#endregion
+//#region ../fragno/dist/api/internal/path.js
+/**
+* Extract parameter names from a path pattern at runtime.
+* Examples:
+* - "/users/:id" => ["id"]
+* - "/files/**" => ["**"]
+* - "/files/**:rest" => ["rest"]
+*/
+function extractPathParams(pathPattern) {
+	const segments = pathPattern.split("/").filter((s) => s.length > 0);
+	const names = [];
+	for (const segment of segments) {
+		if (segment.startsWith(":")) {
+			names.push(segment.slice(1));
+			continue;
+		}
+		if (segment === "**") {
+			names.push("**");
+			continue;
+		}
+		if (segment.startsWith("**:")) {
+			names.push(segment.slice(3));
+			continue;
+		}
+	}
+	return names;
+}
+/**
+* Build a concrete path by replacing placeholders in a path pattern with values.
+*
+* Supports the same placeholder syntax as the matcher:
+* - Named parameter ":name" is URL-encoded as a single segment
+* - Anonymous wildcard "**" inserts the remainder as-is (slashes preserved)
+* - Named wildcard "**:name" inserts the remainder from the named key
+*
+* Examples:
+* - buildPath("/users/:id", { id: "123" }) => "/users/123"
+* - buildPath("/files/**", { "**": "a/b" }) => "/files/a/b"
+* - buildPath("/files/**:rest", { rest: "a/b" }) => "/files/a/b"
+*/
+function buildPath(pathPattern, params) {
+	const patternSegments = pathPattern.split("/");
+	const builtSegments = [];
+	for (const segment of patternSegments) {
+		if (segment.length === 0) {
+			builtSegments.push("");
+			continue;
+		}
+		if (segment.startsWith(":")) {
+			const name = segment.slice(1);
+			const value = params[name];
+			if (value === void 0) throw new Error(`Missing value for path parameter :${name}`);
+			builtSegments.push(encodeURIComponent(value));
+			continue;
+		}
+		if (segment === "**") {
+			const value = params["**"];
+			if (value === void 0) throw new Error("Missing value for path wildcard **");
+			builtSegments.push(value);
+			continue;
+		}
+		if (segment.startsWith("**:")) {
+			const name = segment.slice(3);
+			const value = params[name];
+			if (value === void 0) throw new Error(`Missing value for path wildcard **:${name}`);
+			builtSegments.push(value);
+			continue;
+		}
+		builtSegments.push(segment);
+	}
+	return builtSegments.join("/");
+}
+
 //#endregion
 //#region ../fragno/dist/api/internal/route.js
 function getMountRoute(opts) {
@@ -449,77 +520,95 @@ var RequestOutputContext = class extends OutputContext {
 };
 
 //#endregion
-//#region ../fragno/dist/api/internal/path.js
+//#region ../fragno/dist/util/content-type.js
 /**
-* Extract parameter names from a path pattern at runtime.
-* Examples:
-* - "/users/:id" => ["id"]
-* - "/files/**" => ["**"]
-* - "/files/**:rest" => ["rest"]
+* Parses a content-type header string into its components
+*
+* @param contentType - The content-type header value to parse
+* @returns A ParsedContentType object or null if the input is invalid
+*
+* @example
+* ```ts
+* const { type, subtype, mediaType, parameters }
+*        = parseContentType("application/json; charset=utf-8");
+* console.assert(type === "application");
+* console.assert(subtype === "json");
+* console.assert(mediaType === "application/json");
+* console.assert(parameters["charset"] === "utf-8");
 */
-function extractPathParams(pathPattern) {
-	const segments = pathPattern.split("/").filter((s) => s.length > 0);
-	const names = [];
-	for (const segment of segments) {
-		if (segment.startsWith(":")) {
-			names.push(segment.slice(1));
-			continue;
-		}
-		if (segment === "**") {
-			names.push("**");
-			continue;
-		}
-		if (segment.startsWith("**:")) {
-			names.push(segment.slice(3));
-			continue;
+function parseContentType(contentType) {
+	if (!contentType || typeof contentType !== "string") return null;
+	const trimmed = contentType.trim();
+	if (!trimmed) return null;
+	const parts = trimmed.split(";").map((part) => part.trim());
+	const mediaType = parts[0];
+	if (!mediaType) return null;
+	const typeParts = mediaType.split("/");
+	if (typeParts.length !== 2) return null;
+	const [type, subtype] = typeParts.map((part) => part.trim().toLowerCase());
+	if (!type || !subtype) return null;
+	const parameters = {};
+	for (let i = 1; i < parts.length; i++) {
+		const param = parts[i];
+		const equalIndex = param.indexOf("=");
+		if (equalIndex > 0) {
+			const key = param.slice(0, equalIndex).trim().toLowerCase();
+			let value = param.slice(equalIndex + 1).trim();
+			if (value.startsWith("\"") && value.endsWith("\"")) value = value.slice(1, -1);
+			if (key) parameters[key] = value;
 		}
 	}
-	return names;
+	return {
+		type,
+		subtype,
+		mediaType: `${type}/${subtype}`,
+		parameters
+	};
 }
+
+//#endregion
+//#region ../fragno/dist/util/nanostores.js
 /**
-* Build a concrete path by replacing placeholders in a path pattern with values.
-*
-* Supports the same placeholder syntax as the matcher:
-* - Named parameter ":name" is URL-encoded as a single segment
-* - Anonymous wildcard "**" inserts the remainder as-is (slashes preserved)
-* - Named wildcard "**:name" inserts the remainder from the named key
-*
-* Examples:
-* - buildPath("/users/:id", { id: "123" }) => "/users/123"
-* - buildPath("/files/**", { "**": "a/b" }) => "/files/a/b"
-* - buildPath("/files/**:rest", { rest: "a/b" }) => "/files/a/b"
+* Normalizes a value that could be a plain value, an Atom, or a Vue Ref to a plain value.
 */
-function buildPath(pathPattern, params) {
-	const patternSegments = pathPattern.split("/");
-	const builtSegments = [];
-	for (const segment of patternSegments) {
-		if (segment.length === 0) {
-			builtSegments.push("");
-			continue;
-		}
-		if (segment.startsWith(":")) {
-			const name = segment.slice(1);
-			const value = params[name];
-			if (value === void 0) throw new Error(`Missing value for path parameter :${name}`);
-			builtSegments.push(encodeURIComponent(value));
-			continue;
-		}
-		if (segment === "**") {
-			const value = params["**"];
-			if (value === void 0) throw new Error("Missing value for path wildcard **");
-			builtSegments.push(value);
-			continue;
-		}
-		if (segment.startsWith("**:")) {
-			const name = segment.slice(3);
-			const value = params[name];
-			if (value === void 0) throw new Error(`Missing value for path wildcard **:${name}`);
-			builtSegments.push(value);
-			continue;
-		}
-		builtSegments.push(segment);
+function unwrapAtom(value) {
+	if (value && typeof value === "object" && "get" in value && typeof value.get === "function") return value.get();
+	return value;
+}
+/**
+* Normalizes an object where values can be plain values, Atoms, or Vue Refs.
+* Returns a new object with all values normalized to plain values.
+*/
+function unwrapObject(params) {
+	if (!params) return;
+	return Object.fromEntries(Object.entries(params).map(([key, value]) => [key, unwrapAtom(value)]));
+}
+function isReadableAtom(value) {
+	if (!value) return false;
+	if (typeof value !== "object" || value === null) return false;
+	if (!("get" in value) || typeof value.get !== "function") return false;
+	if (!("lc" in value) || typeof value.lc !== "number") return false;
+	if (!("notify" in value) || typeof value.notify !== "function") return false;
+	if (!("off" in value) || typeof value.off !== "function") return false;
+	if (!("subscribe" in value) || typeof value.subscribe !== "function") return false;
+	if (!("value" in value)) return false;
+	return true;
+}
+
+//#endregion
+//#region ../fragno/dist/util/ssr.js
+let stores = [];
+const SSR_ENABLED = false;
+function addStore(store) {
+	stores.push(store);
+}
+let clientInitialData;
+function getInitialData(key) {
+	if (clientInitialData?.has(key)) {
+		const data = clientInitialData.get(key);
+		clientInitialData.delete(key);
+		return data;
 	}
-	return builtSegments.join("/");
 }
 
 //#endregion
@@ -613,51 +702,38 @@ var FragnoClientApiError = class FragnoClientApiError extends FragnoClientError
 };
 
 //#endregion
-//#region ../fragno/dist/util/content-type.js
+//#region ../fragno/dist/client/internal/fetcher-merge.js
 /**
-* Parses a content-type header string into its components
-*
-* @param contentType - The content-type header value to parse
-* @returns A ParsedContentType object or null if the input is invalid
-*
-* @example
-* ```ts
-* const { type, subtype, mediaType, parameters }
-*        = parseContentType("application/json; charset=utf-8");
-* console.assert(type === "application");
-* console.assert(subtype === "json");
-* console.assert(mediaType === "application/json");
-* console.assert(parameters["charset"] === "utf-8");
+* Merge two fetcher configurations, with user config taking precedence.
+* If user provides a custom function, it takes full precedence.
+* Otherwise, deep merge RequestInit options.
 */
-function parseContentType(contentType) {
-	if (!contentType || typeof contentType !== "string") return null;
-	const trimmed = contentType.trim();
-	if (!trimmed) return null;
-	const parts = trimmed.split(";").map((part) => part.trim());
-	const mediaType = parts[0];
-	if (!mediaType) return null;
-	const typeParts = mediaType.split("/");
-	if (typeParts.length !== 2) return null;
-	const [type, subtype] = typeParts.map((part) => part.trim().toLowerCase());
-	if (!type || !subtype) return null;
-	const parameters = {};
-	for (let i = 1; i < parts.length; i++) {
-		const param = parts[i];
-		const equalIndex = param.indexOf("=");
-		if (equalIndex > 0) {
-			const key = param.slice(0, equalIndex).trim().toLowerCase();
-			let value = param.slice(equalIndex + 1).trim();
-			if (value.startsWith("\"") && value.endsWith("\"")) value = value.slice(1, -1);
-			if (key) parameters[key] = value;
-		}
-	}
+function mergeFetcherConfigs(authorConfig, userConfig) {
+	if (userConfig?.type === "function") return userConfig;
+	if (!userConfig && authorConfig?.type === "function") return authorConfig;
+	const authorOpts = authorConfig?.type === "options" ? authorConfig.options : {};
+	const userOpts = userConfig?.type === "options" ? userConfig.options : {};
+	if (Object.keys(authorOpts).length === 0 && Object.keys(userOpts).length === 0) return;
 	return {
-		type,
-		subtype,
-		mediaType: `${type}/${subtype}`,
-		parameters
+		type: "options",
+		options: {
+			...authorOpts,
+			...userOpts,
+			headers: mergeHeaders(authorOpts.headers, userOpts.headers)
+		}
 	};
 }
+/**
+* Merge headers from author and user configs.
+* User headers override author headers.
+*/
+function mergeHeaders(author, user) {
+	if (!author && !user) return;
+	const merged = new Headers(author);
+	new Headers(user).forEach((value, key) => merged.set(key, value));
+	if (merged.keys().next().done) return;
+	return merged;
+}
 
 //#endregion
 //#region ../fragno/dist/client/internal/ndjson-streaming.js
@@ -742,380 +818,56 @@ async function handleNdjsonStreamingFirstItem(response, store, options = {}) {
 	}
 }
 /**
-* Continues streaming the remaining items in the background
-*/
-async function continueStreaming(reader, decoder, initialBuffer, items, store, abortSignal) {
-	let buffer = initialBuffer;
-	try {
-		while (true) {
-			if (abortSignal?.aborted) throw new FragnoClientFetchAbortError("Operation was aborted");
-			const { done, value } = await (abortSignal ? Promise.race([reader.read(), createAbortPromise(abortSignal)]) : reader.read());
-			if (done) {
-				if (buffer.trim()) {
-					const lines$1 = buffer.split("\n");
-					for (const line of lines$1) {
-						if (!line.trim()) continue;
-						try {
-							const jsonObject = JSON.parse(line);
-							items.push(jsonObject);
-							store?.setData([...items]);
-						} catch (parseError) {
-							throw new FragnoClientUnknownApiError("Failed to parse NDJSON line", 400, { cause: parseError });
-						}
-					}
-				}
-				break;
-			}
-			buffer += decoder.decode(value, { stream: true });
-			const lines = buffer.split("\n");
-			buffer = lines.pop() || "";
-			for (const line of lines) {
-				if (!line.trim()) continue;
-				try {
-					const jsonObject = JSON.parse(line);
-					items.push(jsonObject);
-					store?.setData([...items]);
-				} catch (parseError) {
-					throw new FragnoClientUnknownApiError("Failed to parse NDJSON line", 400, { cause: parseError });
-				}
-			}
-		}
-	} catch (error) {
-		if (error instanceof FragnoClientError) store?.setError(error);
-		else {
-			const clientError = new FragnoClientUnknownApiError("Unknown streaming error", 400, { cause: error });
-			store?.setError(clientError);
-			throw clientError;
-		}
-		throw error;
-	} finally {
-		reader.releaseLock();
-	}
-	return items;
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/nanostores@1.1.0/node_modules/nanostores/task/index.js
-let tasks = 0;
-let resolves = [];
-function startTask() {
-	tasks += 1;
-	return () => {
-		tasks -= 1;
-		if (tasks === 0) {
-			let prevResolves = resolves;
-			resolves = [];
-			for (let i of prevResolves) i();
-		}
-	};
-}
-function task(cb) {
-	let endTask = startTask();
-	let promise = cb().finally(endTask);
-	promise.t = true;
-	return promise;
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/nanostores@1.1.0/node_modules/nanostores/clean-stores/index.js
-let clean = Symbol("clean");
-
-//#endregion
-//#region ../../node_modules/.pnpm/nanostores@1.1.0/node_modules/nanostores/atom/index.js
-let listenerQueue = [];
-let lqIndex = 0;
-const QUEUE_ITEMS_PER_LISTENER = 4;
-let epoch = 0;
-const atom = /* @__NO_SIDE_EFFECTS__ */ (initialValue) => {
-	let listeners = [];
-	let $atom = {
-		get() {
-			if (!$atom.lc) $atom.listen(() => {})();
-			return $atom.value;
-		},
-		lc: 0,
-		listen(listener) {
-			$atom.lc = listeners.push(listener);
-			return () => {
-				for (let i = lqIndex + QUEUE_ITEMS_PER_LISTENER; i < listenerQueue.length;) if (listenerQueue[i] === listener) listenerQueue.splice(i, QUEUE_ITEMS_PER_LISTENER);
-				else i += QUEUE_ITEMS_PER_LISTENER;
-				let index = listeners.indexOf(listener);
-				if (~index) {
-					listeners.splice(index, 1);
-					if (!--$atom.lc) $atom.off();
-				}
-			};
-		},
-		notify(oldValue, changedKey) {
-			epoch++;
-			let runListenerQueue = !listenerQueue.length;
-			for (let listener of listeners) listenerQueue.push(listener, $atom.value, oldValue, changedKey);
-			if (runListenerQueue) {
-				for (lqIndex = 0; lqIndex < listenerQueue.length; lqIndex += QUEUE_ITEMS_PER_LISTENER) listenerQueue[lqIndex](listenerQueue[lqIndex + 1], listenerQueue[lqIndex + 2], listenerQueue[lqIndex + 3]);
-				listenerQueue.length = 0;
-			}
-		},
-		off() {},
-		set(newValue) {
-			let oldValue = $atom.value;
-			if (oldValue !== newValue) {
-				$atom.value = newValue;
-				$atom.notify(oldValue);
-			}
-		},
-		subscribe(listener) {
-			let unbind = $atom.listen(listener);
-			listener($atom.value);
-			return unbind;
-		},
-		value: initialValue
-	};
-	$atom[clean] = () => {
-		listeners = [];
-		$atom.lc = 0;
-		$atom.off();
-	};
-	return $atom;
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/nanostores@1.1.0/node_modules/nanostores/lifecycle/index.js
-const START = 0;
-const STOP = 1;
-const MOUNT = 5;
-const UNMOUNT = 6;
-const REVERT_MUTATION = 10;
-let on = (object, listener, eventKey, mutateStore) => {
-	object.events = object.events || {};
-	if (!object.events[eventKey + REVERT_MUTATION]) object.events[eventKey + REVERT_MUTATION] = mutateStore((eventProps) => {
-		object.events[eventKey].reduceRight((event, l) => (l(event), event), {
-			shared: {},
-			...eventProps
-		});
-	});
-	object.events[eventKey] = object.events[eventKey] || [];
-	object.events[eventKey].push(listener);
-	return () => {
-		let currentListeners = object.events[eventKey];
-		let index = currentListeners.indexOf(listener);
-		currentListeners.splice(index, 1);
-		if (!currentListeners.length) {
-			delete object.events[eventKey];
-			object.events[eventKey + REVERT_MUTATION]();
-			delete object.events[eventKey + REVERT_MUTATION];
-		}
-	};
-};
-let onStart = ($store, listener) => on($store, listener, START, (runListeners) => {
-	let originListen = $store.listen;
-	$store.listen = (arg) => {
-		if (!$store.lc && !$store.starting) {
-			$store.starting = true;
-			runListeners();
-			delete $store.starting;
-		}
-		return originListen(arg);
-	};
-	return () => {
-		$store.listen = originListen;
-	};
-});
-let onStop = ($store, listener) => on($store, listener, STOP, (runListeners) => {
-	let originOff = $store.off;
-	$store.off = () => {
-		runListeners();
-		originOff();
-	};
-	return () => {
-		$store.off = originOff;
-	};
-});
-let STORE_UNMOUNT_DELAY = 1e3;
-let onMount = ($store, initialize) => {
-	let listener = (payload) => {
-		let destroy = initialize(payload);
-		if (destroy) $store.events[UNMOUNT].push(destroy);
-	};
-	return on($store, listener, MOUNT, (runListeners) => {
-		let originListen = $store.listen;
-		$store.listen = (...args) => {
-			if (!$store.lc && !$store.active) {
-				$store.active = true;
-				runListeners();
-			}
-			return originListen(...args);
-		};
-		let originOff = $store.off;
-		$store.events[UNMOUNT] = [];
-		$store.off = () => {
-			originOff();
-			setTimeout(() => {
-				if ($store.active && !$store.lc) {
-					$store.active = false;
-					for (let destroy of $store.events[UNMOUNT]) destroy();
-					$store.events[UNMOUNT] = [];
-				}
-			}, STORE_UNMOUNT_DELAY);
-		};
-		{
-			let originClean = $store[clean];
-			$store[clean] = () => {
-				for (let destroy of $store.events[UNMOUNT]) destroy();
-				$store.events[UNMOUNT] = [];
-				$store.active = false;
-				originClean();
-			};
-		}
-		return () => {
-			$store.listen = originListen;
-			$store.off = originOff;
-		};
-	});
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/nanostores@1.1.0/node_modules/nanostores/computed/index.js
-let computedStore = (stores, cb, batched) => {
-	if (!Array.isArray(stores)) stores = [stores];
-	let previousArgs;
-	let currentEpoch;
-	let set = () => {
-		if (currentEpoch === epoch) return;
-		currentEpoch = epoch;
-		let args = stores.map(($store) => $store.get());
-		if (!previousArgs || args.some((arg, i) => arg !== previousArgs[i])) {
-			previousArgs = args;
-			let value = cb(...args);
-			if (value && value.then && value.t) value.then((asyncValue) => {
-				if (previousArgs === args) $computed.set(asyncValue);
-			});
-			else {
-				$computed.set(value);
-				currentEpoch = epoch;
-			}
-		}
-	};
-	let $computed = /* @__PURE__ */ atom(void 0);
-	let get = $computed.get;
-	$computed.get = () => {
-		set();
-		return get();
-	};
-	let timer;
-	let run = batched ? () => {
-		clearTimeout(timer);
-		timer = setTimeout(set);
-	} : set;
-	onMount($computed, () => {
-		let unbinds = stores.map(($store) => $store.listen(run));
-		set();
-		return () => {
-			for (let unbind of unbinds) unbind();
-		};
-	});
-	return $computed;
-};
-const computed = /* @__NO_SIDE_EFFECTS__ */ (stores, fn) => computedStore(stores, fn);
-const batched = /* @__NO_SIDE_EFFECTS__ */ (stores, fn) => computedStore(stores, fn, true);
-
-//#endregion
-//#region ../../node_modules/.pnpm/nanostores@1.1.0/node_modules/nanostores/map/index.js
-const map = /* @__NO_SIDE_EFFECTS__ */ (initial = {}) => {
-	let $map = /* @__PURE__ */ atom(initial);
-	$map.setKey = function(key, value) {
-		let oldMap = $map.value;
-		if (typeof value === "undefined" && key in $map.value) {
-			$map.value = { ...$map.value };
-			delete $map.value[key];
-			$map.notify(oldMap, key);
-		} else if ($map.value[key] !== value) {
-			$map.value = {
-				...$map.value,
-				[key]: value
-			};
-			$map.notify(oldMap, key);
-		}
-	};
-	return $map;
-};
-
-//#endregion
-//#region ../fragno/dist/util/ssr.js
-let stores = [];
-const SSR_ENABLED = false;
-function addStore(store) {
-	stores.push(store);
-}
-let clientInitialData;
-function getInitialData(key) {
-	if (clientInitialData?.has(key)) {
-		const data = clientInitialData.get(key);
-		clientInitialData.delete(key);
-		return data;
-	}
-}
-
-//#endregion
-//#region ../fragno/dist/util/nanostores.js
-/**
-* Normalizes a value that could be a plain value, an Atom, or a Vue Ref to a plain value.
-*/
-function unwrapAtom(value) {
-	if (value && typeof value === "object" && "get" in value && typeof value.get === "function") return value.get();
-	return value;
-}
-/**
-* Normalizes an object where values can be plain values, Atoms, or Vue Refs.
-* Returns a new object with all values normalized to plain values.
-*/
-function unwrapObject(params) {
-	if (!params) return;
-	return Object.fromEntries(Object.entries(params).map(([key, value]) => [key, unwrapAtom(value)]));
-}
-function isReadableAtom(value) {
-	if (!value) return false;
-	if (typeof value !== "object" || value === null) return false;
-	if (!("get" in value) || typeof value.get !== "function") return false;
-	if (!("lc" in value) || typeof value.lc !== "number") return false;
-	if (!("notify" in value) || typeof value.notify !== "function") return false;
-	if (!("off" in value) || typeof value.off !== "function") return false;
-	if (!("subscribe" in value) || typeof value.subscribe !== "function") return false;
-	if (!("value" in value)) return false;
-	return true;
-}
-
-//#endregion
-//#region ../fragno/dist/client/internal/fetcher-merge.js
-/**
-* Merge two fetcher configurations, with user config taking precedence.
-* If user provides a custom function, it takes full precedence.
-* Otherwise, deep merge RequestInit options.
-*/
-function mergeFetcherConfigs(authorConfig, userConfig) {
-	if (userConfig?.type === "function") return userConfig;
-	if (!userConfig && authorConfig?.type === "function") return authorConfig;
-	const authorOpts = authorConfig?.type === "options" ? authorConfig.options : {};
-	const userOpts = userConfig?.type === "options" ? userConfig.options : {};
-	if (Object.keys(authorOpts).length === 0 && Object.keys(userOpts).length === 0) return;
-	return {
-		type: "options",
-		options: {
-			...authorOpts,
-			...userOpts,
-			headers: mergeHeaders(authorOpts.headers, userOpts.headers)
-		}
-	};
-}
-/**
-* Merge headers from author and user configs.
-* User headers override author headers.
+* Continues streaming the remaining items in the background
 */
-function mergeHeaders(author, user) {
-	if (!author && !user) return;
-	const merged = new Headers(author);
-	new Headers(user).forEach((value, key) => merged.set(key, value));
-	if (merged.keys().next().done) return;
-	return merged;
+async function continueStreaming(reader, decoder, initialBuffer, items, store, abortSignal) {
+	let buffer = initialBuffer;
+	try {
+		while (true) {
+			if (abortSignal?.aborted) throw new FragnoClientFetchAbortError("Operation was aborted");
+			const { done, value } = await (abortSignal ? Promise.race([reader.read(), createAbortPromise(abortSignal)]) : reader.read());
+			if (done) {
+				if (buffer.trim()) {
+					const lines$1 = buffer.split("\n");
+					for (const line of lines$1) {
+						if (!line.trim()) continue;
+						try {
+							const jsonObject = JSON.parse(line);
+							items.push(jsonObject);
+							store?.setData([...items]);
+						} catch (parseError) {
+							throw new FragnoClientUnknownApiError("Failed to parse NDJSON line", 400, { cause: parseError });
+						}
+					}
+				}
+				break;
+			}
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop() || "";
+			for (const line of lines) {
+				if (!line.trim()) continue;
+				try {
+					const jsonObject = JSON.parse(line);
+					items.push(jsonObject);
+					store?.setData([...items]);
+				} catch (parseError) {
+					throw new FragnoClientUnknownApiError("Failed to parse NDJSON line", 400, { cause: parseError });
+				}
+			}
+		}
+	} catch (error) {
+		if (error instanceof FragnoClientError) store?.setError(error);
+		else {
+			const clientError = new FragnoClientUnknownApiError("Unknown streaming error", 400, { cause: error });
+			store?.setError(clientError);
+			throw clientError;
+		}
+		throw error;
+	} finally {
+		reader.releaseLock();
+	}
+	return items;
 }
 
 //#endregion
@@ -1134,7 +886,7 @@ let createNanoEvents = () => ({
 });
 
 //#endregion
-//#region ../../node_modules/.pnpm/@nanostores+query@0.3.4_nanostores@1.1.0/node_modules/@nanostores/query/dist/nanoquery.js
+//#region ../../node_modules/.pnpm/@nanostores+query@0.3.4_nanostores@1.2.0/node_modules/@nanostores/query/dist/nanoquery.js
 function defaultOnErrorRetry({ retryCount }) {
 	return ~~((Math.random() + .5) * (1 << (retryCount < 8 ? retryCount : 8))) * 2e3;
 }
@@ -1240,7 +992,7 @@ const nanoqueryFactory = ([isAppVisible, visibilityChangeSubscribe, reconnectCha
 		};
 		const createFetcherStore = (keyInput, { fetcher = globalFetcher, ...fetcherSettings } = {}) => {
 			if (!fetcher) throw new Error("You need to set up either global fetcher of fetcher in createFetcherStore");
-			const fetcherStore = /* @__PURE__ */ map({ ...notLoading }), settings = {
+			const fetcherStore = map({ ...notLoading }), settings = {
 				...globalSettings,
 				...fetcherSettings,
 				fetcher
@@ -1400,7 +1152,7 @@ const nanoqueryFactory = ([isAppVisible, visibilityChangeSubscribe, reconnectCha
 					keysToRevalidate.forEach(revalidateKeys);
 				}
 			};
-			const store = /* @__PURE__ */ map({
+			const store = map({
 				mutate,
 				...notLoading
 			});
@@ -1430,9 +1182,9 @@ const nanoqueryFactory = ([isAppVisible, visibilityChangeSubscribe, reconnectCha
 		return typeof key === "string" || typeof key === "number" || key === true;
 	}
 	const getKeyStore = (keys) => {
-		if (isSomeKey(keys)) return [/* @__PURE__ */ atom(["" + keys, [keys]]), () => {}];
+		if (isSomeKey(keys)) return [atom(["" + keys, [keys]]), () => {}];
 		const keyParts = [];
-		const $key = /* @__PURE__ */ atom(null);
+		const $key = atom(null);
 		const keysAsStoresToIndexes = /* @__PURE__ */ new Map();
 		const setKeyStoreValue = () => {
 			if (keyParts.some((v) => v === null || v === void 0 || v === false)) $key.set(null);
@@ -1447,7 +1199,7 @@ const nanoqueryFactory = ([isAppVisible, visibilityChangeSubscribe, reconnectCha
 			}
 		}
 		const storesAsArray = [...keysAsStoresToIndexes.keys()];
-		const $storeKeys = /* @__PURE__ */ batched(storesAsArray, (...storeValues) => {
+		const $storeKeys = batched(storesAsArray, (...storeValues) => {
 			for (let i = 0; i < storeValues.length; i++) {
 				const store = storesAsArray[i], partIndex = keysAsStoresToIndexes.get(store);
 				keyParts[partIndex] = store._ === fetcherSymbol ? store.value && "data" in store.value ? store.key : null : storeValues[i];
@@ -1540,6 +1292,18 @@ function prepareRequestBody(body, contentType) {
 		headers: { "Content-Type": "application/json" }
 	};
 }
+async function schemaAllowsUndefined(schema) {
+	try {
+		return !(await schema["~standard"].validate(void 0)).issues;
+	} catch {
+		return false;
+	}
+}
+async function assertBodyProvided(body, inputSchema, errorMessage) {
+	if (typeof body !== "undefined" || inputSchema === void 0) return;
+	if (await schemaAllowsUndefined(inputSchema)) return;
+	throw new Error(errorMessage);
+}
 /**
 * Merge request headers from multiple sources.
 * Returns undefined if there are no headers to merge.
@@ -1594,7 +1358,7 @@ function getCacheKey(method, path, params) {
 	const pathParamValues = extractPathParams(path).map((name) => pathParams?.[name] ?? "<missing>");
 	const queryParamValues = queryParams ? Object.keys(queryParams).sort().map((key) => {
 		const value = queryParams[key];
-		if (value && typeof value === "object" && "get" in value) return /* @__PURE__ */ computed(value, (v) => v ?? "");
+		if (value && typeof value === "object" && "get" in value) return computed(value, (v) => v ?? "");
 		return value ?? "";
 	}) : [];
 	return [
@@ -1650,9 +1414,13 @@ var ClientBuilder = class {
 	get cacheEntries() {
 		return Object.fromEntries(this.#cache.entries());
 	}
-	createStore(obj) {
+	createStore(input) {
+		if (typeof input === "function") return {
+			factory: input,
+			[STORE_SYMBOL]: true
+		};
 		return {
-			obj,
+			obj: input,
 			[STORE_SYMBOL]: true
 		};
 	}
@@ -1685,7 +1453,7 @@ var ClientBuilder = class {
 	}
 	#getFetcher() {
 		if (this.#fetcherConfig?.type === "function") return this.#fetcherConfig.fetcher;
-		return fetch;
+		return globalThis.fetch.bind(globalThis);
 	}
 	#getFetcherOptions() {
 		if (this.#fetcherConfig?.type === "options") return this.#fetcherConfig.options;
@@ -1859,7 +1627,7 @@ var ClientBuilder = class {
 		const mutatorStore = this.#createMutatorStore(async ({ data }) => {
 			if (typeof window === "undefined") {}
 			const { body, path, query } = data;
-			if (typeof body === "undefined" && route.inputSchema !== void 0) throw new Error("Body is required.");
+			await assertBodyProvided(body, route.inputSchema, "Body is required.");
 			const response = await executeMutateQuery({
 				body,
 				path,
@@ -1898,7 +1666,7 @@ var ClientBuilder = class {
 		} });
 		const mutateQuery = async (data) => {
 			const { body, path, query } = data;
-			if (typeof body === "undefined" && route.inputSchema !== void 0) throw new Error("Body is required for mutateQuery");
+			await assertBodyProvided(body, route.inputSchema, "Body is required for mutateQuery");
 			const response = await executeMutateQuery({
 				body,
 				path,
@@ -1960,6 +1728,62 @@ function createClientBuilder(definition, publicConfig, routesOrFactories, author
 //#region src/pi/definition.ts
 const piFragmentDefinition = defineFragment("pi-fragment").extend((x) => x).usesService("workflows").build();
 
+//#endregion
+//#region src/debug-log.ts
+const LOG_LEVEL_PRIORITY = {
+	off: 0,
+	error: 1,
+	warn: 2,
+	info: 3,
+	debug: 4
+};
+const DEFAULT_CONFIG = {
+	enabled: false,
+	level: "off"
+};
+var PiLogger = class PiLogger {
+	static #enabled = DEFAULT_CONFIG.enabled;
+	static #level = DEFAULT_CONFIG.level;
+	static reset() {
+		PiLogger.#enabled = DEFAULT_CONFIG.enabled;
+		PiLogger.#level = DEFAULT_CONFIG.level;
+	}
+	static configure(config) {
+		if (!config) return;
+		if (config.enabled !== void 0) PiLogger.#enabled = config.enabled;
+		if (config.level !== void 0) PiLogger.#level = config.level;
+	}
+	static enable() {
+		PiLogger.#enabled = true;
+	}
+	static disable() {
+		PiLogger.#enabled = false;
+	}
+	static setLogLevel(level) {
+		PiLogger.#level = level;
+	}
+	static debug(message, fields) {
+		PiLogger.#log("debug", message, fields);
+	}
+	static info(message, fields) {
+		PiLogger.#log("info", message, fields);
+	}
+	static warn(message, fields) {
+		PiLogger.#log("warn", message, fields);
+	}
+	static error(message, fields) {
+		PiLogger.#log("error", message, fields);
+	}
+	static #log(level, message, fields) {
+		if (!PiLogger.#enabled) return;
+		if (LOG_LEVEL_PRIORITY[level] > LOG_LEVEL_PRIORITY[PiLogger.#level]) return;
+		console[level](`[pi-fragment] ${message}`, {
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			...fields
+		});
+	}
+};
+
 //#endregion
 //#region src/pi/constants.ts
 const SESSION_STATUSES = [
@@ -1982,12 +1806,16 @@ const THINKING_LEVELS = [
 
 //#endregion
 //#region src/pi/route-schemas.ts
+const AGENT_LOOP_PHASES = [
+	"waiting-for-user",
+	"running-agent",
+	"complete"
+];
 const sessionBaseSchema = z.object({
 	id: z.string(),
 	name: z.string().nullable(),
 	status: z.enum(SESSION_STATUSES),
 	agent: z.string(),
-	workflowInstanceId: z.string().nullable(),
 	steeringMode: z.enum(STEERING_MODES),
 	metadata: z.any().nullable(),
 	tags: z.array(z.string()),
@@ -2016,12 +1844,13 @@ const ToolCallSchema = z.object({
 	arguments: z.record(z.string(), z.unknown()),
 	thoughtSignature: z.string().optional()
 });
-const ContentSchema = z.union([
+const UserContentSchema = z.union([TextContentSchema, ImageContentSchema]);
+const AssistantContentSchema = z.union([
 	TextContentSchema,
 	ThinkingContentSchema,
-	ImageContentSchema,
 	ToolCallSchema
 ]);
+const ToolResultContentSchema = z.union([TextContentSchema, ImageContentSchema]);
 const UsageSchema = z.object({
 	input: z.number(),
 	output: z.number(),
@@ -2039,17 +1868,23 @@ const UsageSchema = z.object({
 const MessageSchema = z.union([
 	z.object({
 		role: z.literal("user"),
-		content: z.union([z.string(), z.array(ContentSchema)]),
+		content: z.union([z.string(), z.array(UserContentSchema)]),
 		timestamp: z.number()
 	}),
 	z.object({
 		role: z.literal("assistant"),
-		content: z.array(ContentSchema),
+		content: z.array(AssistantContentSchema),
 		api: z.string(),
 		provider: z.string(),
 		model: z.string(),
 		usage: UsageSchema,
-		stopReason: z.string(),
+		stopReason: z.enum([
+			"stop",
+			"length",
+			"toolUse",
+			"error",
+			"aborted"
+		]),
 		errorMessage: z.string().optional(),
 		timestamp: z.number()
 	}),
@@ -2057,16 +1892,32 @@ const MessageSchema = z.union([
 		role: z.literal("toolResult"),
 		toolCallId: z.string(),
 		toolName: z.string(),
-		content: z.array(ContentSchema),
+		content: z.array(ToolResultContentSchema),
 		details: z.unknown().optional(),
 		isError: z.boolean(),
 		timestamp: z.number()
 	})
 ]);
-const TraceSchema = z.object({
+const TraceSchema = z.custom();
+const EventSchema = z.object({
+	id: z.string(),
+	runNumber: z.number().nullable().optional(),
 	type: z.string(),
-	timestamp: z.number().optional()
+	payload: z.unknown().nullable(),
+	createdAt: z.date(),
+	deliveredAt: z.date().nullable(),
+	consumedByStepKey: z.string().nullable()
 });
+const WaitingForSchema = z.union([z.object({
+	type: z.literal("user_message"),
+	turn: z.number(),
+	stepKey: z.string(),
+	timeoutMs: z.number().nullable()
+}), z.object({
+	type: z.literal("assistant"),
+	turn: z.number(),
+	stepKey: z.string()
+})]).nullable();
 const workflowStatusSchema = z.object({
 	status: z.enum(SESSION_STATUSES),
 	error: z.object({
@@ -2078,7 +1929,11 @@ const workflowStatusSchema = z.object({
 const sessionDetailSchema = sessionBaseSchema.extend({
 	workflow: workflowStatusSchema,
 	messages: z.array(MessageSchema),
+	events: z.array(EventSchema),
 	trace: z.array(TraceSchema),
+	turn: z.number(),
+	phase: z.enum(AGENT_LOOP_PHASES),
+	waitingFor: WaitingForSchema,
 	summaries: z.array(z.object({
 		turn: z.number(),
 		assistant: z.any().nullable(),
@@ -2086,10 +1941,13 @@ const sessionDetailSchema = sessionBaseSchema.extend({
 	}))
 });
 const messageAckSchema = z.object({ status: z.enum(SESSION_STATUSES) });
+const activeSessionStreamItemSchema = z.custom();
 
 //#endregion
 //#region src/routes.ts
 const piRoutesFactory = defineRoutes(piFragmentDefinition).create(({ config, defineRoute, serviceDeps }) => {
+	PiLogger.reset();
+	if (config.logging) PiLogger.configure(config.logging);
 	return [
 		defineRoute({
 			method: "POST",
@@ -2097,16 +1955,13 @@ const piRoutesFactory = defineRoutes(piFragmentDefinition).create(({ config, def
 			inputSchema: z.object({
 				agent: z.string(),
 				name: z.string().optional(),
+				systemMessage: z.string().optional(),
 				metadata: z.any().optional(),
 				tags: z.array(z.string()).optional(),
 				steeringMode: z.enum(["all", "one-at-a-time"]).optional()
 			}),
 			outputSchema: sessionBaseSchema,
-			errorCodes: [
-				"AGENT_NOT_FOUND",
-				"WORKFLOWS_REQUIRED",
-				"WORKFLOW_CREATE_FAILED"
-			],
+			errorCodes: ["AGENT_NOT_FOUND", "WORKFLOW_CREATE_FAILED"],
 			handler: () => {}
 		}),
 		defineRoute({
@@ -2119,12 +1974,20 @@ const piRoutesFactory = defineRoutes(piFragmentDefinition).create(({ config, def
 		defineRoute({
 			method: "GET",
 			path: "/sessions/:sessionId",
-			outputSchema: sessionDetailSchema,
-			errorCodes: [
-				"SESSION_NOT_FOUND",
-				"WORKFLOWS_REQUIRED",
-				"WORKFLOW_INSTANCE_MISSING"
+			queryParameters: [
+				"events",
+				"trace",
+				"summaries"
 			],
+			outputSchema: sessionDetailSchema,
+			errorCodes: ["SESSION_NOT_FOUND", "WORKFLOW_INSTANCE_MISSING"],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "GET",
+			path: "/sessions/:sessionId/active",
+			outputSchema: z.array(activeSessionStreamItemSchema),
+			errorCodes: ["SESSION_NOT_FOUND", "WORKFLOW_INSTANCE_MISSING"],
 			handler: () => {}
 		}),
 		defineRoute({
@@ -2138,7 +2001,7 @@ const piRoutesFactory = defineRoutes(piFragmentDefinition).create(({ config, def
 			outputSchema: messageAckSchema,
 			errorCodes: [
 				"SESSION_NOT_FOUND",
-				"WORKFLOWS_REQUIRED",
+				"SESSION_NOT_READY",
 				"WORKFLOW_INSTANCE_MISSING"
 			],
 			handler: () => {}
@@ -2147,53 +2010,24 @@ const piRoutesFactory = defineRoutes(piFragmentDefinition).create(({ config, def
 });
 
 //#endregion
-//#region src/pi/clients.ts
-function createPiFragmentClients(fragnoConfig) {
-	const b = createClientBuilder(piFragmentDefinition, fragnoConfig, [piRoutesFactory]);
-	return {
-		useSessions: b.createHook("/sessions"),
-		useSession: b.createHook("/sessions/:sessionId"),
-		useCreateSession: b.createMutator("POST", "/sessions"),
-		useSendMessage: b.createMutator("POST", "/sessions/:sessionId/messages")
-	};
-}
-
-//#endregion
-//#region src/schema.ts
-const piSchema = schema("pi-fragment", (s) => {
-	return s.addTable("session", (t) => {
-		return t.addColumn("id", idColumn()).addColumn("name", column("string").nullable()).addColumn("agent", column("string")).addColumn("status", column("string")).addColumn("workflowInstanceId", column("string").nullable()).addColumn("steeringMode", column("string")).addColumn("metadata", column("json").nullable()).addColumn("tags", column("json").nullable()).addColumn("createdAt", column("timestamp").defaultTo((b) => b.now())).addColumn("updatedAt", column("timestamp").defaultTo((b) => b.now())).createIndex("idx_session_status", ["status"]).createIndex("idx_session_created", ["createdAt"]);
-	});
-});
-
-//#endregion
-//#region src/pi/mappers.ts
-const normalizeSteeringMode = (value) => {
-	return STEERING_MODES.includes(value) ? value : "one-at-a-time";
-};
-
-//#endregion
-//#region src/pi/workflow.ts
-const PI_WORKFLOW_NAME = "agent-loop-workflow";
-const agentLoopParamsSchema = z.object({
-	sessionId: z.string(),
-	agentName: z.string(),
-	systemPrompt: z.string().optional(),
-	initialMessages: z.array(z.custom()).optional()
+//#region src/client/session-store.ts
+const createOverlayState = (sessionId) => ({
+	sessionId,
+	connection: "idle",
+	error: null,
+	sendError: null,
+	sending: false,
+	activity: { kind: "none" },
+	pendingTurn: false,
+	pendingSnapshotReconcile: false,
+	readyForInputOverride: null,
+	optimisticMessages: [],
+	streamedMessages: [],
+	draftAssistant: null,
+	runningTools: [],
+	trace: []
 });
-const userMessageSchema = z.object({
-	text: z.string().optional(),
-	done: z.boolean().optional(),
-	steeringMode: z.enum(["all", "one-at-a-time"]).optional()
-});
-const findLastAssistantMessage = (messages) => {
-	for (let i = messages.length - 1; i >= 0; i -= 1) {
-		const message = messages[i];
-		if (message && typeof message === "object" && "role" in message && message.role === "assistant") return message;
-	}
-	return null;
-};
-const buildUserMessage = (text) => ({
+const buildOptimisticUserMessage = (text) => ({
 	role: "user",
 	content: [{
 		type: "text",
@@ -2201,270 +2035,688 @@ const buildUserMessage = (text) => ({
 	}],
 	timestamp: Date.now()
 });
-const buildErrorMessage = (model, error) => ({
-	role: "assistant",
-	content: [{
-		type: "text",
-		text: ""
-	}],
-	api: model.api,
-	provider: model.provider,
-	model: model.id,
-	usage: {
-		input: 0,
-		output: 0,
-		cacheRead: 0,
-		cacheWrite: 0,
-		totalTokens: 0,
-		cost: {
-			input: 0,
-			output: 0,
-			cacheRead: 0,
-			cacheWrite: 0,
-			total: 0
-		}
-	},
-	stopReason: "error",
-	errorMessage: error instanceof Error ? error.message : String(error),
-	timestamp: Date.now()
-});
-const wrapStreamFn = (streamFn) => streamFn ? async (...args) => {
+const formatJson = (value) => {
 	try {
-		return await streamFn(...args);
-	} catch (error) {
-		const stream = createAssistantMessageEventStream();
-		const [model] = args;
-		stream.push({
-			type: "error",
-			reason: "error",
-			error: buildErrorMessage(model, error)
-		});
-		return stream;
+		return JSON.stringify(value, null, 2);
+	} catch {
+		return String(value);
 	}
-} : void 0;
-const getAssistantErrorMessage = (assistant) => {
-	if (!assistant || typeof assistant !== "object") return;
-	if ("errorMessage" in assistant && typeof assistant.errorMessage === "string") return assistant.errorMessage;
 };
-const buildSessionContext = (options) => {
-	const now = /* @__PURE__ */ new Date();
+const buildLiveToolResultMessage = (message) => {
+	const result = message.result;
+	const content = result && Array.isArray(result.content) ? result.content : [{
+		type: "text",
+		text: formatJson(message.result)
+	}];
 	return {
-		id: options.params.sessionId,
-		name: null,
-		status: "active",
-		agent: options.params.agentName,
-		workflowInstanceId: options.instanceId,
-		steeringMode: options.steeringMode,
-		metadata: null,
-		tags: [],
-		createdAt: now,
-		updatedAt: now
+		role: "toolResult",
+		toolCallId: message.toolCallId,
+		toolName: message.toolName,
+		content,
+		details: result?.details,
+		isError: message.isError,
+		timestamp: Date.now()
 	};
 };
-const resolveTool = async (name, factory, context) => {
-	if (!factory) throw new NonRetryableError(`Tool ${name} not found.`);
-	if (typeof factory === "function") {
-		const tool = await factory(context);
-		if (!tool) throw new NonRetryableError(`Tool ${name} returned no definition.`);
-		return tool;
-	}
-	return factory;
+const appendOrReplaceLiveMessage = (messages, nextMessage) => {
+	if (nextMessage.role === "assistant") {
+		const existingIndex = messages.findIndex((message) => message.role === "assistant" && message.timestamp === nextMessage.timestamp);
+		if (existingIndex >= 0) return [
+			...messages.slice(0, existingIndex),
+			nextMessage,
+			...messages.slice(existingIndex + 1)
+		];
+	}
+	if (nextMessage.role === "toolResult") {
+		const existingIndex = messages.findIndex((message) => message.role === "toolResult" && message.toolCallId === nextMessage.toolCallId);
+		if (existingIndex >= 0) return [
+			...messages.slice(0, existingIndex),
+			nextMessage,
+			...messages.slice(existingIndex + 1)
+		];
+	}
+	return [...messages, nextMessage];
+};
+const mergeMessages = (snapshotMessages, optimisticMessages, streamedMessages, draftAssistant) => {
+	let messages = [...snapshotMessages];
+	for (const optimisticMessage of optimisticMessages) messages = appendOrReplaceLiveMessage(messages, optimisticMessage);
+	for (const streamedMessage of streamedMessages) messages = appendOrReplaceLiveMessage(messages, streamedMessage);
+	if (draftAssistant) messages = appendOrReplaceLiveMessage(messages, draftAssistant);
+	return messages;
 };
-const resolveTools = async (options) => {
-	const toolNames = options.agent.tools ?? [];
-	if (toolNames.length === 0) return [];
-	const toolConfig = options.agent.toolConfig ?? null;
-	const context = {
-		session: options.session,
-		turnId: options.turnId,
-		toolConfig,
-		messages: options.messages
-	};
-	const resolved = [];
-	for (const name of toolNames) {
-		const tool = await resolveTool(name, options.tools[name], context);
-		resolved.push(tool);
+const hasActiveOverlay = (state) => state.draftAssistant !== null || state.runningTools.length > 0 || state.streamedMessages.length > 0;
+const activityLabel = (activity) => {
+	switch (activity.kind) {
+		case "none": return null;
+		case "sending-message": return "Sending message";
+		case "assistant-responding": return "Assistant responding";
+		case "assistant-ready": return "Assistant response ready";
+		case "tool-running": return `Running ${activity.toolName}`;
+		case "tool-updating": return `Updating ${activity.toolName}`;
+		case "tool-finished": return `${activity.toolName} finished`;
+		case "agent-started": return "Agent started";
+		case "agent-finished": return "Agent finished";
+		case "turn-started": return "Turn started";
+		case "turn-finished": return "Turn finished";
+		default: return null;
 	}
-	return resolved;
 };
-const createAgent = async (options) => {
-	const session = buildSessionContext({
-		params: options.params,
-		instanceId: options.instanceId,
-		steeringMode: options.steeringMode
-	});
-	const agentTools = await resolveTools({
-		agent: options.agent,
-		tools: options.tools,
-		session,
-		turnId: options.turnId,
-		messages: options.messages
-	});
-	const initialState = {
-		systemPrompt: options.params.systemPrompt ?? options.agent.systemPrompt,
-		model: options.agent.model,
-		tools: agentTools,
-		messages: options.messages
+const connectionStatusText = (connection) => {
+	switch (connection) {
+		case "connecting": return "Connecting to live updates";
+		case "reconnecting": return "Reconnecting to live updates";
+		default: return null;
+	}
+};
+const reduceProtocolMessage = (state, message) => {
+	if (message.layer === "system") switch (message.type) {
+		case "snapshot": {
+			const readyForInput = isSessionReadyForInput(message.phase, message.waitingFor);
+			return {
+				...state,
+				error: null,
+				activity: readyForInput ? { kind: "none" } : state.activity,
+				pendingTurn: !readyForInput,
+				readyForInputOverride: readyForInput
+			};
+		}
+		case "inactive": return {
+			...state,
+			connection: "idle",
+			error: null,
+			readyForInputOverride: false
+		};
+		case "settled": return {
+			...state,
+			connection: "reconnecting",
+			activity: { kind: "turn-finished" },
+			pendingTurn: true,
+			pendingSnapshotReconcile: true,
+			readyForInputOverride: false,
+			error: null
+		};
+		default: return state;
+	}
+	const event = message.event;
+	const trace = [...state.trace, event];
+	switch (event.type) {
+		case "message_start":
+		case "message_update": return {
+			...state,
+			trace,
+			draftAssistant: event.message,
+			activity: { kind: "assistant-responding" },
+			pendingTurn: true,
+			error: null
+		};
+		case "message_end": return {
+			...state,
+			trace,
+			streamedMessages: appendOrReplaceLiveMessage(state.streamedMessages, event.message),
+			draftAssistant: null,
+			activity: { kind: "assistant-ready" },
+			pendingTurn: true,
+			error: null
+		};
+		case "tool_execution_start": return {
+			...state,
+			trace,
+			runningTools: [...state.runningTools.filter((tool) => tool.toolCallId !== event.toolCallId), {
+				toolCallId: event.toolCallId,
+				toolName: event.toolName,
+				args: event.args,
+				partialResult: null
+			}],
+			activity: {
+				kind: "tool-running",
+				toolName: event.toolName
+			},
+			pendingTurn: true,
+			error: null
+		};
+		case "tool_execution_update": return {
+			...state,
+			trace,
+			runningTools: state.runningTools.map((tool) => tool.toolCallId === event.toolCallId ? {
+				...tool,
+				partialResult: event.partialResult
+			} : tool),
+			activity: {
+				kind: "tool-updating",
+				toolName: event.toolName
+			},
+			pendingTurn: true,
+			error: null
+		};
+		case "tool_execution_end": return {
+			...state,
+			trace,
+			streamedMessages: appendOrReplaceLiveMessage(state.streamedMessages, buildLiveToolResultMessage(event)),
+			runningTools: state.runningTools.filter((tool) => tool.toolCallId !== event.toolCallId),
+			activity: {
+				kind: "tool-finished",
+				toolName: event.toolName
+			},
+			pendingTurn: true,
+			error: null
+		};
+		case "agent_start": return {
+			...state,
+			trace,
+			activity: { kind: "agent-started" },
+			pendingTurn: true,
+			error: null
+		};
+		case "agent_end": return {
+			...state,
+			trace,
+			activity: { kind: "agent-finished" },
+			pendingTurn: true,
+			error: null
+		};
+		case "turn_start": return {
+			...state,
+			trace,
+			activity: { kind: "turn-started" },
+			pendingTurn: true,
+			error: null
+		};
+		case "turn_end": return {
+			...state,
+			trace,
+			activity: { kind: "turn-finished" },
+			pendingTurn: true,
+			error: null
+		};
+		default: return {
+			...state,
+			trace,
+			pendingTurn: true,
+			error: null
+		};
+	}
+};
+const reduceOverlayState = (state, action) => {
+	switch (action.type) {
+		case "snapshot-updated":
+			if (action.sessionId !== state.sessionId) return createOverlayState(action.sessionId);
+			if (!state.pendingSnapshotReconcile) return {
+				...state,
+				optimisticMessages: [],
+				sendError: null,
+				error: null,
+				readyForInputOverride: null
+			};
+			return {
+				...state,
+				optimisticMessages: [],
+				streamedMessages: [],
+				draftAssistant: null,
+				runningTools: [],
+				trace: [],
+				error: null,
+				sendError: null,
+				activity: { kind: "none" },
+				pendingTurn: false,
+				pendingSnapshotReconcile: false,
+				readyForInputOverride: null
+			};
+		case "send-started": return {
+			...state,
+			sending: true,
+			sendError: null,
+			optimisticMessages: [...state.optimisticMessages, {
+				clientId: action.clientId,
+				message: buildOptimisticUserMessage(action.text)
+			}],
+			activity: { kind: "sending-message" },
+			pendingTurn: true,
+			readyForInputOverride: false,
+			error: null
+		};
+		case "send-acknowledged": return {
+			...state,
+			sending: false,
+			sendError: null
+		};
+		case "send-failed": {
+			const optimisticMessages = state.optimisticMessages.filter((message) => message.clientId !== action.clientId);
+			const keepPending = state.pendingSnapshotReconcile || hasActiveOverlay(state);
+			return {
+				...state,
+				sending: false,
+				sendError: action.message,
+				optimisticMessages,
+				activity: keepPending ? state.activity : { kind: "none" },
+				pendingTurn: keepPending,
+				readyForInputOverride: keepPending ? state.readyForInputOverride : null
+			};
+		}
+		case "stream-connecting": {
+			const connection = action.reconnecting ? "reconnecting" : "connecting";
+			return {
+				...state,
+				connection,
+				error: null
+			};
+		}
+		case "stream-open": return {
+			...state,
+			connection: "listening",
+			error: null
+		};
+		case "stream-message": return reduceProtocolMessage(state, action.message);
+		case "stream-settled": return {
+			...state,
+			connection: "reconnecting"
+		};
+		case "stream-inactive": return {
+			...state,
+			connection: "idle",
+			error: null
+		};
+		case "stream-error": return {
+			...state,
+			connection: "error",
+			error: action.message
+		};
+		case "stream-idle": return {
+			...state,
+			connection: "idle",
+			error: null,
+			activity: state.pendingTurn ? state.activity : { kind: "none" }
+		};
+		default: return state;
+	}
+};
+const readPiRouteError = async (response) => {
+	const text = await response.text();
+	if (!text) return `Request failed (${response.status}).`;
+	try {
+		const parsed = JSON.parse(text);
+		return parsed.message ?? parsed.error ?? text;
+	} catch {
+		return text;
+	}
+};
+const consumeProtocolStream = async (body, onMessage, signal) => {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		while (true) {
+			if (signal.aborted) {
+				await reader.cancel();
+				return;
+			}
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop() ?? "";
+			for (const line of lines) {
+				const trimmed = line.trim();
+				if (!trimmed) continue;
+				onMessage(JSON.parse(trimmed));
+			}
+		}
+		const trailing = `${buffer}${decoder.decode()}`.trim();
+		if (trailing) onMessage(JSON.parse(trailing));
+	} finally {
+		reader.releaseLock();
+	}
+};
+const waitWithAbort = (ms, signal) => new Promise((resolve, reject) => {
+	const timeoutId = setTimeout(() => {
+		signal.removeEventListener("abort", handleAbort);
+		resolve();
+	}, ms);
+	function handleAbort() {
+		clearTimeout(timeoutId);
+		signal.removeEventListener("abort", handleAbort);
+		reject(new DOMException("Aborted", "AbortError"));
+	}
+	if (signal.aborted) {
+		handleAbort();
+		return;
+	}
+	signal.addEventListener("abort", handleAbort, { once: true });
+});
+const isSessionReadyForInput = (phase, waitingFor) => phase === "waiting-for-user" && waitingFor?.type === "user_message";
+const shouldKeepLiveConnection = (session) => session?.phase !== "complete";
+const withAcceptHeader = (defaultOptions) => {
+	const headers = new Headers(defaultOptions?.headers);
+	headers.set("accept", "application/x-ndjson");
+	return {
+		...defaultOptions,
+		headers
 	};
-	if (options.agent.thinkingLevel) initialState.thinkingLevel = options.agent.thinkingLevel;
-	const agent = new Agent({
-		initialState,
-		streamFn: wrapStreamFn(options.agent.streamFn),
-		convertToLlm: options.agent.convertToLlm,
-		transformContext: options.agent.transformContext,
-		getApiKey: options.agent.getApiKey,
-		thinkingBudgets: options.agent.thinkingBudgets,
-		maxRetryDelayMs: options.agent.maxRetryDelayMs,
-		sessionId: options.params.sessionId
-	});
-	agent.setSteeringMode(options.steeringMode);
-	const trace = [];
-	const unsubscribe = agent.subscribe((event) => {
-		trace.push(event);
-		if (!options.agent.onEvent) return;
-		try {
-			options.agent.onEvent(event, {
-				sessionId: options.params.sessionId,
-				turnId: options.turnId
+};
+function createPiSessionStore(deps, args) {
+	const detailStore = deps.createDetailStore(args.sessionId);
+	const snapshotStore = atom(args.initialData ?? null);
+	const overlayStore = atom(createOverlayState(args.sessionId));
+	const lastSnapshotVersion = { current: args.initialData ? `${args.initialData.id}:${String(args.initialData.updatedAt)}` : null };
+	let destroyed = false;
+	let mounted = false;
+	let activeAbortController = null;
+	let activeLoopPromise = null;
+	let detailUnsubscribe = null;
+	const logActive = (event, details) => {
+		deps.activeLogger?.(event, {
+			sessionId: args.sessionId,
+			...details
+		});
+	};
+	const updateSnapshot = (session) => {
+		if (!session) return;
+		snapshotStore.set(session);
+		const nextVersion = `${session.id}:${String(session.updatedAt)}`;
+		if (nextVersion !== lastSnapshotVersion.current) {
+			logActive("snapshot:updated", {
+				version: nextVersion,
+				phase: session.phase,
+				status: session.status,
+				turn: session.turn
 			});
-		} catch (error) {
-			console.warn("Agent onEvent hook failed.", {
-				error,
-				sessionId: options.params.sessionId,
-				turnId: options.turnId,
-				agent: options.agent.name
+			lastSnapshotVersion.current = nextVersion;
+			overlayStore.set(reduceOverlayState(overlayStore.get(), {
+				type: "snapshot-updated",
+				sessionId: session.id
+			}));
+		}
+	};
+	const refetch = () => {
+		logActive("detail:refetch");
+		detailStore.revalidate();
+	};
+	const stopActiveLoop = () => {
+		if (activeAbortController || activeLoopPromise) logActive("stream:stop");
+		activeAbortController?.abort();
+		activeAbortController = null;
+		activeLoopPromise = null;
+	};
+	const ensureActiveLoop = () => {
+		if (destroyed || !mounted || activeLoopPromise || deps.enableActiveStream === false) return;
+		const currentSession = snapshotStore.get();
+		if (!shouldKeepLiveConnection(currentSession)) {
+			logActive("stream:idle", {
+				reason: "session-complete",
+				phase: currentSession?.phase ?? null,
+				status: currentSession?.status ?? null
 			});
+			overlayStore.set(reduceOverlayState(overlayStore.get(), { type: "stream-idle" }));
+			return;
 		}
-	});
-	await agent.continue();
-	unsubscribe();
-	const assistant = findLastAssistantMessage(agent.state.messages);
-	const assistantError = getAssistantErrorMessage(assistant);
-	if (agent.state.error || assistantError) throw new Error(assistantError || agent.state.error || "Agent error");
-	return {
-		agent,
-		trace,
-		assistant
+		logActive("stream:start", {
+			phase: currentSession?.phase ?? null,
+			status: currentSession?.status ?? null,
+			turn: currentSession?.turn ?? null
+		});
+		const abortController = new AbortController();
+		activeAbortController = abortController;
+		activeLoopPromise = (async () => {
+			let reconnecting = false;
+			while (!abortController.signal.aborted && !destroyed) {
+				if (!shouldKeepLiveConnection(snapshotStore.get())) {
+					overlayStore.set(reduceOverlayState(overlayStore.get(), { type: "stream-idle" }));
+					return;
+				}
+				const activeUrl = deps.buildActiveUrl(args.sessionId);
+				logActive("stream:connecting", {
+					reconnecting,
+					url: activeUrl
+				});
+				overlayStore.set(reduceOverlayState(overlayStore.get(), {
+					type: "stream-connecting",
+					reconnecting
+				}));
+				try {
+					const response = await deps.fetcher(activeUrl, {
+						...withAcceptHeader(deps.defaultOptions),
+						method: "GET",
+						cache: "no-store",
+						signal: abortController.signal
+					});
+					logActive("stream:response", {
+						ok: response.ok,
+						status: response.status,
+						statusText: response.statusText,
+						url: activeUrl
+					});
+					if (!response.ok) throw new Error(await readPiRouteError(response));
+					if (!response.body) throw new Error("The active session stream did not return a response body.");
+					logActive("stream:open", { url: activeUrl });
+					overlayStore.set(reduceOverlayState(overlayStore.get(), { type: "stream-open" }));
+					let sawInactive = false;
+					let sawSettled = false;
+					await consumeProtocolStream(response.body, (message) => {
+						logActive("stream:message", { message });
+						overlayStore.set(reduceOverlayState(overlayStore.get(), {
+							type: "stream-message",
+							message
+						}));
+						if (message.layer === "system" && message.type === "inactive") sawInactive = true;
+						if (message.layer === "system" && message.type === "settled") sawSettled = true;
+					}, abortController.signal);
+					if (abortController.signal.aborted || destroyed) return;
+					if (sawSettled || sawInactive) {
+						logActive("stream:settled", {
+							sawSettled,
+							sawInactive
+						});
+						overlayStore.set(reduceOverlayState(overlayStore.get(), { type: "stream-settled" }));
+						detailStore.revalidate();
+					}
+					if (sawInactive) {
+						logActive("stream:inactive");
+						overlayStore.set(reduceOverlayState(overlayStore.get(), { type: "stream-inactive" }));
+						return;
+					}
+					reconnecting = true;
+					logActive("stream:retry", { delayMs: 250 });
+					await waitWithAbort(250, abortController.signal);
+				} catch (error) {
+					if (abortController.signal.aborted || destroyed) return;
+					const message = error instanceof Error ? error.message : "Failed to stream the active session.";
+					logActive("stream:error", { message });
+					overlayStore.set(reduceOverlayState(overlayStore.get(), {
+						type: "stream-error",
+						message
+					}));
+					reconnecting = true;
+					logActive("stream:retry", { delayMs: 1e3 });
+					await waitWithAbort(1e3, abortController.signal).catch(() => void 0);
+				}
+			}
+		})().finally(() => {
+			logActive("stream:end");
+			if (activeAbortController === abortController) activeAbortController = null;
+			if (activeLoopPromise) activeLoopPromise = null;
+		});
 	};
-};
-const runAgentTurn = async (options) => {
-	const result = await createAgent({
-		agent: options.agent,
-		tools: options.tools,
-		params: options.params,
-		messages: options.messages,
-		steeringMode: options.steeringMode,
-		turnId: options.turnId,
-		instanceId: options.instanceId
+	const store = computed([
+		detailStore,
+		snapshotStore,
+		overlayStore
+	], (detailValue, session, overlay) => {
+		const optimisticMessages = overlay.optimisticMessages.map((entry) => entry.message);
+		const messages = mergeMessages(session?.messages ?? [], optimisticMessages, overlay.streamedMessages, overlay.draftAssistant);
+		const statusText = activityLabel(overlay.activity) ?? connectionStatusText(overlay.connection);
+		const readyForInput = session !== null && (overlay.readyForInputOverride ?? (isSessionReadyForInput(session.phase, session.waitingFor) && !overlay.pendingTurn));
+		return {
+			loading: detailValue.loading,
+			session,
+			messages,
+			traceEvents: [...session?.trace ?? [], ...overlay.trace],
+			runningTools: overlay.runningTools,
+			connection: overlay.connection,
+			statusText,
+			readyForInput,
+			sending: overlay.sending,
+			error: detailValue.error?.message ?? overlay.error,
+			sendError: overlay.sendError
+		};
+	});
+	onMount(store, () => {
+		mounted = true;
+		logActive("store:mount");
+		updateSnapshot(detailStore.get().data);
+		detailUnsubscribe = detailStore.listen((value) => {
+			updateSnapshot(value.data);
+			if (destroyed) return;
+			if (!shouldKeepLiveConnection(snapshotStore.get())) {
+				logActive("stream:idle", { reason: "detail-store-update" });
+				stopActiveLoop();
+				overlayStore.set(reduceOverlayState(overlayStore.get(), { type: "stream-idle" }));
+				return;
+			}
+			ensureActiveLoop();
+		});
+		ensureActiveLoop();
+		return () => {
+			logActive("store:unmount");
+			mounted = false;
+			stopActiveLoop();
+			detailUnsubscribe?.();
+			detailUnsubscribe = null;
+		};
 	});
+	const sendMessage = (input) => {
+		const text = input.text.trim();
+		if (!text) return false;
+		const current = store.get();
+		if (current.sending || !current.readyForInput) return false;
+		const clientId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+		logActive("send:start", {
+			clientId,
+			text
+		});
+		overlayStore.set(reduceOverlayState(overlayStore.get(), {
+			type: "send-started",
+			clientId,
+			text
+		}));
+		ensureActiveLoop();
+		deps.sendMessage({
+			sessionId: args.sessionId,
+			text,
+			done: input.done,
+			steeringMode: input.steeringMode
+		}).then(() => {
+			logActive("send:acknowledged", { clientId });
+			overlayStore.set(reduceOverlayState(overlayStore.get(), { type: "send-acknowledged" }));
+		}).catch((error) => {
+			const message = error instanceof Error ? error.message : "Failed to send message.";
+			logActive("send:failed", {
+				clientId,
+				message
+			});
+			overlayStore.set(reduceOverlayState(overlayStore.get(), {
+				type: "send-failed",
+				clientId,
+				message
+			}));
+		});
+		return true;
+	};
+	const deactivate = () => {
+		logActive("store:dispose");
+		mounted = false;
+		stopActiveLoop();
+		detailUnsubscribe?.();
+		detailUnsubscribe = null;
+	};
+	const destroy = () => {
+		if (destroyed) return;
+		logActive("store:destroy");
+		destroyed = true;
+		deactivate();
+	};
 	return {
-		messages: result.agent.state.messages,
-		trace: result.trace,
-		assistant: result.assistant
+		store,
+		sendMessage,
+		refetch,
+		deactivate,
+		destroy
 	};
-};
-const agentLoopWorkflow = (options) => defineWorkflow({
-	name: PI_WORKFLOW_NAME,
-	schema: agentLoopParamsSchema
-}, async (event, step) => {
-	const params = agentLoopParamsSchema.parse(event.payload ?? {});
-	const agentDefinition = options.agents[params.agentName];
-	if (!agentDefinition) throw new NonRetryableError(`Agent ${params.agentName} not found.`);
-	let messages = Array.isArray(params.initialMessages) ? params.initialMessages : [];
-	let turn = 0;
-	while (true) {
-		const userEvent = await step.waitForEvent(`wait-user-${turn}`, {
-			type: "user_message",
-			timeout: "1 hour"
+}
+
+//#endregion
+//#region src/client/session-controller.ts
+const select = (store, selector) => computed(store, selector);
+function createPiSessionControllerStore(input) {
+	return ({ path, initialData }) => {
+		const controller = createPiSessionStore(input, {
+			sessionId: path.sessionId,
+			initialData
 		});
-		const payload = userMessageSchema.parse(userEvent.payload ?? {});
-		const steeringMode = normalizeSteeringMode(payload.steeringMode);
-		const turnId = `${event.instanceId}:${turn}`;
-		messages = (await step.do(`user-${turn}`, async () => {
-			const userMessage = buildUserMessage(payload.text ?? "");
-			return {
-				messages: [...messages, userMessage],
-				user: userMessage
-			};
-		})).messages;
-		messages = (await step.do(`assistant-${turn}`, { retries: {
-			limit: 1,
-			delay: "10 ms",
-			backoff: "constant"
-		} }, async () => await runAgentTurn({
-			params,
-			agent: agentDefinition,
-			tools: options.tools,
-			messages,
-			steeringMode,
-			turnId,
-			instanceId: event.instanceId
-		}))).messages;
-		if (payload.done) return { messages };
-		turn += 1;
-	}
-});
-const createPiWorkflows = (options) => ({ agentLoop: agentLoopWorkflow(options) });
+		return {
+			loading: select(controller.store, (state) => state.loading),
+			session: select(controller.store, (state) => state.session),
+			messages: select(controller.store, (state) => state.messages),
+			traceEvents: select(controller.store, (state) => state.traceEvents),
+			runningTools: select(controller.store, (state) => state.runningTools),
+			connection: select(controller.store, (state) => state.connection),
+			statusText: select(controller.store, (state) => state.statusText),
+			readyForInput: select(controller.store, (state) => state.readyForInput),
+			sending: select(controller.store, (state) => state.sending),
+			error: select(controller.store, (state) => state.error),
+			sendError: select(controller.store, (state) => state.sendError),
+			sendMessage: controller.sendMessage,
+			refetch: controller.refetch,
+			[Symbol.dispose]: controller.deactivate
+		};
+	};
+}
 
 //#endregion
-//#region src/pi/dsl.ts
-const defineAgent = (name, definition) => {
-	if (definition.name && definition.name !== name) throw new Error(`defineAgent name mismatch: expected ${name}, got ${definition.name}`);
-	return {
-		...definition,
-		name
+//#region src/client/clients.ts
+const createActiveSessionLogger = (enabled) => {
+	if (!enabled) return;
+	return (event, details) => {
+		console.log(`[pi-active] ${event}`, details ?? {});
 	};
 };
-const createPi = () => {
-	const agents = {};
-	const tools = {};
-	let defaultSteeringMode;
-	const builder = {
-		agent(definition) {
-			agents[definition.name] = definition;
-			return builder;
-		},
-		agents(registry) {
-			Object.assign(agents, registry);
-			return builder;
-		},
-		tool(name, tool) {
-			tools[name] = tool;
-			return builder;
-		},
-		tools(registry) {
-			Object.assign(tools, registry);
-			return builder;
-		},
-		defaultSteeringMode(mode) {
-			defaultSteeringMode = mode;
-			return builder;
-		},
-		build() {
-			const agentsSnapshot = { ...agents };
-			const toolsSnapshot = { ...tools };
-			return {
-				config: {
-					agents: agentsSnapshot,
-					tools: toolsSnapshot,
-					defaultSteeringMode
-				},
-				workflows: createPiWorkflows({
-					agents: agentsSnapshot,
-					tools: toolsSnapshot
-				})
-			};
-		}
+function createPiFragmentClients(fragnoConfig) {
+	const builder = createClientBuilder(piFragmentDefinition, fragnoConfig, [piRoutesFactory]);
+	const useSessionDetail = builder.createHook("/sessions/:sessionId");
+	const useSendMessage = builder.createMutator("POST", "/sessions/:sessionId/messages", (invalidate, params) => {
+		const sessionId = params.pathParams.sessionId;
+		if (!sessionId) return;
+		invalidate("GET", "/sessions/:sessionId", { pathParams: { sessionId } });
+		invalidate("GET", "/sessions", {});
+	});
+	const { fetcher, defaultOptions } = builder.getFetcher();
+	const sessionStoreDependencies = {
+		createDetailStore: (sessionId) => useSessionDetail.store({ path: { sessionId } }),
+		sendMessage: ({ sessionId, text, done, steeringMode }) => useSendMessage.mutateQuery({
+			path: { sessionId },
+			body: {
+				text,
+				done,
+				steeringMode
+			}
+		}).then((result) => {
+			if (!result) throw new Error("The message mutation did not return a status response.");
+			return result;
+		}),
+		buildActiveUrl: (sessionId) => builder.buildUrl("/sessions/:sessionId/active", { path: { sessionId } }),
+		fetcher,
+		defaultOptions,
+		enableActiveStream: typeof window === "undefined" ? false : void 0,
+		activeLogger: createActiveSessionLogger(fragnoConfig.debugActiveSession)
+	};
+	return {
+		useSessions: builder.createHook("/sessions"),
+		useSessionDetail,
+		useSession: builder.createStore(createPiSessionControllerStore(sessionStoreDependencies)),
+		useCreateSession: builder.createMutator("POST", "/sessions"),
+		useActiveSession: builder.createHook("/sessions/:sessionId/active"),
+		useSendMessage
 	};
-	return builder;
-};
-
-//#endregion
-//#region src/pi/factory.ts
-function createPiFragment(config, options, services) {
-	return {};
 }
 
 //#endregion
-export { createPiWorkflows as a, SESSION_STATUSES as c, piFragmentDefinition as d, isGetHook as f, atom as g, isReadableAtom as h, PI_WORKFLOW_NAME as i, STEERING_MODES as l, isStore as m, createPi as n, createPiFragmentClients as o, isMutatorHook as p, defineAgent as r, piRoutesFactory as s, createPiFragment as t, THINKING_LEVELS as u };
-//# sourceMappingURL=factory-DKoO_lRA.js.map
+export { STEERING_MODES as a, piFragmentDefinition as c, isStore as d, isReadableAtom as f, SESSION_STATUSES as i, isGetHook as l, createPiSessionStore as n, THINKING_LEVELS as o, piRoutesFactory as r, PiLogger as s, createPiFragmentClients as t, isMutatorHook as u };
+//# sourceMappingURL=clients-BscY_HVe.js.map