windmill-client 1.651.1 → 1.653.0

package/dist/client.d.ts

@@ -87,12 +87,6 @@ export declare function getResult(jobId: string): Promise<any>;
  * @returns Object with started, completed, success, and result properties
  */
 export declare function getResultMaybe(jobId: string): Promise<any>;
-/**
- * Wrap a function to execute as a Windmill task within a flow context
- * @param f - Function to wrap as a task
- * @returns Async wrapper function that executes as a Windmill job
- */
-export declare function task<P, T>(f: (_: P) => T): (_: P) => Promise<T>;
 /**
  * @deprecated Use runScriptByPathAsync or runScriptByHashAsync instead
  */
@@ -417,3 +411,119 @@ export declare function requestInteractiveTeamsApproval({ teamName, channelName,
  * @returns S3 object record with storage and s3 key
  */
 export declare function parseS3Object(s3Object: S3Object): S3ObjectRecord;
+export declare class StepSuspend extends Error {
+    dispatchInfo: Record<string, any>;
+    constructor(dispatchInfo: Record<string, any>);
+}
+export interface TaskOptions {
+    timeout?: number;
+    tag?: string;
+    cache_ttl?: number;
+    priority?: number;
+    concurrency_limit?: number;
+    concurrency_key?: string;
+    concurrency_time_window_s?: number;
+}
+export declare let _workflowCtx: WorkflowCtx | null;
+export declare function setWorkflowCtx(ctx: WorkflowCtx | null): void;
+export declare class WorkflowCtx {
+    private completed;
+    private counters;
+    private pending;
+    private _suspended;
+    /** When set, the task matching this key executes its inner function directly */
+    _executingKey: string | null;
+    constructor(checkpoint?: Record<string, any>);
+    /** Name-based key: `double` for first call, `double_2`, `double_3` for subsequent. */
+    _allocKey(name: string): string;
+    _nextStep(name: string, script: string, args?: Record<string, any>, dispatch_type?: string, options?: TaskOptions): PromiseLike<any>;
+    /** Return and clear any pending (unawaited) steps. */
+    _flushPending(): Array<{
+        name: string;
+        script: string;
+        args: Record<string, any>;
+        key: string;
+        dispatch_type: string;
+    }>;
+    _waitForApproval(options?: {
+        timeout?: number;
+        form?: object;
+    }): PromiseLike<{
+        value: any;
+        approver: string;
+        approved: boolean;
+    }>;
+    _sleep(seconds: number): PromiseLike<void>;
+    _runInlineStep<T>(name: string, fn: () => T | Promise<T>): Promise<T>;
+}
+export declare function sleep(seconds: number): Promise<void>;
+export declare function step<T>(name: string, fn: () => T | Promise<T>): Promise<T>;
+/**
+ * Wrap an async function as a workflow task.
+ *
+ * @example
+ * const extract_data = task(async (url: string) => { ... });
+ * const run_external = task("f/external_script", async (x: number) => { ... });
+ *
+ * Inside a `workflow()`, calling a task dispatches it as a step.
+ * Outside a workflow, the function body executes directly.
+ */
+export declare function task<T extends (...args: any[]) => Promise<any>>(fnOrPath: T | string, maybeFnOrOptions?: T | TaskOptions, maybeOptions?: TaskOptions): T;
+/**
+ * Create a task that dispatches to a separate Windmill script.
+ *
+ * @example
+ * const extract = taskScript("f/data/extract");
+ * // inside workflow: await extract({ url: "https://..." })
+ */
+export declare function taskScript(path: string, options?: TaskOptions): (...args: any[]) => PromiseLike<any>;
+/**
+ * Create a task that dispatches to a separate Windmill flow.
+ *
+ * @example
+ * const pipeline = taskFlow("f/etl/pipeline");
+ * // inside workflow: await pipeline({ input: data })
+ */
+export declare function taskFlow(path: string, options?: TaskOptions): (...args: any[]) => PromiseLike<any>;
+/**
+ * Mark an async function as a workflow-as-code entry point.
+ *
+ * The function must be **deterministic**: given the same inputs it must call
+ * tasks in the same order on every replay. Branching on task results is fine
+ * (results are replayed from checkpoint), but branching on external state
+ * (current time, random values, external API calls) must use `step()` to
+ * checkpoint the value so replays see the same result.
+ */
+export declare function workflow<T>(fn: (...args: any[]) => Promise<T>): (...args: any[]) => Promise<T>;
+/**
+ * Suspend the workflow and wait for an external approval.
+ *
+ * Use `getResumeUrls()` (wrapped in `step()`) to obtain resume/cancel/approvalPage
+ * URLs before calling this function.
+ *
+ * @example
+ * const urls = await step("urls", () => getResumeUrls());
+ * await step("notify", () => sendEmail(urls.approvalPage));
+ * const { value, approver } = await waitForApproval({ timeout: 3600 });
+ */
+export declare function waitForApproval(options?: {
+    timeout?: number;
+    form?: object;
+}): PromiseLike<{
+    value: any;
+    approver: string;
+    approved: boolean;
+}>;
+/**
+ * Process items in parallel with optional concurrency control.
+ *
+ * Each item is processed by calling `fn(item)`, which should be a task().
+ * Items are dispatched in batches of `concurrency` (default: all at once).
+ *
+ * @example
+ * const process = task(async (item: string) => { ... });
+ * const results = await parallel(items, process, { concurrency: 5 });
+ */
+export declare function parallel<T, R>(items: T[], fn: (item: T) => PromiseLike<R> | R, options?: {
+    concurrency?: number;
+}): Promise<R[]>;

package/dist/client.mjs

@@ -181,37 +181,35 @@ async function getResultMaybe(jobId) {
 	});
 }
 const STRIP_COMMENTS = /(\/\/.*$)|(\/\*[\s\S]*?\*\/)|(\s*=[^,\)]*(('(?:\\'|[^'\r\n])*')|("(?:\\"|[^"\r\n])*"))|(\s*=[^,\)]*))/gm;
