@naturali/sdk 0.115.1 → 0.117.0

package/dist/index.cjs

@@ -3359,7 +3359,7 @@ var Orchestrations = class {
 	/**
 	* List orchestration runs
 	*
-	* Returns orchestration runs the caller can access, optionally filtered by orchestration, by parent run, or by whether the run has a parent at all.
+	* Returns orchestration runs the caller can access, optionally filtered by orchestration, by parent run, by status, or by whether the run has a parent at all.
 	*
 	* Note when aggregating: a run's `usage` covers its whole subtree, so summing it over a list that contains both a parent and its children counts the children more than once. Pass `nested=false` to sum over runs a caller started.
 	*/
@@ -3396,6 +3396,24 @@ var Orchestrations = class {
 		});
 	}
 	/**
+	* Pause an orchestration run
+	*
+	* Parks a run in flight as `awaiting_input` at its next checkpoint, with a `required_action` of type `paused` naming the pause as operator-initiated rather than a node's. Unlike cancel, the run keeps its last checkpoint and resume-orchestration-run re-drives it from there — so work already done is deferred rather than discarded.
+	* A `queued` or `sleeping` run is parked immediately (a sleeping run keeps the wake it was due, and resuming hands it back to the scheduler at that instant). A `running` run keeps running until the round in flight reaches its checkpoint, so the response may still read `running` while `pause_requested_at` is set. A run already parked on a human, webhook or approval node keeps that node's `required_action`; the pause is still recorded, which is what makes submit-human-input refuse until the run is resumed.
+	* The pause fans out to the run's `loop` / `sub_orchestration` descendants — each parks at its own next checkpoint — because otherwise a parent's pause would bound nothing. Resuming does not fan out: each parked descendant is resumed by its own id.
+	* Idempotent: pausing an already-paused run answers with it unchanged.
+	*/
+	static pauseOrchestrationRun(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/orchestration-runs/{orchestration_run_id}/pause",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
 	* Submit human input
 	*
 	* Provides human input to a run that is awaiting_input at a human node.
@@ -3414,6 +3432,7 @@ var Orchestrations = class {
 	* Resume an orchestration run
 	*
 	* Re-drives an awaiting_input orchestration run from its last checkpoint. This does not satisfy the pause itself — it carries no node_id or payload, so a run parked on a human or webhook-receive node re-parks on the same node. Use submit-human-input to supply the awaited payload and advance the run.
+	* It is also the only thing that lifts an operator pause (pause-orchestration-run): a run parked with `required_action.type` of `paused` re-drives the frontier that had not run yet, and one paused mid-timer goes back to `sleeping` for the wake it was already due.
 	*/
 	static resumeOrchestrationRun(options) {
 		return (options.client ?? client).post({
@@ -3555,7 +3574,7 @@ var Quotas = class {
 	/**
 	* Create a quota
 	*
-	* Creates a project-scoped quota. `requests` is valid for `scope: project`/`api_key`; `tokens` and `cost_usd` are valid for `scope: project`/`agent`/`actor`. Any other scope/metric pair is rejected with 400 (no attribution exists to enforce it). An `actor` quota caps one end user's spend, matched from the generation's session; a null `scope_ref` means one budget *per* actor rather than a pooled project total. A duplicate quota (same project, scope, scope_ref, metric, window) is rejected with 409.
+	* Creates a project-scoped quota. `requests` is valid for `scope: project`/`api_key`; `tokens` and `cost_usd` are valid for `scope: project`/`agent`/`actor`. Any other scope/metric pair is rejected with 400 (no attribution exists to enforce it). An `actor` quota caps one end user's spend, matched from the generation's session; a null `scope_ref` means one budget *per* actor rather than a pooled project total. A `cost_usd` quota may name one `meter_type` to cap; omitting it caps every priced meter. A duplicate quota (same project, scope, scope_ref, metric, window, meter_type) is rejected with 409.
 	*/
 	static createQuota(options) {
 		return (options.client ?? client).post({
@@ -3862,7 +3881,7 @@ var Tasks = class {
 	/**
 	* List tasks
 	*
-	* Lists tasks (the board query). Filter by workflow, state, status, or assignee — `GET /tasks?workflow_id=...&state=...` is one board column.
+	* Lists tasks (the board query). Filter by workflow, state, status, automation status, or assignee — `GET /tasks?workflow_id=...&state=...` is one board column.
 	*/
 	static listTasks(options) {
 		return (options.client ?? client).get({
@@ -3938,6 +3957,36 @@ var Tasks = class {
 		});
 	}
 	/**
+	* Pause a task
+	*
+	* Pauses a task's automation. While a pause is in force no state's `on_enter` dispatches and no retry chain continues — an agent generation, a tool call and a sub-orchestration alike — so the task stops spending without losing its place.
+	* A workflow has no run object, so this is the workflow half of pause-orchestration-run: the pause lands on the instance, which is the task. Transitions are deliberately still allowed — a move costs nothing while every dispatch it would start is suppressed — so a board stays usable under a pause. Entering a state whose dispatch is suppressed records `automation_status: paused`, which resume-task reads to know that state still owes its work.
+	* A dispatch already in flight is left to finish, and its outcome still routes; only what would start after it is suppressed.
+	* Idempotent: pausing an already-paused task answers with it unchanged.
+	*/
+	static pauseTask(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/tasks/{task_id}/pause",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Resume a task
+	*
+	* Lifts a task's pause. When the pause suppressed the current state's `on_enter` — `automation_status: paused` — that dispatch is started now, as the caller resuming rather than as whoever last moved the task. A state whose dispatch had already completed, or that declares none, is left alone, so a resume never re-spends work the pause did not stop.
+	* This is the only way a pause is lifted; a task that is merely idle is advanced by firing a transition instead.
+	*/
+	static resumeTask(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/tasks/{task_id}/resume",
+			...options
+		});
+	}
+	/**
 	* Get task history
 	*
 	* Returns the append-only transition history of a task.