@windmill-labs/chat-sdk 1.846.1 → 1.848.0

package/README.md

@@ -148,6 +148,45 @@ const chat = useWindmillChat({ flowPath: 'f/support/assistant' })
 - **`wmill app dev`**: there is no viewer session on the dev server, so pass
   `baseUrl`, `workspace` and `token` explicitly during development.
 
+### A saved agent, through an agent runnable
+
+To chat with a saved AI agent (an `ai_agent` resource), give the app an **agent
+runnable**: a path runnable of type `agent` naming the agent, picked under "AI agents"
+in the editor, or in `raw_app.yaml`:
+
+```yaml
+runnables:
+  chat:
+    type: agent
+    path: f/support/agent
+```
+
+Each call runs one turn of the agent's chat as the app, so a sandboxed app declares no
+frontend SDK scope, viewers get no consent prompt and need no access to the agent.
+Name the runnable and pass the app's generated `wmill.ts`, which the chat goes through:
+
+```tsx
+import { useWindmillChat } from '@windmill-labs/chat-sdk/react'
+import * as wmill from './wmill'
+
+const chat = useWindmillChat({ wmill, runnable: 'chat' })
+```
+
+`runnable` is checked against the runnables `wmill.ts` declares, and names the local
+history, so two agent runnables in one app keep separate conversations. Going through
+`wmill.ts` is what makes the same code work in a deployed app and under `wmill app dev`.
+
+`createChat` and the assistant-ui runtime take the same options; the AI SDK transport
+does not. The runnable takes `user_message` and `memory_id`, the conversation id, which
+the agent's memory is keyed by, so it remembers earlier turns (called from `wmill.ts`
+without `memory_id`, it is a single run with no conversation). The agent needs managed
+memory: one whose memory is off takes `previous_messages` instead, the history you keep. A signed-in viewer's turns
+are filed under them, so nobody else can continue their conversations; an anonymous
+visitor's are kept apart per app. The chat makes no request of its own: history is
+`'local'` (the app's own storage), `stop()` stops following without cancelling the turn,
+a message sent while it still runs is refused with `TurnRunningError`, and attachments
+are refused.
+
 ## Any framework
 
 `createChat` returns a store: `subscribe` calls the listener immediately and on every
@@ -178,7 +217,7 @@ await chat.sendMessage('Hello')
 
 | Option | |
 |---|---|
-| `flowPath` | Path of the deployed flow, e.g. `f/support/assistant`. Required. |
+| `flowPath` | Path of the deployed flow, e.g. `f/support/assistant`. Required unless `follow` is set. |
 | `baseUrl` | The Windmill origin. Detected inside a raw app. |
 | `workspace` | Detected inside a raw app. |
 | `token` | A token, or a function returning one (called before every request, so it can fetch a short-lived token from your backend). Omit it inside a raw app. |
@@ -190,6 +229,8 @@ await chat.sendMessage('Hello')
 | `pollDelayMs` | How often, in ms, the server polls a running turn for the stream (Enterprise; 50 at the fastest, other servers ignore it). Unset, the server relaxes from 100 ms to 3 s over a long turn; set it when tokens must keep flowing at that pace. |
 | `onFinish`, `onError` | Called when a turn has its answer, or could not run at all. |
 | `run` | Runs the flow for a turn yourself and returns the job id, instead of the deployed flow at `flowPath` (Windmill's editor chats with an undeployed flow through a preview run this way). Pass `memory_id` = the conversation id. |
+| `follow` | With `run`: follows the job through your own client, calling `onStream` with each chunk of its result stream and resolving with its result. The chat then makes no request of its own; `runnable` sets both for a raw app's agent runnable, see [A saved agent](#a-saved-agent-through-an-agent-runnable). |
+| `runnable`, `wmill` | In a raw app, chat through the agent runnable of that name, going through the app's generated module (`import * as wmill from './wmill'`). Replaces `flowPath`, `run` and `follow`. |
 
 ## State
 
@@ -294,7 +335,8 @@ That store is keyed by the **Windmill user**, so it fits a viewer session or a t
 issued per user. With one token shared by every visitor of a site, all visitors would
 see each other's conversations. For that setup use `history: 'local'` (the default
 with an explicit `token`): the conversation list and messages stay in the browser's
-`localStorage`, per Windmill instance, workspace and flow. `'none'` keeps nothing
+`localStorage`, per Windmill instance, workspace and flow, and the chat starts with that
+list in `state.conversations`, without a `loadConversations()` call. `'none'` keeps nothing
 beyond the page.
 
 When the default `'server'` mode turns out unreadable (a token or sandboxed app
@@ -333,7 +375,8 @@ custom integrations.
 When asked to add a chat over a Windmill flow: the flow must be deployed with chat mode
 on. Pick the entry point from the table at the top (`useChat` → `@windmill-labs/chat-sdk/ai-sdk`,
 assistant-ui → `@windmill-labs/chat-sdk/assistant-ui`, otherwise `@windmill-labs/chat-sdk/react`). Inside a
-Windmill raw app pass only `flowPath`. Elsewhere pass `baseUrl`, `workspace` and a
+Windmill raw app pass only `flowPath`; for a saved agent, use an `agent` runnable and pass
+`{ wmill, runnable }`. Elsewhere pass `baseUrl`, `workspace` and a
 `token`; for a public page use a token scoped to `jobs:run:flows:<flowPath>` and leave
 `history` at its default. Render `role`, `content`, `pending`, `success` and
 `tool.status`; never build the SSE handling yourself.

package/dist/assistant-ui.d.ts

@@ -1,21 +1,21 @@
 import { type AssistantRuntime, type ThreadMessageLike } from '@assistant-ui/react';
-import type { ChatMessage, ChatOptions } from './types';
+import type { ChatMessage, RawAppWmill, TypedChatOptions } from './types';
 /** One assistant turn: the assistant and tool rows between two user messages. */
 export interface WindmillTurn {
     id: string;
     role: 'user' | 'assistant' | 'system';
     messages: ChatMessage[];
 }
-export interface WindmillRuntimeOptions extends ChatOptions {
+export type WindmillRuntimeOptions<W extends RawAppWmill = RawAppWmill> = TypedChatOptions<W> & {
     /** Load the conversation list on mount so `ThreadListPrimitive` has something to show. Default true. */
     threadList?: boolean;
-}
+};
 /**
  * An assistant-ui runtime over a chat-mode flow, for `AssistantRuntimeProvider`.
  * Conversations become threads, so the thread list primitives switch, create and
  * delete Windmill conversations.
  */
-export declare function useWindmillRuntime(options: WindmillRuntimeOptions): AssistantRuntime;
+export declare function useWindmillRuntime<W extends RawAppWmill>(options: WindmillRuntimeOptions<W>): AssistantRuntime;
 /** Folds the role-per-row message list into turns: one entry per user message, one per answer. */
 export declare function groupTurns(messages: ChatMessage[]): WindmillTurn[];
 /** A turn as assistant-ui content parts; the status reflects streaming and a failed flow. */

package/dist/{chat-u1tspn7Q.cjs → chat-C0iOSX6H.cjs}

@@ -1,4 +1,29 @@
 const require_follow = require("./follow-Dug-Afeu.cjs");
+//#region src/runnable.ts
+/**
+* `run` and `follow` over a raw app's agent runnable (a path runnable of type `agent`, naming
+* a saved AI agent), behind the `runnable` option. `memory_id` is the conversation id, the
+* agent's memory key.
+*/
+function rawAppRunnable(start, streamJob) {
+	return {
+		run: async (args, { conversationId }) => {
+			try {
+				return String(await start({
+					...args,
+					memory_id: conversationId
+				}));
+			} catch (e) {
+				const text = e instanceof Error ? e.message : String(e);
+				throw require_follow.turnRunningError(text.slice(text.indexOf("{"), text.lastIndexOf("}") + 1)) ?? e;
+			}
+		},
+		follow: (jobId, onStream) => streamJob(jobId, (update) => {
+			if (update.new_result_stream) onStream(update.new_result_stream);
+		})
+	};
+}
+//#endregion
 //#region src/config.ts
 /**
 * The Windmill a raw app bundle runs in. A sandboxed app gets `window.process.env`
@@ -22,19 +47,32 @@ function detectRawApp() {
 	};
 }
 function resolveConfig(options) {
-	if (!options.flowPath) throw new Error("windmill-chat: flowPath is required");
+	if (options.runnable !== void 0) {
+		if (!options.wmill) throw new Error("windmill-chat: `runnable` needs `wmill`, the app's generated module");
+		if (options.flowPath || options.run || options.follow) throw new Error("windmill-chat: `runnable` replaces `flowPath`, `run` and `follow`");
+		const app = globalThis.ctx?.path;
+		options = {
+			...options,
+			...rawAppRunnable(options.wmill.backendAsync[options.runnable], options.wmill.streamJob),
+			flowPath: `runnable:${typeof app === "string" ? `${app}:` : ""}${options.runnable}`
+		};
+	}
+	const follow = options.follow;
+	if (follow && !options.run) throw new Error("windmill-chat: `follow` needs `run`, which starts the job it follows");
+	if (follow && options.history === "server") throw new Error("windmill-chat: server history is read with the SDK's own requests, which `follow` replaces");
+	if (!options.flowPath && !follow) throw new Error("windmill-chat: flowPath is required");
 	const explicitToken = options.token !== void 0;
 	const detected = options.baseUrl && options.workspace && explicitToken ? void 0 : detectRawApp();
 	const baseUrl = options.baseUrl ?? detected?.baseUrl;
 	const workspace = options.workspace ?? detected?.workspace;
-	if (!baseUrl || !workspace) throw new Error("windmill-chat: pass baseUrl and workspace. They are only detected inside a raw app: an unsandboxed one on the Windmill origin, or a sandboxed one whose policy declares frontend SDK scopes.");
+	if ((!baseUrl || !workspace) && !follow) throw new Error("windmill-chat: pass baseUrl and workspace. They are only detected inside a raw app: an unsandboxed one on the Windmill origin, or a sandboxed one whose policy declares frontend SDK scopes.");
 	const token = options.token ?? (options.baseUrl === void 0 || options.baseUrl === detected?.baseUrl ? detected?.token : void 0);
 	return {
-		flowPath: options.flowPath,
-		baseUrl,
-		workspace,
+		flowPath: options.flowPath ?? "",
+		baseUrl: baseUrl ?? "",
+		workspace: workspace ?? "",
 		token,
-		history: options.history ?? (explicitToken ? "local" : "server"),
+		history: options.history ?? (explicitToken || follow ? "local" : "server"),
 		historyExplicit: options.history !== void 0,
 		inputs: options.inputs ?? {},
 		fetch: options.fetch,
@@ -43,6 +81,7 @@ function resolveConfig(options) {
 		pageSize: options.pageSize ?? 50,
 		pollDelayMs: options.pollDelayMs,
 		run: options.run,
+		follow,
 		onFinish: options.onFinish,
 		onError: options.onError
 	};
@@ -188,7 +227,8 @@ async function uploadAttachments(api, attachments, turnId, signal) {
 		const results = await Promise.allSettled(attachments.map(async (attachment, index) => {
 			try {
 				const blob = attachmentBlob(attachment);
-				const filename = storedAttachmentName(attachment.name || `attachment-${index + 1}`, blob.type);
+				const name = attachment.name?.split(/[\\/]/).pop()?.replace(/^\.+$/, "");
+				const filename = storedAttachmentName(name || `attachment-${index + 1}`, blob.type);
 				const { file_key } = await api.uploadFile(`${prefix}/${index}/${filename}`, blob, {
 					contentType: blob.type,
 					signal: batch.signal
@@ -267,6 +307,7 @@ var ChatImpl = class {
 			const attachments = options.attachments ?? [];
 			const attachmentsInput = options.attachmentsInput;
 			if (attachments.length > 0 && !attachmentsInput) throw new Error("windmill-chat: attachments need `attachmentsInput`, the flow input that takes them");
+			if (attachments.length > 0 && require_follow._classPrivateFieldGet2(_config, this).follow) throw new Error("windmill-chat: attachments upload with the SDK's own requests, which `follow` replaces");
 			if (attachmentsInput && !attachmentsInput.multiple && attachments.length > 1) throw new Error(`windmill-chat: \`${attachmentsInput.name}\` holds one file; got ${attachments.length}`);
 			const isNew = require_follow._classPrivateFieldGet2(_state, this).conversationId === void 0;
 			const conversationId = require_follow._classPrivateFieldGet2(_state, this).conversationId ?? require_follow.randomId();
@@ -429,7 +470,7 @@ var ChatImpl = class {
 				});
 				require_follow._assertClassBrand(_ChatImpl_brand, this, _persistLocal).call(this);
 			}
-			if (turn.jobId) await require_follow._classPrivateFieldGet2(_api, this).cancelJob(turn.jobId).catch(() => {});
+			if (turn.jobId && !require_follow._classPrivateFieldGet2(_config, this).follow) await require_follow._classPrivateFieldGet2(_api, this).cancelJob(turn.jobId).catch(() => {});
 			if (require_follow._classPrivateFieldGet2(_state, this).history !== "server") return;
 			await require_follow.sleep(RECONCILE_DELAY_MS).catch(() => {});
 			if (require_follow._classPrivateFieldGet2(_turn, this) || require_follow._classPrivateFieldGet2(_state, this).conversationId !== turn.conversationId) return;
@@ -560,7 +601,7 @@ var ChatImpl = class {
 			messages: [],
 			status: "idle",
 			error: void 0,
-			conversations: [],
+			conversations: require_follow._classPrivateFieldGet2(_config, this).history === "local" ? require_follow._classPrivateFieldGet2(_local, this).listConversations() : [],
 			history: require_follow._classPrivateFieldGet2(_config, this).history,
 			loadingMessages: false,
 			hasMoreMessages: false
@@ -635,6 +676,26 @@ async function _select(conversationId) {
 }
 async function _follow(turn, onStreamStart) {
 	let started = false;
+	const { follow } = require_follow._classPrivateFieldGet2(_config, this);
+	if (follow) {
+		const { signal } = turn.controller;
+		const parser = require_follow.createStreamEventParser();
+		const onStream = (chunk) => {
+			if (signal.aborted) return;
+			if (!started) {
+				started = true;
+				onStreamStart();
+			}
+			require_follow._assertClassBrand(_ChatImpl_brand, this, _applyEvents).call(this, turn, parser.push(chunk));
+		};
+		const aborted = new Promise((_, reject) => {
+			if (signal.aborted) reject(require_follow.abortError());
+			signal.addEventListener("abort", () => reject(require_follow.abortError()), { once: true });
+		});
+		const result = await Promise.race([follow(turn.jobId, onStream, { signal }), aborted]);
+		require_follow._assertClassBrand(_ChatImpl_brand, this, _applyEvents).call(this, turn, parser.flush());
+		return result;
+	}
 	for await (const event of require_follow.followJob(require_follow._classPrivateFieldGet2(_api, this), turn.jobId, { signal: turn.controller.signal })) {
 		if (event.type === "completed") {
 			if (event.streamLost) require_follow._assertClassBrand(_ChatImpl_brand, this, _dropCutRound).call(this, turn);
@@ -772,7 +833,7 @@ async function _finishTurn(turn, result, isNew) {
 	let messages = require_follow._classPrivateFieldGet2(_state, this).messages;
 	let failed = false;
 	if (require_follow.isErrorResult(result)) {
-		failed = await require_follow._classPrivateFieldGet2(_api, this).getCompletedResult(turn.jobId, turn.controller.signal).then((r) => r.success === false).catch(() => true);
+		failed = require_follow._classPrivateFieldGet2(_config, this).follow ? true : await require_follow._classPrivateFieldGet2(_api, this).getCompletedResult(turn.jobId, turn.controller.signal).then((r) => r.success === false).catch(() => true);
 		if (!require_follow._assertClassBrand(_ChatImpl_brand, this, _turnActive).call(this, turn)) return;
 		if (failed) messages = [...messages, assistantMessage(require_follow.errorResultMessage(result), false, turn.jobId)];
 	}

package/dist/{chat-DgINfcUU.js → chat-DjonfE4j.js}

@@ -1,4 +1,29 @@
-import { C as _assertClassBrand, S as _classPrivateFieldSet2, T as _classPrivateMethodInitSpec, _ as WindmillApiError, a as errorResultMessage, c as isErrorResult, d as randomId, f as sleep, g as TurnRunningError, i as conversationTitle, l as now, n as abortError, o as extractChatAnswer, p as truncateTitle, s as isAbortError, t as followJob, v as WindmillChatApi, w as _classPrivateFieldInitSpec, x as _classPrivateFieldGet2 } from "./follow-DXfmfPfr.js";
+import { C as _assertClassBrand, S as _classPrivateFieldSet2, T as _classPrivateMethodInitSpec, _ as WindmillApiError, a as errorResultMessage, b as turnRunningError, c as isErrorResult, d as randomId, f as sleep, g as TurnRunningError, i as conversationTitle, l as now, m as createStreamEventParser, n as abortError, o as extractChatAnswer, p as truncateTitle, s as isAbortError, t as followJob, v as WindmillChatApi, w as _classPrivateFieldInitSpec, x as _classPrivateFieldGet2 } from "./follow-DXfmfPfr.js";
+//#region src/runnable.ts
+/**
+* `run` and `follow` over a raw app's agent runnable (a path runnable of type `agent`, naming
+* a saved AI agent), behind the `runnable` option. `memory_id` is the conversation id, the
+* agent's memory key.
+*/
+function rawAppRunnable(start, streamJob) {
+	return {
+		run: async (args, { conversationId }) => {
+			try {
+				return String(await start({
+					...args,
+					memory_id: conversationId
+				}));
+			} catch (e) {
+				const text = e instanceof Error ? e.message : String(e);
+				throw turnRunningError(text.slice(text.indexOf("{"), text.lastIndexOf("}") + 1)) ?? e;
+			}
+		},
+		follow: (jobId, onStream) => streamJob(jobId, (update) => {
+			if (update.new_result_stream) onStream(update.new_result_stream);
+		})
+	};
+}
+//#endregion
 //#region src/config.ts
 /**
 * The Windmill a raw app bundle runs in. A sandboxed app gets `window.process.env`
@@ -22,19 +47,32 @@ function detectRawApp() {
 	};
 }
 function resolveConfig(options) {
-	if (!options.flowPath) throw new Error("windmill-chat: flowPath is required");
+	if (options.runnable !== void 0) {
+		if (!options.wmill) throw new Error("windmill-chat: `runnable` needs `wmill`, the app's generated module");
+		if (options.flowPath || options.run || options.follow) throw new Error("windmill-chat: `runnable` replaces `flowPath`, `run` and `follow`");
+		const app = globalThis.ctx?.path;
+		options = {
+			...options,
+			...rawAppRunnable(options.wmill.backendAsync[options.runnable], options.wmill.streamJob),
+			flowPath: `runnable:${typeof app === "string" ? `${app}:` : ""}${options.runnable}`
+		};
+	}
+	const follow = options.follow;
+	if (follow && !options.run) throw new Error("windmill-chat: `follow` needs `run`, which starts the job it follows");
+	if (follow && options.history === "server") throw new Error("windmill-chat: server history is read with the SDK's own requests, which `follow` replaces");
+	if (!options.flowPath && !follow) throw new Error("windmill-chat: flowPath is required");
 	const explicitToken = options.token !== void 0;
 	const detected = options.baseUrl && options.workspace && explicitToken ? void 0 : detectRawApp();
 	const baseUrl = options.baseUrl ?? detected?.baseUrl;
 	const workspace = options.workspace ?? detected?.workspace;
-	if (!baseUrl || !workspace) throw new Error("windmill-chat: pass baseUrl and workspace. They are only detected inside a raw app: an unsandboxed one on the Windmill origin, or a sandboxed one whose policy declares frontend SDK scopes.");
+	if ((!baseUrl || !workspace) && !follow) throw new Error("windmill-chat: pass baseUrl and workspace. They are only detected inside a raw app: an unsandboxed one on the Windmill origin, or a sandboxed one whose policy declares frontend SDK scopes.");
 	const token = options.token ?? (options.baseUrl === void 0 || options.baseUrl === detected?.baseUrl ? detected?.token : void 0);
 	return {
-		flowPath: options.flowPath,
-		baseUrl,
-		workspace,
+		flowPath: options.flowPath ?? "",
+		baseUrl: baseUrl ?? "",
+		workspace: workspace ?? "",
 		token,
-		history: options.history ?? (explicitToken ? "local" : "server"),
+		history: options.history ?? (explicitToken || follow ? "local" : "server"),
 		historyExplicit: options.history !== void 0,
 		inputs: options.inputs ?? {},
 		fetch: options.fetch,
@@ -43,6 +81,7 @@ function resolveConfig(options) {
 		pageSize: options.pageSize ?? 50,
 		pollDelayMs: options.pollDelayMs,
 		run: options.run,
+		follow,
 		onFinish: options.onFinish,
 		onError: options.onError
 	};
@@ -188,7 +227,8 @@ async function uploadAttachments(api, attachments, turnId, signal) {
 		const results = await Promise.allSettled(attachments.map(async (attachment, index) => {
 			try {
 				const blob = attachmentBlob(attachment);
-				const filename = storedAttachmentName(attachment.name || `attachment-${index + 1}`, blob.type);
+				const name = attachment.name?.split(/[\\/]/).pop()?.replace(/^\.+$/, "");
+				const filename = storedAttachmentName(name || `attachment-${index + 1}`, blob.type);
 				const { file_key } = await api.uploadFile(`${prefix}/${index}/${filename}`, blob, {
 					contentType: blob.type,
 					signal: batch.signal
@@ -267,6 +307,7 @@ var ChatImpl = class {
 			const attachments = options.attachments ?? [];
 			const attachmentsInput = options.attachmentsInput;
 			if (attachments.length > 0 && !attachmentsInput) throw new Error("windmill-chat: attachments need `attachmentsInput`, the flow input that takes them");
+			if (attachments.length > 0 && _classPrivateFieldGet2(_config, this).follow) throw new Error("windmill-chat: attachments upload with the SDK's own requests, which `follow` replaces");
 			if (attachmentsInput && !attachmentsInput.multiple && attachments.length > 1) throw new Error(`windmill-chat: \`${attachmentsInput.name}\` holds one file; got ${attachments.length}`);
 			const isNew = _classPrivateFieldGet2(_state, this).conversationId === void 0;
 			const conversationId = _classPrivateFieldGet2(_state, this).conversationId ?? randomId();
@@ -429,7 +470,7 @@ var ChatImpl = class {
 				});
 				_assertClassBrand(_ChatImpl_brand, this, _persistLocal).call(this);
 			}
-			if (turn.jobId) await _classPrivateFieldGet2(_api, this).cancelJob(turn.jobId).catch(() => {});
+			if (turn.jobId && !_classPrivateFieldGet2(_config, this).follow) await _classPrivateFieldGet2(_api, this).cancelJob(turn.jobId).catch(() => {});
 			if (_classPrivateFieldGet2(_state, this).history !== "server") return;
 			await sleep(RECONCILE_DELAY_MS).catch(() => {});
 			if (_classPrivateFieldGet2(_turn, this) || _classPrivateFieldGet2(_state, this).conversationId !== turn.conversationId) return;
@@ -560,7 +601,7 @@ var ChatImpl = class {
 			messages: [],
 			status: "idle",
 			error: void 0,
-			conversations: [],
+			conversations: _classPrivateFieldGet2(_config, this).history === "local" ? _classPrivateFieldGet2(_local, this).listConversations() : [],
 			history: _classPrivateFieldGet2(_config, this).history,
 			loadingMessages: false,
 			hasMoreMessages: false
@@ -635,6 +676,26 @@ async function _select(conversationId) {
 }
 async function _follow(turn, onStreamStart) {
 	let started = false;
+	const { follow } = _classPrivateFieldGet2(_config, this);
+	if (follow) {
+		const { signal } = turn.controller;
+		const parser = createStreamEventParser();
+		const onStream = (chunk) => {
+			if (signal.aborted) return;
+			if (!started) {
+				started = true;
+				onStreamStart();
+			}
+			_assertClassBrand(_ChatImpl_brand, this, _applyEvents).call(this, turn, parser.push(chunk));
+		};
+		const aborted = new Promise((_, reject) => {
+			if (signal.aborted) reject(abortError());
+			signal.addEventListener("abort", () => reject(abortError()), { once: true });
+		});
+		const result = await Promise.race([follow(turn.jobId, onStream, { signal }), aborted]);
+		_assertClassBrand(_ChatImpl_brand, this, _applyEvents).call(this, turn, parser.flush());
+		return result;
+	}
 	for await (const event of followJob(_classPrivateFieldGet2(_api, this), turn.jobId, { signal: turn.controller.signal })) {
 		if (event.type === "completed") {
 			if (event.streamLost) _assertClassBrand(_ChatImpl_brand, this, _dropCutRound).call(this, turn);
@@ -772,7 +833,7 @@ async function _finishTurn(turn, result, isNew) {
 	let messages = _classPrivateFieldGet2(_state, this).messages;
 	let failed = false;
 	if (isErrorResult(result)) {
-		failed = await _classPrivateFieldGet2(_api, this).getCompletedResult(turn.jobId, turn.controller.signal).then((r) => r.success === false).catch(() => true);
+		failed = _classPrivateFieldGet2(_config, this).follow ? true : await _classPrivateFieldGet2(_api, this).getCompletedResult(turn.jobId, turn.controller.signal).then((r) => r.success === false).catch(() => true);
 		if (!_assertClassBrand(_ChatImpl_brand, this, _turnActive).call(this, turn)) return;
 		if (failed) messages = [...messages, assistantMessage(errorResultMessage(result), false, turn.jobId)];
 	}

package/dist/chat.d.ts

@@ -1,2 +1,2 @@
-import type { Chat, ChatOptions } from './types';
-export declare function createChat(options: ChatOptions): Chat;
+import type { Chat, RawAppWmill, TypedChatOptions } from './types';
+export declare function createChat<W extends RawAppWmill>(options: TypedChatOptions<W>): Chat;

package/dist/config.d.ts

@@ -14,6 +14,7 @@ export interface ResolvedConfig {
     pageSize: number;
     pollDelayMs: number | undefined;
     run: ChatOptions['run'];
+    follow: ChatOptions['follow'];
     onFinish: ChatOptions['onFinish'];
     onError: ChatOptions['onError'];
 }

package/dist/index.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_follow = require("./follow-Dug-Afeu.cjs");
-const require_chat = require("./chat-u1tspn7Q.cjs");
+const require_chat = require("./chat-C0iOSX6H.cjs");
 exports.CHAT_UPLOADS_PREFIX = require_chat.CHAT_UPLOADS_PREFIX;
 exports.TurnRunningError = require_follow.TurnRunningError;
 exports.WindmillApiError = require_follow.WindmillApiError;

package/dist/index.d.ts

@@ -5,4 +5,4 @@ export { parseStreamEvents, createStreamEventParser, type AgentStreamEvent } fro
 export { followJob, type FollowEvent } from './follow';
 export { extractChatAnswer, conversationIdFor } from './utils';
 export { storedAttachmentName, uploadAttachments, CHAT_UPLOADS_PREFIX, type UploadedAttachment } from './attachments';
-export type { AttachmentsInput, AttachmentUpload, Chat, ChatAttachment, ChatMessage, ChatOptions, ChatRole, ChatState, ChatStatus, Conversation, FetchLike, HistoryMode, SendMessageOptions, StorageLike, TokenSource, ToolInvocation } from './types';
+export type { AttachmentsInput, AttachmentUpload, Chat, ChatAttachment, ChatMessage, ChatOptions, ChatRole, ChatState, ChatStatus, Conversation, FetchLike, HistoryMode, RawAppWmill, TypedChatOptions, SendMessageOptions, StorageLike, TokenSource, ToolInvocation } from './types';

package/dist/index.js

@@ -1,3 +1,3 @@
 import { _ as WindmillApiError, b as turnRunningError, g as TurnRunningError, h as parseStreamEvents, m as createStreamEventParser, o as extractChatAnswer, r as conversationIdFor, t as followJob, v as WindmillChatApi, y as readServerSentEvents } from "./follow-DXfmfPfr.js";
-import { a as detectRawApp, i as uploadAttachments, n as CHAT_UPLOADS_PREFIX, r as storedAttachmentName, t as createChat } from "./chat-DgINfcUU.js";
+import { a as detectRawApp, i as uploadAttachments, n as CHAT_UPLOADS_PREFIX, r as storedAttachmentName, t as createChat } from "./chat-DjonfE4j.js";
 export { CHAT_UPLOADS_PREFIX, TurnRunningError, WindmillApiError, WindmillChatApi, conversationIdFor, createChat, createStreamEventParser, detectRawApp, extractChatAnswer, followJob, parseStreamEvents, readServerSentEvents, storedAttachmentName, turnRunningError, uploadAttachments };

package/dist/react.cjs

@@ -1,16 +1,16 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_chat = require("./chat-u1tspn7Q.cjs");
+const require_chat = require("./chat-C0iOSX6H.cjs");
 let react = require("react");
 //#region src/react.ts
 /**
 * A chat on a chat-mode flow. The chat is created once per `flowPath`, `baseUrl`,
-* `workspace`, `history`, `storageKey`, credential and presence of `run`, and
+* `workspace`, `history`, `storageKey`, credential and presence of `run` and `follow`, and
 * destroyed on unmount. A credential change is a new user, whose chat must not
 * carry the previous one's state: a different token string, or a switch between no
 * token, a token string and a token function, all recreate it. A token function is
 * read through a ref on every call, so a new closure per render changes what the
 * next call runs and nothing else; pass a `storageKey` per user when local history
-* must not be shared. `run`, the callbacks and `inputs` are read the same way: the
+* must not be shared. `run`, `follow`, the callbacks and `inputs` are read the same way: the
 * latest render's values go with the next message.
 */
 function useWindmillChat(options) {
@@ -18,6 +18,7 @@ function useWindmillChat(options) {
 	latest.current = options;
 	const credential = typeof options.token === "function" ? "fn" : typeof options.token === "string" ? `str:${options.token}` : "none";
 	const customRun = options.run !== void 0;
+	const customFollow = options.follow !== void 0;
 	const chat = (0, react.useMemo)(() => require_chat.createChat({
 		...options,
 		inputs: void 0,
@@ -26,16 +27,20 @@ function useWindmillChat(options) {
 			return typeof token === "function" ? token() : token ?? "";
 		} : options.token,
 		run: customRun ? (args, turn) => (latest.current.run ?? options.run)(args, turn) : void 0,
+		follow: customFollow ? (jobId, onStream, turn) => (latest.current.follow ?? options.follow)(jobId, onStream, turn) : void 0,
 		onFinish: (turn) => latest.current.onFinish?.(turn),
 		onError: (error, turn) => latest.current.onError?.(error, turn)
 	}), [
 		options.flowPath,
+		options.runnable,
+		options.wmill,
 		options.baseUrl,
 		options.workspace,
 		options.history,
 		options.storageKey,
 		credential,
-		customRun
+		customRun,
+		customFollow
 	]);
 	(0, react.useEffect)(() => () => chat.destroy(), [chat]);
 	const state = (0, react.useSyncExternalStore)(chat.subscribe, chat.getState, chat.getState);

package/dist/react.d.ts

@@ -1,16 +1,16 @@
-import type { Chat, ChatOptions, ChatState } from './types';
+import type { Chat, ChatState, RawAppWmill, TypedChatOptions } from './types';
 export type UseWindmillChat = ChatState & Pick<Chat, 'sendMessage' | 'resumeTurn' | 'stop' | 'newConversation' | 'selectConversation' | 'loadConversations' | 'deleteConversation' | 'renameConversation' | 'loadOlderMessages' | 'refreshMessages'> & {
     chat: Chat;
 };
 /**
  * A chat on a chat-mode flow. The chat is created once per `flowPath`, `baseUrl`,
- * `workspace`, `history`, `storageKey`, credential and presence of `run`, and
+ * `workspace`, `history`, `storageKey`, credential and presence of `run` and `follow`, and
  * destroyed on unmount. A credential change is a new user, whose chat must not
  * carry the previous one's state: a different token string, or a switch between no
  * token, a token string and a token function, all recreate it. A token function is
  * read through a ref on every call, so a new closure per render changes what the
  * next call runs and nothing else; pass a `storageKey` per user when local history
- * must not be shared. `run`, the callbacks and `inputs` are read the same way: the
+ * must not be shared. `run`, `follow`, the callbacks and `inputs` are read the same way: the
  * latest render's values go with the next message.
  */
-export declare function useWindmillChat(options: ChatOptions): UseWindmillChat;
+export declare function useWindmillChat<W extends RawAppWmill>(options: TypedChatOptions<W>): UseWindmillChat;

package/dist/react.js

@@ -1,15 +1,15 @@
-import { t as createChat } from "./chat-DgINfcUU.js";
+import { t as createChat } from "./chat-DjonfE4j.js";
 import { useEffect, useMemo, useRef, useSyncExternalStore } from "react";
 //#region src/react.ts
 /**
 * A chat on a chat-mode flow. The chat is created once per `flowPath`, `baseUrl`,
-* `workspace`, `history`, `storageKey`, credential and presence of `run`, and
+* `workspace`, `history`, `storageKey`, credential and presence of `run` and `follow`, and
 * destroyed on unmount. A credential change is a new user, whose chat must not
 * carry the previous one's state: a different token string, or a switch between no
 * token, a token string and a token function, all recreate it. A token function is
 * read through a ref on every call, so a new closure per render changes what the
 * next call runs and nothing else; pass a `storageKey` per user when local history
-* must not be shared. `run`, the callbacks and `inputs` are read the same way: the
+* must not be shared. `run`, `follow`, the callbacks and `inputs` are read the same way: the
 * latest render's values go with the next message.
 */
 function useWindmillChat(options) {
@@ -17,6 +17,7 @@ function useWindmillChat(options) {
 	latest.current = options;
 	const credential = typeof options.token === "function" ? "fn" : typeof options.token === "string" ? `str:${options.token}` : "none";
 	const customRun = options.run !== void 0;
+	const customFollow = options.follow !== void 0;
 	const chat = useMemo(() => createChat({
 		...options,
 		inputs: void 0,
@@ -25,16 +26,20 @@ function useWindmillChat(options) {
 			return typeof token === "function" ? token() : token ?? "";
 		} : options.token,
 		run: customRun ? (args, turn) => (latest.current.run ?? options.run)(args, turn) : void 0,
+		follow: customFollow ? (jobId, onStream, turn) => (latest.current.follow ?? options.follow)(jobId, onStream, turn) : void 0,
 		onFinish: (turn) => latest.current.onFinish?.(turn),
 		onError: (error, turn) => latest.current.onError?.(error, turn)
 	}), [
 		options.flowPath,
+		options.runnable,
+		options.wmill,
 		options.baseUrl,
 		options.workspace,
 		options.history,
 		options.storageKey,
 		credential,
-		customRun
+		customRun,
+		customFollow
 	]);
 	useEffect(() => () => chat.destroy(), [chat]);
 	const state = useSyncExternalStore(chat.subscribe, chat.getState, chat.getState);

package/dist/runnable.d.ts

@@ -0,0 +1,9 @@
+import type { ChatOptions } from './types';
+/**
+ * `run` and `follow` over a raw app's agent runnable (a path runnable of type `agent`, naming
+ * a saved AI agent), behind the `runnable` option. `memory_id` is the conversation id, the
+ * agent's memory key.
+ */
+export declare function rawAppRunnable(start: (args: any) => Promise<string>, streamJob: (jobId: string, onUpdate?: (update: {
+    new_result_stream?: string;
+}) => void) => Promise<unknown>): Required<Pick<ChatOptions, 'run' | 'follow'>>;

package/dist/types.d.ts

@@ -81,9 +81,33 @@ export interface ChatState {
 export type TokenSource = string | (() => string | Promise<string>);
 export type StorageLike = Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>;
 export type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+/** A raw app's generated `wmill.ts`, as far as a chat uses it. */
+export interface RawAppWmill {
+    backendAsync: Record<string, (args: any) => Promise<string>>;
+    streamJob: (jobId: string, onUpdate?: (update: {
+        new_result_stream?: string;
+    }) => void) => Promise<unknown>;
+}
+/** `ChatOptions` whose `runnable` must name one of `wmill`'s runnables. */
+export type TypedChatOptions<W extends RawAppWmill> = ChatOptions & {
+    wmill?: W;
+    runnable?: keyof W['backendAsync'] & string;
+};
 export interface ChatOptions {
-    /** Path of a deployed flow with chat mode enabled, e.g. `f/support/assistant`. */
-    flowPath: string;
+    /**
+     * Path of a deployed flow with chat mode enabled, e.g. `f/support/assistant`. Required
+     * unless `runnable` or `follow` is set, where it only names the local history.
+     */
+    flowPath?: string;
+    /**
+     * In a raw app, chat through its agent runnable of this name instead of a flow:
+     * `{ wmill, runnable: 'chat' }`. Each turn runs as the app, so a sandboxed app needs no
+     * frontend SDK scope and its viewers no access to the agent; the chat follows it as
+     * with `follow`. It also names the local history, so each runnable keeps its own.
+     */
+    runnable?: string;
+    /** The app's generated module, `import * as wmill from './wmill'`, which `runnable` goes through. */
+    wmill?: RawAppWmill;
     /** Windmill origin, e.g. `https://app.windmill.dev`. Detected inside a raw app. */
     baseUrl?: string;
     /** Detected inside a raw app. */
@@ -124,6 +148,17 @@ export interface ChatOptions {
         conversationId: string;
         signal: AbortSignal;
     }) => Promise<string>;
+    /**
+     * Follows the job `run` returned through your own client instead of the SDK's requests:
+     * call `onStream` with each chunk of the job's result stream and resolve with its result.
+     * With it the chat makes no request of its own, so it needs no credential, `baseUrl` or
+     * `workspace`, and in exchange history is `local` (or `none`), `stop()` stops following
+     * without cancelling the job, and attachments are refused. `runnable` sets both for a raw
+     * app's agent runnable.
+     */
+    follow?: (jobId: string, onStream: (chunk: string) => void, turn: {
+        signal: AbortSignal;
+    }) => Promise<unknown>;
     /** Called once a turn has its answer (a failed flow included: its error is the answer). */
     onFinish?: (turn: {
         conversationId: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@windmill-labs/chat-sdk",
   "description": "Build chat interfaces on Windmill flows deployed in chat mode, from any frontend or raw app",
-  "version": "1.846.1",
+  "version": "1.848.0",
   "author": "Ruben Fiszel",
   "license": "Apache-2.0",
   "homepage": "https://github.com/windmill-labs/windmill/tree/main/chat-sdk#readme",