@soat/sdk 0.68.0 → 0.70.0

package/dist/index.cjs

@@ -779,7 +779,7 @@ var Agents = class {
 	/**
 	* Delete an agent
 	*
-	* Deletes an agent by ID. Fails with `409` if the agent has dependent generations or traces, unless `force=true` is passed, in which case those generations and traces are deleted along with the agent.
+	* Deletes an agent by ID. Fails with `409` if the agent has dependent generations or traces, or another project has accepted a share of it, unless `force=true` is passed, in which case those generations and traces are deleted along with the agent and the shares are revoked. Every share of the agent is revoked when it is deleted.
 	*
 	*/
 	static deleteAgent(options) {
@@ -791,7 +791,8 @@ var Agents = class {
 	/**
 	* Get an agent
 	*
-	* Returns a single agent by ID.
+	* Returns a single agent by ID. A credential scoped to a project the agent is shared with, through an accepted share, reads its `id` and `name` only.
+	*
 	*/
 	static getAgent(options) {
 		return (options.client ?? client).get({
@@ -834,6 +835,8 @@ var Agents = class {
 	*
 	* Sends messages to the agent, resolves its tools, and runs the AI model loop. Background by default: returns `202 Accepted` with a `generation_id` to poll via `GET /api/v1/generations/{generation_id}`. Pass `?wait=true` to block and receive the result inline, where client tools pause the generation and return `requires_action`. Streaming (`stream: true`) implies waiting. Pass `idempotency_key` to make a retry safe: a request whose key is already claimed runs nothing and answers `202` with the generation the key names.
 	*
+	* A credential scoped to a project the agent is shared with, through an accepted share, runs it in that project: on the publisher's configuration, recorded, metered and governed in the grantee project.
+	*
 	*/
 	static createAgentGeneration(options) {
 		return (options.client ?? client).post({
@@ -4141,6 +4144,167 @@ var Sessions = class {
 		});
 	}
 };
+var Shares = class {
+	/**
+	* List shares
+	*
+	* With `role=publisher` (the default), the shares the project published. With `role=grantee`, the shares addressed to the project and the public shares it accepted, each with the project's own `acceptance`. A public share the project never accepted is not listed.
+	*/
+	static listShares(options) {
+		return (options?.client ?? client).get({
+			url: "/api/v1/shares",
+			...options
+		});
+	}
+	/**
+	* Create a share
+	*
+	* Offers one of the project's resources to another project — or, with `grantee: "*"`, to every project — with the listed actions. The share grants nothing until the grantee accepts it. `grantee: "*"` is refused with `403 PUBLIC_SHARES_DISABLED` unless the deployment sets `SHARES_ALLOW_PUBLIC=true`.
+	*/
+	static createShare(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/shares",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a share
+	*
+	* Deletes a share and every acceptance of it. Each project whose acceptance was active gets a `share_revoked` activity entry.
+	*/
+	static deleteShare(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/shares/{share_id}",
+			...options
+		});
+	}
+	/**
+	* Get a share
+	*
+	* Returns a share with the grantee's view of the resource in `projection`. The publisher reads any of its shares; a grantee project, named by `project_id` or by its scoped credential, reads a share addressed to it or a public one, with its own `acceptance`.
+	*/
+	static getShare(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/shares/{share_id}",
+			...options
+		});
+	}
+	/**
+	* Update a share
+	*
+	* Changes a share's `cap`, as its publisher. The next call through the share reads the new cap; a changed `window` starts a fresh count.
+	*/
+	static updateShare(options) {
+		return (options.client ?? client).patch({
+			url: "/api/v1/shares/{share_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Accept a share
+	*
+	* Records the grantee project's acceptance, which is what makes the share grant anything. Idempotent. A project that revoked its own acceptance may accept again; one whose acceptance the publisher revoked answers `403 SHARE_REVOKED` until the publisher deletes that acceptance. A suspended share can be accepted and grants nothing until resumed.
+	*/
+	static acceptShare(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/shares/{share_id}/accept",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Suspend a share
+	*
+	* Sets `suspended_at`, which denies every acceptance without removing any. Reversible with resume; nobody re-accepts. Each project with an active acceptance gets a `share_suspended` activity entry. Idempotent.
+	*/
+	static suspendShare(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/shares/{share_id}/suspend",
+			...options
+		});
+	}
+	/**
+	* Resume a share
+	*
+	* Clears `suspended_at`. Each project with an active acceptance gets a `share_resumed` activity entry. Idempotent.
+	*/
+	static resumeShare(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/shares/{share_id}/resume",
+			...options
+		});
+	}
+	/**
+	* Revoke a share
+	*
+	* As the publisher, revokes the whole share and every acceptance of it; terminal. Each project whose acceptance was active gets a `share_revoked` activity entry. As a grantee (`project_id`, or a credential scoped to it), revokes that project's own acceptance, which it may accept again later; while the project's own resources still name the shared resource (see `GET /api/v1/shares/{share_id}/references`), that answers `409 SHARE_IN_USE` unless `force=true`. A publisher's revoke is never refused on that account. Idempotent.
+	*/
+	static revokeShare(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/shares/{share_id}/revoke",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* List a grantee's references to a shared resource
+	*
+	* The grantee project's own resources that name the resource the share grants: agents binding a shared tool, pipelines stepping through it, ingestion rules converting with it, orchestrations, triggers and formations naming it. What degrades if the project revokes its acceptance, and what `409 SHARE_IN_USE` lists. The grantee is named by `project_id` or by its scoped credential; the publisher holds none of these and is answered `400`.
+	*/
+	static listShareReferences(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/shares/{share_id}/references",
+			...options
+		});
+	}
+	/**
+	* List a share's acceptances
+	*
+	* The projects that accepted the share, for its publisher.
+	*/
+	static listShareAcceptances(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/shares/{share_id}/acceptances",
+			...options
+		});
+	}
+	/**
+	* Revoke an acceptance
+	*
+	* The publisher cutting one consumer. The acceptance is kept with `revoked_by: publisher`, and a new accept from that project answers `403 SHARE_REVOKED` until the publisher deletes it. The project gets a `share_revoked` activity entry if the acceptance was active.
+	*/
+	static revokeShareAcceptance(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/shares/{share_id}/acceptances/{acceptance_id}/revoke",
+			...options
+		});
+	}
+	/**
+	* Delete an acceptance
+	*
+	* Removes one project's acceptance, which lets a project the publisher revoked accept again. The project gets a `share_revoked` activity entry if the acceptance was active.
+	*/
+	static deleteShareAcceptance(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/shares/{share_id}/acceptances/{acceptance_id}",
+			...options
+		});
+	}
+};
 var Tasks = class {
 	/**
 	* List tasks
@@ -4292,7 +4456,7 @@ var Tools = class {
 	/**
 	* Delete a tool
 	*
-	* Deletes a tool by ID. A tool that is a decider's backend is refused with `409 TOOL_HAS_DEPENDENTS`.
+	* Deletes a tool by ID. A tool that is a decider's backend is refused with `409 TOOL_HAS_DEPENDENTS`, and so is one another project has accepted a share of, or one of its own project's ingestion rules converts with, until `force=true`. Every share of the tool is revoked when it is deleted; an ingestion rule keeps its `tool_id` and fails the documents it matches with `CONVERTER_FAILED` until repointed.
 	*/
 	static deleteTool(options) {
 		return (options.client ?? client).delete({
@@ -4303,7 +4467,8 @@ var Tools = class {
 	/**
 	* Get a tool
 	*
-	* Returns a single tool by ID.
+	* Returns a single tool by ID. A credential scoped to a project the tool is shared with, through an accepted share, reads its `id`, `name`, `description` and `parameters` only.
+	*
 	*/
 	static getTool(options) {
 		return (options.client ?? client).get({
@@ -4334,6 +4499,8 @@ var Tools = class {
 	* `preset_parameters` stored on the tool are pinned over the caller-supplied `input` before execution: a key the tool presets keeps its preset value even when `input` sets it. Keys the presets do not name are taken from `input` as sent.
 	* Guardrails attached to the tool or to its project adjudicate the call before dispatch, composing project + tool scope. A call this route cannot await a decision on — class C (human sign-off), class D, or a class-B tripwire — is refused with `422 TOOL_DISPATCH_FAILED`, whose `meta` carries the `tool_id` and the `outcome`. A `pipeline` tool is adjudicated before its first step runs, and every step is adjudicated as the call of that tool it is.
 	*
+	* A credential scoped to a project the tool is shared with, through an accepted share, calls it in that project: the calling project's guardrails adjudicate it, it is metered there with `publisher_project_id`, and the tool receives the calling project as the `calling_project_id` tool context key.
+	*
 	*/
 	static callTool(options) {
 		return (options.client ?? client).post({
@@ -4541,9 +4708,9 @@ var Usage = class {
 	/**
 	* Get aggregated usage for a project
 	*
-	* Returns a project's usage rolled up over an optional `[from, to]` time window, optionally bucketed by a single dimension and narrowed by any combination of fifteen filters — session, actor, agent, AI provider, orchestration run, orchestration, generation, trace, tool, meter type, model, source, trigger, action and outcome. That is how "what did this conversation cost", "what has this end user cost" and "what did this agent cost" are answered. Each group and the grand total carry an `event_count`, summed token counts, a measured `quantity` per component (so infra meters report their real amount, not zeros), and `cost_usd` (null when no event in the bucket was priced). This is the per-project cost-by-range/by-category query — a monthly figure without scanning raw usage events client-side.
+	* Returns a project's usage rolled up over an optional `[from, to]` time window, optionally bucketed by a single dimension and narrowed by any combination of sixteen filters — session, actor, agent, AI provider, orchestration run, orchestration, generation, trace, tool, publisher project, meter type, model, source, trigger, action and outcome. That is how "what did this conversation cost", "what has this end user cost" and "what did this agent cost" are answered. Each group and the grand total carry an `event_count`, summed token counts, a measured `quantity` per component (so infra meters report their real amount, not zeros), and `cost_usd` (null when no event in the bucket was priced). This is the per-project cost-by-range/by-category query — a monthly figure without scanning raw usage events client-side.
 	*
-	* Narrowings intersect and apply to the whole rollup — every bucket, `totals` and `totals.distinct` alike — so each composes with any `group_by`, and all fifteen are echoed back under `filters`. The nine naming a resource are resolved against the project, and one naming nothing there empties the rollup rather than being dropped: a mistyped id must never read back as the project's whole spend. The other six are matched against the value the event recorded.
+	* Narrowings intersect and apply to the whole rollup — every bucket, `totals` and `totals.distinct` alike — so each composes with any `group_by`, and all sixteen are echoed back under `filters`. The ten naming a resource are resolved against the project (a tool also through an accepted share), and one naming nothing there empties the rollup rather than being dropped: a mistyped id must never read back as the project's whole spend. The other six are matched against the value the event recorded.
 	*
 	* `groups` is paginated. Its `total` is the number of distinct buckets in the window — bucket cardinality, including a null bucket for the events the dimension does not apply to, and never a count of entities. To count entities, send `include=distinct` and read `totals.distinct`. `totals` always describes the whole window — never the page above it, and never the bucketing: omit `group_by` and `totals` is unchanged while `groups` is empty.
 	*
@@ -5051,6 +5218,7 @@ var SoatClient = class {
 	quotas;
 	secrets;
 	sessions;
+	shares;
 	tasks;
 	tools;
 	traces;
@@ -5101,6 +5269,7 @@ var SoatClient = class {
 		this.quotas = bindResource(Quotas, httpClient);
 		this.secrets = bindResource(Secrets, httpClient);
 		this.sessions = bindResource(Sessions, httpClient);
+		this.shares = bindResource(Shares, httpClient);
 		this.tasks = bindResource(Tasks, httpClient);
 		this.tools = bindResource(Tools, httpClient);
 		this.traces = bindResource(Traces, httpClient);
@@ -5145,6 +5314,7 @@ exports.Projects = Projects;
 exports.Quotas = Quotas;
 exports.Secrets = Secrets;
 exports.Sessions = Sessions;
+exports.Shares = Shares;
 exports.SoatClient = SoatClient;
 exports.Tasks = Tasks;
 exports.Tools = Tools;