@tangle-network/hub-sdk 1.0.8 → 1.0.9

package/dist/{client-gF4iRjd3.js → client-cT9lHMpc.js}

@@ -1053,12 +1053,7 @@ var HubWorkflowsClient = class extends WorkflowKvResource {
 	async list() {
 		return this.request("/v1/workflows", { method: "GET" });
 	}
-	/**
-	* Owner-wide fleet overview: one row per workflow with its run tallies over
-	* a trailing window (default 7d), sorted failing-first. Answers "how are ALL
-	* my workflows doing" in one call — the per-workflow insights endpoint is
-	* the drill-down, not a way to build this row set client-side.
-	*/
+	/** Owner-wide fleet overview: one row per workflow with its run tallies over a trailing window (default 7d), sorted failing-first. */
 	async fleetInsights(opts = {}) {
 		const query = opts.window ? `?window=${encodeURIComponent(opts.window)}` : "";
 		return this.request(`/v1/workflows/insights/fleet${query}`, { method: "GET" });
@@ -1066,21 +1061,17 @@ var HubWorkflowsClient = class extends WorkflowKvResource {
 	async get(id) {
 		return this.request(`/v1/workflows/${encodeURIComponent(id)}`, { method: "GET" });
 	}
-	async create(yaml) {
-		return this.request("/v1/workflows", jsonInit("POST", { yaml }));
+	async create(yaml, opts = {}) {
+		return this.request("/v1/workflows", jsonInit("POST", {
+			yaml,
+			...opts
+		}));
 	}
-	/**
-	* Replace the workflow's definition from YAML (recompiled server-side,
-	* triggers reconciled). Every landed update appends a revision;
-	* `opts.note` rides onto that revision row (e.g. "why this change"), visible
-	* in {@link listRevisions}. Throws `HubSdkError`: `WORKFLOW_INVALID` when the
-	* YAML doesn't compile or its connections aren't met, `CONFLICT` on a
-	* concurrent modification, `NOT_FOUND` for an unknown/foreign id.
-	*/
+	/** Replace the workflow's definition from YAML (recompiled server-side, triggers reconciled). */
 	async update(id, yaml, opts = {}) {
 		return this.request(`/v1/workflows/${encodeURIComponent(id)}`, jsonInit("PUT", {
 			yaml,
-			...opts.note !== void 0 ? { note: opts.note } : {}
+			...opts
 		}));
 	}
 	async delete(id) {
@@ -1105,91 +1096,46 @@ var HubWorkflowsClient = class extends WorkflowKvResource {
 		const query = params.toString();
 		return this.request(`/v1/workflows/${encodeURIComponent(id)}/runs${query ? `?${query}` : ""}`, { method: "GET" });
 	}
-	/**
-	* Enqueue an immediate ("Run now") run and return its `runId`. The run goes
-	* through the identical execution path a trigger delivery uses.
-	*
-	* `inputs` supplies the trigger fields the workflow reads (its
-	* {@link HubWorkflow.manualRunInputs}), as a flat `{ path: value }` map — e.g.
-	* `{ "pull_request.number": "123" }`. Omit it for a one-click run of a
-	* workflow that reads no trigger fields. Throws `HubSdkError`:
-	* `MISSING_RUN_INPUTS` when a required field is absent (`details.missing`
-	* names them), `NOT_FOUND` for an unknown/foreign id. A paused workflow
-	* still runs once; pausing only stops its triggers. Pass `opts.signal` to
-	* abort a slow request.
-	*/
+	/** Enqueue an immediate ("Run now") run and return its `runId`. */
 	async run(id, inputs, opts = {}) {
 		const hasInputs = inputs !== void 0 && Object.keys(inputs).length > 0;
 		return this.request(`/v1/workflows/${encodeURIComponent(id)}/run`, {
-			...jsonInit("POST", hasInputs ? { inputs } : {}),
+			...jsonInit("POST", {
+				...hasInputs ? { inputs } : {},
+				...opts.resumeRunId ? { resumeRunId: opts.resumeRunId } : {},
+				...opts.sourceSha ? { sourceSha: opts.sourceSha } : {},
+				...opts.expectedRev !== void 0 ? { expectedRev: opts.expectedRev } : {}
+			}),
 			...opts.signal ? { signal: opts.signal } : {}
 		});
 	}
-	/**
-	* A single run's full detail: per-action `output` + `agentRun` execution
-	* detail (size-capped server-side) and the trigger context — the deep "why
-	* did this run do what it did" view. `NOT_FOUND` when the run is unknown or
-	* does not belong to both the caller and this workflow.
-	*/
-	async getRun(id, runId, opts = {}) {
-		return this.request(`/v1/workflows/${encodeURIComponent(id)}/runs/${encodeURIComponent(runId)}`, {
+	async getRun(id, runIdOrOptions, options = {}) {
+		const runId = typeof runIdOrOptions === "string" ? runIdOrOptions : id;
+		const opts = typeof runIdOrOptions === "string" ? options : runIdOrOptions ?? {};
+		const path = typeof runIdOrOptions === "string" ? `${encodeURIComponent(id)}/runs/${encodeURIComponent(runId)}` : `runs/${encodeURIComponent(runId)}`;
+		const query = new URLSearchParams();
+		for (const ref of opts.blobRefs ?? []) query.append("blobRef", ref);
+		if (opts.trace) query.set("trace", "1");
+		return this.request(`/v1/workflows/${path}${query.size ? `?${query}` : ""}`, {
 			method: "GET",
 			...opts.signal ? { signal: opts.signal } : {}
 		});
 	}
-	/**
-	* Stop a queued or in-flight run. A `queued` run is cancelled synchronously
-	* and comes back `{ status: "cancelled" }` (already terminal); a `running` run
-	* is signalled to abort and comes back `{ status: "cancelling", signalled }` —
-	* it settles `cancelled` a moment later as its current action tears down, which
-	* a {@link watchRun}/{@link getRun} observes. Throws `HubSdkError`:
-	* `RUN_NOT_CANCELLABLE` when the run already finished, `NOT_FOUND` for an
-	* unknown/foreign run id. Pass `opts.signal` to abort a slow request.
-	*/
+	/** Stop a queued or in-flight run. */
 	async cancel(id, runId, opts = {}) {
 		return this.request(`/v1/workflows/${encodeURIComponent(id)}/runs/${encodeURIComponent(runId)}/cancel`, {
 			method: "POST",
 			...opts.signal ? { signal: opts.signal } : {}
 		});
 	}
-	/**
-	* Re-run a terminal failed/cancelled run: enqueues a FRESH run of the same
-	* workflow with the SAME trigger context the original ran against, linked
-	* back to it via `retriedFromRunId`. The original row is never mutated —
-	* execution is at-most-once, so a retry is always a new run, never a
-	* requeue. The response carries the NEW run id (and the run it retried);
-	* follow it with {@link getRun}/{@link watchRun}/{@link waitForRun} like any
-	* other run. Throws `HubSdkError`: `RUN_NOT_RETRYABLE` when the run is not
-	* terminal-failed/cancelled (queued/running/waiting, or succeeded),
-	* `NOT_FOUND` for an unknown/foreign run id; a workflow paused since the
-	* failure still retries. Pass `opts.signal` to abort a slow request.
-	*/
+	/** Re-run a terminal failed/cancelled run: enqueues a FRESH run of the same workflow with the SAME trigger context the original ran against, linked back to it via `retriedFromRunId`. */
 	async retryRun(id, runId, opts = {}) {
 		return this.request(`/v1/workflows/${encodeURIComponent(id)}/runs/${encodeURIComponent(runId)}/retry`, {
 			method: "POST",
 			...opts.signal ? { signal: opts.signal } : {}
 		});
 	}
-	/**
-	* Stream a run's live progress as an async iterable of typed events. The
-	* first event is always a `snapshot` of the current persisted state; then
-	* `action.*` / `iteration.*` / `token` ticks arrive as the run executes;
-	* `ping` is a keepalive; a terminal `run.done` ends the iteration. If the run
-	* is already finished when the stream opens, it yields the snapshot then
-	* `run.done` and completes.
-	*
-	* Live ticks require the worker executing the run to share the API process;
-	* across instances only `snapshot` + `run.done` (from the server's terminal
-	* poll) arrive — the persisted record, read via {@link getRun}, stays the
-	* source of truth. Pass `signal` to cancel; iterating to `run.done` (or
-	* breaking early) releases the connection.
-	*
-	* A stream that ends before `run.done` or `run.waiting` (the Platform is
-	* restarting or handing over) is reopened after a second, as is one refused
-	* with `SERVICE_DRAINING`; the reopened stream starts with a fresh
-	* `snapshot`. After 30 reopens in a row that deliver nothing it throws
-	* `HubSdkError(WORKFLOW_STREAM_INTERRUPTED)`.
-	*/
+	/** Stream a run's live progress as an async iterable of typed events. */
 	async *watchRun(id, runId, opts = {}) {
 		const openStream = this.stream;
 		if (!openStream) throw new HubSdkError({
@@ -1256,21 +1202,7 @@ var HubWorkflowsClient = class extends WorkflowKvResource {
 			await reader.cancel().catch(() => {});
 		}
 	}
-	/**
-	* Poll {@link getRun} until the run reaches a terminal state (`succeeded` or
-	* `failed`) and return its detail. The scripting primitive behind "run and
-	* print the result": pairs with {@link run} for a one-call trigger-and-wait.
-	*
-	* Returns as soon as the run leaves the active set (`queued` / `running`) —
-	* i.e. on `succeeded`, `failed`, or any future non-active status — so a new
-	* terminal state can never hang the wait. Polls every `pollIntervalMs`
-	* (default 2000). With `timeoutMs` set, throws
-	* `HubSdkError(WORKFLOW_RUN_TIMEOUT)` — carrying the last observed status on
-	* `details.status` — only once the deadline has actually passed; the last
-	* wait is clamped to the remaining time so a `timeoutMs` shorter than the
-	* poll interval still waits the full requested window rather than giving up a
-	* poll early. Pass `signal` to cancel the wait between polls.
-	*/
+	/** Poll {@link getRun} until the run reaches a terminal state (`succeeded` or `failed`) and return its detail. */
 	async waitForRun(id, runId, opts = {}) {
 		const pollIntervalMs = opts.pollIntervalMs ?? 2e3;
 		if (!Number.isFinite(pollIntervalMs) || pollIntervalMs <= 0) throw new HubSdkError({
@@ -1328,34 +1260,16 @@ var HubWorkflowsClient = class extends WorkflowKvResource {
 	async getRevision(id, rev) {
 		return this.request(`/v1/workflows/${encodeURIComponent(id)}/revisions/${encodeURIComponent(String(rev))}`, { method: "GET" });
 	}
-	/**
-	* Restore a prior rev's YAML as a NEW head revision (history is append-only)
-	* through the same compile path as {@link update}, so the restored definition
-	* is re-validated against today's connections/models. Throws `HubSdkError`:
-	* `REVISION_NOT_FOUND` for an unknown rev, `WORKFLOW_INVALID` when the old
-	* YAML no longer compiles, `CONFLICT` on a concurrent modification.
-	*/
+	/** Restore a prior rev's YAML as a NEW head revision (history is append-only) through the same compile path as {@link update}, so the restored definition is re-validated against today's connections/models. */
 	async rollback(id, rev) {
 		return this.request(`/v1/workflows/${encodeURIComponent(id)}/rollback`, jsonInit("POST", { rev }));
 	}
-	/**
-	* Deterministic health stats over the workflow's last N terminal runs
-	* (default 20, max 100): per-node visits/failures/cost/duration, failure
-	* clusters by normalized error signature, and distillation CANDIDATES
-	* (agent.run nodes with near-static outputs — labeled with their
-	* measurements, never as verdicts). No model in this path.
-	*/
+	/** Deterministic health stats over the workflow's last N terminal runs (default 20, max 100): per-node visits/failures/cost/duration, failure clusters by normalized error signature, and distillation CANDIDATES (agent.run nodes with near-static outputs — labeled with their measurements, never as verdicts). */
 	async health(id, opts = {}) {
 		const query = opts.runs !== void 0 ? `?runs=${opts.runs}` : "";
 		return this.request(`/v1/workflows/${encodeURIComponent(id)}/health${query}`, { method: "GET" });
 	}
-	/**
-	* One agent round's execution timeline, paged. `action` is the action's
-	* `${steps[N]}` position and `iteration` the round's position in that
-	* action's `iterations` — both exactly as the run detail serializes them.
-	* Pass the previous page's `nextCursor` as `after` for the next page; a null
-	* `nextCursor` means the round is fully read.
-	*/
+	/** One agent round's execution timeline, paged. */
 	async listRunSteps(id, runId, input) {
 		const params = new URLSearchParams({
 			action: String(input.action),
@@ -1365,13 +1279,7 @@ var HubWorkflowsClient = class extends WorkflowKvResource {
 		if (input.limit !== void 0) params.set("limit", String(input.limit));
 		return this.request(`/v1/workflows/${encodeURIComponent(id)}/runs/${encodeURIComponent(runId)}/steps?${params.toString()}`, { method: "GET" });
 	}
-	/**
-	* Store one artifact for a run (raw bytes) and return the opaque ref — the
-	* value a script.run node returns as its step output. `contentType` defaults
-	* to `application/octet-stream`; `nodeId` attributes the write to a graph
-	* node (owner credential only — a run-scoped token binds its own node).
-	* Throws `HubSdkError(ARTIFACT_TOO_LARGE)` past the server cap.
-	*/
+	/** Store one artifact for a run (raw bytes) and return the opaque ref — the value a script.run node returns as its step output. */
 	async uploadArtifact(id, runId, input) {
 		const headers = {
 			"Content-Type": input.contentType ?? "application/octet-stream",
@@ -1405,14 +1313,7 @@ var HubWorkflowsClient = class extends WorkflowKvResource {
 	async listTemplates() {
 		return this.request("/v1/workflows/templates", { method: "GET" });
 	}
-	/**
-	* One-click create from a gallery template: substitutes `parameters` into
-	* the template server-side, then runs the SAME create path as
-	* {@link create}. A `{ created: false }` result is NOT an error — an
-	* actionable continuation listing the connections to satisfy before
-	* retrying. Invalid parameters or a compile failure throw `HubSdkError`
-	* (400); an unknown template id throws `NOT_FOUND`.
-	*/
+	/** One-click create from a gallery template: substitutes `parameters` into the template server-side, then runs the SAME create path as {@link create}. */
 	async instantiateTemplate(templateId, parameters) {
 		return this.request(`/v1/workflows/templates/${encodeURIComponent(templateId)}/instantiate`, jsonInit("POST", parameters ? { parameters } : {}));
 	}
@@ -1431,32 +1332,15 @@ var HubWorkflowsClient = class extends WorkflowKvResource {
 	async getRunDecision(id, runId) {
 		return this.request(`/v1/workflows/${encodeURIComponent(id)}/runs/${encodeURIComponent(runId)}/decision`, { method: "GET" });
 	}
-	/**
-	* Answer the decision a run is parked on and resume it from the next action.
-	* `decisionId` is REQUIRED: a run can resolve one decision and re-park on the
-	* next, so an answer addressed only by run could silently land on a question
-	* the caller never saw — a mismatch throws `HubSdkError(DECISION_SUPERSEDED)`.
-	* Other typed failures: `INVALID_CHOICE` (400), `DECISION_ALREADY_RESOLVED` /
-	* `DECISION_EXPIRED` (409), `DECISION_NOT_FOUND` (404), `RUN_NOT_WAITING`
-	* (409 — answered, timed out, or cancelled first).
-	*/
+	/** Answer the decision a run is parked on and resume it from the next action. */
 	async resolveRunDecision(id, runId, input) {
 		return this.request(`/v1/workflows/${encodeURIComponent(id)}/runs/${encodeURIComponent(runId)}/decision/resolve`, jsonInit("POST", input));
 	}
-	/**
-	* Dry-run a YAML definition against the platform compiler without saving it.
-	*
-	* `opts.structural` selects the CI mode: the platform skips its owner-scoped
-	* connection/skill/profile resolution, so the verdict depends only on the
-	* definition and the deployment's capabilities — identical no matter which
-	* providers the calling account has connected. Use it in pipelines that
-	* assert "this YAML is well-formed"; leave it off in an editor, where naming
-	* the unconnected providers is the point.
-	*/
+	/** Dry-run a YAML definition against the platform compiler without saving it. */
 	async validate(yaml, opts = {}) {
 		return this.request("/v1/workflows/validate", jsonInit("POST", {
 			yaml,
-			...opts.structural ? { structural: true } : {}
+			...opts
 		}));
 	}
 	async schema() {
@@ -1576,4 +1460,4 @@ var HubClient = class HubClient extends HubTransport {
 //#endregion
 export { HubLinesClient as C, HubAllowancesClient as D, HubAppsClient as E, jsonInit as O, HubManagedNumbersClient as S, HubKnowledgeManagementClient as T, resolveHubBaseUrl as _, HubChannelsClient as a, isHubUnauthenticated as b, HubInboundWebhooksClient as c, HubPermissionsClient as d, HubTokensClient as f, resolveHubAuth as g, HUB_URL_ENV_VAR as h, HubGithubAppClient as i, HubToolsClient as l, HUB_CAPABILITY_TOKEN_ENV_VAR as m, HubWorkflowsClient as n, HubEventSubscriptionsClient as o, HUB_API_KEY_ENV_VAR as p, HubAuditClient as r, HubConnectionsClient as s, HubClient as t, HubApprovalsClient as u, HubSdkError as v, HubKnowledgeClient as w, redactHubValue as x, HubTransport as y };
 
-//# sourceMappingURL=client-gF4iRjd3.js.map
+//# sourceMappingURL=client-cT9lHMpc.js.map