@todoist/automations-sdk 0.0.0-stage → 1.0.0

package/dist/connection-selection-BjNp9A-d.js

@@ -0,0 +1,226 @@
+import { z } from "zod";
+//#region ../core/dist/esm/constants/usage-billing.constants.js
+const USAGE_BILLING_DENIAL_CODES = [
+	"usage_billing_insufficient_credit",
+	"usage_billing_no_billing_account",
+	"usage_billing_plan_required",
+	"usage_billing_billing_paused"
+];
+const USAGE_BILLING_TEMPORARILY_UNAVAILABLE_CODE = "usage_billing_temporarily_unavailable";
+const USAGE_BILLING_UNAVAILABLE_CODE = "usage_billing_unavailable";
+function isUsageBillingDenialCode(code) {
+	return typeof code === "string" && USAGE_BILLING_DENIAL_CODES.includes(code);
+}
+//#endregion
+//#region ../core/dist/esm/types/automation.types.js
+const AUTOMATION_CONNECTION_STATUSES = [
+	"ready",
+	"almost-ready",
+	"not-ready"
+];
+const AUTOMATION_VISIBILITIES = ["private", "workspace"];
+const AUTOMATION_DISABLED_REASONS = ["creator-left-workspace", "workspace-plan-lapsed"];
+//#endregion
+//#region ../core/dist/esm/schemas/automation-draft-message.schema.js
+const saveMessageSchema = z.object({
+	role: z.string(),
+	parts: z.unknown(),
+	order: z.number(),
+	messageId: z.string()
+});
+//#endregion
+//#region ../core/dist/esm/schemas/chat.schema.js
+const chatConversationSchema = z.object({
+	id: z.string(),
+	title: z.string().nullable(),
+	archivedAt: z.string().nullable(),
+	isArchived: z.boolean(),
+	todoistUserId: z.string(),
+	workspaceId: z.string().nullable(),
+	createdAt: z.string(),
+	updatedAt: z.string()
+});
+const chatMessageSchema = saveMessageSchema;
+const getConversationsResponseSchema = z.array(chatConversationSchema);
+const getMessagesResponseSchema = z.array(chatMessageSchema);
+const chatCompactionStatusSchema = z.enum([
+	"starting",
+	"complete",
+	"failed"
+]);
+const chatCompactionBlockerSchema = z.enum([
+	"none",
+	"insufficient_messages",
+	"trailing_unanswered_user",
+	"incomplete_tool_interaction"
+]);
+const chatCompactionResultStatusSchema = z.enum([
+	"compacted",
+	"skipped",
+	"stale",
+	"failed"
+]);
+const chatCompactionStatusDataSchema = z.object({
+	status: chatCompactionStatusSchema,
+	conversationId: z.string(),
+	compactionId: z.string(),
+	message: z.string()
+});
+const chatCompactionTelemetryDataSchema = z.object({
+	kind: z.literal("telemetry"),
+	phase: z.enum(["snapshot", "post-compaction"]),
+	conversationId: z.string(),
+	compactionId: z.string().nullable(),
+	triggerMessages: z.number().int().positive(),
+	triggerTokens: z.number().int().positive(),
+	hardMaxTokens: z.number().int().positive(),
+	preserveRecentTurns: z.number().int().positive(),
+	messageCountAfterCutoff: z.number().int().nonnegative(),
+	estimatedTokens: z.number().int().nonnegative(),
+	thresholdProgressPercent: z.number().int().min(0).max(100),
+	shouldCompact: z.boolean(),
+	boundaryEligible: z.boolean(),
+	blocker: chatCompactionBlockerSchema,
+	attempted: z.boolean(),
+	resultStatus: chatCompactionResultStatusSchema.nullable(),
+	messagesSummarized: z.number().int().nonnegative().nullable(),
+	cutoffOrder: z.number().int().positive().nullable()
+});
+const chatCompactionDataSchema = z.union([chatCompactionStatusDataSchema, chatCompactionTelemetryDataSchema]);
+z.object({
+	type: z.literal("data-compaction"),
+	data: chatCompactionDataSchema
+});
+const chatConversationTitleUpdatedDataSchema = z.object({
+	kind: z.literal("conversation-title-updated"),
+	conversationId: z.string(),
+	title: z.string()
+});
+z.object({
+	type: z.literal("data-conversation"),
+	data: chatConversationTitleUpdatedDataSchema
+});
+const CHAT_ACKNOWLEDGEMENT_PART_TYPE = "data-acknowledgement";
+const chatAcknowledgementMessageSchema = z.string().trim().min(1).max(300);
+const shownChatAcknowledgementDataSchema = z.object({
+	status: z.literal("shown"),
+	message: chatAcknowledgementMessageSchema
+});
+z.discriminatedUnion("status", [
+	z.object({ status: z.literal("pending") }),
+	shownChatAcknowledgementDataSchema,
+	z.object({ status: z.literal("skipped") })
+]);
+const shownChatAcknowledgementDataPartSchema = z.object({
+	type: z.literal(CHAT_ACKNOWLEDGEMENT_PART_TYPE),
+	id: z.string().optional(),
+	data: shownChatAcknowledgementDataSchema
+});
+function isShownChatAcknowledgement(part) {
+	return typeof part === "object" && part !== null && "type" in part && part.type === "data-acknowledgement" && shownChatAcknowledgementDataPartSchema.safeParse(part).success;
+}
+const chatUsagePhaseSchema = z.enum(["streaming", "final"]);
+const chatUsageMessageMetadataSchema = z.object({
+	kind: z.literal("usage"),
+	phase: chatUsagePhaseSchema,
+	modelId: z.string(),
+	providerNames: z.array(z.string()).optional(),
+	inputTokens: z.number().int().nonnegative(),
+	noCacheInputTokens: z.number().int().nonnegative(),
+	cacheReadInputTokens: z.number().int().nonnegative(),
+	cacheWriteInputTokens: z.number().int().nonnegative(),
+	outputTokens: z.number().int().nonnegative(),
+	totalTokens: z.number().int().nonnegative(),
+	inputCostMicroDollars: z.number().int().nonnegative(),
+	outputCostMicroDollars: z.number().int().nonnegative(),
+	totalCostMicroDollars: z.number().int().nonnegative(),
+	cacheWrite1hCostMicroDollars: z.number().int().nonnegative().default(0),
+	searchCostMicroDollars: z.number().int().nonnegative(),
+	nestedLlmCostMicroDollars: z.number().int().nonnegative(),
+	estimatedUserInputTokens: z.number().int().nonnegative(),
+	estimatedUserInputCostMicroDollars: z.number().int().nonnegative(),
+	estimatedBaselineInputTokens: z.number().int().nonnegative(),
+	estimatedBaselineInputCostMicroDollars: z.number().int().nonnegative()
+});
+z.object({
+	type: z.string(),
+	messageMetadata: chatUsageMessageMetadataSchema
+});
+const chatUsagePreviewSchema = z.object({
+	kind: z.literal("preview"),
+	modelId: z.string(),
+	estimatedBaselineInputTokens: z.number().int().nonnegative(),
+	estimatedBaselineInputCostMicroDollars: z.number().int().nonnegative(),
+	excludesToolSchemaOverhead: z.boolean()
+});
+const chatStreamRequestErrorResponseSchema = z.object({
+	message: z.string(),
+	statusCode: z.number().int(),
+	code: z.enum([
+		...USAGE_BILLING_DENIAL_CODES,
+		USAGE_BILLING_TEMPORARILY_UNAVAILABLE_CODE,
+		USAGE_BILLING_UNAVAILABLE_CODE
+	]).optional().catch(void 0),
+	execution_started: z.boolean().optional()
+});
+function getChatBillingRefusal(error) {
+	if (!(error instanceof Error) || !error.message.trim().startsWith("{")) return null;
+	let body;
+	try {
+		body = JSON.parse(error.message);
+	} catch {
+		return null;
+	}
+	const parsed = chatStreamRequestErrorResponseSchema.safeParse(body);
+	if (!parsed.success) return null;
+	if (isUsageBillingDenialCode(parsed.data.code)) return {
+		message: parsed.data.message,
+		code: parsed.data.code
+	};
+	if (parsed.data.statusCode === 402 && isBodyWithoutCodeOrReason(body)) return {
+		message: parsed.data.message,
+		code: void 0
+	};
+	return null;
+}
+function isBodyWithoutCodeOrReason(body) {
+	return typeof body === "object" && body !== null && !("code" in body) && !("reason" in body);
+}
+const chatConversationStatusSchema = z.enum([
+	"active",
+	"archived",
+	"all"
+]);
+const getChatConversationsQuerySchema = z.object({
+	status: chatConversationStatusSchema.default("active"),
+	limit: z.coerce.number().int().positive().max(200).default(10)
+});
+const createChatConversationSchema = z.object({ title: z.string().nullable().optional() }).meta({ id: "CreateChatConversation" });
+const createWorkspaceChatConversationSchema = createChatConversationSchema.extend({ visibility: z.enum(AUTOMATION_VISIBILITIES).optional() }).meta({ id: "CreateWorkspaceChatConversation" });
+const updateChatConversationSchema = z.object({
+	title: z.string().nullable().optional(),
+	isArchived: z.boolean().optional()
+}).refine((value) => value.title !== void 0 || value.isArchived !== void 0, { message: "At least one field must be provided" }).meta({ id: "UpdateChatConversation" });
+//#endregion
+//#region src/connectors/connection-selection.ts
+function describeCandidateConnection({ id, accountDisplayLabel, mcpServerUrl }) {
+	const label = accountDisplayLabel ? connectionAccountLabel({
+		label: accountDisplayLabel,
+		mcpServerUrl
+	}) : mcpServerUrl && mcpServerHost(mcpServerUrl);
+	return label ? `${id} (${label})` : id;
+}
+function connectionAccountLabel({ label, mcpServerUrl }) {
+	if (!mcpServerUrl) return label;
+	const host = mcpServerHost(mcpServerUrl);
+	return label === host ? label : `${label} on ${host}`;
+}
+function mcpServerHost(mcpServerUrl) {
+	try {
+		return new URL(mcpServerUrl).host;
+	} catch {
+		return mcpServerUrl;
+	}
+}
+//#endregion
+export { AUTOMATION_VISIBILITIES as _, chatStreamRequestErrorResponseSchema as a, createWorkspaceChatConversationSchema as c, getConversationsResponseSchema as d, getMessagesResponseSchema as f, AUTOMATION_DISABLED_REASONS as g, AUTOMATION_CONNECTION_STATUSES as h, chatConversationSchema as i, getChatBillingRefusal as l, updateChatConversationSchema as m, describeCandidateConnection as n, chatUsagePreviewSchema as o, isShownChatAcknowledgement as p, mcpServerHost as r, createChatConversationSchema as s, connectionAccountLabel as t, getChatConversationsQuerySchema as u };