-const ARGUMENT_NAMES = /([^\s,]+)/g;
 function getParamNames(func) {
 	const fnStr = func.toString().replace(STRIP_COMMENTS, "");
-	let result = fnStr.slice(fnStr.indexOf("(") + 1, fnStr.indexOf(")")).match(ARGUMENT_NAMES);
-	if (result === null) result = [];
-	return result;
-}
-/**
-* Wrap a function to execute as a Windmill task within a flow context
-* @param f - Function to wrap as a task
-* @returns Async wrapper function that executes as a Windmill job
-*/
-function task(f) {
-	return async (...y) => {
-		const args = {};
-		const paramNames = getParamNames(f);
-		y.forEach((x, i) => args[paramNames[i]] = x);
-		let req = await fetch(`${OpenAPI.BASE}/w/${getWorkspace()}/jobs/run/workflow_as_code/${getEnv("WM_JOB_ID")}/${f.name}`, {
-			method: "POST",
-			headers: {
-				"Content-Type": "application/json",
-				Authorization: `Bearer ${getEnv("WM_TOKEN")}`
-			},
-			body: JSON.stringify({ args })
-		});
-		let jobId = await req.text();
-		console.log(`Started task ${f.name} as job ${jobId}`);
-		let r = await waitJob(jobId);
-		console.log(`Task ${f.name} (${jobId}) completed`);
-		return r;
-	};
+	const openIdx = fnStr.indexOf("(");
+	if (openIdx === -1) return [];
+	let depth = 1;
+	let closeIdx = openIdx + 1;
+	for (; closeIdx < fnStr.length && depth > 0; closeIdx++) if (fnStr[closeIdx] === "(") depth++;
+	else if (fnStr[closeIdx] === ")") depth--;
+	const paramStr = fnStr.slice(openIdx + 1, closeIdx - 1).trim();
+	if (!paramStr) return [];
+	const params = [];
+	let current = "";
+	let d = 0;
+	for (const ch of paramStr) {
+		if ("(<{".includes(ch)) d++;
+		else if (")>}".includes(ch)) d--;
+		if (ch === "," && d === 0) {
+			params.push(current.trim());
+			current = "";
+		} else current += ch;
+	}
+	if (current.trim()) params.push(current.trim());
+	return params.map((p) => {
+		p = p.replace(/^\.\.\./, "");
+		if (p.startsWith("{") || p.startsWith("[")) return "";
+		const colonIdx = p.indexOf(":");
+		if (colonIdx !== -1) p = p.slice(0, colonIdx);
+		return p.replace(/\?$/, "").trim();
+	}).filter(Boolean);
 }
 /**
 * @deprecated Use runScriptByPathAsync or runScriptByHashAsync instead
@@ -928,6 +926,315 @@ function parseS3Object(s3Object) {
 function parseVariableSyntax(s) {
 	if (s.startsWith("var://")) return s.substring(6);
 }
+var StepSuspend = class extends Error {
+	constructor(dispatchInfo) {
+		super("__step_suspend__");
+		this.dispatchInfo = dispatchInfo;
+		this.name = "StepSuspend";
+	}
+};
+let _workflowCtx = null;
+function setWorkflowCtx(ctx) {
+	_workflowCtx = ctx;
+	Reflect.set(globalThis, "__wmill_wf_ctx", ctx);
+}
+var WorkflowCtx = class {
+	completed;
+	counters = {};
+	pending = [];
+	_suspended = false;
+	/** When set, the task matching this key executes its inner function directly */
+	_executingKey;
+	constructor(checkpoint = {}) {
+		this.completed = checkpoint?.completed_steps ?? {};
+		this._executingKey = checkpoint?._executing_key ?? null;
+	}
+	/** Name-based key: `double` for first call, `double_2`, `double_3` for subsequent. */
+	_allocKey(name) {
+		const n = (this.counters[name] ?? 0) + 1;
+		this.counters[name] = n;
+		return n === 1 ? name : `${name}_${n}`;
+	}
+	_nextStep(name, script, args = {}, dispatch_type = "inline", options) {
+		const key = this._allocKey(name || script || "step");
+		if (key in this.completed) {
+			const value = this.completed[key];
+			if (value && typeof value === "object" && value.__wmill_error) {
+				const err = new Error(value.message || `Task '${name}' failed`);
+				err.result = value.result;
+				err.step_key = value.step_key;
+				err.child_job_id = value.child_job_id;
+				return { then: (_resolve, reject) => {
+					if (reject) reject(err);
+					else throw err;
+				} };
+			}
+			return { then: (resolve) => resolve(value) };
+		}
+		if (this._executingKey === key) return {
+			then: (resolve) => resolve(null),
+			_execute_directly: true
+		};
+		if (this._executingKey !== null) return { then: () => new Promise(() => {}) };
+		const stepInfo = {
+			name: name || key,
+			script: script || key,
+			args,
+			key,
+			dispatch_type
+		};
+		if (options) {
+			if (options.timeout !== void 0) stepInfo.timeout = options.timeout;
+			if (options.tag !== void 0) stepInfo.tag = options.tag;
+			if (options.cache_ttl !== void 0) stepInfo.cache_ttl = options.cache_ttl;
+			if (options.priority !== void 0) stepInfo.priority = options.priority;
+			if (options.concurrency_limit !== void 0) stepInfo.concurrent_limit = options.concurrency_limit;
+			if (options.concurrency_key !== void 0) stepInfo.concurrency_key = options.concurrency_key;
+			if (options.concurrency_time_window_s !== void 0) stepInfo.concurrency_time_window_s = options.concurrency_time_window_s;
+		}
+		this.pending.push(stepInfo);
+		return { then: () => {
+			if (this._suspended) return new Promise(() => {});
+			this._suspended = true;
+			const steps = [...this.pending];
+			this.pending = [];
+			throw new StepSuspend({
+				mode: steps.length > 1 ? "parallel" : "sequential",
+				steps
+			});
+		} };
+	}
+	/** Return and clear any pending (unawaited) steps. */
+	_flushPending() {
+		const steps = [...this.pending];
+		this.pending = [];
+		return steps;
+	}
+	_waitForApproval(options) {
+		const key = this._allocKey("approval");
+		if (key in this.completed) {
+			const value = this.completed[key];
+			return { then: (resolve) => resolve(value) };
+		}
+		if (this._executingKey !== null) return { then: () => new Promise(() => {}) };
+		throw new StepSuspend({
+			mode: "approval",
+			key,
+			timeout: options?.timeout ?? 1800,
+			form: options?.form,
+			steps: []
+		});
+	}
+	_sleep(seconds) {
+		const key = this._allocKey("sleep");
+		if (key in this.completed) return { then: (resolve) => resolve(void 0) };
+		if (this._executingKey !== null) return { then: () => new Promise(() => {}) };
+		throw new StepSuspend({
+			mode: "sleep",
+			key,
+			seconds: Math.max(1, Math.round(seconds)),
+			steps: []
+		});
+	}
+	async _runInlineStep(name, fn) {
+		const key = this._allocKey(name || "step");
+		if (key in this.completed) {
+			const value = this.completed[key];
+			if (value && typeof value === "object" && value.__wmill_error) {
+				const err = new Error(value.message || `Step '${name}' failed`);
+				err.result = value.result;
+				err.step_key = value.step_key;
+				err.child_job_id = value.child_job_id;
+				throw err;
+			}
+			return value;
+		}
+		if (this._executingKey !== null) return new Promise(() => {});
+		const result = await fn();
+		throw new StepSuspend({
+			mode: "inline_checkpoint",
+			steps: [],
+			key,
+			result
+		});
+	}
+};
+async function sleep(seconds) {
+	const ctx = _workflowCtx ?? Reflect.get(globalThis, "__wmill_wf_ctx");
+	if (ctx) return ctx._sleep(seconds);
+	await new Promise((r) => setTimeout(r, seconds * 1e3));
+}
+async function step(name, fn) {
+	const ctx = _workflowCtx ?? Reflect.get(globalThis, "__wmill_wf_ctx");
+	if (ctx) return ctx._runInlineStep(name, fn);
+	return fn();
+}
+/**
+* Wrap an async function as a workflow task.
+*
+* @example
+* const extract_data = task(async (url: string) => { ... });
+* const run_external = task("f/external_script", async (x: number) => { ... });
+*
+* Inside a `workflow()`, calling a task dispatches it as a step.
+* Outside a workflow, the function body executes directly.
+*/
+function task(fnOrPath, maybeFnOrOptions, maybeOptions) {
+	let fn;
+	let taskPath;
+	let taskOptions;
+	if (typeof fnOrPath === "string") {
+		taskPath = fnOrPath;
+		fn = maybeFnOrOptions;
+		taskOptions = maybeOptions;
+	} else {
+		fn = fnOrPath;
+		taskOptions = maybeFnOrOptions;
+	}
+	const taskName = fn.name || taskPath || "";
+	const wrapper = function(...args) {
+		const ctx = _workflowCtx ?? Reflect.get(globalThis, "__wmill_wf_ctx");
+		if (ctx) {
+			const script = taskPath ?? taskName;
+			const paramNames = getParamNames(fn);
+			const kwargs = {};
+			for (let i = 0; i < args.length; i++) if (paramNames[i]) kwargs[paramNames[i]] = args[i];
+			else kwargs[`arg${i}`] = args[i];
+			const stepResult = ctx._nextStep(taskName, script, kwargs, "inline", taskOptions);
+			if (stepResult?._execute_directly) return (async () => {
+				const result = await fn(...args);
+				throw new StepSuspend({
+					mode: "step_complete",
+					steps: [],
+					result
+				});
+			})();
+			return stepResult;
+		} else if (getEnv("WM_JOB_ID") && !getEnv("WM_FLOW_JOB_ID")) return (async () => {
+			const paramNames = getParamNames(fn);
+			const kwargs = {};
+			args.forEach((x, i) => kwargs[paramNames[i]] = x);
+			let req = await fetch(`${OpenAPI.BASE}/w/${getWorkspace()}/jobs/run/workflow_as_code/${getEnv("WM_JOB_ID")}/${taskName}`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: `Bearer ${getEnv("WM_TOKEN")}`
+				},
+				body: JSON.stringify({ args: kwargs })
+			});
+			let jobId = await req.text();
+			console.log(`Started task ${taskName} as job ${jobId}`);
+			let r = await waitJob(jobId);
+			console.log(`Task ${taskName} (${jobId}) completed`);
+			return r;
+		})();
+		else return fn(...args);
+	};
+	Object.defineProperty(wrapper, "name", { value: taskName });
+	wrapper._is_task = true;
+	wrapper._task_path = taskPath;
+	return wrapper;
+}
+/**
+* Create a task that dispatches to a separate Windmill script.
+*
+* @example
+* const extract = taskScript("f/data/extract");
+* // inside workflow: await extract({ url: "https://..." })
+*/
+function taskScript(path, options) {
+	const name = path.split("/").pop() || path;
+	const wrapper = function(...args) {
+		const ctx = _workflowCtx ?? Reflect.get(globalThis, "__wmill_wf_ctx");
+		if (ctx) {
+			const kwargs = args.length === 1 && typeof args[0] === "object" && args[0] !== null ? args[0] : args.reduce((acc, v, i) => {
+				acc[`arg${i}`] = v;
+				return acc;
+			}, {});
+			return ctx._nextStep(name, path, kwargs, "script", options);
+		}
+		throw new Error(`taskScript("${path}") can only be called inside a workflow()`);
+	};
+	Object.defineProperty(wrapper, "name", { value: name });
+	wrapper._is_task = true;
+	wrapper._task_path = path;
+	return wrapper;
+}
+/**
+* Create a task that dispatches to a separate Windmill flow.
+*
+* @example
+* const pipeline = taskFlow("f/etl/pipeline");
+* // inside workflow: await pipeline({ input: data })
+*/
+function taskFlow(path, options) {
+	const name = path.split("/").pop() || path;
+	const wrapper = function(...args) {
+		const ctx = _workflowCtx ?? Reflect.get(globalThis, "__wmill_wf_ctx");
+		if (ctx) {
+			const kwargs = args.length === 1 && typeof args[0] === "object" && args[0] !== null ? args[0] : args.reduce((acc, v, i) => {
+				acc[`arg${i}`] = v;
+				return acc;
+			}, {});
+			return ctx._nextStep(name, path, kwargs, "flow", options);
+		}
+		throw new Error(`taskFlow("${path}") can only be called inside a workflow()`);
+	};
+	Object.defineProperty(wrapper, "name", { value: name });
+	wrapper._is_task = true;
+	wrapper._task_path = path;
+	return wrapper;
+}
+/**
+* Mark an async function as a workflow-as-code entry point.
+*
+* The function must be **deterministic**: given the same inputs it must call
+* tasks in the same order on every replay. Branching on task results is fine
+* (results are replayed from checkpoint), but branching on external state
+* (current time, random values, external API calls) must use `step()` to
+* checkpoint the value so replays see the same result.
+*/
+function workflow(fn) {
+	fn._is_workflow = true;
+	return fn;
+}
+/**
+* Suspend the workflow and wait for an external approval.
+*
+* Use `getResumeUrls()` (wrapped in `step()`) to obtain resume/cancel/approvalPage
+* URLs before calling this function.
+*
+* @example
+* const urls = await step("urls", () => getResumeUrls());
+* await step("notify", () => sendEmail(urls.approvalPage));
+* const { value, approver } = await waitForApproval({ timeout: 3600 });
+*/
+function waitForApproval(options) {
+	const ctx = _workflowCtx ?? Reflect.get(globalThis, "__wmill_wf_ctx");
+	if (!ctx) throw new Error("waitForApproval can only be called inside a workflow()");
+	return ctx._waitForApproval(options);
+}
+/**
+* Process items in parallel with optional concurrency control.
+*
+* Each item is processed by calling `fn(item)`, which should be a task().
+* Items are dispatched in batches of `concurrency` (default: all at once).
+*
+* @example
+* const process = task(async (item: string) => { ... });
+* const results = await parallel(items, process, { concurrency: 5 });
+*/
+async function parallel(items, fn, options) {
+	const concurrency = options?.concurrency ?? items.length;
+	if (concurrency <= 0 || items.length === 0) return [];
+	const results = [];
+	for (let i = 0; i < items.length; i += concurrency) {
+		const batch = items.slice(i, i + concurrency);
+		const batchResults = await Promise.all(batch.map((item) => fn(item)));
+		results.push(...batchResults);
+	}
+	return results;
+}
 
 //#endregion
