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

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

@@ -0,0 +1,486 @@
+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/dist/auth/isomorphic.d.ts

@@ -22,7 +22,7 @@ import * as _tanstack_react_start0 from "@tanstack/react-start";
  *   requestMiddleware: [softrAuthMiddleware()],
  * }))
  */
-declare function softrAuthMiddleware(): _tanstack_react_start0.RequestMiddlewareAfterServer<{}, readonly [_tanstack_react_start0.RequestMiddlewareAfterServer<{}, undefined, undefined>, _tanstack_react_start0.RequestMiddlewareAfterServer<{}, undefined, undefined>, _tanstack_react_start0.RequestMiddlewareAfterServer<{}, undefined, undefined>, _tanstack_react_start0.RequestMiddlewareAfterServer<{}, undefined, undefined>, _tanstack_react_start0.RequestMiddlewareAfterServer<{}, undefined, undefined>], {
+declare function softrAuthMiddleware(): _tanstack_react_start0.RequestMiddlewareAfterServer<{}, readonly [_tanstack_react_start0.RequestMiddlewareAfterServer<{}, undefined, undefined>, _tanstack_react_start0.RequestMiddlewareAfterServer<{}, undefined, undefined>, _tanstack_react_start0.RequestMiddlewareAfterServer<{}, undefined, undefined>, _tanstack_react_start0.RequestMiddlewareAfterServer<{}, undefined, undefined>], {
   user: User | null;
   permissions: Permissions;
   formatting: Formatting;

package/dist/auth/isomorphic.js

@@ -10,7 +10,6 @@ import { bootErrorMiddleware } from "../boot-error.js";
 import { pwaMiddleware } from "../pwa.js";
 import { faviconMiddleware } from "../favicon.js";
 import { embeddingMiddleware } from "../embedding.js";
-import { appIdentityMiddleware } from "../app-identity.js";
 import { createContext, useContext } from "react";
 import { createMiddleware, createServerFn, getGlobalStartContext } from "@tanstack/react-start";
 import { getRequestHeader } from "@tanstack/react-start/server";
@@ -35,7 +34,6 @@ import { jsx } from "react/jsx-runtime";
 function softrAuthMiddleware() {
 	return createMiddleware({ type: "request" }).middleware([
 		embeddingMiddleware(),
-		appIdentityMiddleware(),
 		bootErrorMiddleware(),
 		pwaMiddleware(),
 		faviconMiddleware()

package/dist/formatting.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import * as react2 from "react";
+import * as react0 from "react";
 import { ReactNode } from "react";
 
 //#region src/formatting.d.ts
@@ -94,7 +94,7 @@ declare function FormattingScope({
   /** A BCP 47 locale, such as `de-DE`. It drops the app's fixed date format inside the scope. */
   locale?: string;
   children?: ReactNode;
-}): react2.FunctionComponentElement<react2.ProviderProps<Scope>>;
+}): react0.FunctionComponentElement<react0.ProviderProps<Scope>>;
 /**
  * A date in the app's format, safe to render on the server. A timestamp whose
  * zone is not known yet renders `fallback` until the browser supplies it, so
@@ -115,6 +115,6 @@ declare function FormattedDate({
   time?: boolean;
   /** What renders while the visitor's zone is unknown. */
   fallback?: ReactNode;
-}): react2.FunctionComponentElement<react2.FragmentProps>;
+}): react0.FunctionComponentElement<react0.FragmentProps>;
 //#endregion
 export { DateOptions, DateParts, DateSeparator, DateValue, FixedDateFormat, FormattedDate, Formatting, FormattingScope, WeekDay, formatDate, formatDateTime, formatNumber, useFormatting };

package/dist/index.d.ts

@@ -16,5 +16,7 @@ import { useOverrides } from "./core/use-overrides.js";
 import { useUserTimezone } from "./timezone.js";
 import { PwaInstall, PwaPlatform, SoftrPwaHead, usePwaInstall } from "./pwa.js";
 import { DefaultErrorOverlay } from "./default-error-overlay.js";
+import { Agent, AgentChatSummary, listAgents } from "./agent/agent-fns.js";
+import { AgentBlock, AgentChat, AgentChatOptions, AgentMessage, AgentQuestion, AgentTodo, AgentToolCall, useAgentChat } from "./agent/use-agent-chat.js";
 import { Audience } from "./route/audience.js";