package/dist/connection-selection-C9yMkCvL.d.ts

@@ -0,0 +1,29 @@
+//#region src/connectors/connection-selection.d.ts
+/** An explicit connector-to-connection mapping supplied by the caller. */
+type ConnectionSelection = {
+  connectorId: string;
+  connectionType?: 'mcp' | 'trigger';
+  connectionId: string;
+};
+/** One of several authorised connections the user has to choose between. */
+type CandidateConnection = {
+  readonly id: string;
+  /** The account it belongs to, such as an email address, so the user can tell them apart. */
+  readonly accountDisplayLabel?: string;
+  /** The connection's own MCP server URL, for a tenant or self-hosted server. */
+  readonly mcpServerUrl?: string;
+};
+/** The id to pass back, with the account it belongs to when known. */
+declare function describeCandidateConnection({ id, accountDisplayLabel, mcpServerUrl }: CandidateConnection): string;
+/**
+ * An account label that tells connections on different MCP servers apart: a
+ * connection with its own server URL names the server's host after the account.
+ */
+declare function connectionAccountLabel({ label, mcpServerUrl }: {
+  label: string;
+  mcpServerUrl?: string | null;
+}): string;
+/** The host of a connection's own MCP server URL. */
+declare function mcpServerHost(mcpServerUrl: string): string;
+//#endregion
+export { mcpServerHost as a, describeCandidateConnection as i, ConnectionSelection as n, connectionAccountLabel as r, CandidateConnection as t };

