@soat/sdk 0.20.4 → 0.21.0

package/dist/index.mjs

@@ -824,7 +824,7 @@ var Agents = class {
 	/**
 	* Run an agent generation
 	*
-	* Sends messages to the agent, resolves its tools, and runs the AI model loop. Supports streaming via `stream: true`. Client tools pause the generation and return `requires_action`.
+	* 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.
 	*
 	*/
 	static createAgentGeneration(options) {
@@ -922,6 +922,8 @@ var AgentVersions = class {
 	*
 	* Makes the canary version's config the agent's live config and clears the release. The canary is pinned by version, so an edit that landed mid-rollout is not promoted in its place — it stays an unreleased draft in the version history.
 	*
+	* When the release carries a `promotion_gate`, the eval it names must have a run that finished `completed` with `passed: true` **and** was pinned to the canary version (`agent_version`); otherwise the call is a `409` and the rollout is left running untouched. The run that cleared the gate is recorded as `eval_run_id` on the version that goes live.
+	*
 	*/
 	static promoteAgentRelease(options) {
 		return (options.client ?? client).post({
@@ -974,7 +976,7 @@ var AiProviders = class {
 	*
 	* Deletes an AI provider configuration.
 	*
-	* Live references — chats, agents, discussions, and model routes whose targets name this provider — always block deletion with `409 AI_PROVIDER_HAS_DEPENDENTS`; `force` does not override them, so delete or repoint those resources first. Soft dependents — price overrides, usage/generation records, and discussion participants — also block with `409` unless `force=true`, which deletes the provider's price overrides and unlinks (nulls) its usage and participant history, preserving those rows. The `409` body's `error.meta` reports the counts, a sample of offending IDs, and a `forcible` flag that is `true` when a `force=true` retry would succeed.
+	* Live references — chats, agents, and model routes whose targets name this provider — always block deletion with `409 AI_PROVIDER_HAS_DEPENDENTS`; `force` does not override them, so delete or repoint those resources first. Soft dependents — price overrides and usage/generation records — also block with `409` unless `force=true`, which deletes the provider's price overrides and unlinks (nulls) its usage history, preserving those rows. The `409` body's `error.meta` reports the counts, a sample of offending IDs, and a `forcible` flag that is `true` when a `force=true` retry would succeed.
 	*
 	*/
 	static deleteAiProvider(options) {
@@ -1010,6 +1012,20 @@ var AiProviders = class {
 		});
 	}
 	/**
+	* List the models this provider can run
+	*
+	* Asks the provider which models it can run, using this provider record's own credentials and configuration, and returns provider-native model ids — the same strings `default_model` and an agent's `model` carry.
+	* Which models are reachable is a property of the credential, not of the provider type: a Vertex provider sees only the publisher models its Google Cloud project and location serve, and a Bedrock provider only the foundation models enabled in its region. Reading the list is how a caller avoids pinning a model that fails at generation time.
+	* Not every provider type can answer. `azure` lists deployments an operator named rather than models, and `ollama` lists whatever was pulled onto that host, so both return `400 MODEL_LISTING_UNSUPPORTED`.
+	*
+	*/
+	static listAiProviderModels(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/ai-providers/{ai_provider_id}/models",
+			...options
+		});
+	}
+	/**
 	* List per-provider price overrides
 	*
 	* Returns the per-provider price overrides for this AI provider instance. An override prices this specific provider (e.g. an enterprise-negotiated rate or a gateway with markup) and wins over the global default at cost time. Authorized by the caller's access to the provider's project — so, unlike the global price book, a project's own overrides are visible here.
@@ -1385,9 +1401,14 @@ var Conversations = class {
 	* Generate the next message in a conversation
 	*
 	* Generates the next message using the specified actor's linked agent or chat.
-	* On `completed`, the reply is persisted as a new ConversationMessage authored
-	* by that actor. On `requires_action`, nothing is persisted; the caller must
-	* submit tool outputs via the Agents module and re-invoke generate.
+	* Background by default: returns `202 Accepted` immediately and the reply
+	* lands as a new ConversationMessage when it completes — poll
+	* `GET /api/v1/conversations/{conversation_id}/messages` for it.
+	* Pass `?wait=true` to block and receive the result inline. On
+	* `completed`, the reply is persisted as a new ConversationMessage
+	* authored by that actor. On `requires_action`, nothing is persisted; the
+	* caller must submit tool outputs via the Agents module and re-invoke
+	* generate — so a flow using client tools should pass `?wait=true`.
 	*
 	*/
 	static generateConversationMessage(options) {
@@ -1453,109 +1474,6 @@ var Conversations = class {
 		});
 	}
 };
-var Discussions = class {
-	/**
-	* List discussions
-	*
-	* Returns all discussions the caller has access to. If project_id is provided, returns only discussions in that project.
-	*/
-	static listDiscussions(options) {
-		return (options?.client ?? client).get({
-			url: "/api/v1/discussions",
-			...options
-		});
-	}
-	/**
-	* Create a discussion
-	*
-	* Creates a new discussion config. project keys infer the project from the key's scope; JWT callers must supply project_id.
-	*/
-	static createDiscussion(options) {
-		return (options.client ?? client).post({
-			url: "/api/v1/discussions",
-			...options,
-			headers: {
-				"Content-Type": "application/json",
-				...options.headers
-			}
-		});
-	}
-	/**
-	* Get a discussion run by ID
-	*
-	* Returns a single discussion run, including its outcome, transcript conversation, and outcome document.
-	*/
-	static getDiscussionRun(options) {
-		return (options.client ?? client).get({
-			url: "/api/v1/discussions/runs/{run_id}",
-			...options
-		});
-	}
-	/**
-	* Delete a discussion
-	*
-	* Deletes a discussion config and its participants.
-	*/
-	static deleteDiscussion(options) {
-		return (options.client ?? client).delete({
-			url: "/api/v1/discussions/{discussion_id}",
-			...options
-		});
-	}
-	/**
-	* Get a discussion by ID
-	*
-	* Returns a discussion config with its participants.
-	*/
-	static getDiscussion(options) {
-		return (options.client ?? client).get({
-			url: "/api/v1/discussions/{discussion_id}",
-			...options
-		});
-	}
-	/**
-	* Update a discussion
-	*
-	* Updates a discussion. Providing participants replaces the full set (not merged).
-	*/
-	static updateDiscussion(options) {
-		return (options.client ?? client).patch({
-			url: "/api/v1/discussions/{discussion_id}",
-			...options,
-			headers: {
-				"Content-Type": "application/json",
-				...options.headers
-			}
-		});
-	}
-	/**
-	* List a discussion's runs
-	*
-	* Returns the run history of a discussion, most recent first.
-	*/
-	static listDiscussionRuns(options) {
-		return (options.client ?? client).get({
-			url: "/api/v1/discussions/{discussion_id}/runs",
-			...options
-		});
-	}
-	/**
-	* Invoke a discussion
-	*
-	* Runs the discussion synchronously over the given topic and returns the completed run, whose outcome inlines the synthesized text. The run's transcript is persisted as a conversation and the outcome as a document.
-	*
-	*/
-	static createDiscussionRun(options) {
-		return (options.client ?? client).post({
-			url: "/api/v1/discussions/{discussion_id}/runs",
-			...options,
-			headers: {
-				"Content-Type": "application/json",
-				...options.headers
-			}
-		});
-	}
-};
 var Documents = class {
 	/**
 	* List documents
@@ -1670,8 +1588,8 @@ var Documents = class {
 	* source file. Existing chunks are discarded and the document is reset to
 	* `status=pending` before re-processing. Use this to recover a document
 	* stuck in `processing`/`failed` or to re-chunk with a different strategy
-	* without re-uploading the file. Async by default (`202`); pass
-	* `?async=false` to run synchronously (`201`).
+	* without re-uploading the file. Background by default (`202`); pass
+	* `?wait=true` to run synchronously (`201`).
 	*
 	*/
 	static reingestDocument(options) {
@@ -1770,6 +1688,261 @@ var Embeddings = class {
 		});
 	}
 };
+var Evaluations = class {
+	/**
+	* List datasets
+	*
+	* Returns the datasets defined in a project
+	*/
+	static listDatasets(options) {
+		return (options?.client ?? client).get({
+			url: "/api/v1/datasets",
+			...options
+		});
+	}
+	/**
+	* Create a dataset
+	*
+	* Creates a project-scoped dataset — a named collection of test cases an eval runs an agent against. Names are unique per project.
+	*
+	* Datasets are operator-owned **fixtures**. The platform's content purge never deletes or mutates a dataset item, so erasing a generation cannot silently stop a test suite from being runnable.
+	*/
+	static createDataset(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/datasets",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a dataset
+	*
+	* Deletes a dataset, its items, and every eval bound to it. Results of runs that already scored those items keep their frozen copies of the input and expected output.
+	*/
+	static deleteDataset(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/datasets/{dataset_id}",
+			...options
+		});
+	}
+	/**
+	* Get a dataset
+	*
+	* Returns a specific dataset
+	*/
+	static getDataset(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/datasets/{dataset_id}",
+			...options
+		});
+	}
+	/**
+	* Update a dataset
+	*
+	* Updates a dataset's name and/or description
+	*/
+	static updateDataset(options) {
+		return (options.client ?? client).put({
+			url: "/api/v1/datasets/{dataset_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* List dataset items
+	*
+	* Returns the test cases in a dataset, oldest first
+	*/
+	static listDatasetItems(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/datasets/{dataset_id}/items",
+			...options
+		});
+	}
+	/**
+	* Add a dataset item
+	*
+	* Adds one test case. `input` is replayed verbatim as the generation's messages, so it must be a non-empty array of `{ role, content }`.
+	*/
+	static createDatasetItem(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/datasets/{dataset_id}/items",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a dataset item
+	*
+	* Deletes a test case. Results of runs that already scored it stay readable; their `dataset_item_id` becomes null.
+	*/
+	static deleteDatasetItem(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/datasets/{dataset_id}/items/{item_id}",
+			...options
+		});
+	}
+	/**
+	* Update a dataset item
+	*
+	* Updates a test case. Runs that already scored it are unaffected — each result carries its own frozen copy of the input and expected output.
+	*/
+	static updateDatasetItem(options) {
+		return (options.client ?? client).put({
+			url: "/api/v1/datasets/{dataset_id}/items/{item_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* List evals
+	*
+	* Returns the evals defined in a project
+	*/
+	static listEvals(options) {
+		return (options?.client ?? client).get({
+			url: "/api/v1/evals",
+			...options
+		});
+	}
+	/**
+	* Create an eval
+	*
+	* Binds an agent under test to a dataset and a list of scorers. The agent and the dataset must belong to the same project as the eval; a cross-project reference is rejected with 400.
+	*
+	* Scorer config is frozen here rather than read from the agent at run time, so two runs of the same eval are always judged by the same criteria and their comparison measures the agent instead of the config drifting underneath it. Each scorer `type` may appear at most once.
+	*/
+	static createEval(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/evals",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete an eval
+	*
+	* Deletes an eval, its runs, and their results
+	*/
+	static deleteEval(options) {
+		return (options.client ?? client).delete({
+			url: "/api/v1/evals/{eval_id}",
+			...options
+		});
+	}
+	/**
+	* Get an eval
+	*
+	* Returns a specific eval
+	*/
+	static getEval(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/evals/{eval_id}",
+			...options
+		});
+	}
+	/**
+	* Update an eval
+	*
+	* Updates an eval. Changing `agent_id` re-validates the scorers against the new agent, since an `output_schema` scorer that was legal against the old one may not be.
+	*/
+	static updateEval(options) {
+		return (options.client ?? client).put({
+			url: "/api/v1/evals/{eval_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* List eval runs
+	*
+	* Returns an eval's runs, newest first
+	*/
+	static listEvalRuns(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/evals/{eval_id}/runs",
+			...options
+		});
+	}
+	/**
+	* Start an eval run
+	*
+	* Runs the eval against its dataset, creating one real agent generation per item and scoring the outputs.
+	*
+	* `wait: true` executes the run synchronously and returns it terminal, with its scores. The dataset is capped at 25 items for a synchronous run; a larger one is rejected with 400 rather than partially scored.
+	*
+	* `wait: false` (the default) enqueues one task per item and returns immediately with `status: "queued"`. A worker executes the items and the run settles itself; poll `GET /evals/{eval_id}/runs/{eval_run_id}` for the terminal status, or subscribe to the `eval_run.completed` webhook. There is no item cap on a queued run.
+	*
+	* The whole run is pinned to **one** agent version, stamped on `agent_version`: pass one explicitly to evaluate a canary before promoting it, or omit it to use the active release's stable version (or the live draft when no release is in effect). Without the pin, release assignment would bucket each item independently and blend two configs into a single score.
+	*
+	* With `baseline_run_id`, the finished run's `aggregate_scores.baseline` carries per-scorer deltas against that run, computed over the items present and scorable in **both** runs, with the divergence counted. A delta over a shifted dataset is therefore never presented as a clean comparison.
+	*/
+	static startEvalRun(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/evals/{eval_id}/runs",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Get an eval run
+	*
+	* Returns a run's status, counts, and aggregate scores
+	*/
+	static getEvalRun(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/evals/{eval_id}/runs/{eval_run_id}",
+			...options
+		});
+	}
+	/**
+	* List eval run results
+	*
+	* Returns the per-item results of a run, oldest first
+	*/
+	static listEvalResults(options) {
+		return (options.client ?? client).get({
+			url: "/api/v1/evals/{eval_id}/runs/{eval_run_id}/results",
+			...options
+		});
+	}
+	/**
+	* Cancel an eval run
+	*
+	* Cancels a queued or running run: its outstanding item tasks are dropped so it stops consuming provider budget, and the run settles as `canceled`.
+	*
+	* Results already written are kept — they are real measurements of generations that were really paid for — and `completed_count` / `errored_count` report what ran. `aggregate_scores` is deliberately left null: a partial roll-up in the same field a completed run uses would read as a whole-dataset verdict.
+	*
+	* A run that has already finished is rejected with 400.
+	*/
+	static cancelEvalRun(options) {
+		return (options.client ?? client).post({
+			url: "/api/v1/evals/{eval_id}/runs/{eval_run_id}/cancel",
+			...options
+		});
+	}
+};
 var Exceptions = class {
 	/**
 	* List exception items
@@ -3176,7 +3349,7 @@ var Sessions = class {
 	/**
 	* Trigger agent generation
 	*
-	* Triggers the agent to generate a response based on the current conversation. Returns the assistant reply or a requires_action status if the agent needs client tool outputs. Pass ?async=true for a 202 accepted response when you do not need to wait for the result.
+	* Triggers the agent to generate a response based on the current conversation. Background by default: returns `202 Accepted` immediately while the generation runs. Pass ?wait=true to block and receive the assistant reply (or a requires_action status if the agent needs client tool outputs) in the response.
 	*
 	*/
 	static generateSessionResponse(options) {
@@ -3540,7 +3713,7 @@ var Triggers = class {
 	/**
 	* Fire a trigger
 	*
-	* Fires a trigger synchronously and returns the terminal firing record.
+	* 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({
@@ -4067,31 +4240,49 @@ const bindResource = (SdkClass, client) => {
 * the corresponding static class from the generated SDK, so all method
 * signatures, types, and return values are identical — the only difference
 * is that you never need to supply `client` yourself.
+*
+* The list is exhaustive by construction: `NoUnregisteredResource` at the
+* bottom of this file fails `pnpm typecheck` when a spec adds a resource this
+* class does not expose.
 */
 var SoatClient = class {
+	activity;
 	actors;
 	agents;
+	agentVersions;
 	aiProviders;
 	apiKeys;
+	approvals;
+	auditLog;
 	chats;
 	conversations;
 	documents;
+	embeddings;
+	evaluations;
+	exceptions;
 	files;
 	formations;
+	generations;
+	guardrails;
 	ingestionRules;
 	knowledge;
 	memories;
 	memoryEntries;
+	modelRoutes;
+	orchestrations;
 	policies;
 	projects;
+	quotas;
 	secrets;
 	sessions;
+	tasks;
 	tools;
 	traces;
 	triggers;
 	usage;
 	users;
 	webhooks;
+	workflows;
 	constructor({ baseUrl, token, headers } = {}) {
 		const authHeaders = token ? { Authorization: `Bearer ${token}` } : {};
 		const httpClient = createClient(createConfig({
@@ -4101,30 +4292,44 @@ var SoatClient = class {
 				...headers
 			}
 		}));
+		this.activity = bindResource(Activity, httpClient);
 		this.actors = bindResource(Actors, httpClient);
 		this.agents = bindResource(Agents, httpClient);
+		this.agentVersions = bindResource(AgentVersions, httpClient);
 		this.aiProviders = bindResource(AiProviders, httpClient);
 		this.apiKeys = bindResource(ApiKeys, httpClient);
+		this.approvals = bindResource(Approvals, httpClient);
+		this.auditLog = bindResource(AuditLog, httpClient);
 		this.chats = bindResource(Chats, httpClient);
 		this.conversations = bindResource(Conversations, httpClient);
 		this.documents = bindResource(Documents, httpClient);
+		this.embeddings = bindResource(Embeddings, httpClient);
+		this.evaluations = bindResource(Evaluations, httpClient);
+		this.exceptions = bindResource(Exceptions, httpClient);
 		this.files = bindResource(Files, httpClient);
 		this.formations = bindResource(Formations, httpClient);
+		this.generations = bindResource(Generations, httpClient);
+		this.guardrails = bindResource(Guardrails, httpClient);
 		this.ingestionRules = bindResource(IngestionRules, httpClient);
 		this.knowledge = bindResource(Knowledge, httpClient);
 		this.memories = bindResource(Memories, httpClient);
 		this.memoryEntries = bindResource(MemoryEntries, httpClient);
+		this.modelRoutes = bindResource(ModelRoutes, httpClient);
+		this.orchestrations = bindResource(Orchestrations, httpClient);
 		this.policies = bindResource(Policies, httpClient);
 		this.projects = bindResource(Projects, httpClient);
+		this.quotas = bindResource(Quotas, httpClient);
 		this.secrets = bindResource(Secrets, httpClient);
 		this.sessions = bindResource(Sessions, httpClient);
+		this.tasks = bindResource(Tasks, httpClient);
 		this.tools = bindResource(Tools, httpClient);
 		this.traces = bindResource(Traces, httpClient);
 		this.triggers = bindResource(Triggers, httpClient);
 		this.usage = bindResource(Usage, httpClient);
 		this.users = bindResource(Users, httpClient);
 		this.webhooks = bindResource(Webhooks, httpClient);
+		this.workflows = bindResource(Workflows, httpClient);
 	}
 };
 //#endregion
-export { Activity, Actors, AgentVersions, Agents, AiProviders, ApiKeys, Approvals, AuditLog, Chats, Conversations, Discussions, Documents, Embeddings, Exceptions, Files, Formations, Generations, Guardrails, IngestionRules, Knowledge, Memories, MemoryEntries, ModelRoutes, Orchestrations, Policies, Projects, Quotas, Secrets, Sessions, SoatClient, Tasks, Tools, Traces, Triggers, Usage, Users, Webhooks, Workflows, createClient, createConfig };
+export { Activity, Actors, AgentVersions, Agents, AiProviders, ApiKeys, Approvals, AuditLog, Chats, Conversations, Documents, Embeddings, Evaluations, Exceptions, Files, Formations, Generations, Guardrails, IngestionRules, Knowledge, Memories, MemoryEntries, ModelRoutes, Orchestrations, Policies, Projects, Quotas, Secrets, Sessions, SoatClient, Tasks, Tools, Traces, Triggers, Usage, Users, Webhooks, Workflows, createClient, createConfig };

package/package.json

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