@softr/sdk 0.0.90-alpha.3 → 0.0.90-alpha.5

package/dist/agent/use-agent-chat.d.ts

@@ -1,106 +0,0 @@
-import { AgentChatSummary } from "./agent-fns.js";
-
-//#region src/agent/use-agent-chat.d.ts
-/** A step of the agent's work: a tool it calls, and where that call stands. */
-type AgentToolCall = {
-  type: "tool";
-  id: string;
-  name: string;
-  /** The tool's input as the agent sent it, usually JSON. */
-  input?: string;
-  /**
-   * `awaiting-approval` waits for `approve` or `reject`. `awaiting-connection`
-   * waits for the visitor to `connect` their own `integration` account, and is
-   * `connecting` while they sign in.
-   */
-  status: "running" | "done" | "failed" | "awaiting-approval" | "approved" | "rejected" | "awaiting-connection" | "connecting";
-  error?: string;
-  integration?: string;
-  /** Why the agent calls it, in its own words. */
-  thought?: string;
-  /** How long a finished call took. */
-  durationMs?: number;
-};
-type AgentTodo = {
-  content: string;
-  status: "pending" | "in_progress" | "completed";
-};
-type AgentQuestion = {
-  question: string;
-  header: string;
-  options: Array<{
-    label: string;
-    description: string;
-  }>;
-  multiSelect: boolean;
-};
-/**
- * One piece of a message, in the order the agent produced it. A tool waiting for
- * the visitor comes last, below the text that asks for it, until they answer.
- */
-type AgentBlock = {
-  type: "text";
-  text: string;
-} | AgentToolCall
-/** The agent's plan. It replaces itself as the agent works through it. */ | {
-  type: "todo";
-  todos: AgentTodo[];
-}
-/** The agent asks the visitor to pick. They answer by sending a message. */ | {
-  type: "question";
-  questions: AgentQuestion[];
-} | {
-  type: "error";
-  message: string;
-};
-type AgentMessage = {
-  id: string;
-  role: "user" | "assistant";
-  blocks: AgentBlock[];
-};
-type AgentChat = {
-  /** The whole chat, oldest first. While the agent replies, its reply is the last one and grows. */
-  messages: AgentMessage[];
-  /** `thinking` until the first part of the reply arrives, `replying` until it ends. */
-  status: "idle" | "thinking" | "replying";
-  /** True while a past chat loads, including the one reopened on mount. */
-  loading: boolean;
-  /** Why the last request failed. Cleared by the next one. */
-  error: Error | null;
-  /** The chat the next message goes to, `null` for a new one. */
-  chatId: string | null;
-  send: (text: string) => void;
-  /** Stops the reply. What arrived so far stays. */
-  stop: () => void;
-  newChat: () => void;
-  /** Opens a past chat from `listChats`. */
-  openChat: (chatId: string) => void;
-  /** The visitor's past chats with this agent. */
-  listChats: () => Promise<AgentChatSummary[]>;
-  /** Lets a tool waiting for approval run: once, for the rest of this chat, or for this agent from now on. */
-  approve: (toolCallId: string, scope?: "ONCE" | "SESSION" | "USER") => void;
-  reject: (toolCallId: string) => void;
-  /** Opens the sign-in for a tool's `integration` in a popup. Call it from a click, or the browser blocks the popup. */
-  connect: (toolCallId: string) => void;
-};
-type AgentChatOptions = {
-  /**
-   * The record the visitor is looking at, so they can say "this one". Sent
-   * with each message. Keys are what the agent reads, so use field names.
-   */
-  record?: {
-    id: string;
-    fields: Record<string, unknown>;
-  } | null;
-};
-/**
- * A chat with one of the app's Softr agents, as the signed-in visitor. No UI:
- * render `messages` with the app's own components.
- *
- * @example
- * const chat = useAgentChat(AGENT_ID, { record: ticket && { id: ticket.id, fields: ticket.fields } })
- * <form onSubmit={(e) => { e.preventDefault(); chat.send(draft) }}>
- */
-declare function useAgentChat(agentId: string, options?: AgentChatOptions): AgentChat;
-//#endregion
-export { AgentBlock, AgentChat, AgentChatOptions, AgentMessage, AgentQuestion, AgentTodo, AgentToolCall, useAgentChat };