package/dist/context-CxEkwuyE.js

@@ -0,0 +1,109 @@
+import { n as AutomationsRequestError, t as AutomationsNetworkError } from "./request-error-DoLXUa2p.js";
+//#region src/transport/http-client.ts
+function buildUrl(baseUrl, path, query) {
+	const trimmedBase = baseUrl.replace(/\/+$/, "");
+	const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+	const url = new URL(`${trimmedBase}${normalizedPath}`);
+	if (query) for (const [key, value] of Object.entries(query)) {
+		if (value === void 0 || value === null) continue;
+		if (Array.isArray(value)) {
+			for (const item of value) url.searchParams.append(key, String(item));
+			continue;
+		}
+		url.searchParams.append(key, String(value));
+	}
+	return url.toString();
+}
+async function readResponseBody(response) {
+	const text = await response.text();
+	if (text.length === 0) return void 0;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+}
+async function request(args) {
+	const { method, baseUrl, path, authToken, query, body, signal, headers: extraHeaders, isPublic, fetch: fetchImpl = fetch } = args;
+	const url = buildUrl(baseUrl, path, query);
+	const headers = {
+		Accept: "application/json",
+		...extraHeaders
+	};
+	if (!isPublic) headers.Authorization = `Bearer ${authToken}`;
+	const init = {
+		method,
+		headers
+	};
+	if (body !== void 0) {
+		headers["Content-Type"] = "application/json";
+		init.body = JSON.stringify(body);
+	}
+	if (signal !== void 0) init.signal = signal;
+	let response;
+	try {
+		response = await fetchImpl(url, init);
+	} catch (error) {
+		if (signal?.aborted) throw error;
+		throw new AutomationsNetworkError("Request failed before a response was received", error);
+	}
+	const data = await readResponseBody(response);
+	if (!response.ok) {
+		const message = typeof data === "object" && data !== null && "message" in data ? String(data.message) : response.statusText || `Request failed with status ${response.status}`;
+		throw new AutomationsRequestError(message, response.status, data, response.headers.get("WWW-Authenticate") ?? void 0, response.headers.get("X-Request-Id") ?? void 0);
+	}
+	return data;
+}
+//#endregion
+//#region src/clients/base-client.ts
+function mergeHeaders$1(defaults, overrides) {
+	if (!defaults && !overrides) return void 0;
+	const merged = {};
+	if (defaults) for (const [key, value] of Object.entries(defaults)) merged[key.toLowerCase()] = value;
+	if (overrides) for (const [key, value] of Object.entries(overrides)) merged[key.toLowerCase()] = value;
+	return merged;
+}
+var BaseClient = class {
+	context;
+	constructor(context) {
+		this.context = context;
+	}
+	request(args) {
+		const normalizedPath = args.path.startsWith("/") ? args.path : `/${args.path}`;
+		return request({
+			method: args.method,
+			baseUrl: this.context.baseUrl,
+			path: `/v1${normalizedPath}`,
+			authToken: this.context.authToken,
+			query: args.query,
+			body: args.body,
+			signal: args.options?.signal,
+			headers: mergeHeaders$1(this.context.defaultHeaders, args.options?.headers),
+			isPublic: args.isPublic,
+			fetch: this.context.fetch
+		});
+	}
+};
+//#endregion
+//#region src/clients/context.ts
+const DEFAULT_BASE_URL = "https://automations.todoist.com/api";
+const DEFAULT_TODOIST_BASE_URL = "https://api.todoist.com/api";
+function mergeHeaders(defaults, overrides) {
+	if (!defaults && !overrides) return void 0;
+	const merged = {};
+	for (const headers of [defaults, overrides]) {
+		if (!headers) continue;
+		for (const [key, value] of Object.entries(headers)) merged[key.toLowerCase()] = value;
+	}
+	return merged;
+}
+function createClientContext(authToken, options = {}, apiOrigin = "automations") {
+	return {
+		authToken,
+		baseUrl: (apiOrigin === "todoist" ? options.todoistBaseUrl ?? "https://api.todoist.com/api" : options.baseUrl ?? "https://automations.todoist.com/api").replace(/\/+$/, ""),
+		defaultHeaders: mergeHeaders(options.defaultHeaders, apiOrigin === "todoist" ? options.todoistDefaultHeaders : options.automationsDefaultHeaders),
+		fetch: options.fetch
+	};
+}
+//#endregion
+export { BaseClient as i, DEFAULT_TODOIST_BASE_URL as n, createClientContext as r, DEFAULT_BASE_URL as t };