-export { SHARED_FOLDER, appendToResultStream, base64ToUint8Array, databaseUrlFromResource, denoS3LightClientSettings, getFlowUserState, getIdToken, getInternalState, getPresignedS3PublicUrl, getPresignedS3PublicUrls, getProgress, getResource, getResult, getResultMaybe, getResumeEndpoints, getResumeUrls, getRootJobId, getState, getStatePath, getVariable, getWorkspace, loadS3File, loadS3FileStream, parseS3Object, requestInteractiveSlackApproval, requestInteractiveTeamsApproval, resolveDefaultResource, runFlow, runFlowAsync, runScript, runScriptAsync, runScriptByHash, runScriptByHashAsync, runScriptByPath, runScriptByPathAsync, setClient, setFlowUserState, setInternalState, setProgress, setResource, setState, setVariable, signS3Object, signS3Objects, streamResult, task, uint8ArrayToBase64, usernameToEmail, waitJob, writeS3File };
+export { SHARED_FOLDER, StepSuspend, WorkflowCtx, _workflowCtx, appendToResultStream, base64ToUint8Array, databaseUrlFromResource, denoS3LightClientSettings, getFlowUserState, getIdToken, getInternalState, getPresignedS3PublicUrl, getPresignedS3PublicUrls, getProgress, getResource, getResult, getResultMaybe, getResumeEndpoints, getResumeUrls, getRootJobId, getState, getStatePath, getVariable, getWorkspace, loadS3File, loadS3FileStream, parallel, parseS3Object, requestInteractiveSlackApproval, requestInteractiveTeamsApproval, resolveDefaultResource, runFlow, runFlowAsync, runScript, runScriptAsync, runScriptByHash, runScriptByHashAsync, runScriptByPath, runScriptByPathAsync, setClient, setFlowUserState, setInternalState, setProgress, setResource, setState, setVariable, setWorkflowCtx, signS3Object, signS3Objects, sleep, step, streamResult, task, taskFlow, taskScript, uint8ArrayToBase64, usernameToEmail, waitForApproval, waitJob, workflow, writeS3File };

