@naturali/sdk 0.69.0 → 0.70.0

package/dist/index.cjs

@@ -2115,6 +2115,219 @@ var Models = class {
 		});
 	}
 };
+var Orchestrations = class {
+	/**
+	* List orchestrations
+	*
+	* Returns orchestrations accessible to the caller.
+	*/
+	static listOrchestrations(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/orchestrations",
+			...options
+		});
+	}
+	/**
+	* Create an orchestration
+	*
+	* Creates a new orchestration (pipeline) definition in the project.
+	*/
+	static createOrchestration(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/orchestrations",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Validate an orchestration graph
+	*
+	* Statically validates an orchestration graph without persisting anything. Checks that every node has its required field, node ids are unique, edges reference existing nodes, the graph is acyclic (unless it contains a loop node), and every `input_mapping` `{"var": "..."}` reference resolves to a state key written by an upstream node or seeded by `input_schema`. Returns blocking `errors` and non-blocking `warnings` (e.g. a state key only written on a conditional branch). The same `errors` checks are enforced on create and update, which fail with `400` when any error is present.
+	*
+	*/
+	static validateOrchestration(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/orchestrations/validate",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Get orchestration queue stats
+	*
+	* Returns a point-in-time snapshot of the orchestration run queue: how many tasks are waiting to be claimed (`queue_depth`), how many are currently claimed with a valid lease (`claimed_tasks`), the age of the oldest waiting task, recent claim-latency percentiles over a rolling in-process window, and a per-project breakdown. Intended for admin/operator policies; guarded by `orchestrations:GetQueueStats`. A project-scoped caller sees only their own projects under `per_project`.
+	*
+	*/
+	static getQueueStats(options) {
+		return (options.client ?? client).get({
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/v1/projects/{project_id}/orchestrations/queue/stats",
+			...options
+		});
+	}
+	/**
+	* Delete an orchestration
+	*
+	* Deletes an orchestration definition and all its runs.
+	*/
+	static deleteOrchestration(options) {
+		return (options.client ?? client).delete({
+			url: "/v1/projects/{project_id}/orchestrations/{orchestration_id}",
+			...options
+		});
+	}
+	/**
+	* Get an orchestration
+	*
+	* Returns the orchestration with nodes and edges.
+	*/
+	static getOrchestration(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/orchestrations/{orchestration_id}",
+			...options
+		});
+	}
+	/**
+	* Update an orchestration
+	*
+	* Partially updates an orchestration definition.
+	*/
+	static updateOrchestration(options) {
+		return (options.client ?? client).patch({
+			url: "/v1/projects/{project_id}/orchestrations/{orchestration_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* List an orchestration's graph versions
+	*
+	* Returns the orchestration's archived graphs, newest first. A version is written on create and on every subsequent write that changes the graph (`nodes`, `edges`, `state_schema`, `input_schema`) — through the REST API or a formation apply alike. Metadata-only edits (name, description) do not archive a version. See [Versioning](/docs/modules/orchestrations#versioning).
+	*
+	*/
+	static listOrchestrationVersions(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/orchestrations/{orchestration_id}/versions",
+			...options
+		});
+	}
+	/**
+	* Fetch an archived orchestration version
+	*
+	* Returns the exact graph a given version describes. Every run records the version it started on in `orchestration_version` and executes that graph for its whole life, so this is how you read the topology a run actually took — including a run whose orchestration has been rewired since.
+	*
+	*/
+	static getOrchestrationVersion(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/orchestrations/{orchestration_id}/versions/{version}",
+			...options
+		});
+	}
+	/**
+	* Restore an archived orchestration graph
+	*
+	* Writes an archived version's graph back as the orchestration's live definition, which archives it again as a **new** version rather than rewinding the counter — so a run pinned to any version in between still resolves the graph it started on.
+	*
+	* The restore runs through the ordinary update path, so the archived graph goes through the same static validation as an authored one. Node resource references (`agent_id`, `tool_id`, `orchestration_id`) resolve when a run reaches the node, so a target deleted since the snapshot was taken restores cleanly and surfaces as a failed run rather than a `400`. Restoring the graph the orchestration already holds is a no-op and archives nothing. Runs already in flight are unaffected either way — a restore is an ordinary edit, and pinning is what keeps it from reaching them.
+	*
+	*/
+	static restoreOrchestrationVersion(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/orchestrations/{orchestration_id}/versions/{version}/restore",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* List orchestration runs
+	*
+	* Returns orchestration runs the caller can access, optionally filtered by orchestration.
+	*/
+	static listOrchestrationRuns(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/orchestration-runs",
+			...options
+		});
+	}
+	/**
+	* Start an orchestration run
+	*
+	* Creates a new run for the orchestration named by orchestration_id. By default the run executes durably in the background: the response returns immediately with status "queued" (a worker then claims it and moves it to "running") and progress is observed via get-orchestration-run or run lifecycle webhook events (orchestration_runs.started/awaiting_input/succeeded/failed). Delay and poll waits park the run as "sleeping" and are woken by a background scheduler, surviving restarts. Pass wait=true to block until the run reaches a terminal or awaiting_input state.
+	*/
+	static startOrchestrationRun(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/orchestration-runs",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Cancel an orchestration run
+	*
+	* Cancels a run that has not yet reached a terminal state.
+	*/
+	static cancelOrchestrationRun(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/orchestration-runs/{orchestration_run_id}/cancel",
+			...options
+		});
+	}
+	/**
+	* Submit human input
+	*
+	* Provides human input to a run that is awaiting_input at a human node.
+	*/
+	static submitHumanInput(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/orchestration-runs/{orchestration_run_id}/human-input",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* 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.
+	*/
+	static resumeOrchestrationRun(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/orchestration-runs/{orchestration_run_id}/resume",
+			...options
+		});
+	}
+	/**
+	* Get an orchestration run
+	*
+	* Returns the status, state, and artifacts of a specific run.
+	*/
+	static getOrchestrationRun(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/orchestration-runs/{orchestration_run_id}",
+			...options
+		});
+	}
+};
 var Projects = class {
 	/**
 	* List projects
@@ -2468,6 +2681,97 @@ var Sessions = class {
 		});
 	}
 };
+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.
+	*/
+	static listTasks(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/tasks",
+			...options
+		});
+	}
+	/**
+	* Create a task
+	*
+	* Creates a task bound to a workflow. By default the task is placed in the workflow's initial state; passing `state` places it directly in that named state instead — an alternate entry point for starting a task mid-flow (e.g. "a new recorte for an existing theme by id"), rather than re-submitting from the initial state and hoping a guard or similarity gate recognizes it. Entering the resulting state, initial or named, behaves identically: that state's `on_enter` automation fires and its `stalled_after` clock arms.
+	*/
+	static createTask(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/tasks",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a task
+	*
+	* Deletes a task. Its transition history cascades.
+	*/
+	static deleteTask(options) {
+		return (options.client ?? client).delete({
+			url: "/v1/projects/{project_id}/tasks/{task_id}",
+			...options
+		});
+	}
+	/**
+	* Get a task
+	*
+	* Retrieves a task, including its active dispatch and automation status.
+	*/
+	static getTask(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/tasks/{task_id}",
+			...options
+		});
+	}
+	/**
+	* Update a task
+	*
+	* Updates a task's payload, title, or assignee. `state` is never directly writable — move it with a transition; sending a `state` field is rejected as an unknown field (`VALIDATION_FAILED`). `payload` is shallow-merged over the existing payload (PATCH semantics): keys the request omits are preserved. The payload is caller-owned; the automation result lives in the read-only `last_result` field, which no patch can reach. The merged payload is validated against the workflow's `payload_schema`.
+	*/
+	static updateTask(options) {
+		return (options.client ?? client).patch({
+			url: "/v1/projects/{project_id}/tasks/{task_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Transition a task
+	*
+	* Fires a named transition on a task. The transition must exist in the workflow and be valid from the task's current state; its guard must pass. This is the single path every state change routes through. A transition declaring `requires_approval` does not move the task — it parks a pending ApprovalItem and returns the task with `pending_transition` set; the move applies only when the approval is approved.
+	*/
+	static transitionTask(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/tasks/{task_id}/transitions",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Get task history
+	*
+	* Returns the append-only transition history of a task.
+	*/
+	static getTaskHistory(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/tasks/{task_id}/history",
+			...options
+		});
+	}
+};
 var Tools = class {
 	/**
 	* List tools
@@ -2603,6 +2907,130 @@ var Traces = class {
 		});
 	}
 };
+var Triggers = class {
+	/**
+	* List triggers
+	*
+	* Lists triggers. Filter by project, starter type, or target type.
+	*/
+	static listTriggers(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/triggers",
+			...options
+		});
+	}
+	/**
+	* Create a trigger
+	*
+	* Creates a new trigger for a project
+	*/
+	static createTrigger(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/triggers",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a trigger
+	*
+	* Deletes a trigger
+	*/
+	static deleteTrigger(options) {
+		return (options.client ?? client).delete({
+			url: "/v1/projects/{project_id}/triggers/{trigger_id}",
+			...options
+		});
+	}
+	/**
+	* Get a trigger
+	*
+	* Retrieves the details of a specific trigger
+	*/
+	static getTrigger(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/triggers/{trigger_id}",
+			...options
+		});
+	}
+	/**
+	* Update a trigger
+	*
+	* Updates an existing trigger's configuration. The type is immutable.
+	*/
+	static updateTrigger(options) {
+		return (options.client ?? client).patch({
+			url: "/v1/projects/{project_id}/triggers/{trigger_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Fire a trigger
+	*
+	* Fires a trigger synchronously and returns the terminal firing record. The firing itself always settles here; an `eval` target's run is queued rather than executed inline, so the record names a `queued` run to poll.
+	*/
+	static fireTrigger(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/triggers/{trigger_id}/fire",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Get trigger secret
+	*
+	* Retrieves the signing secret for a webhook trigger
+	*/
+	static getTriggerSecret(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/triggers/{trigger_id}/secret",
+			...options
+		});
+	}
+	/**
+	* Rotate trigger secret
+	*
+	* Rotates the signing secret for a webhook trigger
+	*/
+	static rotateTriggerSecret(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/triggers/{trigger_id}/rotate-secret",
+			...options
+		});
+	}
+	/**
+	* List trigger firings
+	*
+	* Lists firings for a trigger (trigger_id is required).
+	*/
+	static listTriggerFirings(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/trigger-firings",
+			...options
+		});
+	}
+	/**
+	* Get a trigger firing
+	*
+	* Retrieves the details of a specific trigger firing
+	*/
+	static getTriggerFiring(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/trigger-firings/{firing_id}",
+			...options
+		});
+	}
+};
 var Users = class {
 	/**
 	* Get the current user
@@ -2752,6 +3180,113 @@ var Webhooks = class {
 		});
 	}
 };
+var Workflows = class {
+	/**
+	* List workflows
+	*
+	* Lists workflow definitions in a project.
+	*/
+	static listWorkflows(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/workflows",
+			...options
+		});
+	}
+	/**
+	* Create a workflow
+	*
+	* Creates a new workflow definition. The definition is statically validated.
+	*/
+	static createWorkflow(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/workflows",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a workflow
+	*
+	* Deletes a workflow. Rejected while open tasks exist.
+	*/
+	static deleteWorkflow(options) {
+		return (options.client ?? client).delete({
+			url: "/v1/projects/{project_id}/workflows/{workflow_id}",
+			...options
+		});
+	}
+	/**
+	* Get a workflow
+	*
+	* Retrieves a workflow definition.
+	*/
+	static getWorkflow(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/workflows/{workflow_id}",
+			...options
+		});
+	}
+	/**
+	* Update a workflow
+	*
+	* Updates a workflow definition. Structural changes (states/transitions) are re-validated. Existing tasks in a removed state stay put but can only leave via transitions valid in the new definition.
+	*/
+	static updateWorkflow(options) {
+		return (options.client ?? client).patch({
+			url: "/v1/projects/{project_id}/workflows/{workflow_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* List a workflow's versions
+	*
+	* Returns the workflow's archived state machines, newest first. A version is written on create and on every subsequent write that changes the definition (`states`, `transitions`, `payload_schema`) — through the REST API or a formation apply alike. Metadata-only edits (name, description) do not archive a version. See [Versioning](/docs/modules/workflows#versioning).
+	*
+	*/
+	static listWorkflowVersions(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/workflows/{workflow_id}/versions",
+			...options
+		});
+	}
+	/**
+	* Fetch an archived workflow version
+	*
+	* Returns the exact state machine a given version describes. Every task records the version it entered on in `workflow_version` and runs on that machine for its whole life, so this is how you read the definition a task is actually being validated against — including a task whose workflow has been rewired since.
+	*
+	*/
+	static getWorkflowVersion(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/workflows/{workflow_id}/versions/{version}",
+			...options
+		});
+	}
+	/**
+	* Restore an archived workflow state machine
+	*
+	* Writes an archived version's state machine back as the workflow's live definition, which archives it again as a **new** version rather than rewinding the counter — so a task pinned to any version in between still runs on the machine it entered on.
+	*
+	* The restore runs through the ordinary update path, so the archived definition goes through the same validation as an authored one. That includes resolving every `on_enter` dispatch target, so restoring a version whose agent or orchestration has since been deleted fails with `400` rather than writing a definition that would strand a task on entry. Restoring the definition the workflow already holds is a no-op and archives nothing. Tasks already in flight are unaffected either way — a restore is an ordinary edit, and pinning is what keeps it from reaching them.
+	*
+	*/
+	static restoreWorkflowVersion(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/workflows/{workflow_id}/versions/{version}/restore",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
 //#endregion
 //#region src/naturaliClient.ts
 /**
@@ -2812,13 +3347,17 @@ var NaturaliClient = class {
 	generations;
 	modelRoutes;
 	models;
+	orchestrations;
 	projects;
 	secrets;
 	sessions;
+	tasks;
 	tools;
 	traces;
+	triggers;
 	users;
 	webhooks;
+	workflows;
 	/** The underlying HTTP client, for interceptors or one-off requests. */
 	http;
 	constructor({ token, headers } = {}) {
@@ -2842,13 +3381,17 @@ var NaturaliClient = class {
 		this.generations = bindResource(Generations, this.http);
 		this.modelRoutes = bindResource(ModelRoutes, this.http);
 		this.models = bindResource(Models, this.http);
+		this.orchestrations = bindResource(Orchestrations, this.http);
 		this.projects = bindResource(Projects, this.http);
 		this.secrets = bindResource(Secrets, this.http);
 		this.sessions = bindResource(Sessions, this.http);
+		this.tasks = bindResource(Tasks, this.http);
 		this.tools = bindResource(Tools, this.http);
 		this.traces = bindResource(Traces, this.http);
+		this.triggers = bindResource(Triggers, this.http);
 		this.users = bindResource(Users, this.http);
 		this.webhooks = bindResource(Webhooks, this.http);
+		this.workflows = bindResource(Workflows, this.http);
 	}
 };
 //#endregion
@@ -2866,12 +3409,16 @@ exports.Generations = Generations;
 exports.ModelRoutes = ModelRoutes;
 exports.Models = Models;
 exports.NaturaliClient = NaturaliClient;
+exports.Orchestrations = Orchestrations;
 exports.Projects = Projects;
 exports.Secrets = Secrets;
 exports.Sessions = Sessions;
+exports.Tasks = Tasks;
 exports.Tools = Tools;
 exports.Traces = Traces;
+exports.Triggers = Triggers;
 exports.Users = Users;
 exports.Webhooks = Webhooks;
+exports.Workflows = Workflows;
 exports.createClient = createClient;
 exports.createConfig = createConfig;