package/dist/agent/use-agent-chat.js

@@ -1,486 +0,0 @@
-import { assert } from "../assertions.js";
-import { useCurrentUser } from "../auth/isomorphic.js";
-import { agentChatFn, awaitAgentConnectionFn, decideAgentToolFn, finishAgentConnectionFn, listAgentChatsFn, loadAgentChatFn, startAgentConnectionFn } from "./agent-fns.js";
-import { useCallback, useEffect, useRef, useState } from "react";
-
-//#region src/agent/use-agent-chat.ts
-/**
-* A chat with one of the app's Softr agents, as the signed-in visitor. No UI:
-* render `messages` with the app's own components.
-*
-* @example
-* const chat = useAgentChat(AGENT_ID, { record: ticket && { id: ticket.id, fields: ticket.fields } })
-* <form onSubmit={(e) => { e.preventDefault(); chat.send(draft) }}>
-*/
-function useAgentChat(agentId, options = {}) {
-	const [messages, setMessages] = useState([]);
-	const [live, setLive] = useState(null);
-	const [status, setStatus] = useState("idle");
-	const [loading, setLoading] = useState(false);
-	const [error, setError] = useState(null);
-	const [chatId, setChatId] = useState(null);
-	const storeKey = chatKey(agentId, useCurrentUser()?.id ?? null);
-	const chatIdRef = useRef(chatId);
-	chatIdRef.current = chatId;
-	const recordRef = useRef(options.record ?? null);
-	recordRef.current = options.record ?? null;
-	const liveRef = useRef(live);
-	liveRef.current = live;
-	const abortRef = useRef(null);
-	useEffect(() => () => abortRef.current?.abort(), []);
-	const commitLive = useCallback((blocks) => {
-		setLive(null);
-		if (!blocks?.some((b) => b.type !== "text" || b.text.trim())) return;
-		setMessages((prev) => [...prev, {
-			id: crypto.randomUUID(),
-			role: "assistant",
-			blocks: endRunningTools(blocks)
-		}]);
-	}, []);
-	const stream = useCallback(async (message) => {
-		abortRef.current?.abort();
-		const controller = new AbortController();
-		abortRef.current = controller;
-		setError(null);
-		setStatus("thinking");
-		let blocks = [];
-		try {
-			const request = {
-				agentId,
-				message,
-				sessionId: chatIdRef.current,
-				timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-				pageName: document.title,
-				pageUrl: location.href,
-				record: recordRef.current
-			};
-			const form = new FormData();
-			form.append("payload", JSON.stringify(request));
-			const res = await fetch(agentChatFn.url, {
-				method: "POST",
-				body: form,
-				signal: controller.signal
-			});
-			if (!res.ok) throw new Error(await failureMessage(res));
-			assert(res.body, "agent chat: the reply has no body");
-			const reader = res.body.pipeThrough(new TextDecoderStream()).getReader();
-			let buffer = "";
-			const onLine = (line) => {
-				const event = parseEvent(line);
-				if (event === null) return;
-				if (event.sessionId && event.sessionId !== chatIdRef.current) {
-					chatIdRef.current = event.sessionId;
-					setChatId(event.sessionId);
-					saveChatId(storeKey, event.sessionId);
-				}
-				blocks = reduceEvent(blocks, event);
-				setLive(blocks);
-				setStatus("replying");
-			};
-			for (;;) {
-				const { done, value } = await reader.read();
-				if (done) break;
-				buffer += value;
-				const lines = buffer.split("\n");
-				buffer = lines.pop() ?? "";
-				lines.forEach(onLine);
-			}
-			onLine(buffer);
-		} catch (err) {
-			if (controller.signal.aborted) return;
-			setError(err instanceof Error ? err : new Error(String(err)));
-		}
-		if (abortRef.current !== controller) return;
-		abortRef.current = null;
-		commitLive(blocks);
-		setStatus("idle");
-	}, [
-		agentId,
-		storeKey,
-		commitLive
-	]);
-	const send = useCallback((text) => {
-		const trimmed = text.trim();
-		if (!trimmed) return;
-		abortRef.current?.abort();
-		commitLive(liveRef.current);
-		setMessages((prev) => [...prev, {
-			id: crypto.randomUUID(),
-			role: "user",
-			blocks: [{
-				type: "text",
-				text: trimmed
-			}]
-		}]);
-		stream(trimmed);
-	}, [stream, commitLive]);
-	const stop = useCallback(() => {
-		if (abortRef.current === null) return;
-		abortRef.current.abort();
-		abortRef.current = null;
-		commitLive(liveRef.current);
-		setStatus("idle");
-	}, [commitLive]);
-	const reset = useCallback((id) => {
-		abortRef.current?.abort();
-		abortRef.current = null;
-		chatIdRef.current = id;
-		setChatId(id);
-		saveChatId(storeKey, id);
-		setMessages([]);
-		setLive(null);
-		setStatus("idle");
-		setLoading(false);
-		setError(null);
-	}, [storeKey]);
-	const newChat = useCallback(() => reset(null), [reset]);
-	const load = useCallback((id, restoring) => {
-		reset(id);
-		setLoading(true);
-		loadAgentChatFn({ data: {
-			agentId,
-			sessionId: id
-		} }).then((history) => {
-			if (chatIdRef.current !== id) return;
-			if (history === null) {
-				reset(null);
-				if (!restoring) setError(new Error(CHAT_GONE_MESSAGE));
-				return;
-			}
-			setLoading(false);
-			setMessages(fromHistory(history));
-		}).catch((err) => {
-			if (chatIdRef.current !== id) return;
-			setLoading(false);
-			setError(err instanceof Error ? err : new Error(String(err)));
-		});
-	}, [agentId, reset]);
-	const openChat = useCallback((id) => load(id, false), [load]);
-	useEffect(() => {
-		const saved = savedChatId(storeKey);
-		if (saved) load(saved, true);
-		else newChat();
-	}, [
-		storeKey,
-		load,
-		newChat
-	]);
-	const listChats = useCallback(() => listAgentChatsFn({ data: { agentId } }), [agentId]);
-	const setToolStatus = useCallback((toolCallId, next) => {
-		const update = (blocks) => blocks.map((b) => b.type === "tool" && b.id === toolCallId ? {
-			...b,
-			status: next
-		} : b);
-		setLive((prev) => prev && update(prev));
-		setMessages((prev) => prev.map((m) => ({
-			...m,
-			blocks: update(m.blocks)
-		})));
-	}, []);
-	const decide = useCallback((toolCallId, decision, scope) => {
-		const sessionId = chatIdRef.current;
-		const tool = [...messages.flatMap((m) => m.blocks), ...liveRef.current ?? []].find((b) => b.type === "tool" && b.id === toolCallId);
-		if (sessionId === null || tool?.status !== "awaiting-approval") return;
-		setToolStatus(toolCallId, decision === "APPROVE" ? "approved" : "rejected");
-		decideAgentToolFn({ data: {
-			agentId,
-			sessionId,
-			toolCallId,
-			toolName: tool.name,
-			decision,
-			scope
-		} }).then((saved) => {
-			if (!saved) {
-				reset(null);
-				setError(new Error(CHAT_GONE_MESSAGE));
-				return;
-			}
-			if (decision !== "APPROVE") return;
-			abortRef.current?.abort();
-			commitLive(liveRef.current);
-			stream("");
-		}).catch((err) => {
-			setToolStatus(toolCallId, "awaiting-approval");
-			setError(err instanceof Error ? err : new Error(String(err)));
-		});
-	}, [
-		agentId,
-		messages,
-		setToolStatus,
-		commitLive,
-		stream,
-		reset
-	]);
-	const approve = useCallback((toolCallId, scope = "ONCE") => decide(toolCallId, "APPROVE", scope), [decide]);
-	const reject = useCallback((toolCallId) => decide(toolCallId, "REJECT", "ONCE"), [decide]);
-	const connect = useCallback((toolCallId) => {
-		const sessionId = chatIdRef.current;
-		const tool = [...messages.flatMap((m) => m.blocks), ...liveRef.current ?? []].find((b) => b.type === "tool" && b.id === toolCallId);
-		if (sessionId === null || tool?.status !== "awaiting-connection" || !tool.integration) return;
-		const popup = window.open("", "softr-agent-connect", popupFeatures(500, 600));
-		if (!popup) {
-			setError(/* @__PURE__ */ new Error("Allow pop-ups for this site to connect your account."));
-			return;
-		}
-		setToolStatus(toolCallId, "connecting");
-		const connection = {
-			integration: tool.integration,
-			requestId: crypto.randomUUID()
-		};
-		const deadline = Date.now() + CONNECT_TIMEOUT_MS;
-		(async () => {
-			popup.location.href = await startAgentConnectionFn({ data: connection });
-			while (!await awaitAgentConnectionFn({ data: connection })) {
-				if (Date.now() > deadline) throw new Error("Connecting took too long. Try again.");
-				await new Promise((resolve) => setTimeout(resolve, CONNECT_RETRY_MS));
-			}
-			popup.close();
-			if (!await finishAgentConnectionFn({ data: {
-				agentId,
-				sessionId,
-				toolCallId
-			} })) {
-				reset(null);
-				setError(new Error(CHAT_GONE_MESSAGE));
-				return;
-			}
-			setToolStatus(toolCallId, "approved");
-			abortRef.current?.abort();
-			commitLive(liveRef.current);
-			stream("");
-		})().catch((err) => {
-			popup.close();
-			setToolStatus(toolCallId, "awaiting-connection");
-			setError(err instanceof Error ? err : new Error(String(err)));
-		});
-	}, [
-		agentId,
-		messages,
-		setToolStatus,
-		commitLive,
-		stream,
-		reset
-	]);
-	return {
-		messages: (live === null ? messages : [...messages, {
-			id: "live",
-			role: "assistant",
-			blocks: live
-		}]).map(waitingLast),
-		status,
-		loading,
-		error,
-		chatId,
-		send,
-		stop,
-		newChat,
-		openChat,
-		listChats,
-		approve,
-		reject,
-		connect
-	};
-}
-const waitsForVisitor = (b) => b.type === "tool" && (b.status === "awaiting-approval" || b.status === "awaiting-connection" || b.status === "connecting");
-function waitingLast(message) {
-	if (!message.blocks.some(waitsForVisitor)) return message;
-	const blocks = [...message.blocks.filter((b) => !waitsForVisitor(b)), ...message.blocks.filter(waitsForVisitor)];
-	return {
-		...message,
-		blocks
-	};
-}
-const CONNECT_TIMEOUT_MS = 5 * 6e4;
-const CONNECT_RETRY_MS = 3e3;
-function popupFeatures(width, height) {
-	return `width=${width},height=${height},left=${window.screenX + (window.innerWidth - width) / 2},top=${window.screenY + (window.innerHeight - height) / 2}`;
-}
-const TODO_TOOL = "TodoWrite";
-/** Its question shows as a question block, so the call itself is noise. */
-const QUESTION_TOOL = "AskUserQuestion";
-function parseEvent(line) {
-	if (!line.trim()) return null;
-	try {
-		return JSON.parse(line);
-	} catch {
-		return null;
-	}
-}
-function reduceEvent(blocks, event) {
-	switch (event.type) {
-		case "TEXT": {
-			const last = blocks.at(-1);
-			return last?.type === "text" ? [...blocks.slice(0, -1), {
-				type: "text",
-				text: last.text + event.response
-			}] : [...blocks, {
-				type: "text",
-				text: event.response
-			}];
-		}
-		case "TOOL_CALL_START":
-			if (event.toolName === TODO_TOOL) {
-				const todos = parseTodos(event.input);
-				if (todos) return upsertTodos(blocks, todos);
-			}
-			if (event.toolName === QUESTION_TOOL) return blocks;
-			if (blocks.some((b) => b.type === "tool" && b.id === event.toolCallId)) return updateTool(blocks, event.toolCallId, (b) => b.status === "running" ? {
-				...b,
-				input: event.input ?? b.input,
-				thought: event.innerThought ?? b.thought
-			} : b);
-			return [...blocks, {
-				type: "tool",
-				id: event.toolCallId,
-				name: event.toolName,
-				input: event.input,
-				thought: event.innerThought,
-				integration: event.integrationType,
-				status: "running"
-			}];
-		case "TOOL_CALL_END": return updateTool(blocks, event.toolCallId, (b) => b.status === "running" || b.status === "approved" ? {
-			...b,
-			status: event.failed ? "failed" : "done",
-			error: event.errorMessage,
-			durationMs: event.durationMs
-		} : b);
-		case "TOOL_PERMISSION_REQUEST":
-		case "INTEGRATION_AUTH_REQUEST": {
-			const status = event.type === "TOOL_PERMISSION_REQUEST" ? "awaiting-approval" : "awaiting-connection";
-			const integration = event.type === "INTEGRATION_AUTH_REQUEST" ? event.integrationType : void 0;
-			if (blocks.some((b) => b.type === "tool" && b.id === event.toolCallId)) return updateTool(blocks, event.toolCallId, (b) => ({
-				...b,
-				status,
-				integration: integration ?? b.integration,
-				input: ("input" in event ? event.input : void 0) ?? b.input
-			}));
-			return [...blocks, {
-				type: "tool",
-				id: event.toolCallId,
-				name: event.toolName,
-				input: "input" in event ? event.input : void 0,
-				integration,
-				status
-			}];
-		}
-		case "QUESTION": return [...blocks, {
-			type: "question",
-			questions: event.questions
-		}];
-		case "ERROR": return [...blocks, {
-			type: "error",
-			message: event.message
-		}];
-		default: return blocks;
-	}
-}
-function updateTool(blocks, id, update) {
-	return blocks.map((b) => b.type === "tool" && b.id === id ? update(b) : b);
-}
-/** A reply that ended without finishing a tool call, stopped or cut off, never will. */
-function endRunningTools(blocks) {
-	return blocks.map((b) => b.type === "tool" && b.status === "running" ? {
-		...b,
-		status: "failed",
-		error: "The agent stopped before this step finished."
-	} : b);
-}
-/** Each plan update re-sends the whole list, so only the latest one is kept, where the first one was. */
-function upsertTodos(blocks, todos) {
-	const index = blocks.findIndex((b) => b.type === "todo");
-	if (index === -1) return [...blocks, {
-		type: "todo",
-		todos
-	}];
-	return blocks.map((b, i) => i === index ? {
-		type: "todo",
-		todos
-	} : b);
-}
-function parseTodos(input) {
-	if (!input) return null;
-	try {
-		const parsed = JSON.parse(input);
-		if (typeof parsed !== "object" || parsed === null || !("todos" in parsed)) return null;
-		const outer = parsed.todos;
-		const raw = typeof outer === "object" && outer !== null && "todos" in outer ? outer.todos : outer;
-		if (!Array.isArray(raw)) return null;
-		const todos = raw.flatMap((item) => {
-			if (typeof item !== "object" || item === null) return [];
-			const { content, status } = item;
-			if (typeof content !== "string" || !content.trim()) return [];
-			if (status !== "pending" && status !== "in_progress" && status !== "completed") return [];
-			return [{
-				content,
-				status
-			}];
-		});
-		return todos.length > 0 ? todos : null;
-	} catch {
-		return null;
-	}
-}
-function fromHistory(history) {
-	const toolsByMessage = Map.groupBy(history.toolCalls, (call) => call.messageId);
-	return history.messages.filter((m) => m.role !== "USER" || m.content.trim()).map((m) => {
-		if (m.role === "USER") return {
-			id: m.id,
-			role: "user",
-			blocks: [{
-				type: "text",
-				text: m.content
-			}]
-		};
-		let blocks = [];
-		const calls = (toolsByMessage.get(m.id) ?? []).toSorted((a, b) => a.createdAt - b.createdAt);
-		for (const call of calls) {
-			const todos = call.toolName === TODO_TOOL ? parseTodos(call.input) : null;
-			if (todos) blocks = upsertTodos(blocks, todos);
-			else if (call.toolName !== QUESTION_TOOL) blocks.push({
-				type: "tool",
-				id: call.id,
-				name: call.toolName,
-				input: call.input,
-				thought: call.metadata.innerThought ?? void 0,
-				durationMs: call.metadata.durationMs ?? void 0,
-				status: call.metadata.failed ? "failed" : "done"
-			});
-		}
-		if (m.content) blocks.push({
-			type: "text",
-			text: m.content
-		});
-		return {
-			id: m.id,
-			role: "assistant",
-			blocks
-		};
-	});
-}
-const CHAT_GONE_MESSAGE = "This chat is no longer available. Start a new one.";
-const VISITOR = "visitor";
-const chatKey = (agentId, userId) => `softr-code-app:agent-chat:${agentId}:${userId ?? VISITOR}`;
-function chatStore(key) {
-	return key.endsWith(`:${VISITOR}`) ? sessionStorage : localStorage;
-}
-function savedChatId(key) {
-	try {
-		return chatStore(key).getItem(key);
-	} catch {
-		return null;
-	}
-}
-function saveChatId(key, chatId) {
-	try {
-		if (chatId) chatStore(key).setItem(key, chatId);
-		else chatStore(key).removeItem(key);
-	} catch {}
-}
-async function failureMessage(res) {
-	const body = await res.json().catch(() => null);
-	if (typeof body === "object" && body !== null && "message" in body && typeof body.message === "string") return body.message;
-	return `The agent could not answer (${res.status}).`;
-}
-
-//#endregion
-export { useAgentChat };

