@soat/sdk 0.19.2 → 0.20.1

package/dist/index.mjs

@@ -2196,7 +2196,7 @@ var Guardrails = class {
 	/**
 	* Create a guardrail
 	*
-	* Creates a new guardrail in the project. The `document` is validated on write: `class` must be a literal (A/B/C/D) or a JSON Logic expression, and every variable it (and `guard`) reference must resolve to the `args.*` / `context.*` / `soat.*` namespaces — an out-of-catalog `soat.*` key is rejected with 400.
+	* Creates a new guardrail in the project, archiving its document as version 1. The `document` is validated on write: `class` must be a literal (A/B/C/D) or a JSON Logic expression, and every variable it (and `guard`) reference must resolve to the `args.*` / `context.*` / `soat.*` namespaces — an out-of-catalog `soat.*` key is rejected with 400.
 	*
 	*/
 	static createGuardrail(options) {
@@ -2234,7 +2234,7 @@ var Guardrails = class {
 	/**
 	* Update a guardrail
 	*
-	* Updates an existing guardrail. A `document` write increments `version` and archives the prior document as a GuardrailVersion; metadata-only edits (name / description / context) leave the version untouched.
+	* Updates an existing guardrail. A `document` write that actually changes the policy increments `version` and archives the new document as a GuardrailVersion; metadata-only edits (name / description / context), and re-writing the document the guardrail already holds, leave the version untouched.
 	*
 	*/
 	static updateGuardrail(options) {
@@ -2248,9 +2248,21 @@ var Guardrails = class {
 		});
 	}
 	/**
+	* List a guardrail's config versions
+	*
+	* Returns the guardrail's archived configurations, newest first. A version is written on create and on every subsequent write that changes the policy `document` — through the REST API or a formation apply alike. Metadata-only edits (name, description, context binding) do not archive a version. See [Versioning](/docs/modules/guardrails#versioning).
+	*
+	*/
+	static listGuardrailVersions(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/guardrails/{guardrail_id}/versions",
+			...options
+		});
+	}
+	/**
 	* Fetch an archived guardrail version
 	*
-	* Returns the exact `document` that governed at a given version. Approval items, activity entries, and exceptions record the version that governed them, so the audit chain survives edits.
+	* Returns the exact configuration — and so the exact `document` — that governed at a given version. Approval items, activity entries, and exceptions record the version that governed them, so the audit chain survives edits.
 	*
 	*/
 	static getGuardrailVersion(options) {
@@ -2260,6 +2272,24 @@ var Guardrails = class {
 		});
 	}
 	/**
+	* Restore an archived guardrail config
+	*
+	* Writes an archived version's `document` back as the guardrail's live policy, which archives it again as a **new** version rather than rewinding the counter — so an approval item or exception citing any version in between still resolves.
+	*
+	* The restore runs through the ordinary update path, so the archived document is re-validated; restoring the policy the guardrail already holds is a no-op and archives nothing.
+	*
+	*/
+	static restoreGuardrailVersion(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/guardrails/{guardrail_id}/versions/{version}/restore",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
 	* Dry-run evaluate a guardrail
 	*
 	* Runs the full evaluation pipeline — the `class` expression, the guard, the context tool per `context_mode`, live `soat.*` resolution — against caller-supplied `args` and `guardrail_context`, and returns the exact `guardrail_evaluation` record a real call would produce. Nothing executes, no approval item is filed, and no activity entry is written. This is the adoption path: preview a document's decisions against production-shaped calls before attaching it — or before editing a widely-attached one. Pass an optional `tool_id` to resolve `soat.tool.*`.
@@ -2650,6 +2680,48 @@ var Orchestrations = class {
 		});
 	}
 	/**
+	* 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: "/api/v1/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: "/api/v1/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: "/api/v1/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.
@@ -3910,6 +3982,48 @@ var Workflows = class {
 			}
 		});
 	}
+	/**
+	* 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: "/api/v1/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: "/api/v1/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: "/api/v1/workflows/{workflow_id}/versions/{version}/restore",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
 };
 //#endregion
 //#region src/soatClient.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soat/sdk",
-  "version": "0.19.2",
+  "version": "0.20.1",
   "description": "TypeScript SDK for the SOAT API",
   "type": "module",
   "main": "dist/index.mjs",