@windmill-labs/chat-sdk 0.0.0-stage → 1.830.0

package/README.md

@@ -1,3 +1,339 @@
-# Temporary Holding Version
+# @windmill-labs/chat-sdk
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Build a chat interface on a Windmill flow deployed in **chat mode**, from any frontend
+or from a Windmill raw app. The library is headless: it runs the flow, follows the
+answer as it streams, keeps the conversation history, and hands you state to render.
+
+```
+npm install @windmill-labs/chat-sdk
+```
+
+No runtime dependencies. Optional peers: `react` for `@windmill-labs/chat-sdk/react`, `ai` for
+`@windmill-labs/chat-sdk/ai-sdk`, `@assistant-ui/react` for `@windmill-labs/chat-sdk/assistant-ui`.
+
+| You build the UI with | Import | You get |
+|---|---|---|
+| Vercel AI SDK `useChat`, AI Elements | `@windmill-labs/chat-sdk/ai-sdk` | a `ChatTransport`: `useChat({ transport })`, nothing else changes |
+| assistant-ui | `@windmill-labs/chat-sdk/assistant-ui` | a runtime for `AssistantRuntimeProvider`, threads included |
+| Your own components | `@windmill-labs/chat-sdk/react` or `@windmill-labs/chat-sdk` | a hook / a store with messages, status and actions |
+
+## The flow
+
+Any deployed flow with **Chat mode** enabled in its settings works. Windmill passes the
+message as the `user_message` input and threads the conversation through `memory_id`,
+so an AI agent step remembers earlier turns. The answer is:
+
+- what the last step streams, when it is an AI agent step;
+- otherwise the flow's result: its `windmill_chat_answer` field when it has one, a
+  string as is, anything else as JSON.
+
+## Vercel AI SDK (`useChat`, AI Elements)
+
+```tsx
+import { useChat } from '@ai-sdk/react'
+import { createWindmillChatTransport } from '@windmill-labs/chat-sdk/ai-sdk'
+
+const transport = createWindmillChatTransport({
+  baseUrl: 'https://app.windmill.dev',
+  workspace: 'acme',
+  flowPath: 'f/support/assistant',
+  token: () => fetch('/api/windmill-token').then((r) => r.text())
+})
+
+export function Support() {
+  const { messages, status, sendMessage, stop } = useChat({ id: conversationId, transport })
+  // render `messages[i].parts`: text, reasoning and dynamic-tool parts, as with any AI SDK backend
+}
+```
+
+The chat `id` is the conversation: reuse it to continue one, and pass a UUID when you
+also read server history, so it matches what `flow_conversations` stores (any other id
+maps to a fixed UUID). `sendMessage(msg, { body })` sends extra flow inputs. Tool calls
+arrive as `dynamic-tool` parts (`input-available → output-available | output-error`),
+which AI Elements' `<Tool>` renders as is. A failed flow surfaces as `error`.
+`regenerate()` runs the flow again with the same message: a new turn on the server,
+not a replacement of the previous answer.
+
+The transport also carries the history helpers: `transport.loadMessages(id)` returns
+`UIMessage`s for `useChat({ messages })` or `setMessages`, `transport.listConversations()`
+and `transport.deleteConversation(id)`. A loaded user message lists the files it carried
+in `metadata.attachments`; `WindmillChatApi.attachmentUrl` gives each one's download URL.
+Sending attachments is not supported: `sendMessage` with `files` is refused with an
+explanatory error.
+
+## assistant-ui
+
+```tsx
+import { AssistantRuntimeProvider } from '@assistant-ui/react'
+import { useWindmillRuntime } from '@windmill-labs/chat-sdk/assistant-ui'
+
+export function Support() {
+  const runtime = useWindmillRuntime({ baseUrl, workspace, flowPath, token })
+  return (
+    <AssistantRuntimeProvider runtime={runtime}>
+      <Thread /> {/* your assistant-ui components, thread list included */}
+    </AssistantRuntimeProvider>
+  )
+}
+```
+
+Conversations are threads: `ThreadListPrimitive` switches, creates and deletes them.
+Tool calls render through your `tools` components (`MessagePrimitive.Parts`), reasoning
+through `Reasoning`. It takes the same options as `useWindmillChat` below.
+
+## React
+
+```tsx
+import { useWindmillChat } from '@windmill-labs/chat-sdk/react'
+
+export function Support() {
+  const chat = useWindmillChat({
+    baseUrl: 'https://app.windmill.dev',
+    workspace: 'acme',
+    flowPath: 'f/support/assistant',
+    token: () => fetch('/api/windmill-token').then((r) => r.text())
+  })
+  const [draft, setDraft] = useState('')
+
+  return (
+    <div>
+      {chat.messages.map((m) => (
+        <p key={m.id} data-role={m.role} data-pending={m.pending}>
+          {m.content}
+        </p>
+      ))}
+      <form
+        onSubmit={(e) => {
+          e.preventDefault()
+          chat.sendMessage(draft)
+          setDraft('')
+        }}
+      >
+        <input value={draft} onChange={(e) => setDraft(e.target.value)} />
+        <button disabled={chat.status !== 'idle' && chat.status !== 'error'}>Send</button>
+        {chat.status === 'streaming' && (
+          <button type="button" onClick={chat.stop}>
+            Stop
+          </button>
+        )}
+      </form>
+    </div>
+  )
+}
+```
+
+The hook returns the [state](#state) plus the chat's methods. It recreates the chat
+(fresh state, old one destroyed) when `flowPath`, `baseUrl`, `workspace`, `history`,
+`storageKey` or the credential change: a different token string, or a switch between
+no token, a string and a function; and when a `run` callback appears or goes away.
+A token function is called through a ref, so passing a new closure on every render
+is fine and never resets the chat, and so are `run` and the callbacks; when users
+sign in and out behind a token function, change `storageKey` (their id) so local
+history and state start over with them.
+
+## Raw apps
+
+Inside a Windmill raw app nothing needs configuring: the chat runs as the viewer,
+against the Windmill the app is served from.
+
+```tsx
+const chat = useWindmillChat({ flowPath: 'f/support/assistant' })
+```
+
+- **Unsandboxed app** (the default): the viewer's session is used. Viewers need
+  permission to run the flow.
+- **Sandboxed app**: declare `jobs:run` in the app's frontend SDK scopes, and
+  `flow_conversations:write` for server-side history. The viewer consents once and
+  the app receives a token restricted to those scopes.
+- **`wmill app dev`**: there is no viewer session on the dev server, so pass
+  `baseUrl`, `workspace` and `token` explicitly during development.
+
+## Any framework
+
+`createChat` returns a store: `subscribe` calls the listener immediately and on every
+change, and returns the unsubscribe function. That is the Svelte store contract, so
+`$chat` works as is; other frameworks wrap it in a few lines.
+
+```ts
+import { createChat } from '@windmill-labs/chat-sdk'
+
+const chat = createChat({ baseUrl, workspace, flowPath, token })
+chat.subscribe((state) => render(state))
+await chat.sendMessage('Hello')
+```
+
+```svelte
+<script>
+  import { createChat } from '@windmill-labs/chat-sdk'
+  const chat = createChat({ flowPath: 'f/support/assistant' })
+</script>
+
+{#each $chat.messages as m (m.id)}
+  <p>{m.content}</p>
+{/each}
+<button onclick={() => chat.sendMessage(draft)}>Send</button>
+```
+
+## Options
+
+| Option | |
+|---|---|
+| `flowPath` | Path of the deployed flow, e.g. `f/support/assistant`. Required. |
+| `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. |
+| `history` | `'server'`, `'local'` or `'none'`, see [History](#history). Defaults to `'server'` with a viewer session and `'local'` with an explicit `token`. |
+| `inputs` | Extra flow inputs sent with every message. `sendMessage(text, { inputs })` adds per-message ones, and `{ attachments, attachmentsInput }` files, see [Attachments](#attachments). |
+| `storageKey` | Namespace for `local` history, e.g. the signed-in user's id. Local history is per browser and per flow; without it, users sharing a browser share it. |
+| `fetch`, `storage` | Replacements for the globals, for tests and unusual runtimes. |
+| `pageSize` | Messages and conversations per page of server history. Default 50. |
+| `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. |
+
+## State
+
+```ts
+interface ChatState {
+  conversationId: string | undefined
+  messages: ChatMessage[]
+  status: 'idle' | 'submitted' | 'streaming' | 'error'
+  error: Error | undefined
+  conversations: Conversation[]
+  history: 'server' | 'local' | 'none'
+  loadingMessages: boolean
+  hasMoreMessages: boolean
+}
+
+interface ChatMessage {
+  id: string
+  role: 'user' | 'assistant' | 'tool' | 'system'
+  content: string
+  reasoning?: string // the model's reasoning summary, when streamed
+  tool?: { callId?: string; name: string; arguments?: string; result?: string; status: 'running' | 'success' | 'error' }
+  success: boolean // false for a failed flow or tool
+  pending: boolean // still streaming, or not yet confirmed by the server
+  createdAt: string
+  jobId?: string
+  stepName?: string
+  serverId?: string // the persisted row; `id` itself never changes, so list keys are stable
+}
+```
+
+A turn goes `submitted` (the flow is queued) → `streaming` (the answer is arriving) →
+`idle`. Tool calls appear as `tool` messages whose `status` moves from `running` to
+`success` or `error`. A flow that fails still completes the turn: its error is the
+answer, an `assistant` message with `success: false`. `status: 'error'` (with `error`
+set) means the turn could not run or be followed at all, such as a refused request.
+
+Methods: `sendMessage(text, { inputs?, attachments?, attachmentsInput? })`, `stop()`,
+`newConversation()`, `selectConversation(id)`, `loadConversations({ page?, perPage?, kind? })`,
+`deleteConversation(id)`, `renameConversation(id, title)`, `loadOlderMessages()`,
+`resumeTurn(turn)`, `refreshMessages()` (reads what another tab added to the open
+conversation), `destroy()`. `kind` lists the flow editor's test chats (`'test'`), the deployed flow's
+own (`'deployed'`, the server's default) or both (`'all'`); each `Conversation` carries
+`isTest`. A rename keeps the conversation's place in the list. Switching conversations
+stops following the current answer; the flow keeps running and, with server history,
+its answer is there when you come back.
+
+## Attachments
+
+A flow whose AI agent step reads `user_attachments` from an `s3object[]` (or a single
+`s3object`) flow input takes files with a message:
+
+```ts
+await chat.sendMessage('What does this contract say?', {
+  attachments: [{ name: file.name, data: file }], // a Blob/File, or a `data:` URL
+  attachmentsInput: { name: 'files', multiple: true }
+})
+```
+
+Each file is uploaded to the workspace's object storage under
+`windmill_uploads/chat/<turn>/<index>/<name>` and handed to the input as `{ s3, filename }`
+objects (the object for a single-file input). Once the uploads return, the pending user
+message lists them in `attachments`, as `{ input, s3, filename }` references. The name's
+extension is corrected to the file's media type for PNG, JPEG and PDF, because the worker
+reads the type off the key.
+Files need message text to go with them. A failed upload rejects `sendMessage` before any
+run starts, and `stop()` during the upload aborts it; both leave the transcript as it was.
+The chat never deletes uploads, so files of a send that did not run stay in storage. The
+workspace needs object storage set up. With Enterprise advanced storage permissions, the
+user needs read and write on `windmill_uploads/*`, which the default rules grant. The upload goes through
+`job_helpers`, so a restricted token needs `job_helpers:write`; a sandboxed raw app cannot
+request that scope today, so attachments are not available there yet.
+
+## One turn at a time
+
+A conversation answers one message at a time, and Windmill enforces it: a message sent
+while its previous turn still runs (from another tab, or before a reload) is refused.
+`sendMessage` then rejects with a `TurnRunningError` and shows nothing of the message.
+With server history, a listed `Conversation` also carries `runningTurn` while it is
+answering. Either way, `resumeTurn(turn)` follows that turn in the selected
+conversation: its answer streams in from the start and the turn finishes as if it had
+been sent here, after which the message can be sent again.
+
+```ts
+// `runningTurn` comes from the listing, so read it before selecting.
+await chat.loadConversations()
+const running = chat.getState().conversations.find((c) => c.id === id)?.runningTurn
+await chat.selectConversation(id)
+if (running) await chat.resumeTurn(running)
+```
+
+A dropped connection to the answer is retried; when it keeps failing, the chat stops
+streaming and waits for the flow's result instead, so the turn still ends.
+
+## History
+
+Windmill stores every conversation of a chat-mode flow, and each Windmill user sees
+only their own. `history: 'server'` reads that store: `loadConversations()` lists
+them, `selectConversation(id)` loads one, `loadOlderMessages()` pages back. Every
+message rendered from the server carries its `jobId` and `stepName`.
+
+That store is keyed by the **Windmill user**, so it fits a viewer session or a token
+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
+beyond the page.
+
+When the default `'server'` mode turns out unreadable (a token or sandboxed app
+without `flow_conversations` scopes), the chat switches itself to `'local'` and
+`state.history` says so. Passing `history` explicitly disables that fallback.
+
+## Tokens
+
+Anything a browser holds can be read by its user, so give a chat token exactly what
+the chat needs:
+
+| Setup | Scopes |
+|---|---|
+| Public site, one token for everyone | `jobs:run:flows:f/support/assistant`, and `history: 'local'`. The token can run that one flow and follow its jobs, nothing else. |
+| Per-user tokens minted by your backend | The above plus `flow_conversations:write`, with `history: 'server'` (an explicit token defaults to local history). Return them from an endpoint and pass `token: () => fetch(...)`. |
+| A Windmill user in the browser (raw app, embedded Windmill) | No token: the session is used. |
+
+The token's user must be allowed to run the flow. `stop()` closes the stream in any
+case; cancelling the run on the server as well needs `jobs:write`, which also lets the
+token read every job its user can see, so leave it out unless that matters.
+
+Anyone holding the token can run the flow with inputs of their choosing, so a flow
+exposed this way should treat `user_message` and the other inputs as untrusted.
+
+## Lower level
+
+`WindmillChatApi` wraps the endpoints (`runFlow`, `streamJob`, `listConversations`,
+`listMessages`, `deleteConversation`, `cancelJob`), `followJob` follows a run to
+completion across the server's stream timeouts, `parseStreamEvents` decodes the AI
+agent stream, `extractChatAnswer` turns a flow result into the text a chat shows, and
+`conversationIdFor` maps any chat id to its conversation UUID. They are exported for
+custom integrations.
+
+## For AI coding agents
+
+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
+`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/ai-sdk.cjs

@@ -0,0 +1,344 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_follow = require("./follow-Dug-Afeu.cjs");
+//#region src/ai-sdk.ts
+/**
+* A Vercel AI SDK `ChatTransport` over a chat-mode flow: `useChat({ transport })`
+* (and AI Elements, which builds on it) then work against Windmill unchanged.
+* The chat id is the conversation, so a UUID id lines up with server history.
+*/
+function createWindmillChatTransport(options) {
+	const api = new require_follow.WindmillChatApi(options);
+	const jobs = /* @__PURE__ */ new Map();
+	return {
+		conversationId: require_follow.conversationIdFor,
+		async sendMessages({ chatId, messages, abortSignal, body }) {
+			const last = messages[messages.length - 1];
+			if (!last || last.role !== "user") throw new Error("windmill-chat: the last message must be a user message");
+			if (last.parts.some((p) => p.type === "file")) throw new Error("windmill-chat: attachments are not supported; upload the file yourself and pass its reference through `body`");
+			const text = last.parts.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+			const memoryId = require_follow.conversationIdFor(chatId);
+			const entry = {
+				jobId: await api.runFlow(options.flowPath, {
+					...options.inputs,
+					...body,
+					user_message: text
+				}, {
+					memoryId,
+					signal: abortSignal
+				}),
+				done: false
+			};
+			jobs.set(chatId, entry);
+			return chunkStream(api, entry, abortSignal);
+		},
+		async reconnectToStream({ chatId, abortSignal }) {
+			const entry = jobs.get(chatId);
+			if (!entry || entry.done) return null;
+			return chunkStream(api, entry, abortSignal);
+		},
+		async loadMessages(chatId, pagination) {
+			return toUIMessages((await api.listMessages(require_follow.conversationIdFor(chatId), pagination).catch((e) => {
+				if (e instanceof require_follow.WindmillApiError && e.status === 404) return [];
+				throw e;
+			})).map((row) => ({
+				id: row.id,
+				serverId: row.id,
+				role: row.message_type,
+				content: row.content,
+				success: row.success ?? true,
+				createdAt: row.created_at,
+				jobId: row.job_id ?? void 0,
+				stepName: row.step_name ?? void 0,
+				pending: false,
+				seq: row.created_seq,
+				reasoning: row.reasoning ?? void 0,
+				attachments: row.attachments ?? void 0,
+				tool: toolFromRow(row)
+			})));
+		},
+		async listConversations(pagination) {
+			return (await api.listConversations(options.flowPath, pagination)).map((row) => ({
+				id: row.id,
+				title: row.title ?? void 0,
+				createdAt: row.created_at,
+				updatedAt: row.updated_at
+			}));
+		},
+		async deleteConversation(chatId) {
+			await api.deleteConversation(require_follow.conversationIdFor(chatId));
+			jobs.delete(chatId);
+		}
+	};
+}
+/** The call a stored tool row carries: its tool, named by the sentence the worker words
+*  every tool row from, and the model's arguments and what it got back — for a failed
+*  tool, the result is what it failed with. */
+function toolFromRow(row) {
+	if (row.message_type !== "tool") return void 0;
+	const name = /^Used (.+) tool$/.exec(row.content)?.[1] ?? /^Error executing (.+)$/.exec(row.content)?.[1];
+	if (!name) return void 0;
+	return {
+		name,
+		status: row.success ?? true ? "success" : "error",
+		arguments: row.tool_arguments ?? void 0,
+		result: row.tool_result ?? void 0
+	};
+}
+/** Streams a job's answer as AI SDK chunks; resumes from `entry.offset` when the job is already running. */
+function chunkStream(api, entry, signal) {
+	return new ReadableStream({ async start(controller) {
+		const parts = new PartWriter((chunk) => controller.enqueue(chunk));
+		parts.emit({ type: "start" });
+		try {
+			let failure;
+			for await (const event of require_follow.followJob(api, entry.jobId, {
+				signal,
+				streamOffset: entry.offset,
+				onOffset: (offset) => {
+					entry.offset = offset;
+				}
+			})) {
+				if (event.type === "stream") {
+					for (const e of event.events) parts.apply(e);
+					continue;
+				}
+				const cut = parts.openText ?? "";
+				parts.closeOpen();
+				failure = await failureText(api, entry.jobId, event.result, signal);
+				if (failure === void 0 && event.streamLost) {
+					const answer = require_follow.extractChatAnswer(event.result);
+					if (answer !== void 0 && answer !== cut) {
+						parts.text(answer.startsWith(cut) ? answer.slice(cut.length) : answer);
+						parts.closeOpen();
+					}
+				} else if (failure === void 0 && !parts.streamedText) {
+					const answer = require_follow.extractChatAnswer(event.result);
+					if (answer !== void 0) {
+						parts.text(answer);
+						parts.closeOpen();
+					}
+				}
+			}
+			entry.done = true;
+			parts.emit(failure === void 0 ? { type: "finish" } : {
+				type: "error",
+				errorText: failure
+			});
+		} catch (e) {
+			if (!require_follow.isAbortError(e)) {
+				parts.closeOpen();
+				parts.emit({
+					type: "error",
+					errorText: e instanceof Error ? e.message : String(e)
+				});
+			}
+		} finally {
+			controller.close();
+		}
+	} });
+}
+/** A completed flow's error, when the job did fail (the envelope alone is a legitimate result). */
+async function failureText(api, jobId, result, signal) {
+	if (!require_follow.isErrorResult(result)) return void 0;
+	return await api.getCompletedResult(jobId, signal).then((r) => r.success === false).catch(() => true) ? require_follow.errorResultMessage(result) : void 0;
+}
+var _textId = /* @__PURE__ */ new WeakMap();
+var _reasoningId = /* @__PURE__ */ new WeakMap();
+var _started = /* @__PURE__ */ new WeakMap();
+var _inputSent = /* @__PURE__ */ new WeakMap();
+var _PartWriter_brand = /* @__PURE__ */ new WeakSet();
+/**
+* Turns agent events into AI SDK chunks. Text and reasoning are open parts that a
+* tool call closes (a new round starts new parts); tool calls are `dynamic-tool`
+* parts, since the UI declares no tools of its own.
+*/
+var PartWriter = class {
+	constructor(emit) {
+		this.emit = emit;
+		require_follow._classPrivateMethodInitSpec(this, _PartWriter_brand);
+		this.streamedText = false;
+		require_follow._classPrivateFieldInitSpec(this, _textId, void 0);
+		require_follow._classPrivateFieldInitSpec(this, _reasoningId, void 0);
+		require_follow._classPrivateFieldInitSpec(this, _started, /* @__PURE__ */ new Set());
+		require_follow._classPrivateFieldInitSpec(this, _inputSent, /* @__PURE__ */ new Set());
+	}
+	text(delta) {
+		this.streamedText = true;
+		if (!require_follow._classPrivateFieldGet2(_textId, this)) {
+			require_follow._classPrivateFieldSet2(_textId, this, require_follow.randomId());
+			this.openText = "";
+			this.emit({
+				type: "text-start",
+				id: require_follow._classPrivateFieldGet2(_textId, this)
+			});
+		}
+		this.openText += delta;
+		this.emit({
+			type: "text-delta",
+			id: require_follow._classPrivateFieldGet2(_textId, this),
+			delta
+		});
+	}
+	reasoning(delta) {
+		if (!require_follow._classPrivateFieldGet2(_reasoningId, this)) {
+			require_follow._classPrivateFieldSet2(_reasoningId, this, require_follow.randomId());
+			this.emit({
+				type: "reasoning-start",
+				id: require_follow._classPrivateFieldGet2(_reasoningId, this)
+			});
+		}
+		this.emit({
+			type: "reasoning-delta",
+			id: require_follow._classPrivateFieldGet2(_reasoningId, this),
+			delta
+		});
+	}
+	closeOpen() {
+		if (require_follow._classPrivateFieldGet2(_reasoningId, this)) {
+			this.emit({
+				type: "reasoning-end",
+				id: require_follow._classPrivateFieldGet2(_reasoningId, this)
+			});
+			require_follow._classPrivateFieldSet2(_reasoningId, this, void 0);
+		}
+		if (require_follow._classPrivateFieldGet2(_textId, this)) {
+			this.emit({
+				type: "text-end",
+				id: require_follow._classPrivateFieldGet2(_textId, this)
+			});
+			require_follow._classPrivateFieldSet2(_textId, this, void 0);
+			this.openText = void 0;
+		}
+	}
+	apply(event) {
+		switch (event.type) {
+			case "token_delta":
+				this.text(event.content);
+				break;
+			case "reasoning_token_delta":
+				this.reasoning(event.content);
+				break;
+			case "tool_call":
+				this.closeOpen();
+				require_follow._assertClassBrand(_PartWriter_brand, this, _toolStart).call(this, event.call_id, event.function_name);
+				break;
+			case "tool_call_arguments":
+				this.closeOpen();
+				require_follow._assertClassBrand(_PartWriter_brand, this, _toolStart).call(this, event.call_id, event.function_name);
+				require_follow._classPrivateFieldGet2(_inputSent, this).add(event.call_id);
+				this.emit({
+					type: "tool-input-available",
+					toolCallId: event.call_id,
+					toolName: event.function_name,
+					input: require_follow.parseJsonOr(event.arguments),
+					dynamic: true
+				});
+				break;
+			case "tool_execution":
+				this.closeOpen();
+				require_follow._assertClassBrand(_PartWriter_brand, this, _toolStart).call(this, event.call_id, event.function_name);
+				break;
+			case "tool_result":
+				require_follow._assertClassBrand(_PartWriter_brand, this, _toolStart).call(this, event.call_id, event.function_name);
+				if (!require_follow._classPrivateFieldGet2(_inputSent, this).has(event.call_id)) {
+					require_follow._classPrivateFieldGet2(_inputSent, this).add(event.call_id);
+					this.emit({
+						type: "tool-input-available",
+						toolCallId: event.call_id,
+						toolName: event.function_name,
+						input: void 0,
+						dynamic: true
+					});
+				}
+				this.emit(event.success ? {
+					type: "tool-output-available",
+					toolCallId: event.call_id,
+					output: require_follow.parseJsonOr(event.result),
+					dynamic: true
+				} : {
+					type: "tool-output-error",
+					toolCallId: event.call_id,
+					errorText: event.result,
+					dynamic: true
+				});
+		}
+	}
+};
+function _toolStart(callId, name) {
+	if (require_follow._classPrivateFieldGet2(_started, this).has(callId)) return;
+	require_follow._classPrivateFieldGet2(_started, this).add(callId);
+	this.emit({
+		type: "tool-input-start",
+		toolCallId: callId,
+		toolName: name,
+		dynamic: true
+	});
+}
+/**
+* `ChatMessage`s (Windmill's role-per-row model) as `UIMessage`s: an assistant
+* turn becomes one message whose parts carry its text, reasoning and tool calls. A
+* user message's attachments ride in `metadata.attachments`, as references for
+* `WindmillChatApi.attachmentUrl`: a `file` part would need a URL the browser can
+* load unauthenticated.
+*/
+function toUIMessages(messages) {
+	const out = [];
+	for (const m of messages) {
+		if (m.role === "user" || m.role === "system") {
+			out.push({
+				id: m.id,
+				role: m.role,
+				...m.attachments?.length ? { metadata: { attachments: m.attachments } } : {},
+				parts: [{
+					type: "text",
+					text: m.content
+				}]
+			});
+			continue;
+		}
+		let target = out[out.length - 1];
+		if (!target || target.role !== "assistant") {
+			target = {
+				id: m.id,
+				role: "assistant",
+				parts: []
+			};
+			out.push(target);
+		}
+		if (m.reasoning) target.parts.push({
+			type: "reasoning",
+			text: m.reasoning,
+			state: "done"
+		});
+		if (m.role === "tool") {
+			const toolCallId = m.tool?.callId ?? m.id;
+			const toolName = m.tool?.name ?? "tool";
+			const input = require_follow.parseJsonOr(m.tool?.arguments);
+			target.parts.push(m.success ? {
+				type: "dynamic-tool",
+				toolName,
+				toolCallId,
+				state: "output-available",
+				input,
+				output: m.tool?.result !== void 0 ? require_follow.parseJsonOr(m.tool.result) : m.content
+			} : {
+				type: "dynamic-tool",
+				toolName,
+				toolCallId,
+				state: "output-error",
+				input,
+				errorText: m.tool?.result ?? m.content
+			});
+			continue;
+		}
+		if (m.content) target.parts.push({
+			type: "text",
+			text: m.content,
+			state: "done"
+		});
+	}
+	return out;
+}
+//#endregion
+exports.createWindmillChatTransport = createWindmillChatTransport;
+exports.toUIMessages = toUIMessages;