-export { type ActionPermissions, Audience, type AuthOptions, type AuthSettings, AuthSettingsProvider, type DateOptions, type DateParts, type DateSeparator, type DateValue, DefaultErrorOverlay, type FieldShape, type FileAttachment, type FileItem, type FixedDateFormat, FormattedDate, type Formatting, FormattingScope, type Page, type PageSettings, type PwaInstall, type PwaPlatform, type SoftrContext, type SoftrDatasources, type SoftrFieldRegistry, SoftrPwaHead, type SoftrUserGroupId, type SoftrUserGroups, type SoftrUserProperties, type User, type WeekDay, assertRouteAccess, checkAccess, defineIntegration, defineMutation, definePage, defineQuery, defineVisibility, defineWorkflow, fieldShape, formatDate, formatDateTime, formatDuration, formatField, formatNumber, formatValue, getAuthSettings, getSoftrContext, guardRoute, initialSoftrContext, isAccessError, isAlreadyAuthenticatedError, isAuthorized, isForbiddenError, isUnauthenticatedError, pageHead, registerSoftrFields, softrAuthMiddleware, softrMcpMiddleware, toReturnPath, useAuthSettings, useCurrentUser, useFileUpload, useFormatting, useOverrides, usePwaInstall, useUserTimezone };
+export { type ActionPermissions, type Agent, type AgentBlock, type AgentChat, type AgentChatOptions, type AgentChatSummary, type AgentMessage, type AgentQuestion, type AgentTodo, type AgentToolCall, Audience, type AuthOptions, type AuthSettings, AuthSettingsProvider, type DateOptions, type DateParts, type DateSeparator, type DateValue, DefaultErrorOverlay, type FieldShape, type FileAttachment, type FileItem, type FixedDateFormat, FormattedDate, type Formatting, FormattingScope, type Page, type PageSettings, type PwaInstall, type PwaPlatform, type SoftrContext, type SoftrDatasources, type SoftrFieldRegistry, SoftrPwaHead, type SoftrUserGroupId, type SoftrUserGroups, type SoftrUserProperties, type User, type WeekDay, assertRouteAccess, checkAccess, defineIntegration, defineMutation, definePage, defineQuery, defineVisibility, defineWorkflow, fieldShape, formatDate, formatDateTime, formatDuration, formatField, formatNumber, formatValue, getAuthSettings, getSoftrContext, guardRoute, initialSoftrContext, isAccessError, isAlreadyAuthenticatedError, isAuthorized, isForbiddenError, isUnauthenticatedError, listAgents, pageHead, registerSoftrFields, softrAuthMiddleware, softrMcpMiddleware, toReturnPath, useAgentChat, useAuthSettings, useCurrentUser, useFileUpload, useFormatting, useOverrides, usePwaInstall, useUserTimezone };

package/dist/index.js

@@ -12,6 +12,8 @@ import { fieldShape, formatDuration, formatField, formatValue, registerSoftrFiel
 import { useOverrides } from "./core/use-overrides.js";
 import { useUserTimezone } from "./timezone.js";
 import { DefaultErrorOverlay } from "./default-error-overlay.js";
+import { listAgents } from "./agent/agent-fns.js";
+import { useAgentChat } from "./agent/use-agent-chat.js";
 import { Audience } from "./route/audience.js";
 
-export { Audience, AuthSettingsProvider, DefaultErrorOverlay, FormattedDate, FormattingScope, SoftrPwaHead, assertRouteAccess, checkAccess, defineIntegration, defineMutation, definePage, defineQuery, defineVisibility, defineWorkflow, fieldShape, formatDate, formatDateTime, formatDuration, formatField, formatNumber, formatValue, getAuthSettings, getSoftrContext, guardRoute, initialSoftrContext, isAccessError, isAlreadyAuthenticatedError, isAuthorized, isForbiddenError, isUnauthenticatedError, pageHead, registerSoftrFields, softrAuthMiddleware, softrMcpMiddleware, toReturnPath, useAuthSettings, useCurrentUser, useFileUpload, useFormatting, useOverrides, usePwaInstall, useUserTimezone };
+export { Audience, AuthSettingsProvider, DefaultErrorOverlay, FormattedDate, FormattingScope, SoftrPwaHead, assertRouteAccess, checkAccess, defineIntegration, defineMutation, definePage, defineQuery, defineVisibility, defineWorkflow, fieldShape, formatDate, formatDateTime, formatDuration, formatField, formatNumber, formatValue, getAuthSettings, getSoftrContext, guardRoute, initialSoftrContext, isAccessError, isAlreadyAuthenticatedError, isAuthorized, isForbiddenError, isUnauthenticatedError, listAgents, pageHead, registerSoftrFields, softrAuthMiddleware, softrMcpMiddleware, toReturnPath, useAgentChat, useAuthSettings, useCurrentUser, useFileUpload, useFormatting, useOverrides, usePwaInstall, useUserTimezone };

package/dist/mcp.d.ts

@@ -1,5 +1,5 @@
 import { DatasourceAction } from "./action.js";
-import * as _tanstack_react_start0 from "@tanstack/react-start";
+import * as _tanstack_react_start6 from "@tanstack/react-start";
 
 //#region src/mcp.d.ts
 
@@ -31,6 +31,6 @@ type SoftrMcpOptions = {
  *   ],
  * }))
  */
