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

package/dist/ai-sdk.d.ts

@@ -0,0 +1,38 @@
+import type { ChatTransport, UIMessage } from 'ai';
+import { type WindmillChatApiOptions } from './api';
+import type { ChatMessage, Conversation } from './types';
+export interface WindmillChatTransportOptions extends WindmillChatApiOptions {
+    /** Path of a deployed flow with chat mode enabled, e.g. `f/support/assistant`. */
+    flowPath: string;
+    /** Extra flow inputs sent with every message; `sendMessage(msg, { body })` adds per-message ones. */
+    inputs?: Record<string, unknown>;
+}
+export interface WindmillChatTransport<UI_MESSAGE extends UIMessage = UIMessage> extends ChatTransport<UI_MESSAGE> {
+    /** The Windmill conversation id behind an AI SDK chat id (a UUID chat id is used as is). */
+    conversationId(chatId: string): string;
+    /** Server history of a chat as `UIMessage`s, oldest first, for `useChat({ messages })`. Needs `flow_conversations:read`. */
+    loadMessages(chatId: string, options?: {
+        page?: number;
+        perPage?: number;
+    }): Promise<UI_MESSAGE[]>;
+    /** The user's conversations for this flow, most recent first. */
+    listConversations(options?: {
+        page?: number;
+        perPage?: number;
+    }): Promise<Conversation[]>;
+    deleteConversation(chatId: string): Promise<void>;
+}
+/**
+ * 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.
+ */
+export declare function createWindmillChatTransport<UI_MESSAGE extends UIMessage = UIMessage>(options: WindmillChatTransportOptions): WindmillChatTransport<UI_MESSAGE>;
+/**
+ * `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.
+ */
+export declare function toUIMessages(messages: ChatMessage[]): UIMessage[];

package/dist/ai-sdk.js

