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

package/dist/assistant-ui.d.ts

@@ -0,0 +1,22 @@
+import { type AssistantRuntime, type ThreadMessageLike } from '@assistant-ui/react';
+import type { ChatMessage, ChatOptions } 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 {
+    /** 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;
+/** 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. */
+export declare function toThreadMessage(turn: WindmillTurn): ThreadMessageLike;

package/dist/assistant-ui.js

@@ -0,0 +1,119 @@
+import { u as parseJsonOr } from "./follow-DXfmfPfr.js";
+import { useWindmillChat } from "./react.js";
+import { useExternalStoreRuntime } from "@assistant-ui/react";
+import { useEffect, useMemo } from "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 = useWindmillChat(options);
+	const turns = useMemo(() => groupTurns(chat.messages), [chat.messages]);
+	const withThreadList = options.threadList !== false;
+	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 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 = 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 ? 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
+export { groupTurns, toThreadMessage, useWindmillRuntime };

package/dist/attachments.d.ts

@@ -0,0 +1,27 @@
+import type { WindmillChatApi } from './api';
+import type { AttachmentUpload } from './types';
+/**
+ * Where a chat's uploads live in the workspace's object storage. Under `windmill_uploads/`
+ * because the default Enterprise storage permissions grant every user write and read there
+ * and deny any other top-level prefix: a key outside it is refused for non-admins, both on
+ * upload and when the agent's job reads the file back.
+ */
+export declare const CHAT_UPLOADS_PREFIX = "windmill_uploads/chat";
+/** What an AI agent step reads out of `user_attachments`. */
+export interface UploadedAttachment {
+    s3: string;
+    filename: string;
+}
+/**
+ * The name an attachment is stored under: the picked name with the extension its media type
+ * needs, e.g. a `photo.webp` re-encoded to PNG becomes `photo.png`. Other types keep their name.
+ */
+export declare function storedAttachmentName(filename: string, mediaType: string): string;
+/** The bytes of an attachment as a Blob carrying its media type. */
+export declare function attachmentBlob(attachment: AttachmentUpload): Blob;
+/**
+ * Put each attachment in the workspace's object storage and hand back what the agent reads.
+ * The key's turn prefix and per-file index keep two files with the same name, in this turn or
+ * an earlier one, from overwriting each other; the name stays the last segment.
+ */
+export declare function uploadAttachments(api: WindmillChatApi, attachments: AttachmentUpload[], turnId: string, signal?: AbortSignal): Promise<UploadedAttachment[]>;