@mastra/react 1.7.3-alpha.2 → 1.8.0-alpha.4

package/dist/hooks/agents/index.js

@@ -0,0 +1,952 @@
+import { n as useMastraClient } from "../../mastra-client-context-Bx_g84YB.js";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { skipToken, useInfiniteQuery, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { RequestContext } from "@mastra/core/di";
+//#region src/hooks/agents/use-agent-messages.ts
+const PER_PAGE = 40;
+const NEWEST_PAGE = "";
+const createdAtMs = (message) => new Date(message.createdAt).getTime();
+const byCreatedAt = (a, b) => createdAtMs(a) - createdAtMs(b);
+const useAgentMessages = ({ threadId, agentId, memory, requestContext, queryOptions }) => {
+	const client = useMastraClient();
+	return useInfiniteQuery({
+		queryKey: [
+			"memory",
+			"messages",
+			threadId,
+			agentId,
+			requestContext
+		],
+		initialPageParam: NEWEST_PAGE,
+		queryFn: memory && threadId ? ({ pageParam: olderThan }) => client.listThreadMessages(threadId, {
+			agentId,
+			requestContext,
+			includeSystemReminders: true,
+			perPage: PER_PAGE,
+			orderBy: {
+				field: "createdAt",
+				direction: "DESC"
+			},
+			filter: olderThan ? { dateRange: { end: new Date(olderThan) } } : void 0
+		}) : skipToken,
+		getNextPageParam: (lastPage, _allPages, lastPageParam) => {
+			if (!lastPage.hasMore || lastPage.messages.length === 0) return void 0;
+			const next = new Date(Math.min(...lastPage.messages.map(createdAtMs))).toISOString();
+			return next === lastPageParam ? void 0 : next;
+		},
+		select: (data) => {
+			const seen = /* @__PURE__ */ new Set();
+			const messages = data.pages.flatMap((page) => page.messages).filter((message) => {
+				if (seen.has(message.id)) return false;
+				seen.add(message.id);
+				return true;
+			}).sort(byCreatedAt);
+			return {
+				...data,
+				messages
+			};
+		},
+		staleTime: 0,
+		gcTime: 0,
+		retry: false,
+		refetchOnWindowFocus: false,
+		...queryOptions
+	});
+};
+//#endregion
+//#region src/hooks/agents/use-agent-plan.ts
+function useAgentPlan({ agentId, path, agentVersionId, requestContext, queryOptions }) {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: [
+			"agent-plan",
+			agentId,
+			agentVersionId,
+			path,
+			requestContext
+		],
+		queryFn: () => {
+			return (agentVersionId ? client.getAgent(agentId, { versionId: agentVersionId }) : client.getAgent(agentId)).readPlan(path, requestContext);
+		},
+		retry: false,
+		...queryOptions
+	});
+}
+//#endregion
+//#region src/hooks/agents/use-background-tasks.ts
+const EVENT_STATUS_MAP = {
+	"background-task-running": "running",
+	"background-task-output": "running",
+	"background-task-completed": "completed",
+	"background-task-failed": "failed",
+	"background-task-cancelled": "cancelled",
+	"background-task-suspended": "suspended",
+	"background-task-resumed": "running"
+};
+function useBackgroundTaskStream(options = {}) {
+	const { enabled = true, agentId, runId, threadId, resourceId, taskId } = options;
+	const client = useMastraClient();
+	const [tasks, setTasks] = useState({});
+	const [isConnected, setIsConnected] = useState(false);
+	const [error, setError] = useState(null);
+	const abortRef = useRef(null);
+	const readerRef = useRef(null);
+	const connectSeqRef = useRef(0);
+	const runningTasks = useMemo(() => {
+		return Object.values(tasks).filter((task) => task.status === "running");
+	}, [tasks]);
+	const completedTasks = useMemo(() => {
+		return Object.values(tasks).filter((task) => task.status === "completed");
+	}, [tasks]);
+	const failedTasks = useMemo(() => {
+		return Object.values(tasks).filter((task) => task.status === "failed");
+	}, [tasks]);
+	const cleanup = useCallback(() => {
+		readerRef.current?.cancel().catch(() => {});
+		readerRef.current = null;
+		abortRef.current?.abort();
+		abortRef.current = null;
+		setIsConnected(false);
+	}, []);
+	const connect = useCallback(async () => {
+		const seq = ++connectSeqRef.current;
+		cleanup();
+		setError(null);
+		const controller = new AbortController();
+		abortRef.current = controller;
+		try {
+			const stream = await client.streamBackgroundTasks({
+				agentId,
+				runId,
+				threadId,
+				resourceId,
+				taskId
+			});
+			if (!stream) {
+				setError(/* @__PURE__ */ new Error("Stream connection failed"));
+				return;
+			}
+			if (seq === connectSeqRef.current) setIsConnected(true);
+			const reader = stream.getReader();
+			readerRef.current = reader;
+			while (!controller.signal.aborted) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				const event = value;
+				if (event.type !== "background-task-output") setTasks((prev) => ({
+					...prev,
+					[event.payload.taskId]: {
+						...prev[event.payload.taskId],
+						...event.payload,
+						status: EVENT_STATUS_MAP[event.type],
+						args: ("args" in event.payload ? event.payload.args : void 0) ?? prev[event.payload.taskId]?.args ?? {}
+					}
+				}));
+			}
+		} catch (err) {
+			if (err?.name !== "AbortError") {
+				if (seq === connectSeqRef.current) setError(err instanceof Error ? err : new Error(String(err)));
+			}
+		} finally {
+			if (seq === connectSeqRef.current) setIsConnected(false);
+		}
+	}, [
+		client,
+		agentId,
+		runId,
+		threadId,
+		resourceId,
+		taskId,
+		cleanup
+	]);
+	useEffect(() => {
+		if (!enabled) {
+			cleanup();
+			return;
+		}
+		connect();
+		return cleanup;
+	}, [
+		enabled,
+		connect,
+		cleanup
+	]);
+	const disconnect = useCallback(() => {
+		cleanup();
+	}, [cleanup]);
+	const reconnect = useCallback(() => {
+		connect();
+	}, [connect]);
+	const clearCompletedAndFailedTasks = () => {
+		setTasks((prev) => {
+			const newTasks = { ...prev };
+			Object.values(newTasks).forEach((task) => {
+				if (task.status === "completed" || task.status === "failed" || task.status === "cancelled" || task.status === "timed_out") delete newTasks[task.taskId];
+			});
+			return newTasks;
+		});
+	};
+	return {
+		tasks,
+		isConnected,
+		error,
+		disconnect,
+		reconnect,
+		runningTasks,
+		completedTasks,
+		failedTasks,
+		clearCompletedAndFailedTasks
+	};
+}
+const useGetBackgroundTaskById = ({ backgroundTaskId, queryOptions }) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: ["background-task", backgroundTaskId],
+		queryFn: () => client.getBackgroundTask(backgroundTaskId),
+		...queryOptions
+	});
+};
+//#endregion
+//#region src/hooks/agents/use-browser-session-probe.ts
+const browserSessionProbeQueryKey = (agentId, threadId) => [
+	"browser-session-probe",
+	agentId,
+	threadId
+];
+const LEGACY_FALLBACK = {
+	hasSession: true,
+	screencastAvailable: true
+};
+const isNotFoundError = (error) => {
+	if (!error || typeof error !== "object") return false;
+	if ("status" in error && error.status === 404) return true;
+	if ("statusCode" in error && error.statusCode === 404) return true;
+	return false;
+};
+/**
+* Query hook that probes the server for the agent's browser session state.
+*
+* Used by {@link BrowserSessionProvider} to decide whether to open a screencast
+* WebSocket. The probe avoids two failure modes:
+*
+* 1. `screencastAvailable: false` — the server doesn't have `ws` / `@hono/node-ws`
+*    installed (or the route was never registered). Opening a WS would fail and
+*    trigger a reconnect loop.
+* 2. `hasSession: false` — no active browser session for this thread yet. Opening
+*    a WS would succeed but sit idle, holding resources for no reason.
+*
+* When the endpoint itself returns 404 (older server that predates this probe),
+* the hook assumes screencast is available and a session is active so behavior
+* matches the legacy unconditional connect.
+*
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+function useBrowserSessionProbe({ agentId, threadId, queryOptions }) {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: browserSessionProbeQueryKey(agentId, threadId),
+		queryFn: async () => {
+			if (!agentId) return {
+				hasSession: false,
+				screencastAvailable: false
+			};
+			try {
+				return await client.getAgent(agentId).browserSession(threadId);
+			} catch (error) {
+				if (isNotFoundError(error)) return LEGACY_FALLBACK;
+				throw error;
+			}
+		},
+		refetchOnWindowFocus: true,
+		staleTime: 0,
+		retry: 1,
+		...queryOptions
+	});
+}
+//#endregion
+//#region src/hooks/agents/is-model-not-allowed.ts
+/**
+* The wire-level error code the server emits on a 422 when a model is blocked
+* by the admin's builder policy. Kept as a local literal so the browser bundle
+* never imports server-only agent-builder EE code.
+*/
+const MODEL_NOT_ALLOWED_CODE = "MODEL_NOT_ALLOWED";
+/**
+* Detects HTTP 422 + MODEL_NOT_ALLOWED responses thrown by `MastraClientError`
+* (or any error carrying `status` + `body.error.code`). Returns the parsed
+* details when matched, or `null` otherwise.
+*/
+function isModelNotAllowedError(err) {
+	if (!err || typeof err !== "object") return null;
+	const candidate = err;
+	if (candidate.status !== 422) return null;
+	const body = candidate.body;
+	if (body?.error?.code !== MODEL_NOT_ALLOWED_CODE) return null;
+	const errorBody = body.error;
+	return {
+		message: errorBody.message || candidate.message || "Model not allowed by admin policy",
+		attempted: errorBody.attempted,
+		offendingLabel: errorBody.offendingLabel
+	};
+}
+//#endregion
+//#region src/hooks/agents/use-stored-agents.ts
+const useStoredAgents = ({ queryOptions, ...params } = {}) => {
+	const client = useMastraClient();
+	const listParams = Object.keys(params).length > 0 ? params : void 0;
+	return useQuery({
+		queryKey: ["stored-agents", listParams],
+		queryFn: () => client.listStoredAgents(listParams),
+		...queryOptions
+	});
+};
+/**
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+const useStoredAgent = ({ agentId, status, requestContext, queryOptions } = {}) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: [
+			"stored-agent",
+			agentId,
+			status,
+			requestContext
+		],
+		queryFn: async () => {
+			if (!agentId) return null;
+			try {
+				return await client.getStoredAgent(agentId).details(requestContext, { status });
+			} catch (error) {
+				if (error && typeof error === "object" && "status" in error && error.status === 404) return null;
+				throw error;
+			}
+		},
+		retry: false,
+		...queryOptions
+	});
+};
+/**
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+const useStoredAgentDependents = ({ agentId, requestContext, queryOptions } = {}) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: [
+			"stored-agent-dependents",
+			agentId,
+			requestContext
+		],
+		queryFn: () => client.getStoredAgent(agentId).dependents(requestContext),
+		retry: false,
+		...queryOptions
+	});
+};
+const useStoredAgentMutations = ({ agentId, requestContext, queryOptions } = {}) => {
+	const client = useMastraClient();
+	const queryClient = useQueryClient();
+	const invalidateBuilderSettingsOnPolicyReject = (err) => {
+		if (isModelNotAllowedError(err)) queryClient.invalidateQueries({ queryKey: ["builder-settings"] });
+	};
+	return {
+		createStoredAgent: useMutation({
+			mutationFn: (params) => client.createStoredAgent(params),
+			onSuccess: (created) => {
+				queryClient.setQueryData([
+					"stored-agent",
+					created.id,
+					"draft",
+					requestContext
+				], created);
+				queryClient.setQueryData([
+					"stored-agent",
+					created.id,
+					void 0,
+					requestContext
+				], created);
+				queryClient.invalidateQueries({ queryKey: ["stored-agents"] });
+				queryClient.invalidateQueries({ queryKey: ["agents"] });
+				queryClient.invalidateQueries({ queryKey: ["agent", created.id] });
+			},
+			onError: invalidateBuilderSettingsOnPolicyReject,
+			...queryOptions?.createStoredAgent
+		}),
+		updateStoredAgent: useMutation({
+			mutationFn: (params) => {
+				if (!agentId) throw new Error("agentId is required for update");
+				return client.getStoredAgent(agentId).update(params, requestContext);
+			},
+			onSuccess: () => {
+				queryClient.invalidateQueries({ queryKey: ["stored-agents"] });
+				queryClient.invalidateQueries({ queryKey: ["agents"] });
+				if (agentId) {
+					queryClient.invalidateQueries({ queryKey: ["stored-agent", agentId] });
+					queryClient.invalidateQueries({ queryKey: ["agent", agentId] });
+				}
+			},
+			onError: invalidateBuilderSettingsOnPolicyReject,
+			...queryOptions?.updateStoredAgent
+		}),
+		deleteStoredAgent: useMutation({
+			mutationFn: () => {
+				if (!agentId) throw new Error("agentId is required for delete");
+				return client.getStoredAgent(agentId).delete(requestContext);
+			},
+			onSuccess: () => {
+				queryClient.invalidateQueries({ queryKey: ["stored-agents"] });
+				queryClient.invalidateQueries({ queryKey: ["agents"] });
+				if (agentId) {
+					queryClient.removeQueries({ queryKey: ["stored-agent", agentId] });
+					queryClient.removeQueries({ queryKey: ["agent", agentId] });
+				}
+			},
+			...queryOptions?.deleteStoredAgent
+		})
+	};
+};
+//#endregion
+//#region src/hooks/agents/use-agent-skills.ts
+/**
+* Hook to read and mutate the skills config for a stored agent.
+*
+* The skills field is `Record<string, StoredAgentSkillConfig>` on the agent
+* snapshot. Each key is a stored skill ID and the value holds per-skill
+* overrides (description, instructions, pin, strategy).
+*/
+function useAgentSkills({ agentId, requestContext, queryOptions } = {}) {
+	const client = useMastraClient();
+	const queryClient = useQueryClient();
+	const { data: agent } = useStoredAgent({
+		agentId,
+		status: "draft",
+		queryOptions: { enabled: Boolean(agentId) }
+	});
+	return {
+		skills: useMemo(() => {
+			if (!agent?.skills) return {};
+			if (Array.isArray(agent.skills)) {
+				const merged = {};
+				for (const variant of agent.skills) Object.assign(merged, variant.value);
+				return merged;
+			}
+			return agent.skills;
+		}, [agent?.skills]),
+		updateSkills: useMutation({
+			mutationFn: (newSkills) => {
+				if (!agentId) throw new Error("agentId is required");
+				const params = { skills: newSkills };
+				return client.getStoredAgent(agentId).update(params, requestContext);
+			},
+			onSuccess: () => {
+				if (agentId) {
+					queryClient.invalidateQueries({ queryKey: ["stored-agent", agentId] });
+					queryClient.invalidateQueries({ queryKey: ["agent", agentId] });
+					queryClient.invalidateQueries({ queryKey: ["agent-versions", agentId] });
+				}
+			},
+			...queryOptions?.updateSkills
+		})
+	};
+}
+//#endregion
+//#region src/hooks/agents/use-agent-versions.ts
+/**
+* Hook to list versions of a stored agent
+*
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+const useAgentVersions = ({ agentId, params, requestContext, queryOptions }) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: [
+			"agent-versions",
+			agentId,
+			params,
+			requestContext
+		],
+		queryFn: agentId ? () => client.getStoredAgent(agentId).listVersions(params, requestContext) : skipToken,
+		...queryOptions
+	});
+};
+/**
+* Hook to get a single version of a stored agent
+*
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+const useAgentVersion = ({ agentId, versionId, requestContext, queryOptions }) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: [
+			"agent-version",
+			agentId,
+			versionId,
+			requestContext
+		],
+		queryFn: () => client.getStoredAgent(agentId).getVersion(versionId, requestContext),
+		...queryOptions
+	});
+};
+/**
+* Hook to create a new version of a stored agent
+*/
+const useCreateAgentVersion = ({ agentId, requestContext, queryOptions }) => {
+	const client = useMastraClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (params) => client.getStoredAgent(agentId).createVersion(params, requestContext),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["agent-versions", agentId] });
+			queryClient.invalidateQueries({ queryKey: ["agent", agentId] });
+		},
+		...queryOptions
+	});
+};
+/**
+* Hook to activate a specific version of a stored agent
+*/
+const useActivateAgentVersion = ({ agentId, requestContext, queryOptions }) => {
+	const client = useMastraClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (versionId) => client.getStoredAgent(agentId).activateVersion(versionId, requestContext),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["agent-versions", agentId] });
+			queryClient.invalidateQueries({ queryKey: ["agent", agentId] });
+		},
+		...queryOptions
+	});
+};
+/**
+* Hook to restore a specific version of a stored agent (creates a new version from an old one)
+*/
+const useRestoreAgentVersion = ({ agentId, requestContext, queryOptions }) => {
+	const client = useMastraClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (versionId) => client.getStoredAgent(agentId).restoreVersion(versionId, requestContext),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["agent-versions", agentId] });
+			queryClient.invalidateQueries({ queryKey: ["agent", agentId] });
+		},
+		...queryOptions
+	});
+};
+/**
+* Hook to delete a specific version of a stored agent
+*/
+const useDeleteAgentVersion = ({ agentId, requestContext, queryOptions }) => {
+	const client = useMastraClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (versionId) => client.getStoredAgent(agentId).deleteVersion(versionId, requestContext),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["agent-versions", agentId] });
+		},
+		...queryOptions
+	});
+};
+/**
+* Hook to compare two versions of a stored agent
+*
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+const useCompareAgentVersions = ({ agentId, fromVersionId, toVersionId, requestContext, queryOptions }) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: [
+			"agent-versions-compare",
+			agentId,
+			fromVersionId,
+			toVersionId,
+			requestContext
+		],
+		queryFn: () => client.getStoredAgent(agentId).compareVersions(fromVersionId, toVersionId, requestContext),
+		...queryOptions
+	});
+};
+//#endregion
+//#region src/hooks/agents/use-agent-working-memory.ts
+function parseJsonString(jsonString) {
+	try {
+		return JSON.stringify(JSON.parse(jsonString), null, 2);
+	} catch {
+		return jsonString;
+	}
+}
+function useAgentWorkingMemory(agentId, threadId, resourceId, requestContext) {
+	const client = useMastraClient();
+	const [threadExists, setThreadExists] = useState(false);
+	const [workingMemoryData, setWorkingMemoryData] = useState(null);
+	const [workingMemorySource, setWorkingMemorySource] = useState("thread");
+	const [workingMemoryFormat, setWorkingMemoryFormat] = useState("markdown");
+	const [isLoading, setIsLoading] = useState(true);
+	const [isUpdating, setIsUpdating] = useState(false);
+	const latestRequest = useRef(0);
+	const refetch = useCallback(async () => {
+		const requestId = ++latestRequest.current;
+		setIsLoading(true);
+		try {
+			if (!agentId || !threadId) {
+				setWorkingMemoryData(null);
+				setIsLoading(false);
+				return;
+			}
+			const res = await client.getWorkingMemory({
+				agentId,
+				threadId,
+				resourceId,
+				requestContext
+			});
+			if (requestId !== latestRequest.current) return;
+			const { workingMemory, source, workingMemoryTemplate, threadExists } = res;
+			setThreadExists(threadExists);
+			setWorkingMemoryData(workingMemory);
+			setWorkingMemorySource(source);
+			setWorkingMemoryFormat(workingMemoryTemplate?.format || "markdown");
+			if (workingMemoryTemplate?.format === "json") {
+				let dataToSet = "";
+				if (workingMemory) dataToSet = parseJsonString(workingMemory);
+				else if (workingMemoryTemplate?.content) dataToSet = parseJsonString(workingMemoryTemplate.content);
+				else dataToSet = "";
+				setWorkingMemoryData(dataToSet);
+			} else setWorkingMemoryData(workingMemory || workingMemoryTemplate?.content || "");
+		} catch (error) {
+			if (requestId !== latestRequest.current) return;
+			setWorkingMemoryData(null);
+			console.error("Error fetching working memory", error);
+		} finally {
+			if (requestId === latestRequest.current) setIsLoading(false);
+		}
+	}, [
+		agentId,
+		threadId,
+		resourceId,
+		client,
+		requestContext
+	]);
+	useEffect(() => {
+		refetch();
+	}, [refetch]);
+	const updateWorkingMemory = async (newMemory) => {
+		setIsUpdating(true);
+		try {
+			if (workingMemoryFormat === "json") try {
+				JSON.parse(newMemory);
+			} catch {
+				throw new Error("Invalid JSON working memory");
+			}
+			await client.updateWorkingMemory({
+				agentId,
+				threadId,
+				workingMemory: newMemory,
+				resourceId,
+				requestContext
+			});
+			refetch();
+		} catch (error) {
+			console.error("Error updating working memory", error);
+			throw error;
+		} finally {
+			setIsUpdating(false);
+		}
+	};
+	return {
+		threadExists,
+		workingMemoryData,
+		workingMemorySource,
+		workingMemoryFormat,
+		isLoading,
+		isUpdating,
+		refetch,
+		updateWorkingMemory
+	};
+}
+//#endregion
+//#region src/hooks/agents/use-agent-workspace.ts
+/**
+* Hook to read and mutate the workspace reference for a stored agent.
+*
+* The workspace ref is part of the agent snapshot config and can be:
+* - `{ type: 'id', workspaceId }` — references a stored workspace by ID
+* - `{ type: 'inline', config }` — inline workspace config
+* - `undefined` — no workspace assigned
+*/
+function useAgentWorkspace({ agentId, requestContext, queryOptions } = {}) {
+	const client = useMastraClient();
+	const queryClient = useQueryClient();
+	const { data: agent } = useStoredAgent({
+		agentId,
+		status: "draft",
+		queryOptions: { enabled: Boolean(agentId) }
+	});
+	return {
+		workspace: useMemo(() => {
+			if (!agent?.workspace) return void 0;
+			if (Array.isArray(agent.workspace)) return agent.workspace[0]?.value;
+			return agent.workspace;
+		}, [agent?.workspace]),
+		updateWorkspace: useMutation({
+			mutationFn: (ref) => {
+				if (!agentId) throw new Error("agentId is required");
+				const params = { workspace: ref };
+				return client.getStoredAgent(agentId).update(params, requestContext);
+			},
+			onSuccess: () => {
+				if (agentId) {
+					queryClient.invalidateQueries({ queryKey: ["stored-agent", agentId] });
+					queryClient.invalidateQueries({ queryKey: ["agent", agentId] });
+					queryClient.invalidateQueries({ queryKey: ["agent-versions", agentId] });
+				}
+			},
+			...queryOptions?.updateWorkspace
+		})
+	};
+}
+//#endregion
+//#region src/hooks/agents/use-agent.ts
+/**
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+const useAgent = ({ agentId, requestContext, queryOptions } = {}) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: [
+			"agent",
+			agentId,
+			requestContext
+		],
+		queryFn: () => agentId ? client.getAgent(agentId).details(requestContext) : null,
+		retry: false,
+		...queryOptions
+	});
+};
+//#endregion
+//#region src/hooks/agents/use-agents-model-providers.ts
+const useAgentsModelProviders = ({ queryOptions } = {}) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: ["agents-model-providers"],
+		queryFn: () => client.listAgentsModelProviders(),
+		retry: false,
+		...queryOptions
+	});
+};
+//#endregion
+//#region src/hooks/agents/use-agents.ts
+const useAgents = ({ requestContext, queryOptions } = {}) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: ["agents", requestContext],
+		queryFn: () => client.listAgents(requestContext),
+		...queryOptions
+	});
+};
+const useUpdateAgentModel = ({ agentId, queryOptions }) => {
+	const client = useMastraClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (payload) => client.getAgent(agentId).updateModel(payload),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["agent", agentId] });
+		},
+		onError: (err) => {
+			console.error("Error updating model", err);
+		},
+		...queryOptions
+	});
+};
+const useReorderModelList = ({ agentId, queryOptions }) => {
+	const client = useMastraClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (payload) => client.getAgent(agentId).reorderModelList(payload),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["agent", agentId] });
+		},
+		onError: (err) => {
+			console.error("Error reordering model list", err);
+		},
+		...queryOptions
+	});
+};
+const useUpdateModelInModelList = ({ agentId, queryOptions }) => {
+	const client = useMastraClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (payload) => client.getAgent(agentId).updateModelInModelList(payload),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["agent", agentId] });
+		},
+		onError: (err) => {
+			console.error("Error updating model in model list", err);
+		},
+		...queryOptions
+	});
+};
+const useResetAgentModel = ({ agentId, queryOptions }) => {
+	const client = useMastraClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async () => client.getAgent(agentId).resetModel(),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["agent", agentId] });
+		},
+		onError: (err) => {
+			console.error("Error resetting model", err);
+		},
+		...queryOptions
+	});
+};
+//#endregion
+//#region src/hooks/agents/use-close-browser.ts
+/**
+* Mutation hook for closing an agent's browser session.
+*/
+function useCloseBrowser({ queryOptions } = {}) {
+	const client = useMastraClient();
+	return useMutation({
+		mutationFn: ({ agentId, threadId }) => client.getAgent(agentId).closeBrowser(threadId),
+		onError: (err) => {
+			console.error("[useCloseBrowser] Error closing browser:", err);
+		},
+		...queryOptions
+	});
+}
+//#endregion
+//#region src/hooks/agents/use-preview-instructions.ts
+/**
+* Normalize blocks to API format.
+* Form-format ref blocks have `{ type: 'prompt_block_ref', promptBlockId }`,
+* while API-format blocks have `{ type: 'prompt_block_ref', id }`.
+*/
+function toApiBlocks(blocks) {
+	return blocks.map((block) => {
+		if (block.type === "prompt_block_ref") return {
+			type: "prompt_block_ref",
+			id: block.promptBlockId ?? block.id
+		};
+		return {
+			type: block.type,
+			content: block.content,
+			rules: block.rules
+		};
+	});
+}
+/**
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+function usePreviewInstructions({ blocks, requestContext, queryOptions }) {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: [
+			"preview-instructions",
+			blocks,
+			requestContext
+		],
+		queryFn: async () => {
+			if (!blocks || blocks.length === 0) return "";
+			return (await client.request("/stored/agents/preview-instructions", {
+				method: "POST",
+				body: {
+					blocks: toApiBlocks(blocks),
+					context: requestContext
+				}
+			})).result;
+		},
+		...queryOptions
+	});
+}
+//#endregion
+//#region src/hooks/agents/use-stored-skills.ts
+function useStoredSkills({ queryOptions } = {}) {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: ["stored-skills"],
+		queryFn: () => client.listStoredSkills(),
+		...queryOptions
+	});
+}
+//#endregion
+//#region src/hooks/agents/use-channels.ts
+const useChannelPlatforms = ({ queryOptions } = {}) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: ["channels", "platforms"],
+		queryFn: () => client.channels.listPlatforms(),
+		staleTime: 60 * 1e3,
+		retry: false,
+		...queryOptions
+	});
+};
+/**
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+const useChannelInstallations = ({ platform, agentId, queryOptions }) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: [
+			"channels",
+			"installations",
+			platform,
+			agentId
+		],
+		queryFn: () => client.channels.listInstallations(platform, agentId),
+		staleTime: 10 * 1e3,
+		retry: false,
+		...queryOptions
+	});
+};
+const useConnectChannel = ({ platform, queryOptions }) => {
+	const client = useMastraClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: ({ agentId, options }) => client.channels.connect(platform, agentId, {
+			...options,
+			redirectUrl: window.location.href
+		}),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: [
+				"channels",
+				"installations",
+				platform
+			] });
+		},
+		...queryOptions
+	});
+};
+const useDisconnectChannel = ({ platform, queryOptions }) => {
+	const client = useMastraClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (agentId) => client.channels.disconnect(platform, agentId),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: [
+				"channels",
+				"installations",
+				platform
+			] });
+		},
+		...queryOptions
+	});
+};
+//#endregion
+//#region src/hooks/agents/use-execute-agent-tool.ts
+const useExecuteAgentTool = ({ queryOptions } = {}) => {
+	const client = useMastraClient();
+	return useMutation({
+		mutationFn: async ({ agentId, toolId, input, playgroundRequestContext }) => {
+			const requestContext = new RequestContext();
+			Object.entries(playgroundRequestContext ?? {}).forEach(([key, value]) => {
+				requestContext.set(key, value);
+			});
+			return client.getAgent(agentId).executeTool(toolId, {
+				data: input,
+				requestContext
+			});
+		},
+		...queryOptions
+	});
+};
+//#endregion
+export { browserSessionProbeQueryKey, isModelNotAllowedError, useActivateAgentVersion, useAgent, useAgentMessages, useAgentPlan, useAgentSkills, useAgentVersion, useAgentVersions, useAgentWorkingMemory, useAgentWorkspace, useAgents, useAgentsModelProviders, useBackgroundTaskStream, useBrowserSessionProbe, useChannelInstallations, useChannelPlatforms, useCloseBrowser, useCompareAgentVersions, useConnectChannel, useCreateAgentVersion, useDeleteAgentVersion, useDisconnectChannel, useExecuteAgentTool, useGetBackgroundTaskById, usePreviewInstructions, useReorderModelList, useResetAgentModel, useRestoreAgentVersion, useStoredAgent, useStoredAgentDependents, useStoredAgentMutations, useStoredAgents, useStoredSkills, useUpdateAgentModel, useUpdateModelInModelList };
+
+//# sourceMappingURL=index.js.map