@@ -0,0 +1,342 @@
+import { C as _assertClassBrand, S as _classPrivateFieldSet2, T as _classPrivateMethodInitSpec, _ as WindmillApiError, a as errorResultMessage, c as isErrorResult, d as randomId, o as extractChatAnswer, r as conversationIdFor, s as isAbortError, t as followJob, u as parseJsonOr, v as WindmillChatApi, w as _classPrivateFieldInitSpec, x as _classPrivateFieldGet2 } from "./follow-DXfmfPfr.js";
+//#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 WindmillChatApi(options);
+	const jobs = /* @__PURE__ */ new Map();
+	return {
+		conversationId: 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 = 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(conversationIdFor(chatId), pagination).catch((e) => {
+				if (e instanceof 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(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 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 = 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 = 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 (!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 (!isErrorResult(result)) return void 0;
+	return await api.getCompletedResult(jobId, signal).then((r) => r.success === false).catch(() => true) ? 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;
+		_classPrivateMethodInitSpec(this, _PartWriter_brand);
+		this.streamedText = false;
+		_classPrivateFieldInitSpec(this, _textId, void 0);
+		_classPrivateFieldInitSpec(this, _reasoningId, void 0);
+		_classPrivateFieldInitSpec(this, _started, /* @__PURE__ */ new Set());
+		_classPrivateFieldInitSpec(this, _inputSent, /* @__PURE__ */ new Set());
+	}
+	text(delta) {
+		this.streamedText = true;
+		if (!_classPrivateFieldGet2(_textId, this)) {
+			_classPrivateFieldSet2(_textId, this, randomId());
+			this.openText = "";
+			this.emit({
+				type: "text-start",
+				id: _classPrivateFieldGet2(_textId, this)
+			});
+		}
+		this.openText += delta;
+		this.emit({
+			type: "text-delta",
+			id: _classPrivateFieldGet2(_textId, this),
+			delta
+		});
+	}
+	reasoning(delta) {
+		if (!_classPrivateFieldGet2(_reasoningId, this)) {
+			_classPrivateFieldSet2(_reasoningId, this, randomId());
+			this.emit({
+				type: "reasoning-start",
+				id: _classPrivateFieldGet2(_reasoningId, this)
+			});
+		}
+		this.emit({
+			type: "reasoning-delta",
+			id: _classPrivateFieldGet2(_reasoningId, this),
+			delta
+		});
+	}
+	closeOpen() {
+		if (_classPrivateFieldGet2(_reasoningId, this)) {
+			this.emit({
+				type: "reasoning-end",
+				id: _classPrivateFieldGet2(_reasoningId, this)
+			});
+			_classPrivateFieldSet2(_reasoningId, this, void 0);
+		}
+		if (_classPrivateFieldGet2(_textId, this)) {
+			this.emit({
+				type: "text-end",
+				id: _classPrivateFieldGet2(_textId, this)
+			});
+			_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();
+				_assertClassBrand(_PartWriter_brand, this, _toolStart).call(this, event.call_id, event.function_name);
+				break;
+			case "tool_call_arguments":
+				this.closeOpen();
+				_assertClassBrand(_PartWriter_brand, this, _toolStart).call(this, event.call_id, event.function_name);
+				_classPrivateFieldGet2(_inputSent, this).add(event.call_id);
+				this.emit({
+					type: "tool-input-available",
+					toolCallId: event.call_id,
+					toolName: event.function_name,
+					input: parseJsonOr(event.arguments),
+					dynamic: true
+				});
+				break;
+			case "tool_execution":
+				this.closeOpen();
+				_assertClassBrand(_PartWriter_brand, this, _toolStart).call(this, event.call_id, event.function_name);
+				break;
+			case "tool_result":
+				_assertClassBrand(_PartWriter_brand, this, _toolStart).call(this, event.call_id, event.function_name);
+				if (!_classPrivateFieldGet2(_inputSent, this).has(event.call_id)) {
+					_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: parseJsonOr(event.result),
+					dynamic: true
+				} : {
+					type: "tool-output-error",
+					toolCallId: event.call_id,
+					errorText: event.result,
+					dynamic: true
+				});
+		}
+	}
+};
+function _toolStart(callId, name) {
+	if (_classPrivateFieldGet2(_started, this).has(callId)) return;
+	_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 = parseJsonOr(m.tool?.arguments);
+			target.parts.push(m.success ? {
+				type: "dynamic-tool",
+				toolName,
+				toolCallId,
+				state: "output-available",
+				input,
+				output: m.tool?.result !== void 0 ? 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
+export { createWindmillChatTransport, toUIMessages };

package/dist/api.d.ts

@@ -0,0 +1,182 @@
+import type { ChatAttachment, FetchLike, TokenSource } from './types';
+export interface WindmillChatApiOptions {
+    baseUrl: string;
+    workspace: string;
+    /** Omit to rely on the session cookie of the Windmill origin. */
+    token?: TokenSource;
+    fetch?: FetchLike;
+    /** Server poll interval for a turn's stream (Enterprise; see `ChatOptions.pollDelayMs`). */
+    pollDelayMs?: number;
+}
+export declare class WindmillApiError extends Error {
+    readonly status: number;
+    /** The response body, as the server sent it. */
+    readonly body?: string | undefined;
+    constructor(message: string, status: number, 
+    /** The response body, as the server sent it. */
+    body?: string | undefined);
+}
+/** The turn a conversation is still answering, as the server reports it. */
+export interface RunningTurn {
+    jobId: string;
+    /** `created_seq` of the user message that started the turn. */
+    userSeq: number;
+}
+/**
+ * A message was sent to a conversation whose turn is still running. The server refuses
+ * it (409) so two runs never write one agent memory; `turn` is the run to follow instead.
+ */
+export declare class TurnRunningError extends Error {
+    readonly turn: RunningTurn;
+    constructor(message: string, turn: RunningTurn);
+}
+/**
+ * The running turn named by a run's 409 body, or undefined for any other body. Exported
+ * for a custom `run` that calls Windmill through its own client: it rethrows the refusal
+ * as a `TurnRunningError` so the chat can follow the running turn.
+ */
+export declare function turnRunningError(body: string): TurnRunningError | undefined;
+export interface FlowConversation {
+    id: string;
+    workspace_id: string;
+    flow_path: string;
+    title?: string | null;
+    created_at: string;
+    updated_at: string;
+    created_by: string;
+    /** Started from the flow editor's test panel rather than a deployed run. */
+    is_test: boolean;
+    /** Set by the list: the turn this conversation is still answering. */
+    running_turn?: {
+        job_id: string;
+        user_seq: number;
+    } | null;
+}
+/**
+ * Which conversations a listing holds: the flow editor's test chats, the deployed flow's
+ * own (the server's default), or both.
+ */
+export type ConversationKind = 'test' | 'deployed' | 'all';
+export interface FlowConversationMessage {
+    id: string;
+    conversation_id: string;
+    message_type: 'user' | 'assistant' | 'system' | 'tool';
+    content: string;
+    job_id?: string | null;
+    created_at: string;
+    created_seq: number;
+    step_name?: string | null;
+    success?: boolean;
+    /** On a tool row, the arguments the model wrote, without the inputs a step wires in; null for a web search. */
+    tool_arguments?: string | null;
+    /** On a tool row, the text the model got back or what the call failed with; a web search's citations. */
+    tool_result?: string | null;
+    /** On an answer, the thinking that produced it; on a tool row, the thinking that led to the call. */
+    reasoning?: string | null;
+    /** The files a user message carried, as object-storage references. */
+    attachments?: ChatAttachment[] | null;
+}
+export type JobUpdateEvent = {
+    type: 'update';
+    running?: boolean;
+    completed?: boolean;
+    new_result_stream?: string;
+    stream_offset?: number;
+    only_result?: unknown;
+    flow_stream_job_id?: string;
+} | {
+    type: 'error';
+    error: string;
+} | {
+    type: 'notfound';
+} | {
+    type: 'timeout';
+} | {
+    type: 'ping';
+};
+export interface CompletedJobResult {
+    completed: boolean;
+    success?: boolean;
+    result?: unknown;
+}
+/** The part of a flow job's status that names the jobs its steps ran as. */
+export interface FlowJobStatus {
+    flow_status?: {
+        modules?: FlowStepStatus[] | null;
+        failure_module?: FlowStepStatus | null;
+        preprocessor_module?: FlowStepStatus | null;
+    } | null;
+}
+export interface FlowStepStatus {
+    job?: string | null;
+    flow_jobs?: string[] | null;
+    /** An agent step's rounds; a tool call ran as a job of its own, which its row is persisted under. */
+    agent_actions?: {
+        type?: string;
+        job_id?: string | null;
+    }[] | null;
+}
+/** Thin client over the Windmill endpoints a chat-mode flow uses. */
+export declare class WindmillChatApi {
+    #private;
+    constructor(options: WindmillChatApiOptions);
+    /**
+     * Starts a turn: runs the flow with `memory_id` set to the conversation id. Returns the
+     * job id. Throws `TurnRunningError` when the conversation is still answering.
+     */
+    runFlow(flowPath: string, args: Record<string, unknown>, options: {
+        memoryId: string;
+        signal?: AbortSignal;
+    }): Promise<string>;
+    /**
+     * One server-sent-events connection to a job's updates. The server closes it after
+     * `TIMEOUT_SSE_STREAM` (a `timeout` event); resume by calling again with the last
+     * `stream_offset`, never by re-running the flow.
+     */
+    streamJob(jobId: string, options?: {
+        streamOffset?: number;
+        signal?: AbortSignal;
+    }): AsyncGenerator<JobUpdateEvent>;
+    getCompletedResult(jobId: string, signal?: AbortSignal): Promise<CompletedJobResult>;
+    /** A flow job with its status: the step job ids are what persisted messages carry as `job_id`. */
+    getFlowJob(jobId: string, signal?: AbortSignal): Promise<FlowJobStatus>;
+    /**
+     * Where a message's attachment downloads from. The endpoint authenticates like every other
+     * request: a consumer holding a token must fetch it with that token, not put the URL in an
+     * `img src`, which would send only the Windmill session cookie.
+     */
+    attachmentUrl(attachment: ChatAttachment): string;
+    cancelJob(jobId: string, reason?: string): Promise<void>;
+    listConversations(flowPath: string, options?: {
+        page?: number;
+        perPage?: number;
+        kind?: ConversationKind;
+        signal?: AbortSignal;
+    }): Promise<FlowConversation[]>;
+    /** Sets a conversation's title. Its place in the list is kept: only a turn moves one. */
+    renameConversation(conversationId: string, title: string): Promise<void>;
+    /**
+     * Without `afterSeq`: one page counted from the newest message, returned oldest first.
+     * With `afterSeq`: the messages created after that cursor, oldest first.
+     */
+    listMessages(conversationId: string, options?: {
+        page?: number;
+        perPage?: number;
+        afterSeq?: number;
+        signal?: AbortSignal;
+    }): Promise<FlowConversationMessage[]>;
+    /**
+     * Puts bytes in the workspace's object storage under `fileKey` and returns the key they were
+     * stored under (the server may rewrite it). Needs the workspace to have object storage set.
+     */
+    uploadFile(fileKey: string, body: Blob, options?: {
+        contentType?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        file_key: string;
+    }>;
+    deleteConversation(conversationId: string): Promise<void>;
+}
+export declare function normalizeBaseUrl(baseUrl: string): string;
+/** Yields the `data` payload of each event in a `text/event-stream` body. */
+export declare function readServerSentEvents(body: ReadableStream<Uint8Array>): AsyncGenerator<string>;

package/dist/assistant-ui.cjs

@@ -0,0 +1,122 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_follow = require("./follow-Dug-Afeu.cjs");
+const require_react = require("./react.cjs");
+let _assistant_ui_react = require("@assistant-ui/react");
+let react = require("react");
+//#region src/assistant-ui.ts
+/**
+* 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.
+*/
+function useWindmillRuntime(options) {
+	const chat = require_react.useWindmillChat(options);
+	const turns = (0, react.useMemo)(() => groupTurns(chat.messages), [chat.messages]);
+	const withThreadList = options.threadList !== false;
+	(0, react.useEffect)(() => {
+		if (withThreadList) chat.loadConversations().catch(() => {});
+	}, [chat.chat, withThreadList]);
+	const adapter = {
+		messages: turns,
+		isRunning: chat.status === "submitted" || chat.status === "streaming",
+		convertMessage: toThreadMessage,
+		onNew: async (message) => {
+			if (message.role !== "user") return;
+			await chat.sendMessage(appendedText(message));
+		},
+		onCancel: async () => {
+			await chat.stop();
+		},
+		adapters: withThreadList ? { threadList: {
+			threadId: chat.conversationId,
+			threads: chat.conversations.map((c) => ({
+				status: "regular",
+				id: c.id,
+				title: c.title
+			})),
+			onSwitchToNewThread: () => chat.newConversation(),
+			onSwitchToThread: (id) => chat.selectConversation(id),
+			onDelete: (id) => chat.deleteConversation(id),
+			onRename: (id, title) => chat.renameConversation(id, title)
+		} } : void 0
+	};
+	return (0, _assistant_ui_react.useExternalStoreRuntime)(adapter);
+}
+function appendedText(message) {
+	return message.content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+}
+/** Folds the role-per-row message list into turns: one entry per user message, one per answer. */
+function groupTurns(messages) {
+	const turns = [];
+	for (const m of messages) {
+		const last = turns[turns.length - 1];
+		if (m.role === "user" || m.role === "system" || !last || last.role !== "assistant") turns.push({
+			id: m.id,
+			role: m.role === "tool" ? "assistant" : m.role,
+			messages: [m]
+		});
+		else last.messages.push(m);
+	}
+	return turns;
+}
+/** A turn as assistant-ui content parts; the status reflects streaming and a failed flow. */
+function toThreadMessage(turn) {
+	const first = turn.messages[0];
+	const createdAt = new Date(first.createdAt);
+	if (turn.role !== "assistant") return {
+		id: turn.id,
+		role: turn.role,
+		createdAt,
+		content: [{
+			type: "text",
+			text: first.content
+		}]
+	};
+	const content = [];
+	for (const m of turn.messages) {
+		if (m.reasoning) content.push({
+			type: "reasoning",
+			text: m.reasoning
+		});
+		if (m.role === "tool") {
+			const args = require_follow.parseJsonOr(m.tool?.arguments);
+			content.push({
+				type: "tool-call",
+				toolCallId: m.tool?.callId ?? m.id,
+				toolName: m.tool?.name ?? "tool",
+				args: isJsonObject(args) ? args : args === void 0 ? {} : { input: args },
+				argsText: m.tool?.arguments ?? "",
+				result: m.tool?.status === "running" ? void 0 : m.tool?.result !== void 0 ? require_follow.parseJsonOr(m.tool.result) : m.content,
+				isError: m.tool?.status === "error"
+			});
+			continue;
+		}
+		if (m.content) content.push({
+			type: "text",
+			text: m.content
+		});
+	}
+	const last = turn.messages[turn.messages.length - 1];
+	const status = turn.messages.some((m) => m.pending) ? { type: "running" } : last.role === "assistant" && !last.success ? {
+		type: "incomplete",
+		reason: "error",
+		error: last.content
+	} : {
+		type: "complete",
+		reason: "stop"
+	};
+	return {
+		id: turn.id,
+		role: "assistant",
+		createdAt,
+		content,
+		status
+	};
+}
+function isJsonObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+exports.groupTurns = groupTurns;
+exports.toThreadMessage = toThreadMessage;
+exports.useWindmillRuntime = useWindmillRuntime;