package/dist/context-DsrXdqq8.d.ts

@@ -0,0 +1,65 @@
+//#region src/transport/http-client.d.ts
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+type QueryParams = Record<string, string | number | boolean | null | undefined | readonly string[] | readonly number[]>;
+//#endregion
+//#region src/clients/base-client.d.ts
+type ClientContext = {
+  authToken: string;
+  baseUrl: string;
+  defaultHeaders?: Record<string, string>;
+  fetch?: typeof fetch;
+};
+type RequestOptions = {
+  signal?: AbortSignal;
+  headers?: Record<string, string>;
+};
+declare abstract class BaseClient {
+  protected readonly context: ClientContext;
+  constructor(context: ClientContext);
+  protected request<T = unknown>(args: {
+    method: HttpMethod;
+    path: string;
+    query?: QueryParams;
+    body?: unknown;
+    options?: RequestOptions;
+    /**
+     * Set to `true` for backend routes decorated with `@Public()` so the
+     * `Authorization` header is omitted. Defaults to `false`.
+     */
+    isPublic?: boolean;
+  }): Promise<T>;
+}
+//#endregion
+//#region src/clients/context.d.ts
+declare const DEFAULT_BASE_URL = "https://automations.todoist.com/api";
+declare const DEFAULT_TODOIST_BASE_URL = "https://api.todoist.com/api";
+type ClientApiOptions = {
+  baseUrl?: string;
+  todoistBaseUrl?: string;
+  /**
+   * Headers merged into every request this client makes. Useful for
+   * static values like `x-todoist-staging` that should follow the token
+   * for the lifetime of the instance. Per-call `RequestOptions.headers`
+   * take precedence on conflict.
+   */
+  defaultHeaders?: Record<string, string>;
+  /** Headers merged into Automations API requests after `defaultHeaders`. */
+  automationsDefaultHeaders?: Record<string, string>;
+  /** Headers merged into Todoist API requests after `defaultHeaders`. */
+  todoistDefaultHeaders?: Record<string, string>;
+  /**
+   * The `fetch` every request on both API origins goes through. Defaults to
+   * the global `fetch`. Lets a caller add per-request values, such as a new
+   * request ID, that a static `defaultHeaders` map cannot carry.
+   */
+  fetch?: typeof fetch;
+};
+/**
+ * Builds the immutable context shared by every sub-client of an API instance.
+ * Normalizes the base URL (strips trailing slashes) so callers can pass values
+ * with or without one. Shared by `AutomationsApi` and the admin SDK so both
+ * resolve tokens, base URLs and default headers identically.
+ */
+declare function createClientContext(authToken: string, options?: ClientApiOptions, apiOrigin?: 'automations' | 'todoist'): ClientContext;
+//#endregion
+export { BaseClient as a, createClientContext as i, DEFAULT_BASE_URL as n, ClientContext as o, DEFAULT_TODOIST_BASE_URL as r, RequestOptions as s, ClientApiOptions as t };