package/skills/softr-sdk/agent-chat/SKILL.md

@@ -1,106 +0,0 @@
----
-name: agent-chat
-description: >-
-  Chat with one of the app's Softr agents: listAgents() and useAgentChat(agentId,
-  { record }) from @softr/sdk give the chat state with no UI — messages, the
-  streaming reply, past chats, approve, reject, connect. Load it for an agent
-  chat, approving its actions, or connecting the visitor's account a tool needs.
-metadata:
-  type: sub-skill
-  library: softr-sdk
-  library_version: 0.0.90-alpha.3
----
-
-**Boundary.** `listAgents` and `useAgentChat` live on `@softr/sdk`. `listAgents` runs in a route loader, `useAgentChat` in a component. Neither needs a route, server function or registration of its own. It chats as the signed-in visitor, or anonymously when no one is signed in.
-
-# Agent chat
-
-A Softr agent is set up in Studio's Agents tab and attached to the app there. There is no chat widget: the hook gives the state, and the app draws it with its own components.
-
-## Setup
-
-```ts
-import { listAgents, useAgentChat } from '@softr/sdk'
-```
-
-`listAgents()` resolves to the agents this visitor may chat with, `{ id, title, avatar, thumbnail }[]`. Call it in the route's `loader`. An agent hidden from this visitor isn't in the list, so show no chat when it's empty. When there are several, let the visitor pick one, or pick the one the builder named by its `title`. Take the id from the list. A hand-written id fails on the first message, and shows an agent the visitor may not see.
-
-## Core pattern
-
-```tsx
-// agentId comes from listAgents() in the route's loader.
-function AgentPanel({ agentId, ticket }: { agentId: string; ticket: Ticket | null }) {
-  const chat = useAgentChat(agentId, {
-    record: ticket && { id: ticket.id, fields: { Title: ticket.title, Status: ticket.status } },
-  })
-  const [draft, setDraft] = useState('')
-
-  return (
-    <>
-      {chat.messages.map((message) => (
-        <Message key={message.id} message={message} onApprove={chat.approve} onReject={chat.reject} />
-      ))}
-      {chat.error && <p role="alert">{chat.error.message}</p>}
-      <form onSubmit={(e) => { e.preventDefault(); chat.send(draft); setDraft('') }}>
-        <Textarea value={draft} onChange={(e) => setDraft(e.target.value)} />
-        {chat.status === 'idle'
-          ? <Button type="submit">Send</Button>
-          : <Button type="button" onClick={chat.stop}>Stop</Button>}
-      </form>
-    </>
-  )
-}
-```
-
-## What the hook returns
-
-- `messages`: the whole chat, oldest first. While the agent answers, its reply is the last message and grows as it streams.
-- `status`: `thinking` until the first part of the reply arrives, `replying` until it ends, then `idle`. Show a typing hint while it's `thinking`.
-- `loading`: `true` while a past chat loads. Show a spinner, not the empty-chat greeting.
-- `error`: why the last request failed, or `null`.
-- `send(text)`, `stop()`, `newChat()`.
-- `listChats()` resolves to the visitor's past chats, `{ id, title }[]`, with `title` `null` until the agent names the chat. `openChat(id)` loads one. `chatId` is the open one, `null` for a new chat. The open chat is kept in the browser for each signed-in user, so the hook reopens it after a remount or a reload. A signed-out visitor keeps it only until the tab closes.
-- `approve(toolCallId, scope?)` and `reject(toolCallId)` answer a tool waiting for approval. `scope` is `ONCE` (default), `SESSION` for the rest of this chat, or `USER` for this agent from now on.
-- `connect(toolCallId)` signs the visitor in to a tool's `integration` in a popup. Call it straight from the click, or the browser blocks the popup.
-
-## Rendering a message
-
-Each message has `role` (`user` or `assistant`) and `blocks`. Render every block type, in the order given. Show only `text` and a tool waiting for approval never appears, so the agent waits forever. A tool waiting for Approve or Connect comes last in its message, below the text asking for it.
-
-| Block | Show it as |
-| --- | --- |
-| `text` | Markdown, tables included |
-| `tool` | One line: the tool `name` and its `status`. Collapse finished ones. Expanded, show `thought`, `input` as `Label: value` lines (never raw JSON), `error` and `durationMs`, leaving out empty ones. |
-| `todo` | A checklist of the agent's plan. It updates in place. |
-| `question` | The questions with their options. One question with a single choice sends its label with `send` on click. Several questions, or `multiSelect`, collect the picks and show a Send button, enabled once each question has one. It sends one line per question, picked labels joined by ", ". An answered question stays locked. |
-| `error` | An error line inside the reply |
-
-A `tool` with status `awaiting-approval` blocks the agent until the visitor answers. Give it a split Approve button and a Reject button. The button says "Approve once" (`approve(id)`), and its menu offers "Approve for this session" (`approve(id, 'SESSION')`) and "Approve for this agent" (`approve(id, 'USER')`). With only one Approve, the visitor approves the same action again on every call. The agent continues on its own after an approval.
-
-A `tool` with status `awaiting-connection` needs the visitor's own `integration` account, such as their Gmail. Say "You need to connect to {integration} for this request. You'll only need to connect once.", with the name in readable case, and show a Connect button that calls `connect`. While it's `connecting`, show "Connecting…" and disable the button. The agent continues on its own once they're signed in. Every integration works the same way, so build one button, not one per integration.
-
-## Context
-
-`record` is the one record the visitor is looking at, so they can say "close this one". Pass it where a page shows one record, and `null` elsewhere. Use readable field names as keys. The agent reads them as they are.
-
-The page title and URL go along on their own. Nothing else about the page does, so don't try to send whole lists.
-
-## Letting the agent act on the app
-
-The agent reads and changes data through the app's own MCP, as the visitor who is chatting, using the actions `softrMcpMiddleware` lists. With no MCP wired, the agent can only talk. Load [mcp/SKILL.md](../mcp/SKILL.md) to wire it and choose the actions.
-
-**The agent calls a listed action directly, with any input.** It skips pages and server functions, so the action's `permissions` are its only guard: a read returns every row those groups may see, an update or delete takes any id.
-
-- Narrow `permissions` to who may really run it. When roles differ, split the action: each writes only that role's fields, with `customGroups` for that role. One update open to every signed-in visitor that writes the status lets an employee have the agent approve their own vacation request.
-- Don't list an action that is only safe for a visitor's own records. Nothing scopes it to them.
-
-## Failure modes
-
-**Building a chat without the hook.** Calling the agents service from the browser fails: only the app's server can sign the request in as the visitor. Use `useAgentChat`.
-
-**The hook inside a component that unmounts when the panel closes.** Closing it stops a reply that is still coming. Call `useAgentChat` in the component that owns the panel's open state and pass `chat` down. Keep the selected agent there too, or closing the panel resets it.
-
-## References
-
-- [mcp/SKILL.md](../mcp/SKILL.md): the actions the agent may call
-- [current-user/SKILL.md](../current-user/SKILL.md): showing the chat to signed-in visitors only