@todoist/automations-sdk 0.0.0-stage → 1.0.0

package/dist/chat-turn.js

@@ -0,0 +1,710 @@
+import { a as chatStreamRequestErrorResponseSchema, l as getChatBillingRefusal, p as isShownChatAcknowledgement, t as connectionAccountLabel } from "./connection-selection-BjNp9A-d.js";
+import { n as AutomationsRequestError, t as AutomationsNetworkError } from "./request-error-DoLXUa2p.js";
+import { z } from "zod";
+import { DefaultChatTransport, readUIMessageStream } from "ai";
+//#region ../core/dist/esm/schemas/automation-preview-artifact.schema.js
+const automationPreviewSources = ["synthetic", "run"];
+const automationPreviewKinds = [
+	"content",
+	"action",
+	"none",
+	"error"
+];
+const automationPreviewGenerationKinds = [
+	"content",
+	"action",
+	"none"
+];
+const automationPreviewSourceSchema = z.enum(automationPreviewSources);
+const automationPreviewKindSchema = z.enum(automationPreviewKinds);
+const automationPreviewGenerationKindSchema = z.enum(automationPreviewGenerationKinds);
+const automationPreviewArtifactSchema = z.object({
+	source: automationPreviewSourceSchema,
+	kind: automationPreviewKindSchema,
+	manifestHash: z.string().regex(/^[a-f0-9]{64}$/, "manifestHash must be a sha256 hex digest"),
+	title: z.string().trim().min(1),
+	summary: z.string().trim().min(1),
+	markdown: z.string().trim().min(1).nullable()
+}).superRefine((artifact, ctx) => {
+	if (artifact.kind === "content" && artifact.markdown == null) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "content artifacts must include markdown",
+		path: ["markdown"]
+	});
+	if (artifact.kind !== "content" && artifact.markdown != null) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "only content artifacts may include markdown",
+		path: ["markdown"]
+	});
+});
+z.object({
+	kind: automationPreviewGenerationKindSchema,
+	title: z.string().trim().min(1),
+	summary: z.string().trim().min(1),
+	markdown: z.string().trim().min(1).nullish()
+});
+//#endregion
+//#region ../core/dist/esm/chat-tools/complete-automation-draft.js
+const CompleteAutomationDraftActionSchema = z.enum(["create", "update"]);
+const CompleteAutomationDraftInputSchema = z.object({
+	draftId: z.string().min(1).describe("The draft ID to generate an automation preview for."),
+	language: z.string().trim().min(1).optional().describe("Optional human language name for the preview. When relevant, pass the language used in the current user conversation.")
+});
+const CompleteAutomationDraftOutputSchema = z.union([z.object({
+	success: z.literal(true),
+	message: z.string().min(1),
+	instructions: z.string().min(1),
+	draftId: z.string().min(1),
+	action: CompleteAutomationDraftActionSchema,
+	artifact: automationPreviewArtifactSchema
+}), z.object({
+	success: z.literal(false),
+	message: z.string().min(1),
+	instructions: z.string().min(1),
+	draftId: z.string().min(1)
+})]);
+z.object({
+	type: z.literal("tool-complete-automation-draft"),
+	toolCallId: z.string().min(1),
+	state: z.literal("input-available"),
+	input: CompleteAutomationDraftInputSchema
+});
+z.object({
+	type: z.literal("tool-complete-automation-draft"),
+	toolCallId: z.string().min(1),
+	state: z.literal("output-available"),
+	input: CompleteAutomationDraftInputSchema,
+	output: CompleteAutomationDraftOutputSchema
+});
+//#endregion
+//#region ../core/dist/esm/chat-tools/publish-draft.js
+const PublishDraftInputSchema = z.object({
+	draftId: z.string().min(1).describe("The draft ID to preview and publish."),
+	language: z.string().trim().min(1).optional().describe("Optional human language name for the preview. When relevant, pass the language used in the current user conversation.")
+});
+const PublishDraftOutputSchema = z.union([z.object({
+	success: z.literal(true),
+	message: z.string().min(1),
+	instructions: z.string().min(1),
+	draftId: z.string().min(1),
+	action: CompleteAutomationDraftActionSchema,
+	automationId: z.string().min(1),
+	previewArtifact: automationPreviewArtifactSchema.optional()
+}), z.object({
+	success: z.literal(false),
+	message: z.string().min(1),
+	instructions: z.string().min(1),
+	draftId: z.string().min(1),
+	action: CompleteAutomationDraftActionSchema.optional(),
+	previewArtifact: automationPreviewArtifactSchema.optional()
+})]);
+z.object({
+	type: z.literal("tool-publish-draft"),
+	toolCallId: z.string().min(1),
+	state: z.literal("input-available"),
+	input: PublishDraftInputSchema
+});
+const toolPublishDraftResultSchema = z.object({
+	type: z.literal("tool-publish-draft"),
+	toolCallId: z.string().min(1),
+	state: z.literal("output-available"),
+	input: PublishDraftInputSchema,
+	output: PublishDraftOutputSchema
+});
+function isPublishDraftCandidate(part) {
+	return typeof part === "object" && part !== null && "type" in part && part.type === "tool-publish-draft";
+}
+function isPublishDraftResult(part) {
+	if (!isPublishDraftCandidate(part)) return false;
+	return toolPublishDraftResultSchema.safeParse(part).success;
+}
+//#endregion
+//#region ../core/dist/esm/chat-tools/prompt-enable-push.js
+const PromptEnablePushInputSchema = z.object({ draftId: z.string().min(1).optional().describe("Optional draft ID currently being edited, if available") });
+const PromptEnablePushOutputSchema = z.object({
+	enabled: z.boolean().describe("Whether the user finished enabling push notifications and has at least one active subscription."),
+	deviceCount: z.number().int().min(0).describe("Number of active push devices the user has registered."),
+	message: z.string().min(1).describe("Human-readable status describing the outcome of the prompt.")
+});
+const toolPromptEnablePushSchema = z.object({
+	type: z.literal("tool-prompt-enable-push-notifications"),
+	toolCallId: z.string().min(1),
+	state: z.literal("input-available"),
+	input: PromptEnablePushInputSchema
+});
+z.object({
+	type: z.literal("tool-prompt-enable-push-notifications"),
+	toolCallId: z.string().min(1),
+	state: z.literal("output-available"),
+	input: PromptEnablePushInputSchema,
+	output: PromptEnablePushOutputSchema
+});
+function isPromptEnablePush(part) {
+	return toolPromptEnablePushSchema.safeParse(part).success;
+}
+//#endregion
+//#region ../core/dist/esm/chat-tools/select-connections.js
+const SelectConnectionTypeSchema = z.enum(["mcp", "trigger"]);
+const ConnectionItemSchema = z.object({
+	connectorId: z.string().min(1).describe("The connector ID to select a connection for"),
+	serviceName: z.string().min(1).describe("The human-readable name of the service"),
+	connectionType: SelectConnectionTypeSchema.describe("Type of connection needed: \"mcp\" for actions, \"trigger\" for events")
+});
+const SelectConnectionsInputSchema = z.object({
+	draftId: z.string().min(1).describe("The draft ID these connections belong to"),
+	connections: z.array(ConnectionItemSchema).min(1).describe("List of connections needed for this automation")
+});
+const ConnectionResultItemSchema = z.union([z.object({
+	type: z.literal("success"),
+	connectionId: z.string().min(1),
+	connectorId: z.string().min(1),
+	connectionType: SelectConnectionTypeSchema
+}), z.object({
+	type: z.literal("error"),
+	message: z.string().min(1),
+	connectorId: z.string().min(1),
+	connectionType: SelectConnectionTypeSchema
+})]);
+const SelectConnectionsOutputSchema = z.array(ConnectionResultItemSchema);
+const toolSelectConnectionsSchema = z.object({
+	type: z.literal("tool-select-connections"),
+	toolCallId: z.string().min(1),
+	state: z.literal("input-available"),
+	input: SelectConnectionsInputSchema
+});
+z.object({
+	type: z.literal("tool-select-connections"),
+	toolCallId: z.string().min(1),
+	state: z.literal("output-available"),
+	input: SelectConnectionsInputSchema,
+	output: SelectConnectionsOutputSchema
+});
+function isSelectConnections(part) {
+	return toolSelectConnectionsSchema.safeParse(part).success;
+}
+//#endregion
+//#region src/chat-turn/connection-requirements.ts
+const CONNECTION_LOOKUP_CONCURRENCY = 4;
+function deduplicateConnectionRequirements(requirements) {
+	const seen = /* @__PURE__ */ new Set();
+	return requirements.filter((requirement) => {
+		const key = JSON.stringify([requirement.connectorId, requirement.connectionType]);
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+async function loadConnectionRequirements(connections, requirements, options) {
+	return mapWithConcurrency(deduplicateConnectionRequirements(requirements), CONNECTION_LOOKUP_CONCURRENCY, async (requirement) => {
+		const response = await connections.list({
+			connectorId: requirement.connectorId,
+			capability: requirement.connectionType,
+			status: "authorized"
+		}, options);
+		return {
+			...requirement,
+			availableConnections: response.connections.map((connection) => ({
+				id: connection.id,
+				label: connectionAccountLabel({
+					label: connection.accountDisplayLabel ?? connection.name ?? connection.id,
+					mcpServerUrl: connection.mcpServerUrl
+				})
+			}))
+		};
+	});
+}
+async function mapWithConcurrency(items, concurrency, map) {
+	const results = new Array(items.length);
+	let next = 0;
+	const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+		while (next < items.length) {
+			const index = next;
+			next += 1;
+			results[index] = await map(items[index]);
+		}
+	});
+	await Promise.all(workers);
+	return results;
+}
+//#endregion
+//#region src/chat-turn/connection-setup.ts
+async function startConnectionSetup(connections, request, options) {
+	const body = {
+		...request.automationIds?.length ? { automationIds: [...request.automationIds] } : {},
+		...request.tenant !== void 0 ? { tenant: request.tenant } : {},
+		...request.serverUrl !== void 0 ? { serverUrl: request.serverUrl } : {}
+	};
+	const created = await connections.create({
+		connectorId: request.connectorId,
+		capability: request.capability,
+		...Object.keys(body).length > 0 ? { body } : {}
+	}, options);
+	return {
+		connectionId: created.connectionId,
+		setup: created.setup,
+		resumed: false
+	};
+}
+const INPUT_REQUIRED = "input_required";
+function getConnectionInputRequiredMessage(error) {
+	if (!(error instanceof AutomationsRequestError) || error.httpStatusCode !== 400) return;
+	const data = error.responseData;
+	if (data?.code !== INPUT_REQUIRED) return;
+	return typeof data.message === "string" ? data.message : error.message;
+}
+function resumeConnectionSetup(connection) {
+	return {
+		connectionId: connection.id,
+		setup: connection.setup,
+		resumed: true
+	};
+}
+function summarizeConnectionSetup(setup) {
+	if (setup?.kind === "oauth") return {
+		setupKind: "oauth",
+		authorizationUrl: setup.authorizationUrl
+	};
+	if (setup?.kind === "managed") return {
+		setupKind: "managed",
+		instructions: setup.instructions,
+		code: setup.code,
+		deepLinkUrl: setup.deepLinkUrl,
+		expiresAt: setup.expiresAt
+	};
+	return { setupKind: "none" };
+}
+function getConnectionSetupUrl(setup) {
+	if (setup?.kind === "oauth") return setup.authorizationUrl;
+	if (setup?.kind === "managed") return setup.deepLinkUrl;
+	return null;
+}
+//#endregion
+//#region src/chat-turn/messages.ts
+const persistedToolPartSchema = z.object({
+	type: z.string().trim().min(6).refine((type) => type.startsWith("tool-")),
+	toolCallId: z.string().trim().min(1),
+	state: z.enum([
+		"input-streaming",
+		"input-available",
+		"output-available",
+		"output-error"
+	])
+}).passthrough();
+function createUserMessage(text) {
+	return {
+		id: globalThis.crypto.randomUUID(),
+		role: "user",
+		parts: [{
+			type: "text",
+			text
+		}]
+	};
+}
+function toUiMessage(message) {
+	if (message.role !== "user" && message.role !== "assistant" && message.role !== "system") throw new Error(`Unsupported persisted chat role: ${message.role}`);
+	if (!Array.isArray(message.parts)) throw new Error(`Persisted chat message ${message.messageId} has invalid parts.`);
+	return {
+		id: message.messageId,
+		role: message.role,
+		parts: normalizePersistedMessageParts(message.parts)
+	};
+}
+function normalizePersistedMessageParts(parts) {
+	return parts.filter((part) => isTextPart(part) || isStepStartPart(part) || isReasoningPart(part) || persistedToolPartSchema.safeParse(part).success || isShownChatAcknowledgement(part));
+}
+function isTextPart(part) {
+	if (typeof part !== "object" || part === null) return false;
+	const candidate = part;
+	return candidate.type === "text" && typeof candidate.text === "string";
+}
+function isStepStartPart(part) {
+	if (typeof part !== "object" || part === null) return false;
+	return part.type === "step-start";
+}
+function isReasoningPart(part) {
+	if (typeof part !== "object" || part === null) return false;
+	const candidate = part;
+	return candidate.type === "reasoning" && typeof candidate.text === "string" && (candidate.state === void 0 || candidate.state === "streaming" || candidate.state === "done");
+}
+function getVisibleText(message) {
+	return message.parts.filter((part) => part.type === "text").map((part) => part.text).join("");
+}
+function getPendingClientAction(message) {
+	for (let index = message.parts.length - 1; index >= 0; index -= 1) {
+		const part = message.parts[index];
+		if (isSelectConnections(part)) return {
+			kind: "select_connections",
+			message,
+			toolCallId: part.toolCallId,
+			draftId: part.input.draftId,
+			connections: part.input.connections
+		};
+		if (isPromptEnablePush(part)) return {
+			kind: "enable_push",
+			message,
+			toolCallId: part.toolCallId,
+			draftId: part.input.draftId
+		};
+	}
+	return null;
+}
+function getPendingActionFromMessages(messages) {
+	const latestMessage = messages.at(-1);
+	if (!latestMessage || latestMessage.role !== "assistant") return null;
+	return getPendingClientAction(toUiMessage(latestMessage));
+}
+function getPublishedAutomationId(message) {
+	for (let index = message.parts.length - 1; index >= 0; index -= 1) {
+		const part = message.parts[index];
+		if (isPublishDraftResult(part) && part.output.success) return part.output.automationId;
+	}
+}
+function createEnablePushContinuation(action, output) {
+	return {
+		id: action.message.id,
+		role: "assistant",
+		parts: [{
+			type: "tool-prompt-enable-push-notifications",
+			toolCallId: action.toolCallId,
+			state: "output-available",
+			output
+		}]
+	};
+}
+function createSelectConnectionsContinuation(action, output) {
+	return {
+		id: action.message.id,
+		role: "assistant",
+		parts: [{
+			type: "tool-select-connections",
+			toolCallId: action.toolCallId,
+			state: "output-available",
+			output
+		}]
+	};
+}
+//#endregion
+//#region src/chat-turn/types.ts
+var ChatTurnInputError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "ChatTurnInputError";
+		this.code = code;
+	}
+};
+//#endregion
+//#region src/chat-turn/run-conversation-turn.ts
+async function runConversationTurn(options) {
+	const { api, transport, conversationId, signal } = options;
+	const workspaceId = options.workspaceId ?? null;
+	const requestOptions = { signal };
+	const pending = await readPendingAction(options);
+	let nextMessage;
+	if (pending?.kind === "enable_push") {
+		if ("message" in options.input || options.input.selections.length > 0) throw new ChatTurnInputError("awaiting_push", "The conversation is waiting for the push notification prompt to be answered.");
+		nextMessage = await answerEnablePush(options, pending);
+	} else if ("message" in options.input) {
+		if (pending?.kind === "select_connections") throw new ChatTurnInputError("awaiting_selection", "The conversation is waiting for connection selection.");
+		nextMessage = createUserMessage(options.input.message);
+	} else {
+		const selections = options.input.selections;
+		if (pending?.kind !== "select_connections") throw new ChatTurnInputError(selections.length > 0 ? "not_awaiting_selection" : "input_required", selections.length > 0 ? "The conversation is not waiting for connection selection." : "A message is required to continue.");
+		const resolution = await resolveSelectConnections(options, pending, selections);
+		if (resolution.kind === "required") return actionRequired(conversationId, getVisibleText(pending.message), resolution.pendingAction);
+		nextMessage = resolution.continuation;
+	}
+	while (true) {
+		const response = await transport.streamTurn({
+			conversationId,
+			workspaceId,
+			message: nextMessage,
+			signal,
+			onText: options.onText,
+			onToolActivity: options.onToolActivity
+		});
+		const assistantText = getVisibleText(response);
+		const automationId = getPublishedAutomationId(response);
+		if (automationId) {
+			options.onPublished?.(automationId);
+			return {
+				conversationId,
+				outcome: "published",
+				assistantText,
+				automationId,
+				...await archiveConversation(api, conversationId, requestOptions)
+			};
+		}
+		const responseAction = getPendingClientAction(response);
+		if (responseAction?.kind === "select_connections") {
+			const resolution = await resolveSelectConnections(options, responseAction, []);
+			if (resolution.kind === "resolved") {
+				nextMessage = resolution.continuation;
+				continue;
+			}
+			return actionRequired(conversationId, assistantText, resolution.pendingAction);
+		}
+		if (responseAction?.kind === "enable_push") return actionRequired(conversationId, assistantText, {
+			kind: "enable_push",
+			toolCallId: responseAction.toolCallId,
+			draftId: responseAction.draftId
+		});
+		return {
+			conversationId,
+			outcome: "awaiting_input",
+			assistantText
+		};
+	}
+}
+async function answerEnablePush(options, action) {
+	const { subscriptions } = await options.api.notifications.push.list({ signal: options.signal });
+	const deviceCount = subscriptions.length;
+	return createEnablePushContinuation(action, {
+		enabled: deviceCount > 0,
+		deviceCount,
+		message: deviceCount > 0 ? `Push notifications are enabled on ${deviceCount} device${deviceCount === 1 ? "" : "s"}.` : "The user has not enabled push notifications."
+	});
+}
+async function readPendingAction(options) {
+	if (options.pendingAction !== void 0) return options.pendingAction;
+	return getPendingActionFromMessages(await options.api.chat.getMessages(options.conversationId, { signal: options.signal }));
+}
+function actionRequired(conversationId, assistantText, pendingAction) {
+	return {
+		conversationId,
+		outcome: "action_required",
+		assistantText,
+		pendingAction
+	};
+}
+async function archiveConversation(api, conversationId, requestOptions) {
+	try {
+		if (!(await api.chat.updateConversation(conversationId, { isArchived: true }, requestOptions)).isArchived) throw new Error("The Automations API returned an active conversation.");
+		return { conversationArchived: true };
+	} catch (error) {
+		return {
+			conversationArchived: false,
+			conversationArchiveError: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+async function resolveSelectConnections(options, action, selections) {
+	const { api, signal } = options;
+	const requestOptions = { signal };
+	const requirements = await loadConnectionRequirements(api.connections, action.connections, requestOptions);
+	assertSelectionsUnambiguous(requirements, selections);
+	const resolved = [];
+	for (const requirement of requirements) {
+		let connectionId = selections.find((selection) => selection.connectorId === requirement.connectorId && (!selection.connectionType || selection.connectionType === requirement.connectionType))?.connectionId;
+		let setup;
+		if (connectionId) {
+			if (!requirement.availableConnections.some((connection) => connection.id === connectionId)) throw new ChatTurnInputError("unknown_connection", `Connection ${connectionId} is not an authorized ${requirement.serviceName} connection.`);
+		} else if (requirement.availableConnections.length === 1) connectionId = requirement.availableConnections[0]?.id;
+		else if (requirement.availableConnections.length > 1) connectionId = await options.chooseConnection?.(requirement);
+		else if (options.authorizeConnection) connectionId = await options.authorizeConnection(requirement);
+		else setup = await startConnectionSetup(api.connections, {
+			connectorId: requirement.connectorId,
+			capability: requirement.connectionType
+		}, requestOptions).catch((error) => {
+			throw toConnectionInputRequiredError(error, requirement.serviceName) ?? error;
+		});
+		if (!connectionId) return {
+			kind: "required",
+			pendingAction: {
+				kind: "select_connections",
+				toolCallId: action.toolCallId,
+				draftId: action.draftId,
+				requirements: requirements.map((item) => item === requirement && setup ? {
+					...item,
+					setup
+				} : item)
+			}
+		};
+		resolved.push({
+			requirement,
+			connectionId
+		});
+	}
+	const output = [];
+	for (const item of resolved) {
+		const body = {
+			connectorId: item.requirement.connectorId,
+			connectionType: item.requirement.connectionType,
+			connectionId: item.connectionId
+		};
+		const workspaceId = options.workspaceId ?? null;
+		if (workspaceId === null) await api.automationDraftConnections.upsert(action.draftId, body, requestOptions);
+		else await api.workspaceAutomationDraftConnections.upsert(workspaceId, action.draftId, body, requestOptions);
+		output.push({
+			type: "success",
+			...body
+		});
+	}
+	return {
+		kind: "resolved",
+		continuation: createSelectConnectionsContinuation(action, output)
+	};
+}
+function assertSelectionsUnambiguous(requirements, selections) {
+	for (const selection of selections) {
+		if (selection.connectionType) continue;
+		if (new Set(requirements.filter((requirement) => requirement.connectorId === selection.connectorId).map((requirement) => requirement.connectionType)).size > 1) throw new ChatTurnInputError("ambiguous_selection", `Connection selection for ${selection.connectorId} is ambiguous. Specify ${selection.connectorId}:mcp or ${selection.connectorId}:trigger.`);
+	}
+}
+function toConnectionInputRequiredError(error, serviceName) {
+	const message = getConnectionInputRequiredMessage(error);
+	if (message === void 0) return;
+	return new ChatTurnInputError("connection_input_required", `${serviceName} needs to be connected before the agent can continue. ${message}`);
+}
+//#endregion
+//#region src/chat-turn/errors.ts
+var ChatTurnError = class extends Error {
+	conversationId;
+	requestId;
+	stage;
+	response;
+	constructor({ conversationId, requestId, stage, cause }) {
+		const response = stage === "request" ? parseChatStreamRequestError(cause) : void 0;
+		super(response?.message ?? (cause instanceof Error ? cause.message : String(cause)), { cause });
+		this.name = "ChatTurnError";
+		this.conversationId = conversationId;
+		this.requestId = requestId;
+		this.stage = stage;
+		this.response = response;
+	}
+	get httpStatus() {
+		return this.response?.statusCode;
+	}
+};
+function parseChatStreamRequestError(error) {
+	if (!(error instanceof Error) || !error.message.trim().startsWith("{")) return void 0;
+	let body;
+	try {
+		body = JSON.parse(error.message);
+	} catch {
+		return;
+	}
+	const parsed = chatStreamRequestErrorResponseSchema.safeParse(body);
+	return parsed.success ? parsed.data : void 0;
+}
+function getChatTurnBillingRefusal(error) {
+	return getChatBillingRefusal(error instanceof ChatTurnError ? error.cause : error);
+}
+function readFailedRequest(error) {
+	if (error instanceof ChatTurnError) return {
+		requestId: error.requestId,
+		...error.httpStatus !== void 0 ? { httpStatus: error.httpStatus } : {}
+	};
+	if (error instanceof AutomationsRequestError) return {
+		...error.requestId ? { requestId: error.requestId } : {},
+		httpStatus: error.httpStatusCode
+	};
+	return {};
+}
+function classifyChatTurnFailure(error) {
+	const { httpStatus } = readFailedRequest(error);
+	if (httpStatus !== void 0) return httpStatus < 500 ? "refused" : "broken";
+	return error instanceof ChatTurnError || error instanceof AutomationsNetworkError ? "broken" : "other";
+}
+//#endregion
+//#region src/chat-turn/transport.ts
+var ChatTurnTransport = class {
+	transport;
+	constructor({ token, baseUrl, headers, fetch }) {
+		const apiRoot = `${baseUrl.replace(/\/+$/, "")}/v1`;
+		this.transport = new DefaultChatTransport({
+			api: `${apiRoot}/chat`,
+			headers: {
+				Authorization: `Bearer ${token}`,
+				...headers
+			},
+			credentials: "include",
+			fetch,
+			prepareSendMessagesRequest({ messages, body, api }) {
+				const { workspaceId, ...rest } = body ?? {};
+				return {
+					api: workspaceId ? `${apiRoot}/workspaces/${encodeURIComponent(workspaceId)}/chat` : api,
+					body: {
+						...rest,
+						message: messages.at(-1)
+					}
+				};
+			}
+		});
+	}
+	async streamTurn({ conversationId, workspaceId = null, message, signal, onText, onToolActivity }) {
+		const requestId = globalThis.crypto.randomUUID();
+		const fail = (stage, cause) => signal?.aborted ? cause : new ChatTurnError({
+			conversationId,
+			requestId,
+			stage,
+			cause
+		});
+		let stream;
+		try {
+			stream = await this.transport.sendMessages({
+				trigger: "submit-message",
+				chatId: conversationId,
+				messageId: void 0,
+				messages: [message],
+				abortSignal: signal,
+				headers: { "X-Request-Id": requestId },
+				body: {
+					conversationId,
+					workspaceId
+				}
+			});
+		} catch (error) {
+			throw fail("request", error);
+		}
+		let finalMessage;
+		let emittedText = "";
+		const emittedToolStates = /* @__PURE__ */ new Set();
+		let callbackError;
+		const report = (callback) => {
+			try {
+				callback();
+			} catch (error) {
+				callbackError = { error };
+				throw error;
+			}
+		};
+		try {
+			for await (const currentMessage of readUIMessageStream({
+				stream,
+				terminateOnError: true
+			})) {
+				finalMessage = currentMessage;
+				const visibleText = getVisibleText(currentMessage);
+				if (visibleText.startsWith(emittedText)) {
+					const delta = visibleText.slice(emittedText.length);
+					if (delta) report(() => onText?.(delta));
+					emittedText = visibleText;
+				}
+				for (const part of currentMessage.parts) {
+					const activity = toToolActivity(part);
+					if (!activity) continue;
+					const key = `${activity.toolCallId}:${activity.state}`;
+					if (emittedToolStates.has(key)) continue;
+					emittedToolStates.add(key);
+					report(() => onToolActivity?.(activity));
+				}
+			}
+		} catch (error) {
+			if (callbackError) throw callbackError.error;
+			throw fail("stream", error);
+		}
+		if (!finalMessage) throw new Error("The Automations chat returned an empty response.");
+		return finalMessage;
+	}
+};
+function toToolActivity(part) {
+	if (!part.type.startsWith("tool-") || !("toolCallId" in part) || !("state" in part)) return null;
+	return {
+		tool: part.type.slice(5),
+		toolCallId: String(part.toolCallId),
+		state: String(part.state)
+	};
+}
+//#endregion
+export { ChatTurnError, ChatTurnInputError, ChatTurnTransport, classifyChatTurnFailure, createEnablePushContinuation, createSelectConnectionsContinuation, createUserMessage, deduplicateConnectionRequirements, getChatTurnBillingRefusal, getConnectionInputRequiredMessage, getConnectionSetupUrl, getPendingActionFromMessages, getPendingClientAction, getPublishedAutomationId, getVisibleText, isReasoningPart, isStepStartPart, isTextPart, loadConnectionRequirements, normalizePersistedMessageParts, parseChatStreamRequestError, readFailedRequest, resumeConnectionSetup, runConversationTurn, startConnectionSetup, summarizeConnectionSetup, toUiMessage };