-declare function softrMcpMiddleware(options?: SoftrMcpOptions): _tanstack_react_start0.RequestMiddlewareAfterServer<{}, undefined, undefined>;
+declare function softrMcpMiddleware(options?: SoftrMcpOptions): _tanstack_react_start6.RequestMiddlewareAfterServer<{}, undefined, undefined>;
 //#endregion
 export { softrMcpMiddleware };

package/dist/mcp.js

@@ -244,7 +244,8 @@ const WHOAMI = {
 		type: "object",
 		properties: {},
 		additionalProperties: false
-	}
+	},
+	annotations: { readOnlyHint: true }
 };
 /** How many records a read returns when the caller does not say. */
 const DEFAULT_LIMIT = 20;
@@ -265,6 +266,7 @@ function describeTool(action) {
 		case "read": return {
 			name: action.id,
 			description: `Read records from "${action.id}". Returns the fields ${names.join(", ")}. Only records the signed-in user may see come back.`,
+			annotations: { readOnlyHint: true },
 			inputSchema: {
 				type: "object",
 				properties: {
@@ -385,8 +387,10 @@ async function rpc(request, origin, actions) {
 	const token = bearerToken(request);
 	if (token === null) return unauthorized(origin);
 	const session = await platformSession(token);
-	if (!session.ok) return session.refused ? unauthorized(origin) : unavailable();
-	const { sessionToken } = session;
+	let sessionToken;
+	if (session.ok) sessionToken = session.sessionToken;
+	else if (session.refused && await resolveUser(token) !== null) sessionToken = token;
+	else return session.refused ? unauthorized(origin) : unavailable();
 	const body = await readJson(request);
 	const message = z.object({
 		id: z.union([z.string(), z.number()]).optional(),

package/dist/package.js

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "0.0.90-alpha.5";
+var version = "0.0.90-alpha.6";
 
 //#endregion
 export { version };

package/dist/pwa.d.ts

@@ -1,4 +1,4 @@
-import * as react0 from "react";
+import * as react4 from "react";
 import "@tanstack/react-start";
 
 //#region src/pwa.d.ts
@@ -23,7 +23,7 @@ import "@tanstack/react-start";
  *   )
  * }
  */
-declare function SoftrPwaHead(): react0.FunctionComponentElement<react0.FragmentProps>;
+declare function SoftrPwaHead(): react4.FunctionComponentElement<react4.FragmentProps>;
 type PwaPlatform = "ios" | "android" | "desktop";
 type PwaInstall = {
   available: false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softr/sdk",
-  "version": "0.0.90-alpha.5",
+  "version": "0.0.90-alpha.6",
   "type": "module",
   "exports": {
     ".": { "types": "./dist/index.d.ts", "import": "./dist/index.js" },
@@ -21,8 +21,8 @@
   },
   "devDependencies": {
     "@tanstack/intent": "^0.3.6",
-    "@tanstack/react-router": "^1.170.41",
-    "@tanstack/react-start": "^1.168.60",
+    "@tanstack/react-router": "^1.168.0",
+    "@tanstack/react-start": "^1.168.0",
     "@types/node": "^24.3.0",
     "tsdown": "^0.15.0",
     "typescript": "^5.9.2",

package/skills/softr-sdk/SKILL.md

@@ -9,7 +9,7 @@ description: >-
 metadata:
   type: core
   library: softr-sdk
-  library_version: 0.0.90-alpha.5
+  library_version: 0.0.90-alpha.6
 ---
 
 # Softr SDK core
@@ -49,6 +49,7 @@ Each sub-skill stands alone for its task and repeats the boundary above, so most
 | Sign a visitor in, out, or up | [auth/SKILL.md](./auth/SKILL.md) |
 | Call a connected third-party API (Slack, Stripe, Gmail, …) | [integrations/SKILL.md](./integrations/SKILL.md) |
 | Open the app to AI assistants over MCP | [mcp/SKILL.md](./mcp/SKILL.md) |
+| Let visitors chat with a Softr agent | [agent-chat/SKILL.md](./agent-chat/SKILL.md) |
 | Let visitors install the app on their home screen | [pwa/SKILL.md](./pwa/SKILL.md) |
 | Show a date, a time or a number | [formatting/SKILL.md](./formatting/SKILL.md) |
 
@@ -85,6 +86,9 @@ Calling a connected third-party API (Slack, Stripe, Gmail, Google Calendar, …)
 Opening the app to an AI assistant over MCP?
   load softr-sdk/mcp
 
+Adding a chat with one of the app's Softr agents, or a Connect button for the visitor's account it needs?
+  load softr-sdk/agent-chat
+
 Adding an install button, or making the app installable?
   load softr-sdk/pwa