package/dist/core/OpenAPI.mjs

@@ -29,7 +29,7 @@ const OpenAPI = {
 	PASSWORD: void 0,
 	TOKEN: getEnv("WM_TOKEN"),
 	USERNAME: void 0,
-	VERSION: "1.651.1",
+	VERSION: "1.653.0",
 	WITH_CREDENTIALS: true,
 	interceptors: {
 		request: new Interceptors(),

package/dist/index.d.ts

@@ -4,8 +4,8 @@ export { OpenAPI, type OpenAPIConfig } from './core/OpenAPI';
 export * from './services.gen';
 export * from './types.gen';
 export type { DenoS3LightClientSettings } from "./s3Types";
-export { type Base64, setClient, getVariable, setVariable, getResource, setResource, getResumeUrls, setState, setProgress, getProgress, getState, getIdToken, denoS3LightClientSettings, loadS3FileStream, loadS3File, writeS3File, signS3Objects, signS3Object, getPresignedS3PublicUrls, getPresignedS3PublicUrl, task, runScript, runScriptAsync, runScriptByPath, runScriptByHash, runScriptByPathAsync, runScriptByHashAsync, runFlow, runFlowAsync, waitJob, getRootJobId, setFlowUserState, getFlowUserState, usernameToEmail, requestInteractiveSlackApproval, type Sql, requestInteractiveTeamsApproval, appendToResultStream, streamResult, datatable, ducklake, type DatatableSqlTemplateFunction, type SqlTemplateFunction, type S3Object, type S3ObjectRecord, type S3ObjectURI } from "./client";
-import { setClient, getVariable, setVariable, getResource, setResource, getResumeUrls, setState, setProgress, getProgress, getState, getIdToken, denoS3LightClientSettings, loadS3FileStream, loadS3File, writeS3File, signS3Objects, signS3Object, getPresignedS3PublicUrls, getPresignedS3PublicUrl, task, runScript, runScriptAsync, runScriptByPath, runScriptByHash, runScriptByPathAsync, runScriptByHashAsync, runFlow, runFlowAsync, waitJob, getRootJobId, setFlowUserState, getFlowUserState, usernameToEmail, requestInteractiveSlackApproval, requestInteractiveTeamsApproval, appendToResultStream, streamResult, datatable, ducklake, getWorkspace, getStatePath, getInternalState, setInternalState, getResumeEndpoints, getResult, getResultMaybe, resolveDefaultResource, databaseUrlFromResource, base64ToUint8Array, uint8ArrayToBase64, parseS3Object } from "./client";
+export { type Base64, setClient, getVariable, setVariable, getResource, setResource, getResumeUrls, setState, setProgress, getProgress, getState, getIdToken, denoS3LightClientSettings, loadS3FileStream, loadS3File, writeS3File, signS3Objects, signS3Object, getPresignedS3PublicUrls, getPresignedS3PublicUrl, task, taskScript, taskFlow, workflow, step, sleep, parallel, waitForApproval, type TaskOptions, WorkflowCtx, _workflowCtx, setWorkflowCtx, StepSuspend, runScript, runScriptAsync, runScriptByPath, runScriptByHash, runScriptByPathAsync, runScriptByHashAsync, runFlow, runFlowAsync, waitJob, getRootJobId, setFlowUserState, getFlowUserState, usernameToEmail, requestInteractiveSlackApproval, type Sql, requestInteractiveTeamsApproval, appendToResultStream, streamResult, datatable, ducklake, type DatatableSqlTemplateFunction, type SqlTemplateFunction, type S3Object, type S3ObjectRecord, type S3ObjectURI } from "./client";
+import { setClient, getVariable, setVariable, getResource, setResource, getResumeUrls, setState, setProgress, getProgress, getState, getIdToken, denoS3LightClientSettings, loadS3FileStream, loadS3File, writeS3File, signS3Objects, signS3Object, getPresignedS3PublicUrls, getPresignedS3PublicUrl, task, taskScript, taskFlow, workflow, step, sleep, parallel, waitForApproval, WorkflowCtx, setWorkflowCtx, StepSuspend, runScript, runScriptAsync, runScriptByPath, runScriptByHash, runScriptByPathAsync, runScriptByHashAsync, runFlow, runFlowAsync, waitJob, getRootJobId, setFlowUserState, getFlowUserState, usernameToEmail, requestInteractiveSlackApproval, requestInteractiveTeamsApproval, appendToResultStream, streamResult, datatable, ducklake, getWorkspace, getStatePath, getInternalState, setInternalState, getResumeEndpoints, getResult, getResultMaybe, resolveDefaultResource, databaseUrlFromResource, base64ToUint8Array, uint8ArrayToBase64, parseS3Object } from "./client";
 import { AdminService, AuditService, FlowService, GranularAclService, GroupService, JobService, ResourceService, VariableService, ScriptService, ScheduleService, SettingsService, UserService, WorkspaceService, TeamsService } from "./services.gen";
 declare const wmill: {
     setClient: typeof setClient;
@@ -28,6 +28,17 @@ declare const wmill: {
     getPresignedS3PublicUrls: typeof getPresignedS3PublicUrls;
     getPresignedS3PublicUrl: typeof getPresignedS3PublicUrl;
     task: typeof task;
+    taskScript: typeof taskScript;
+    taskFlow: typeof taskFlow;
+    workflow: typeof workflow;
+    step: typeof step;
+    sleep: typeof sleep;
+    parallel: typeof parallel;
+    waitForApproval: typeof waitForApproval;
+    WorkflowCtx: typeof WorkflowCtx;
+    _workflowCtx: WorkflowCtx | null;
+    setWorkflowCtx: typeof setWorkflowCtx;
+    StepSuspend: typeof StepSuspend;
     runScript: typeof runScript;
     runScriptAsync: typeof runScriptAsync;
     runScriptByPath: typeof runScriptByPath;

package/dist/index.js

@@ -126,7 +126,7 @@ const OpenAPI = {
 	PASSWORD: void 0,
 	TOKEN: getEnv$1("WM_TOKEN"),
 	USERNAME: void 0,
-	VERSION: "1.651.1",
+	VERSION: "1.653.0",
 	WITH_CREDENTIALS: true,
 	interceptors: {
 		request: new Interceptors(),
@@ -13261,37 +13261,35 @@ async function getResultMaybe(jobId) {
 	});
 }
 const STRIP_COMMENTS = /(\/\/.*$)|(\/\*[\s\S]*?\*\/)|(\s*=[^,\)]*(('(?:\\'|[^'\r\n])*')|("(?:\\"|[^"\r\n])*"))|(\s*=[^,\)]*))/gm;
-const ARGUMENT_NAMES = /([^\s,]+)/g;
 function getParamNames(func) {
 	const fnStr = func.toString().replace(STRIP_COMMENTS, "");
-	let result = fnStr.slice(fnStr.indexOf("(") + 1, fnStr.indexOf(")")).match(ARGUMENT_NAMES);
-	if (result === null) result = [];
-	return result;
-}
-/**
-* Wrap a function to execute as a Windmill task within a flow context
-* @param f - Function to wrap as a task
-* @returns Async wrapper function that executes as a Windmill job
-*/
-function task(f) {
-	return async (...y) => {
-		const args = {};
-		const paramNames = getParamNames(f);
-		y.forEach((x, i) => args[paramNames[i]] = x);
-		let req = await fetch(`${OpenAPI.BASE}/w/${getWorkspace()}/jobs/run/workflow_as_code/${getEnv("WM_JOB_ID")}/${f.name}`, {
-			method: "POST",
-			headers: {
-				"Content-Type": "application/json",
-				Authorization: `Bearer ${getEnv("WM_TOKEN")}`
-			},
-			body: JSON.stringify({ args })
-		});
-		let jobId = await req.text();
-		console.log(`Started task ${f.name} as job ${jobId}`);
-		let r = await waitJob(jobId);
-		console.log(`Task ${f.name} (${jobId}) completed`);
-		return r;
-	};
+	const openIdx = fnStr.indexOf("(");
+	if (openIdx === -1) return [];
+	let depth = 1;
+	let closeIdx = openIdx + 1;
+	for (; closeIdx < fnStr.length && depth > 0; closeIdx++) if (fnStr[closeIdx] === "(") depth++;
+	else if (fnStr[closeIdx] === ")") depth--;
+	const paramStr = fnStr.slice(openIdx + 1, closeIdx - 1).trim();
+	if (!paramStr) return [];
+	const params = [];
+	let current = "";
+	let d = 0;
+	for (const ch of paramStr) {
+		if ("(<{".includes(ch)) d++;
+		else if (")>}".includes(ch)) d--;
+		if (ch === "," && d === 0) {
+			params.push(current.trim());
+			current = "";
+		} else current += ch;
+	}
+	if (current.trim()) params.push(current.trim());
+	return params.map((p) => {
+		p = p.replace(/^\.\.\./, "");
+		if (p.startsWith("{") || p.startsWith("[")) return "";
+		const colonIdx = p.indexOf(":");
+		if (colonIdx !== -1) p = p.slice(0, colonIdx);
+		return p.replace(/\?$/, "").trim();
+	}).filter(Boolean);
 }
 /**
 * @deprecated Use runScriptByPathAsync or runScriptByHashAsync instead
@@ -14008,6 +14006,315 @@ function parseS3Object(s3Object) {
 function parseVariableSyntax(s) {
 	if (s.startsWith("var://")) return s.substring(6);
 }
+var StepSuspend = class extends Error {
+	constructor(dispatchInfo) {
+		super("__step_suspend__");
+		this.dispatchInfo = dispatchInfo;
+		this.name = "StepSuspend";
+	}
+};
+let _workflowCtx = null;
+function setWorkflowCtx(ctx) {
+	_workflowCtx = ctx;
+	Reflect.set(globalThis, "__wmill_wf_ctx", ctx);
+}
+var WorkflowCtx = class {
+	completed;
+	counters = {};
+	pending = [];
+	_suspended = false;
+	/** When set, the task matching this key executes its inner function directly */
+	_executingKey;
+	constructor(checkpoint = {}) {
+		this.completed = checkpoint?.completed_steps ?? {};
+		this._executingKey = checkpoint?._executing_key ?? null;
+	}
+	/** Name-based key: `double` for first call, `double_2`, `double_3` for subsequent. */
+	_allocKey(name) {
+		const n = (this.counters[name] ?? 0) + 1;
+		this.counters[name] = n;
+		return n === 1 ? name : `${name}_${n}`;
+	}
+	_nextStep(name, script, args = {}, dispatch_type = "inline", options) {
+		const key = this._allocKey(name || script || "step");
+		if (key in this.completed) {
+			const value = this.completed[key];
+			if (value && typeof value === "object" && value.__wmill_error) {
+				const err = new Error(value.message || `Task '${name}' failed`);
+				err.result = value.result;
+				err.step_key = value.step_key;
+				err.child_job_id = value.child_job_id;
+				return { then: (_resolve, reject) => {
+					if (reject) reject(err);
+					else throw err;
+				} };
+			}
+			return { then: (resolve$1) => resolve$1(value) };
+		}
+		if (this._executingKey === key) return {
+			then: (resolve$1) => resolve$1(null),
+			_execute_directly: true
+		};
+		if (this._executingKey !== null) return { then: () => new Promise(() => {}) };
+		const stepInfo = {
+			name: name || key,
+			script: script || key,
+			args,
+			key,
+			dispatch_type
+		};
+		if (options) {
+			if (options.timeout !== void 0) stepInfo.timeout = options.timeout;
+			if (options.tag !== void 0) stepInfo.tag = options.tag;
+			if (options.cache_ttl !== void 0) stepInfo.cache_ttl = options.cache_ttl;
+			if (options.priority !== void 0) stepInfo.priority = options.priority;
+			if (options.concurrency_limit !== void 0) stepInfo.concurrent_limit = options.concurrency_limit;
+			if (options.concurrency_key !== void 0) stepInfo.concurrency_key = options.concurrency_key;
+			if (options.concurrency_time_window_s !== void 0) stepInfo.concurrency_time_window_s = options.concurrency_time_window_s;
+		}
+		this.pending.push(stepInfo);
+		return { then: () => {
+			if (this._suspended) return new Promise(() => {});
+			this._suspended = true;
+			const steps = [...this.pending];
+			this.pending = [];
+			throw new StepSuspend({
+				mode: steps.length > 1 ? "parallel" : "sequential",
+				steps
+			});
+		} };
+	}
+	/** Return and clear any pending (unawaited) steps. */
+	_flushPending() {
+		const steps = [...this.pending];
+		this.pending = [];
+		return steps;
+	}
+	_waitForApproval(options) {
+		const key = this._allocKey("approval");
+		if (key in this.completed) {
+			const value = this.completed[key];
+			return { then: (resolve$1) => resolve$1(value) };
+		}
+		if (this._executingKey !== null) return { then: () => new Promise(() => {}) };
+		throw new StepSuspend({
+			mode: "approval",
+			key,
+			timeout: options?.timeout ?? 1800,
+			form: options?.form,
+			steps: []
+		});
+	}
+	_sleep(seconds) {
+		const key = this._allocKey("sleep");
+		if (key in this.completed) return { then: (resolve$1) => resolve$1(void 0) };
+		if (this._executingKey !== null) return { then: () => new Promise(() => {}) };
+		throw new StepSuspend({
+			mode: "sleep",
+			key,
+			seconds: Math.max(1, Math.round(seconds)),
+			steps: []
+		});
+	}
+	async _runInlineStep(name, fn) {
+		const key = this._allocKey(name || "step");
+		if (key in this.completed) {
+			const value = this.completed[key];
+			if (value && typeof value === "object" && value.__wmill_error) {
+				const err = new Error(value.message || `Step '${name}' failed`);
+				err.result = value.result;
+				err.step_key = value.step_key;
+				err.child_job_id = value.child_job_id;
+				throw err;
+			}
+			return value;
+		}
+		if (this._executingKey !== null) return new Promise(() => {});
+		const result = await fn();
+		throw new StepSuspend({
+			mode: "inline_checkpoint",
+			steps: [],
+			key,
+			result
+		});
+	}
+};
+async function sleep(seconds) {
+	const ctx = _workflowCtx ?? Reflect.get(globalThis, "__wmill_wf_ctx");
+	if (ctx) return ctx._sleep(seconds);
+	await new Promise((r) => setTimeout(r, seconds * 1e3));
+}
+async function step(name, fn) {
+	const ctx = _workflowCtx ?? Reflect.get(globalThis, "__wmill_wf_ctx");
+	if (ctx) return ctx._runInlineStep(name, fn);
+	return fn();
+}
+/**
+* Wrap an async function as a workflow task.
+*
+* @example
+* const extract_data = task(async (url: string) => { ... });
+* const run_external = task("f/external_script", async (x: number) => { ... });
+*
+* Inside a `workflow()`, calling a task dispatches it as a step.
+* Outside a workflow, the function body executes directly.
+*/
+function task(fnOrPath, maybeFnOrOptions, maybeOptions) {
+	let fn;
+	let taskPath;
+	let taskOptions;
+	if (typeof fnOrPath === "string") {
+		taskPath = fnOrPath;
+		fn = maybeFnOrOptions;
+		taskOptions = maybeOptions;
+	} else {
+		fn = fnOrPath;
+		taskOptions = maybeFnOrOptions;
+	}
+	const taskName = fn.name || taskPath || "";
+	const wrapper = function(...args) {
+		const ctx = _workflowCtx ?? Reflect.get(globalThis, "__wmill_wf_ctx");
+		if (ctx) {
+			const script = taskPath ?? taskName;
+			const paramNames = getParamNames(fn);
+			const kwargs = {};
+			for (let i = 0; i < args.length; i++) if (paramNames[i]) kwargs[paramNames[i]] = args[i];
+			else kwargs[`arg${i}`] = args[i];
+			const stepResult = ctx._nextStep(taskName, script, kwargs, "inline", taskOptions);
+			if (stepResult?._execute_directly) return (async () => {
+				const result = await fn(...args);
+				throw new StepSuspend({
+					mode: "step_complete",
+					steps: [],
+					result
+				});
+			})();
+			return stepResult;
+		} else if (getEnv("WM_JOB_ID") && !getEnv("WM_FLOW_JOB_ID")) return (async () => {
+			const paramNames = getParamNames(fn);
+			const kwargs = {};
+			args.forEach((x, i) => kwargs[paramNames[i]] = x);
+			let req = await fetch(`${OpenAPI.BASE}/w/${getWorkspace()}/jobs/run/workflow_as_code/${getEnv("WM_JOB_ID")}/${taskName}`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: `Bearer ${getEnv("WM_TOKEN")}`
+				},
+				body: JSON.stringify({ args: kwargs })
+			});
+			let jobId = await req.text();
+			console.log(`Started task ${taskName} as job ${jobId}`);
+			let r = await waitJob(jobId);
+			console.log(`Task ${taskName} (${jobId}) completed`);
+			return r;
+		})();
+		else return fn(...args);
+	};
+	Object.defineProperty(wrapper, "name", { value: taskName });
+	wrapper._is_task = true;
+	wrapper._task_path = taskPath;
+	return wrapper;
+}
+/**
+* Create a task that dispatches to a separate Windmill script.
+*
+* @example
+* const extract = taskScript("f/data/extract");
+* // inside workflow: await extract({ url: "https://..." })
+*/
+function taskScript(path, options) {
+	const name = path.split("/").pop() || path;
+	const wrapper = function(...args) {
+		const ctx = _workflowCtx ?? Reflect.get(globalThis, "__wmill_wf_ctx");
+		if (ctx) {
+			const kwargs = args.length === 1 && typeof args[0] === "object" && args[0] !== null ? args[0] : args.reduce((acc, v, i) => {
+				acc[`arg${i}`] = v;
+				return acc;
+			}, {});
+			return ctx._nextStep(name, path, kwargs, "script", options);
+		}
+		throw new Error(`taskScript("${path}") can only be called inside a workflow()`);
+	};
+	Object.defineProperty(wrapper, "name", { value: name });
+	wrapper._is_task = true;
+	wrapper._task_path = path;
+	return wrapper;
+}
+/**
+* Create a task that dispatches to a separate Windmill flow.
+*
+* @example
+* const pipeline = taskFlow("f/etl/pipeline");
+* // inside workflow: await pipeline({ input: data })
+*/
+function taskFlow(path, options) {
+	const name = path.split("/").pop() || path;
+	const wrapper = function(...args) {
+		const ctx = _workflowCtx ?? Reflect.get(globalThis, "__wmill_wf_ctx");
+		if (ctx) {
+			const kwargs = args.length === 1 && typeof args[0] === "object" && args[0] !== null ? args[0] : args.reduce((acc, v, i) => {
+				acc[`arg${i}`] = v;
+				return acc;
+			}, {});
+			return ctx._nextStep(name, path, kwargs, "flow", options);
+		}
+		throw new Error(`taskFlow("${path}") can only be called inside a workflow()`);
+	};
+	Object.defineProperty(wrapper, "name", { value: name });
+	wrapper._is_task = true;
+	wrapper._task_path = path;
+	return wrapper;
+}
+/**
+* Mark an async function as a workflow-as-code entry point.
+*
+* The function must be **deterministic**: given the same inputs it must call
+* tasks in the same order on every replay. Branching on task results is fine
+* (results are replayed from checkpoint), but branching on external state
+* (current time, random values, external API calls) must use `step()` to
+* checkpoint the value so replays see the same result.
+*/
+function workflow(fn) {
+	fn._is_workflow = true;
+	return fn;
+}
+/**
+* Suspend the workflow and wait for an external approval.
+*
+* Use `getResumeUrls()` (wrapped in `step()`) to obtain resume/cancel/approvalPage
+* URLs before calling this function.
+*
+* @example
+* const urls = await step("urls", () => getResumeUrls());
+* await step("notify", () => sendEmail(urls.approvalPage));
+* const { value, approver } = await waitForApproval({ timeout: 3600 });
+*/
+function waitForApproval(options) {
+	const ctx = _workflowCtx ?? Reflect.get(globalThis, "__wmill_wf_ctx");
+	if (!ctx) throw new Error("waitForApproval can only be called inside a workflow()");
+	return ctx._waitForApproval(options);
+}
+/**
+* Process items in parallel with optional concurrency control.
+*
+* Each item is processed by calling `fn(item)`, which should be a task().
+* Items are dispatched in batches of `concurrency` (default: all at once).
+*
+* @example
+* const process = task(async (item: string) => { ... });
+* const results = await parallel(items, process, { concurrency: 5 });
+*/
+async function parallel(items, fn, options) {
+	const concurrency = options?.concurrency ?? items.length;
+	if (concurrency <= 0 || items.length === 0) return [];
+	const results = [];
+	for (let i = 0; i < items.length; i += concurrency) {
+		const batch = items.slice(i, i + concurrency);
+		const batchResults = await Promise.all(batch.map((item) => fn(item)));
+		results.push(...batchResults);
+	}
+	return results;
+}
 
 //#endregion
 //#region src/index.ts
@@ -14032,6 +14339,17 @@ const wmill = {
 	getPresignedS3PublicUrls,
 	getPresignedS3PublicUrl,
 	task,
+	taskScript,
+	taskFlow,
+	workflow,
+	step,
+	sleep,
+	parallel,
+	waitForApproval,
+	WorkflowCtx,
+	_workflowCtx,
+	setWorkflowCtx,
+	StepSuspend,
 	runScript,
 	runScriptAsync,
 	runScriptByPath,
@@ -14132,6 +14450,7 @@ exports.ServiceLogsService = ServiceLogsService;
 exports.SettingService = SettingService;
 exports.SettingsService = SettingsService;
 exports.SqsTriggerService = SqsTriggerService;
+exports.StepSuspend = StepSuspend;
 exports.TeamsService = TeamsService;
 exports.TokenService = TokenService;
 exports.TriggerService = TriggerService;
@@ -14140,9 +14459,16 @@ exports.VariableService = VariableService;
 exports.VolumeService = VolumeService;
 exports.WebsocketTriggerService = WebsocketTriggerService;
 exports.WorkerService = WorkerService;
+exports.WorkflowCtx = WorkflowCtx;
 exports.WorkspaceDependenciesService = WorkspaceDependenciesService;
 exports.WorkspaceIntegrationService = WorkspaceIntegrationService;
 exports.WorkspaceService = WorkspaceService;
+Object.defineProperty(exports, '_workflowCtx', {
+  enumerable: true,
+  get: function () {
+    return _workflowCtx;
+  }
+});
 exports.appendToResultStream = appendToResultStream;
 exports.datatable = datatable;
 exports.default = src_default;
@@ -14160,6 +14486,7 @@ exports.getState = getState;
 exports.getVariable = getVariable;
 exports.loadS3File = loadS3File;
 exports.loadS3FileStream = loadS3FileStream;
+exports.parallel = parallel;
 exports.requestInteractiveSlackApproval = requestInteractiveSlackApproval;
 exports.requestInteractiveTeamsApproval = requestInteractiveTeamsApproval;
 exports.runFlow = runFlow;
@@ -14176,10 +14503,17 @@ exports.setProgress = setProgress;
 exports.setResource = setResource;
 exports.setState = setState;
 exports.setVariable = setVariable;
+exports.setWorkflowCtx = setWorkflowCtx;
 exports.signS3Object = signS3Object;
 exports.signS3Objects = signS3Objects;
+exports.sleep = sleep;
+exports.step = step;
 exports.streamResult = streamResult;
 exports.task = task;
+exports.taskFlow = taskFlow;
+exports.taskScript = taskScript;
 exports.usernameToEmail = usernameToEmail;
+exports.waitForApproval = waitForApproval;
 exports.waitJob = waitJob;
+exports.workflow = workflow;
 exports.writeS3File = writeS3File;

package/dist/index.mjs

@@ -3,7 +3,7 @@ import { CancelError, CancelablePromise } from "./core/CancelablePromise.mjs";
 import { OpenAPI } from "./core/OpenAPI.mjs";
 import { AdminService, AgentWorkersService, AppService, AssetService, AuditService, CaptureService, ConcurrencyGroupsService, ConfigService, DocumentationService, DraftService, EmailTriggerService, FavoriteService, FlowConversationService, FlowService, FolderService, GcpTriggerService, GitSyncService, GranularAclService, GroupService, HealthService, HelpersService, HttpTriggerService, IndexSearchService, InputService, IntegrationService, JobService, KafkaTriggerService, McpOauthService, McpService, MetricsService, MqttTriggerService, NativeTriggerService, NatsTriggerService, NpmProxyService, OauthService, OidcService, OpenapiService, PostgresTriggerService, RawAppService, ResourceService, ScheduleService, ScriptService, ServiceLogsService, SettingService, SettingsService, SqsTriggerService, TeamsService, TokenService, TriggerService, UserService, VariableService, VolumeService, WebsocketTriggerService, WorkerService, WorkspaceDependenciesService, WorkspaceIntegrationService, WorkspaceService } from "./services.gen.mjs";
 import { datatable, ducklake } from "./sqlUtils.mjs";
-import { SHARED_FOLDER, appendToResultStream, base64ToUint8Array, databaseUrlFromResource, denoS3LightClientSettings, getFlowUserState, getIdToken, getInternalState, getPresignedS3PublicUrl, getPresignedS3PublicUrls, getProgress, getResource, getResult, getResultMaybe, getResumeEndpoints, getResumeUrls, getRootJobId, getState, getStatePath, getVariable, getWorkspace, loadS3File, loadS3FileStream, parseS3Object, requestInteractiveSlackApproval, requestInteractiveTeamsApproval, resolveDefaultResource, runFlow, runFlowAsync, runScript, runScriptAsync, runScriptByHash, runScriptByHashAsync, runScriptByPath, runScriptByPathAsync, setClient, setFlowUserState, setInternalState, setProgress, setResource, setState, setVariable, signS3Object, signS3Objects, streamResult, task, uint8ArrayToBase64, usernameToEmail, waitJob, writeS3File } from "./client.mjs";
+import { SHARED_FOLDER, StepSuspend, WorkflowCtx, _workflowCtx, appendToResultStream, base64ToUint8Array, databaseUrlFromResource, denoS3LightClientSettings, getFlowUserState, getIdToken, getInternalState, getPresignedS3PublicUrl, getPresignedS3PublicUrls, getProgress, getResource, getResult, getResultMaybe, getResumeEndpoints, getResumeUrls, getRootJobId, getState, getStatePath, getVariable, getWorkspace, loadS3File, loadS3FileStream, parallel, parseS3Object, requestInteractiveSlackApproval, requestInteractiveTeamsApproval, resolveDefaultResource, runFlow, runFlowAsync, runScript, runScriptAsync, runScriptByHash, runScriptByHashAsync, runScriptByPath, runScriptByPathAsync, setClient, setFlowUserState, setInternalState, setProgress, setResource, setState, setVariable, setWorkflowCtx, signS3Object, signS3Objects, sleep, step, streamResult, task, taskFlow, taskScript, uint8ArrayToBase64, usernameToEmail, waitForApproval, waitJob, workflow, writeS3File } from "./client.mjs";
 
 //#region src/index.ts
 const wmill = {
@@ -27,6 +27,17 @@ const wmill = {
 	getPresignedS3PublicUrls,
 	getPresignedS3PublicUrl,
 	task,
+	taskScript,
+	taskFlow,
+	workflow,
+	step,
+	sleep,
+	parallel,
+	waitForApproval,
+	WorkflowCtx,
+	_workflowCtx,
+	setWorkflowCtx,
+	StepSuspend,
 	runScript,
 	runScriptAsync,
 	runScriptByPath,
@@ -77,4 +88,4 @@ const wmill = {
 var src_default = wmill;
 
 //#endregion
-export { AdminService, AgentWorkersService, ApiError, AppService, AssetService, AuditService, CancelError, CancelablePromise, CaptureService, ConcurrencyGroupsService, ConfigService, DocumentationService, DraftService, EmailTriggerService, FavoriteService, FlowConversationService, FlowService, FolderService, GcpTriggerService, GitSyncService, GranularAclService, GroupService, HealthService, HelpersService, HttpTriggerService, IndexSearchService, InputService, IntegrationService, JobService, KafkaTriggerService, McpOauthService, McpService, MetricsService, MqttTriggerService, NativeTriggerService, NatsTriggerService, NpmProxyService, OauthService, OidcService, OpenAPI, OpenapiService, PostgresTriggerService, RawAppService, ResourceService, ScheduleService, ScriptService, ServiceLogsService, SettingService, SettingsService, SqsTriggerService, TeamsService, TokenService, TriggerService, UserService, VariableService, VolumeService, WebsocketTriggerService, WorkerService, WorkspaceDependenciesService, WorkspaceIntegrationService, WorkspaceService, appendToResultStream, datatable, src_default as default, denoS3LightClientSettings, ducklake, getFlowUserState, getIdToken, getPresignedS3PublicUrl, getPresignedS3PublicUrls, getProgress, getResource, getResumeUrls, getRootJobId, getState, getVariable, loadS3File, loadS3FileStream, requestInteractiveSlackApproval, requestInteractiveTeamsApproval, runFlow, runFlowAsync, runScript, runScriptAsync, runScriptByHash, runScriptByHashAsync, runScriptByPath, runScriptByPathAsync, setClient, setFlowUserState, setProgress, setResource, setState, setVariable, signS3Object, signS3Objects, streamResult, task, usernameToEmail, waitJob, writeS3File };
+export { AdminService, AgentWorkersService, ApiError, AppService, AssetService, AuditService, CancelError, CancelablePromise, CaptureService, ConcurrencyGroupsService, ConfigService, DocumentationService, DraftService, EmailTriggerService, FavoriteService, FlowConversationService, FlowService, FolderService, GcpTriggerService, GitSyncService, GranularAclService, GroupService, HealthService, HelpersService, HttpTriggerService, IndexSearchService, InputService, IntegrationService, JobService, KafkaTriggerService, McpOauthService, McpService, MetricsService, MqttTriggerService, NativeTriggerService, NatsTriggerService, NpmProxyService, OauthService, OidcService, OpenAPI, OpenapiService, PostgresTriggerService, RawAppService, ResourceService, ScheduleService, ScriptService, ServiceLogsService, SettingService, SettingsService, SqsTriggerService, StepSuspend, TeamsService, TokenService, TriggerService, UserService, VariableService, VolumeService, WebsocketTriggerService, WorkerService, WorkflowCtx, WorkspaceDependenciesService, WorkspaceIntegrationService, WorkspaceService, _workflowCtx, appendToResultStream, datatable, src_default as default, denoS3LightClientSettings, ducklake, getFlowUserState, getIdToken, getPresignedS3PublicUrl, getPresignedS3PublicUrls, getProgress, getResource, getResumeUrls, getRootJobId, getState, getVariable, loadS3File, loadS3FileStream, parallel, requestInteractiveSlackApproval, requestInteractiveTeamsApproval, runFlow, runFlowAsync, runScript, runScriptAsync, runScriptByHash, runScriptByHashAsync, runScriptByPath, runScriptByPathAsync, setClient, setFlowUserState, setProgress, setResource, setState, setVariable, setWorkflowCtx, signS3Object, signS3Objects, sleep, step, streamResult, task, taskFlow, taskScript, usernameToEmail, waitForApproval, waitJob, workflow, writeS3File };

package/dist/types.gen.d.ts

@@ -1315,7 +1315,7 @@ export type NewScript = {
     path: string;
     parent_hash?: string;
     summary: string;
-    description: string;
+    description?: string;
     content: string;
     schema?: {
         [key: string]: unknown;
@@ -11981,6 +11981,10 @@ export type SearchJobsIndexResponse = {
          * Is the current indexer service being replaced
          */
         lost_lock_ownership?: boolean;
+        /**
+         * Maximum time window in seconds for indexing
+         */
+        max_index_time_window_secs?: number;
     };
 };
 export type SearchLogsIndexData = {
@@ -24774,6 +24778,10 @@ export type $OpenApiTs = {
                          * Is the current indexer service being replaced
                          */
                         lost_lock_ownership?: boolean;
+                        /**
+                         * Maximum time window in seconds for indexing
+                         */
+                        max_index_time_window_secs?: number;
                     };
                 };
             };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "windmill-client",
   "description": "Windmill SDK client for browsers and Node.js",
-  "version": "1.651.1",
+  "version": "1.653.0",
   "author": "Ruben Fiszel",
   "license": "Apache 2.0",
   "sideEffects": false,