@naturali/sdk 0.115.1 → 0.117.0

package/dist/index.mjs

@@ -3358,7 +3358,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.
 	*/
@@ -3395,6 +3395,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.
@@ -3413,6 +3431,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({
@@ -3554,7 +3573,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({
@@ -3861,7 +3880,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({
@@ -3937,6 +3956,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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturali/sdk",
-  "version": "0.115.1",
+  "version": "0.117.0",
   "description": "TypeScript SDK for the naturali.ai API, generated from its OpenAPI specs",
   "type": "module",
   "sideEffects": false,
@@ -37,7 +37,7 @@
     "tsx": "^4.23.1",
     "typescript": "~6.0.3",
     "vitest": "^4.1.10",
-    "@naturali/api": "0.115.1"
+    "@naturali/api": "0.117.0"
   },
   "scripts": {
     "generate": "tsx scripts/generate.ts",