@naturali/sdk 0.66.0 → 0.68.0

package/dist/index.cjs

@@ -607,8 +607,7 @@ var Actors = class {
 	/**
 	* List actors
 	*
-	* Lists the project's actors. Filter by `external_id` to resolve your own key to an actor without creating one.
-	*
+	* Returns all actors the caller has access to. If projectId is provided, returns only actors in that project. project keys are scoped to a single project automatically. JWT users without projectId receive actors across all their accessible projects.
 	*/
 	static listActors(options) {
 		return (options.client ?? client).get({
@@ -619,9 +618,7 @@ var Actors = class {
 	/**
 	* Create an actor
 	*
-	* Creates the actor, or returns the one that already carries this `external_id`. Idempotent on that key: a retry returns the existing actor with `200` rather than creating a second one, so this is safe as the first call your backend makes when it sees a new user.
-	* `external_id` may not start with a channel prefix (`whatsapp:`, `discord:`, …) or `address:` — those name actors that belong to an [address](/docs/api/addresses/get-address), which owns its own.
-	*
+	* Creates a new actor. project keys automatically infer the project from the key's scope; JWT callers must supply projectId.
 	*/
 	static createActor(options) {
 		return (options.client ?? client).post({
@@ -634,11 +631,9 @@ var Actors = class {
 		});
 	}
 	/**
-	* Erase an actor
-	*
-	* Removes the actor and the sessions it holds. Erasure of one identity as this API knows it — narrower than "erase this human everywhere", since naturali does not know that two identities are the same person and does not claim to.
-	* An actor that belongs to an [address](/docs/api/addresses/get-address) responds `409`: erase it through `DELETE /v1/projects/{project_id}/addresses/{identifier}`, which also removes the address and its conversations. Deleting it here would leave those behind, pointing at an identity that no longer exists.
+	* Delete an actor
 	*
+	* Deletes an actor by its ID
 	*/
 	static deleteActor(options) {
 		return (options.client ?? client).delete({
@@ -647,10 +642,9 @@ var Actors = class {
 		});
 	}
 	/**
-	* Get an actor
-	*
-	* Returns one actor. An actor belonging to another project responds `404`, not `403` — the API never confirms that an id exists elsewhere.
+	* Get an actor by ID
 	*
+	* Returns an actor by its ID
 	*/
 	static getActor(options) {
 		return (options.client ?? client).get({
@@ -661,8 +655,7 @@ var Actors = class {
 	/**
 	* Update an actor
 	*
-	* Updates the fields present in the body and leaves the rest alone. `external_id` is not updatable: it is the key callers converge on, and moving it would silently orphan every reference they hold.
-	*
+	* Updates an actor's properties
 	*/
 	static updateActor(options) {
 		return (options.client ?? client).patch({
@@ -674,6 +667,47 @@ var Actors = class {
 			}
 		});
 	}
+	/**
+	* Get actor tags
+	*
+	* Returns all tags attached to the actor
+	*/
+	static getActorTags(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/actors/{actor_id}/tags",
+			...options
+		});
+	}
+	/**
+	* Merge actor tags
+	*
+	* Merges provided tags with existing tags (existing tags are preserved unless overridden)
+	*/
+	static mergeActorTags(options) {
+		return (options.client ?? client).patch({
+			url: "/v1/projects/{project_id}/actors/{actor_id}/tags",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Replace actor tags
+	*
+	* Replaces all tags on the actor with the provided tags (not merged)
+	*/
+	static replaceActorTags(options) {
+		return (options.client ?? client).put({
+			url: "/v1/projects/{project_id}/actors/{actor_id}/tags",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
 };
 var Channels = class {
 	/**
@@ -817,22 +851,6 @@ var Channels = class {
 		});
 	}
 	/**
-	* Open a conversation
-	*
-	* The outbound-first path (CHANNELS-ROUTING.md §3.11): open a conversation for `{ channel_id, identifier }` ahead of any inbound message, which falls out of making the identifier the unit rather than the message. Resolves the same three-layer action an inbound would (§3.6); a `409` when that does not land on an agent — there is nothing to open for a `message`/`silence` outcome.
-	*
-	*/
-	static createConversation(options) {
-		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/conversations",
-			...options,
-			headers: {
-				"Content-Type": "application/json",
-				...options.headers
-			}
-		});
-	}
-	/**
 	* List channels
 	*
 	* Lists the channels connected in the project.
@@ -920,6 +938,22 @@ var Channels = class {
 		});
 	}
 	/**
+	* Open a conversation
+	*
+	* The outbound-first path: open a conversation for an `identifier` ahead of any inbound message, which falls out of making the identifier the unit rather than the message. Resolves the same three-layer action an inbound would; a `409` when that does not land on an agent — there is nothing to open for a `message`/`silence` outcome.
+	*
+	*/
+	static openChannelConversation(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/channels/{channel_id}/conversations",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
 	* Get a conversation
 	*/
 	static getChannelConversation(options) {
@@ -945,7 +979,7 @@ var Agents = class {
 	/**
 	* List agents
 	*
-	* Lists the agents in the project.
+	* Returns all agents in the project.
 	*/
 	static listAgents(options) {
 		return (options.client ?? client).get({
@@ -956,8 +990,7 @@ var Agents = class {
 	/**
 	* Create an agent
 	*
-	* Create an agent bound to one of the project's providers (provider_id), optionally attaching tools (tool_bindings). See AgentCreate for the runtime config fields.
-	*
+	* Creates a new agent bound to an AI provider.
 	*/
 	static createAgent(options) {
 		return (options.client ?? client).post({
@@ -972,7 +1005,7 @@ var Agents = class {
 	/**
 	* Delete an agent
 	*
-	* Deletes the backing runtime agent. Returns 409 if the agent still has dependent generations or traces — pass `force=true` to delete those along with the agent (destructive and irreversible).
+	* 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.
 	*
 	*/
 	static deleteAgent(options) {
@@ -983,6 +1016,8 @@ var Agents = class {
 	}
 	/**
 	* Get an agent
+	*
+	* Returns a single agent by ID.
 	*/
 	static getAgent(options) {
 		return (options.client ?? client).get({
@@ -991,13 +1026,27 @@ var Agents = class {
 		});
 	}
 	/**
-	* Update an agent
+	* Partially update an agent
 	*
-	* Change the bound provider, name, model, instructions, sampling/step config, attached tools (tool_bindings/tool_choice/step_rules), or the structured-output schema (output_schema). At least one field is required.
+	* Partially updates an existing agent. Identical to PUT — both perform partial updates.
+	*/
+	static patchAgent(options) {
+		return (options.client ?? client).patch({
+			url: "/v1/projects/{project_id}/agents/{agent_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Update an agent
 	*
+	* Updates an existing agent. Identical to PATCH — both perform partial updates.
 	*/
 	static updateAgent(options) {
-		return (options.client ?? client).patch({
+		return (options.client ?? client).put({
 			url: "/v1/projects/{project_id}/agents/{agent_id}",
 			...options,
 			headers: {
@@ -1006,6 +1055,240 @@ var Agents = class {
 			}
 		});
 	}
+	/**
+	* Run an agent generation
+	*
+	* 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 /v1/projects/{project_id}/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) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/agents/{agent_id}/generate",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Submit tool outputs for a paused generation
+	*
+	* Resumes a generation that was paused due to client tool calls. Provide tool outputs for each pending tool call.
+	*
+	*/
+	static submitAgentToolOutputs(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/agents/{agent_id}/generate/{generation_id}/tool-outputs",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var AgentVersions = class {
+	/**
+	* List an agent's config versions
+	*
+	* Returns the agent's archived configurations, newest first. A version is written on create and on every subsequent write that changes the config — through the REST API or a formation apply alike. See [Versioning and Staged Rollout](/docs/modules/agents#versioning-and-staged-rollout).
+	*
+	*/
+	static listAgentVersions(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/agents/{agent_id}/versions",
+			...options
+		});
+	}
+	/**
+	* Get an archived agent config version
+	*
+	* Returns the exact configuration the agent held at a given version, so a generation can be traced back to the config that produced it.
+	*
+	*/
+	static getAgentVersion(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/agents/{agent_id}/versions/{version}",
+			...options
+		});
+	}
+	/**
+	* Restore an archived config as a new version
+	*
+	* Copies the named version's configuration onto the agent as a **new** version rather than rewinding the counter, so history stays append-only and the versions in between remain retrievable. Restoring the config the agent already holds is a no-op and creates no version.
+	*
+	* The restored config fully replaces the current one: a field the archived version did not set is cleared, not merged. Restore re-validates the config, so a tool, provider, or guardrail deleted since the snapshot was taken fails the request instead of writing a broken agent.
+	*
+	*/
+	static restoreAgentVersion(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/agents/{agent_id}/versions/{version}/restore",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Set or replace a staged rollout
+	*
+	* Starts serving two archived versions side by side: `canary_percent` of traffic gets `canary_version`, the rest gets `stable_version`.
+	*
+	* Assignment is deterministic — it hashes the actor behind the request's session (falling back to the session itself), so one end user never flip-flops between configs mid-conversation. Requests with neither are split randomly.
+	*
+	* While a release is active the agent's live columns act as a **draft**: further edits archive new versions but do not disturb either side of the running split. End the rollout with `promote` or `abort`.
+	*
+	*/
+	static setAgentRelease(options) {
+		return (options.client ?? client).put({
+			url: "/v1/projects/{project_id}/agents/{agent_id}/release",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Promote the canary and end the rollout
+	*
+	* 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({
+			url: "/v1/projects/{project_id}/agents/{agent_id}/release/promote",
+			...options
+		});
+	}
+	/**
+	* Abort the rollout and roll back to stable
+	*
+	* Restores the stable version's config as the agent's live config and clears the release, so all traffic returns to the configuration the rollout was measured against — not to whatever draft the live columns happened to hold.
+	*
+	*/
+	static abortAgentRelease(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/agents/{agent_id}/release/abort",
+			...options
+		});
+	}
+};
+var AiProviders = class {
+	/**
+	* List AI providers
+	*
+	* Returns a list of AI provider configurations for a project
+	*/
+	static listAiProviders(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/ai-providers",
+			...options
+		});
+	}
+	/**
+	* Create an AI provider
+	*
+	* Creates a new LLM provider configuration
+	*/
+	static createAiProvider(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/ai-providers",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete an AI provider
+	*
+	* Deletes an AI provider configuration.
+	*
+	* 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) {
+		return (options.client ?? client).delete({
+			url: "/v1/projects/{project_id}/ai-providers/{ai_provider_id}",
+			...options
+		});
+	}
+	/**
+	* Get an AI provider
+	*
+	* Returns a specific AI provider configuration
+	*/
+	static getAiProvider(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/ai-providers/{ai_provider_id}",
+			...options
+		});
+	}
+	/**
+	* Update an AI provider
+	*
+	* Updates an AI provider configuration
+	*/
+	static updateAiProvider(options) {
+		return (options.client ?? client).patch({
+			url: "/v1/projects/{project_id}/ai-providers/{ai_provider_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* 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`.
+	* Listing resolves credentials the same way generation does, so a record that can generate can list. The API-key types (`openai`, `groq`, `xai`, `gateway`, `custom`, `anthropic`, `google`) use the record's linked secret and cannot list without one. `bedrock` and `vertex` use the linked secret when there is one — IAM keys or a Bedrock API key, a Google service-account key — and otherwise fall back to the server environment (the AWS default credential chain, Google Application Default Credentials), so a record with no `secret_id` can still list.
+	* A Vertex record needs no `config.project` when its secret is a service-account key, since the key file names its own project. A Vertex record in express mode (API key) cannot list at all: express mode is a global, project-less endpoint and the publisher-model catalogue is per-project, so it returns `400 MODEL_LISTING_UNSUPPORTED`.
+	*
+	*/
+	static listAiProviderModels(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/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.
+	*
+	*/
+	static getAiProviderPrices(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/ai-providers/{ai_provider_id}/prices",
+			...options
+		});
+	}
+	/**
+	* Upsert per-provider price overrides
+	*
+	* Upserts price overrides for this AI provider instance, keyed on (model, effective_from). The provider slug is taken from the AI provider itself, so only the model, rates, and effective_from are supplied. Authorized by the caller's access to the provider's project. `effective_from` must be in the future — past prices are immutable, so ship corrections as new future-dated rows.
+	*
+	*/
+	static updateAiProviderPrices(options) {
+		return (options.client ?? client).put({
+			url: "/v1/projects/{project_id}/ai-providers/{ai_provider_id}/prices",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
 };
 var ApiKeys = class {
 	/**
@@ -1024,6 +1307,7 @@ var ApiKeys = class {
 	* Create an API key
 	*
 	* Creates an API key. When `project_id` is set the key is scoped to that project (the default and recommended stance); omit it for an account-scoped key. `capabilities` narrows what the key may do; when omitted the key inherits the creator's capabilities. The raw `key` (nat_sk_…) is returned only in this response.
+	* A project-scoped key requires the `admin` role in that project: the key is a standing credential for everything the project can do, so handing one out is an administrative act rather than something a read-only `member` can do for themselves. An account-scoped key requires a credential that is not itself confined to one project.
 	*
 	*/
 	static createApiKey(options) {
@@ -1207,39 +1491,27 @@ var Auth = class {
 			}
 		});
 	}
-	/**
-	* Get the current identity
-	*
-	* Returns the user behind the presented access token.
-	*/
-	static getCurrentUser(options) {
-		return (options?.client ?? client).get({
-			url: "/v1/auth/me",
-			...options
-		});
-	}
 };
-var Boards = class {
+var Conversations = class {
 	/**
-	* List boards
+	* List conversations
 	*
-	* Lists the boards defined in the project, newest first.
+	* Returns all conversations the caller has access to. If projectId is provided, returns only conversations in that project. project keys are scoped to a single project automatically.
 	*/
-	static listBoards(options) {
+	static listConversations(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/boards",
+			url: "/v1/projects/{project_id}/conversations",
 			...options
 		});
 	}
 	/**
-	* Create a board
-	*
-	* Define a board's columns and moves. Exactly one column must be `initial: true`; any number may be `terminal: true` (a card closes when it enters one). Every agent or tool a column dispatches must belong to this project, and every move a column routes to must be declared in `transitions`.
+	* Create a conversation
 	*
+	* Creates a new conversation. project keys automatically infer the project from the key's scope; JWT callers must supply projectId.
 	*/
-	static createBoard(options) {
+	static createConversation(options) {
 		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/boards",
+			url: "/v1/projects/{project_id}/conversations",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1248,39 +1520,35 @@ var Boards = class {
 		});
 	}
 	/**
-	* Delete a board
-	*
-	* Refused while the board still has open cards (409 `board_has_open_tasks`) — close or delete them first. Deleting a board whose cards are all closed removes those cards and their transition history along with it.
+	* Delete a conversation
 	*
+	* Deletes a conversation by its ID
 	*/
-	static deleteBoard(options) {
+	static deleteConversation(options) {
 		return (options.client ?? client).delete({
-			url: "/v1/projects/{project_id}/boards/{board_id}",
+			url: "/v1/projects/{project_id}/conversations/{conversation_id}",
 			...options
 		});
 	}
 	/**
-	* Get a board
-	*
-	* The board's current definition — the source of truth for which columns exist and which moves are legal from each, so a UI renders its columns and its buttons from this response.
+	* Get a conversation by ID
 	*
+	* Returns a conversation by its ID
 	*/
-	static getBoard(options) {
+	static getConversation(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/boards/{board_id}",
+			url: "/v1/projects/{project_id}/conversations/{conversation_id}",
 			...options
 		});
 	}
 	/**
-	* Update a board
-	*
-	* Change the name, description, `payload_schema`, or the definition itself. `states` and `transitions` are edited together or not at all — a column routes to a move and a move names columns, so validating one against a stale copy of the other would accept a definition that cannot route. At least one field is required.
-	* Cards already on the board are not moved. A card sitting in a column the new definition drops stays where it is and can only leave through a move the new definition declares: the definition is the sole authority at the moment a move is fired.
+	* Update a conversation
 	*
+	* Updates the status of a conversation
 	*/
-	static updateBoard(options) {
+	static updateConversation(options) {
 		return (options.client ?? client).patch({
-			url: "/v1/projects/{project_id}/boards/{board_id}",
+			url: "/v1/projects/{project_id}/conversations/{conversation_id}",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1288,35 +1556,25 @@ var Boards = class {
 			}
 		});
 	}
-};
-var Generations = class {
 	/**
-	* List an agent's generations
-	*
-	* Lists the generation records the agent has produced, newest first. Filter by lifecycle `status` to find the failures without paging everything the agent has ever run.
+	* List conversation messages
 	*
+	* Returns all messages (documents) attached to a conversation, ordered by position
 	*/
-	static listAgentGenerations(options) {
+	static listConversationMessages(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/agents/{agent_id}/generations",
+			url: "/v1/projects/{project_id}/conversations/{conversation_id}/messages",
 			...options
 		});
 	}
 	/**
-	* Run an agent generation
-	*
-	* Sends messages to the agent, resolves its tools, and runs the model loop.
-	*
-	* Background by default: this returns `202` immediately with a `generation_id`, and the turn runs on. Poll [`GET /v1/projects/{project_id}/generations/{generation_id}`](/docs/api/generations/get-generation) until its `status` leaves `in_progress`.
-	*
-	* Pass `?wait=true` to block instead and receive the turn itself — the final text when `status` is `completed` (plus `object` when the agent has an output schema), or the pending `tool_calls` when `status` is `requires_action`.
-	*
-	* With `stream: true` the response is a Server-Sent Events stream (Content-Type text/event-stream) proxied from the runtime. A stream holds the request open by definition, so it always waits; combining it with an explicit `wait=false` is a `400`.
+	* Add a message to a conversation
 	*
+	* Creates a document from the message text and attaches it to the conversation at the given position. If position is omitted, it is appended at the end.
 	*/
-	static createGeneration(options) {
+	static addConversationMessage(options) {
 		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/agents/{agent_id}/generations",
+			url: "/v1/projects/{project_id}/conversations/{conversation_id}/messages",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1325,71 +1583,22 @@ var Generations = class {
 		});
 	}
 	/**
-	* Get a generation
+	* Generate the next message in a conversation
 	*
-	* Returns one generation record. Flat rather than nested under the agent, because the ids that need resolving arrive on their own — a session reply carries a `generation_id` with no agent in hand.
-	* A generation belonging to another project responds `404`, not `403` — the API never confirms that an id exists elsewhere.
+	* Generates the next message using the specified actor's linked agent or chat.
+	* Background by default: returns `202 Accepted` immediately and the reply
+	* lands as a new ConversationMessage when it completes — poll
+	* `GET /v1/projects/{project_id}/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 getGeneration(options) {
-		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/generations/{generation_id}",
-			...options
-		});
-	}
-	/**
-	* Purge a generation's content
-	*
-	* Clears the generation's content — `metadata`, `error`, `extraction` and the internal recovery state of a paused run — and stamps `content_redacted_at` as verifiable proof the content is gone.
-	* The billing and audit skeleton is preserved: ids, timestamps, status, stop reason and the attribution fields (`action_id`, `trigger_id`) the usage ledger reads. A purged generation still reads back with `GET /v1/projects/{project_id}/generations/{generation_id}` — a `404` there would prove nothing about what was erased.
-	* This is the narrow erasure, scoped to one model turn. It does **not** delete the parent trace's step payload, which holds this generation's content alongside its siblings'. To erase a whole run's content, purge the trace with `DELETE /v1/projects/{project_id}/traces/{trace_id}/content`, which cascades to every descendant trace and all of their generations.
-	* Idempotent: purging an already-purged generation succeeds and leaves the original `content_redacted_at` in place.
-	* A generation belonging to another project responds `404`, not `403`, and nothing is purged.
-	*
-	*/
-	static purgeGenerationContent(options) {
-		return (options.client ?? client).delete({
-			url: "/v1/projects/{project_id}/generations/{generation_id}/content",
-			...options
-		});
-	}
-	/**
-	* Get a generation's cost
-	*
-	* What this one generation cost, and the tokens it was charged on — the billing-grade receipt the runtime froze at write time, per model line item.
-	* This is the per-generation grain that `GET /v1/projects/{project_id}/usage` cannot express: that meter buckets a whole project by model, agent, run, day or meter type, and a run can hold more than one generation. Use this to price a single turn, and the project meter to roll spend up.
-	* `cost_usd` is `null` when nothing was priced — never that the work was free. Only naturali-managed providers are priced; a BYOK generation runs on your own provider account, so it carries no LLM cost here (its tokens are still reported).
-	* A generation belonging to another project responds `404`, not `403`.
-	*
-	*/
-	static getGenerationUsage(options) {
-		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/generations/{generation_id}/usage",
-			...options
-		});
-	}
-};
-var Knowledge = class {
-	/**
-	* List collections
-	*
-	* Lists the knowledge collections in the project.
-	*/
-	static listKnowledgeCollections(options) {
-		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/knowledge/collections",
-			...options
-		});
-	}
-	/**
-	* Create a collection
-	*
-	* Create a knowledge collection. The name is the key manifests reference (an agent's `knowledge:` block) and must be unique within the project.
-	*
-	*/
-	static createKnowledgeCollection(options) {
+	static generateConversationMessage(options) {
 		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/knowledge/collections",
+			url: "/v1/projects/{project_id}/conversations/{conversation_id}/generate",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1398,34 +1607,35 @@ var Knowledge = class {
 		});
 	}
 	/**
-	* Delete a collection
-	*
-	* Deletes an empty collection. Returns 409 if the collection still has documents (delete them first).
+	* Remove a message from a conversation
 	*
+	* Removes a document from a conversation
 	*/
-	static deleteKnowledgeCollection(options) {
+	static removeConversationMessage(options) {
 		return (options.client ?? client).delete({
-			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}",
+			url: "/v1/projects/{project_id}/conversations/{conversation_id}/messages/{document_id}",
 			...options
 		});
 	}
 	/**
-	* Get a collection
+	* Get conversation tags
+	*
+	* Returns all tags attached to the conversation
 	*/
-	static getKnowledgeCollection(options) {
+	static getConversationTags(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}",
+			url: "/v1/projects/{project_id}/conversations/{conversation_id}/tags",
 			...options
 		});
 	}
 	/**
-	* Update a collection
+	* Merge conversation tags
 	*
-	* Rename the collection or edit its description. At least one field is required.
+	* Merges provided tags with existing tags
 	*/
-	static updateKnowledgeCollection(options) {
+	static mergeConversationTags(options) {
 		return (options.client ?? client).patch({
-			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}",
+			url: "/v1/projects/{project_id}/conversations/{conversation_id}/tags",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1434,14 +1644,13 @@ var Knowledge = class {
 		});
 	}
 	/**
-	* Query a collection (retrieval preview)
-	*
-	* Retrieval preview: returns the chunks the collection would surface for a question — debuggable standalone, before any agent is bound to it. This is the `…:query` action; the path segment is `{collection_id}:query`.
+	* Replace conversation tags
 	*
+	* Replaces all tags on the conversation with the provided tags
 	*/
-	static queryKnowledgeCollection(options) {
-		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}:query",
+	static replaceConversationTags(options) {
+		return (options.client ?? client).put({
+			url: "/v1/projects/{project_id}/conversations/{conversation_id}/tags",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1449,30 +1658,29 @@ var Knowledge = class {
 			}
 		});
 	}
+};
+var Evaluations = class {
 	/**
-	* List documents
+	* List datasets
 	*
-	* Lists the documents in the collection, with their ingestion status.
+	* Returns the datasets defined in a project
 	*/
-	static listKnowledgeDocuments(options) {
+	static listDatasets(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}/documents",
+			url: "/v1/projects/{project_id}/datasets",
 			...options
 		});
 	}
 	/**
-	* Create a document
-	*
-	* Add a document to the collection, from **inline text** (`content`) or from an **uploaded file** (`file`, base64, plus `content_type` and `filename`) — exactly one of the two.
-	*
-	* `application/pdf`, `text/plain` and `text/markdown` are extracted natively. Any other media type needs a converter (`POST /v1/projects/{project_id}/knowledge/converters`) registered for it in the project; without one the request is rejected with `unsupported_content_type` and no document is created.
+	* Create a dataset
 	*
-	* Ingestion (extract → chunk → embed) runs in the background: the document comes back `pending` and becomes `indexed` or `failed`, which is announced by the `knowledge.document_ingested` / `knowledge.ingest_failed` webhook events.
+	* 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 createKnowledgeDocument(options) {
+	static createDataset(options) {
 		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}/documents",
+			url: "/v1/projects/{project_id}/datasets",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1481,73 +1689,61 @@ var Knowledge = class {
 		});
 	}
 	/**
-	* Delete a document
+	* 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 deleteKnowledgeDocument(options) {
+	static deleteDataset(options) {
 		return (options.client ?? client).delete({
-			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}/documents/{document_id}",
+			url: "/v1/projects/{project_id}/datasets/{dataset_id}",
 			...options
 		});
 	}
 	/**
-	* Get a document
+	* Get a dataset
 	*
-	* Returns the document, including its text content when ingestion is complete.
+	* Returns a specific dataset
 	*/
-	static getKnowledgeDocument(options) {
+	static getDataset(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}/documents/{document_id}",
+			url: "/v1/projects/{project_id}/datasets/{dataset_id}",
 			...options
 		});
 	}
 	/**
-	* Re-ingest a document
-	*
-	* Re-run ingestion for a document against its stored source, resetting it to `pending` before re-processing — the recovery path for a `failed` ingest. This is the `…:reingest` action; the path segment is `{document_id}:reingest`.
+	* Update a dataset
 	*
+	* Updates a dataset's name and/or description
 	*/
-	static reingestKnowledgeDocument(options) {
-		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}/documents/{document_id}:reingest",
-			...options
+	static updateDataset(options) {
+		return (options.client ?? client).put({
+			url: "/v1/projects/{project_id}/datasets/{dataset_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
 		});
 	}
 	/**
-	* List converters
+	* List dataset items
 	*
-	* Lists the media converters registered in the project.
+	* Returns the test cases in a dataset, oldest first
 	*/
-	static listKnowledgeConverters(options) {
+	static listDatasetItems(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/knowledge/converters",
+			url: "/v1/projects/{project_id}/datasets/{dataset_id}/items",
 			...options
 		});
 	}
 	/**
-	* Create a converter
-	*
-	* Register a converter for a media type the platform cannot extract natively, so files of that type become ingestable documents like any other. A converter maps a `content_type` glob (`image*`, `audio/mpeg`, …) onto one of two workers:
-	*
-	* - an **agent** (`agent_id`) — the file is handed to a
-	* multimodal model with a fixed "extract all the text" instruction and
-	* its answer becomes the document text. The shortest path for images
-	* and scanned PDFs; nothing to map.
-	*
-	* - a **tool** (`tool_id`) — the file is passed to an
-	* `http` tool as `{ content_type, filename, data_base64 }`, and
-	* whatever string the tool returns becomes the document text. The path
-	* for dedicated non-chat APIs (speech-to-text, a specialist OCR
-	* engine); use the tool's `execute.body_mode: multipart` for
-	* form-data endpoints and its `output_mapping` to reduce a JSON
-	* response to the bare string.
-	*
-	*
-	* Exactly one of `agent_id` / `tool_id`, and one converter per `content_type` in a project.
+	* 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 createKnowledgeConverter(options) {
+	static createDatasetItem(options) {
 		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/knowledge/converters",
+			url: "/v1/projects/{project_id}/datasets/{dataset_id}/items",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1556,35 +1752,45 @@ var Knowledge = class {
 		});
 	}
 	/**
-	* Delete a converter
+	* Curate a dataset item from a generation
+	*
+	* Promotes a real, completed generation into a test case: its input messages become the item's `input`, and its own answer becomes `expected_output` unless you supply one. Use it to build an evaluation set out of production traffic rather than hand-authoring fixtures.
+	*
+	* The item is a **copy**, not a view. It keeps working after the source generation's content is purged, and `source_generation_id` goes null if that generation is deleted — a purge can never quietly stop a suite from being runnable.
 	*
-	* Removes the converter. Documents already ingested through it are untouched; new files of that media type stop being ingestable until another converter covers them.
+	* Requires both `evaluations:CreateDataset` and `generations:GetGeneration`: the call copies content out of a generation, so a principal that may not read that generation may not curate it either.
 	*
+	* Only a **completed** generation can be promoted (`409 GENERATION_NOT_COMPLETED`), and only while its content is still available: an agent or project running with `trace_content_mode: none` never stored the input, and a purged or expired generation no longer has it (`409 GENERATION_CONTENT_UNAVAILABLE`). Generations that predate input recording answer the same way.
 	*/
-	static deleteKnowledgeConverter(options) {
-		return (options.client ?? client).delete({
-			url: "/v1/projects/{project_id}/knowledge/converters/{converter_id}",
-			...options
+	static createDatasetItemFromGeneration(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/datasets/{dataset_id}/items/from-generation",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
 		});
 	}
 	/**
-	* Get a converter
+	* Delete a dataset item
+	*
+	* Deletes a test case. Results of runs that already scored it stay readable; their `dataset_item_id` becomes null.
 	*/
-	static getKnowledgeConverter(options) {
-		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/knowledge/converters/{converter_id}",
+	static deleteDatasetItem(options) {
+		return (options.client ?? client).delete({
+			url: "/v1/projects/{project_id}/datasets/{dataset_id}/items/{item_id}",
 			...options
 		});
 	}
 	/**
-	* Update a converter
-	*
-	* Change the worker or the chunking defaults. At least one field is required; `agent_id` and `tool_id` stay mutually exclusive, so setting one clears the other.
+	* 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 updateKnowledgeConverter(options) {
-		return (options.client ?? client).patch({
-			url: "/v1/projects/{project_id}/knowledge/converters/{converter_id}",
+	static updateDatasetItem(options) {
+		return (options.client ?? client).put({
+			url: "/v1/projects/{project_id}/datasets/{dataset_id}/items/{item_id}",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1592,27 +1798,27 @@ var Knowledge = class {
 			}
 		});
 	}
-};
-var ModelRoutes = class {
 	/**
-	* List model routes
+	* List evals
 	*
-	* Returns the model routes defined in a project
+	* Returns the evals defined in a project
 	*/
-	static listModelRoutes(options) {
+	static listEvals(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/model-routes",
+			url: "/v1/projects/{project_id}/evals",
 			...options
 		});
 	}
 	/**
-	* Create a model route
+	* Create an eval
 	*
-	* Creates a project-scoped model route: a named, ordered list of provider+model targets tried in array order. Every target must reference an AI provider in the same project (400 otherwise), and the total attempt budget — the sum of `1 + max_retries` over all targets — may not exceed 10 (400 naming the computed total). A duplicate `name` in the project is rejected with 409.
+	* 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 createModelRoute(options) {
+	static createEval(options) {
 		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/model-routes",
+			url: "/v1/projects/{project_id}/evals",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1621,35 +1827,69 @@ var ModelRoutes = class {
 		});
 	}
 	/**
-	* Delete a model route
+	* Delete an eval
 	*
-	* Deletes a model route. Returns 409 when an agent still references it — a routed agent has no pinned provider to fall back on, so the reference must be repointed or the agent deleted first.
+	* Deletes an eval, its runs, and their results
 	*/
-	static deleteModelRoute(options) {
+	static deleteEval(options) {
 		return (options.client ?? client).delete({
-			url: "/v1/projects/{project_id}/model-routes/{route_id}",
+			url: "/v1/projects/{project_id}/evals/{eval_id}",
 			...options
 		});
 	}
 	/**
-	* Get a model route
+	* Get an eval
+	*
+	* Returns a specific eval
+	*/
+	static getEval(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/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: "/v1/projects/{project_id}/evals/{eval_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* List eval runs
 	*
-	* Returns a specific model route
+	* Returns an eval's runs, newest first
 	*/
-	static getModelRoute(options) {
+	static listEvalRuns(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/model-routes/{route_id}",
+			url: "/v1/projects/{project_id}/evals/{eval_id}/runs",
 			...options
 		});
 	}
 	/**
-	* Update a model route
+	* Start an eval run
 	*
-	* Updates a model route's name, targets, retry classes, or breaker configuration. Omitted fields are left unchanged.
+	* 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. 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 updateModelRoute(options) {
-		return (options.client ?? client).put({
-			url: "/v1/projects/{project_id}/model-routes/{route_id}",
+	static startEvalRun(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/evals/{eval_id}/runs",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1657,66 +1897,78 @@ var ModelRoutes = class {
 			}
 		});
 	}
-};
-var Models = class {
 	/**
-	* List models
-	*
-	* Lists catalog models, newest sources merged and sorted by id. Filter by vendor, provider, output/input modality, status, or `managed` — the last being the axis that decides whether a model is usable without BYOK credentials, so `?managed=true&status=available` is the set an agent can run on today.
+	* Get an eval run
 	*
+	* Returns a run's status, counts, and aggregate scores
 	*/
-	static listModels(options) {
-		return (options?.client ?? client).get({
-			url: "/v1/models",
+	static getEvalRun(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/evals/{eval_id}/runs/{eval_run_id}",
 			...options
 		});
 	}
 	/**
-	* Get a model
+	* List eval run results
+	*
+	* Returns the per-item results of a run, oldest first
 	*/
-	static getModel(options) {
+	static listEvalResults(options) {
 		return (options.client ?? client).get({
-			url: "/v1/models/{model_id}",
+			url: "/v1/projects/{project_id}/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: "/v1/projects/{project_id}/evals/{eval_id}/runs/{eval_run_id}/cancel",
 			...options
 		});
 	}
 };
-var Orchestrations = class {
+var Generations = class {
 	/**
-	* List orchestrations
+	* List generations
+	*
+	* Returns generations the caller can access, optionally filtered by agent, trace, and status. Replaces the former per-trace generations endpoint (use the trace_id query filter).
 	*
-	* Lists the project's orchestration definitions.
 	*/
-	static listOrchestrations(options) {
+	static listGenerations(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/orchestrations",
+			url: "/v1/projects/{project_id}/generations",
 			...options
 		});
 	}
 	/**
-	* Create an orchestration
+	* Get a generation
+	*
+	* Returns a single generation record by ID, including its status and the structured `error` payload when the generation failed (e.g. because the upstream AI provider returned an error).
 	*
-	* 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
-			}
+	static getGeneration(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/generations/{generation_id}",
+			...options
 		});
 	}
 	/**
-	* Validate an orchestration graph
+	* Update generation metadata
 	*
-	* Statically validates a graph without persisting anything — the same checks `create`/`update` enforce (unique node ids, edges reference existing nodes, the graph is acyclic unless it contains a loop node, every `input_mapping` reference resolves). Returns blocking `errors` and non-blocking `warnings`.
+	* Attaches caller-supplied key/value metadata to a generation record for per-run audit attribution (e.g. recording which knowledge-corpus version produced an AI action). The provided keys are shallow-merged over the existing `metadata`, so repeated patches accumulate. The bag is caller-owned and no key is reserved: server-owned state (usage attribution, the served agent version, the route's record, the extraction summary) lives in its own top-level fields and cannot be written from here.
 	*
 	*/
-	static validateOrchestration(options) {
-		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/orchestrations/validate",
+	static updateGeneration(options) {
+		return (options.client ?? client).patch({
+			url: "/v1/projects/{project_id}/generations/{generation_id}",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1725,63 +1977,60 @@ var Orchestrations = class {
 		});
 	}
 	/**
-	* Delete an orchestration
+	* Purge generation content
+	*
+	* Clears the generation's content — `metadata`, `error`, `extraction`, and the internal recovery state of a paused run — and stamps `content_redacted_at`.
+	*
+	* The usage and audit skeleton is preserved: ids, timestamps, status, stop reason, and the attribution fields (`action_id`, `trigger_id`, `orchestration_run_id`, `node_id`, `agent_version`, `routing`) the billing ledger reads. A purged generation reads back as that skeleton, not a 404.
+	*
+	* This does **not** delete the parent trace's steps object, which holds this generation's content alongside its siblings'. To erase the run's content completely, purge the trace (`DELETE /v1/projects/{project_id}/traces/{trace_id}/content`), which cascades here.
+	*
+	* Idempotent — purging an already-purged generation succeeds and leaves the original `content_redacted_at` in place.
 	*
-	* Deletes the orchestration definition and all of its runs.
 	*/
-	static deleteOrchestration(options) {
+	static purgeGenerationContent(options) {
 		return (options.client ?? client).delete({
-			url: "/v1/projects/{project_id}/orchestrations/{orchestration_id}",
+			url: "/v1/projects/{project_id}/generations/{generation_id}/content",
 			...options
 		});
 	}
 	/**
-	* Get an orchestration
+	* Get a generation's transcript
 	*
-	* Returns one orchestration with its nodes and edges. Belonging to another project responds `404`, not `403` — existence is not leaked.
+	* Returns one generation's turn read back as an ordered sequence of steps: what it was asked, each model step with its tool calls and results, and how it ended.
+	*
+	* The transcript is assembled at read time from the generation record and the trace's steps object; nothing is stored, so it cannot outlive the content it projects. Requires `traces:GetTrace` in addition to `generations:GetGeneration`, because the response merges content from both resources.
+	*
+	* A generation whose content is unavailable — never written under zero-retention, or cleared by a purge — returns `200` with the skeleton rather than an error: `input` and `output` are null, `steps` is empty, and the `content_redacted_*` fields say which happened. `content_redacted_by_principal_id` is `zero_retention` when the content was never stored, and the purging principal's ID when it was erased later. A generation that is still running returns the same shape with an empty `steps`; `status` disambiguates the two.
 	*
 	*/
-	static getOrchestration(options) {
+	static getGenerationTranscript(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/orchestrations/{orchestration_id}",
+			url: "/v1/projects/{project_id}/generations/{generation_id}/transcript",
 			...options
 		});
 	}
+};
+var ModelRoutes = class {
 	/**
-	* Update an orchestration
-	*
-	* Partially updates an orchestration's 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 orchestration runs
-	*
-	* Lists runs of one orchestration. `orchestration_id` is required — it is what scopes the list to this project, since a run carries no cheaper project-level filter of its own.
+	* List model routes
 	*
+	* Returns the model routes defined in a project
 	*/
-	static listOrchestrationRuns(options) {
+	static listModelRoutes(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/orchestration-runs",
+			url: "/v1/projects/{project_id}/model-routes",
 			...options
 		});
 	}
 	/**
-	* Start an orchestration run
+	* Create a model route
 	*
-	* Starts a new run of the orchestration named by `orchestration_id`, which must belong to this project. By default the run executes durably in the background and this returns immediately with `status: "queued"`; pass `wait: true` to block until the run reaches a terminal or `awaiting_input` state instead.
+	* Creates a project-scoped model route: a named, ordered list of provider+model targets tried in array order. Every target must reference an AI provider in the same project (400 otherwise), and the total attempt budget — the sum of `1 + max_retries` over all targets — may not exceed 10 (400 naming the computed total). A duplicate `name` in the project is rejected with 409.
 	*/
-	static startOrchestrationRun(options) {
+	static createModelRoute(options) {
 		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/orchestration-runs",
+			url: "/v1/projects/{project_id}/model-routes",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1790,46 +2039,35 @@ var Orchestrations = class {
 		});
 	}
 	/**
-	* Get an orchestration run
-	*
-	* Returns the status, state, and artifacts of one run.
-	*/
-	static getOrchestrationRun(options) {
-		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/orchestration-runs/{orchestration_run_id}",
-			...options
-		});
-	}
-	/**
-	* Cancel an orchestration run
+	* Delete a model route
 	*
-	* Cancels a run that has not yet reached a terminal state.
+	* Deletes a model route. Returns 409 when an agent still references it — a routed agent has no pinned provider to fall back on, so the reference must be repointed or the agent deleted first.
 	*/
-	static cancelOrchestrationRun(options) {
-		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/orchestration-runs/{orchestration_run_id}/cancel",
+	static deleteModelRoute(options) {
+		return (options.client ?? client).delete({
+			url: "/v1/projects/{project_id}/model-routes/{route_id}",
 			...options
 		});
 	}
 	/**
-	* Resume an orchestration run
+	* Get a model route
 	*
-	* Re-drives an `awaiting_input` run from its last checkpoint. This does not satisfy the pause itself — a run parked on a human or webhook node re-parks on the same node. Use `human-input` to supply the awaited payload and advance the run.
+	* Returns a specific model route
 	*/
-	static resumeOrchestrationRun(options) {
-		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/orchestration-runs/{orchestration_run_id}/resume",
+	static getModelRoute(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/model-routes/{route_id}",
 			...options
 		});
 	}
 	/**
-	* Submit human input
+	* Update a model route
 	*
-	* Provides human input to a run that is `awaiting_input` at a human node, and advances it.
+	* Updates a model route's name, targets, retry classes, or breaker configuration. Omitted fields are left unchanged.
 	*/
-	static submitHumanInput(options) {
-		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/orchestration-runs/{orchestration_run_id}/human-input",
+	static updateModelRoute(options) {
+		return (options.client ?? client).put({
+			url: "/v1/projects/{project_id}/model-routes/{route_id}",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1842,7 +2080,8 @@ var Projects = class {
 	/**
 	* List projects
 	*
-	* Lists projects accessible to the caller.
+	* Lists the projects the caller is a member of. A project-scoped API key lists only its own project.
+	*
 	*/
 	static listProjects(options) {
 		return (options?.client ?? client).get({
@@ -1869,6 +2108,7 @@ var Projects = class {
 	* Delete a project
 	*
 	* Permanently deletes the project and its backing runtime project. Fails with 409 if the runtime project still has dependent resources — remove them first, or pass `force=true` to delete the project and all its dependents (agents, providers, tools, sessions, generations, traces). Forcing is destructive and irreversible.
+	* Requires the `owner` role — an `admin` runs the project day to day, but destroying it is the billing owner's call.
 	*
 	*/
 	static deleteProject(options) {
@@ -1880,8 +2120,8 @@ var Projects = class {
 	/**
 	* Get a project
 	*
-	* Returns one project. An id you do not own — including one that does not exist — responds `404`, not `403`: the API never confirms that an id exists elsewhere.
-	* `403` is reserved for the one case where there is nothing to hide: a project you *do* own, addressed with a credential scoped to a different one. There the wrong-credential message is what makes the failure fixable.
+	* Returns one project you are a member of, and your `role` in it. An id you are not a member of — including one that does not exist — responds `404`, not `403`: the API never confirms that an id exists elsewhere.
+	* `403` is reserved for the cases where there is nothing to hide: a project you *are* in, addressed with a credential scoped to a different one, or an action your role does not carry. There the message is what makes the failure fixable.
 	*
 	*/
 	static getProject(options) {
@@ -1894,6 +2134,7 @@ var Projects = class {
 	* Update a project
 	*
 	* Rename or archive a project, and/or change its content-retention settings (`trace_content_retention_days`, `trace_content_mode`). Archiving is reversible; resources are retained.
+	* Requires the `admin` role in the project (an `owner` has it too).
 	* The two retention controls answer different questions. The window bounds how long content *stays* — a daily sweep purges anything past it, leaving auditable skeletons behind. `trace_content_mode: none` means content is never *written*, which is the stronger guarantee: it cannot be missed by a sweep or survive in a backup.
 	*
 	*/
@@ -1908,6 +2149,19 @@ var Projects = class {
 		});
 	}
 	/**
+	* List project members
+	*
+	* Lists who may act in the project, and with what role. Readable by every member, including a read-only `member`: who else is in the project is not a privileged fact, and hiding it makes "why can that person see my agents?" unanswerable.
+	* Read-only for now — adding and removing members arrives with the invitation flow, since an invitee may not have an account yet.
+	*
+	*/
+	static listProjectMembers(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/members",
+			...options
+		});
+	}
+	/**
 	* Get per-project usage
 	*
 	* The per-project meter — the re-billing view (A11/C12/P3). Aggregates the project's usage over an optional [from, to] window, bucketed by a single dimension. Costs are the billing-grade cost_usd the runtime freezes at write time; null means nothing in the bucket was priced (never that it was free). Only managed providers are priced (on the runtime), so cost reflects managed usage; BYOK usage carries no LLM cost.
@@ -1922,27 +2176,26 @@ var Projects = class {
 		});
 	}
 };
-var Providers = class {
+var Secrets = class {
 	/**
-	* List providers
+	* List secrets
 	*
-	* Lists the AI providers registered in the project.
+	* Returns a list of secrets for a project
 	*/
-	static listProviders(options) {
+	static listSecrets(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/providers",
+			url: "/v1/projects/{project_id}/secrets",
 			...options
 		});
 	}
 	/**
-	* Register a provider (managed or BYOK)
-	*
-	* Register a managed provider (naturali-keyed, priced on the runtime) or a BYOK provider (your credentials, stored write-only and never priced). See ProviderCreate for the fields each mode takes.
+	* Create a secret
 	*
+	* Creates a new encrypted secret in a project
 	*/
-	static createProvider(options) {
+	static createSecret(options) {
 		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/providers",
+			url: "/v1/projects/{project_id}/secrets",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1951,35 +2204,35 @@ var Providers = class {
 		});
 	}
 	/**
-	* Delete a provider
-	*
-	* Deletes the backing provider record on the runtime and its secret. Returns 409 if the provider is still referenced by live resources (agents) — detach those first. `force=true` clears only soft dependents (price overrides, usage history); live references always block deletion.
+	* Delete a secret
 	*
+	* Deletes a secret
 	*/
-	static deleteProvider(options) {
+	static deleteSecret(options) {
 		return (options.client ?? client).delete({
-			url: "/v1/projects/{project_id}/providers/{provider_id}",
+			url: "/v1/projects/{project_id}/secrets/{secret_id}",
 			...options
 		});
 	}
 	/**
-	* Get a provider
+	* Get a secret
+	*
+	* Returns a specific secret
 	*/
-	static getProvider(options) {
+	static getSecret(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/providers/{provider_id}",
+			url: "/v1/projects/{project_id}/secrets/{secret_id}",
 			...options
 		});
 	}
 	/**
-	* Update a provider
-	*
-	* Change the model, name or base URL, or rotate the credentials (api_key). At least one field is required.
+	* Update a secret
 	*
+	* Updates a secret's name and/or value
 	*/
-	static updateProvider(options) {
+	static updateSecret(options) {
 		return (options.client ?? client).patch({
-			url: "/v1/projects/{project_id}/providers/{provider_id}",
+			url: "/v1/projects/{project_id}/secrets/{secret_id}",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1990,14 +2243,25 @@ var Providers = class {
 };
 var Sessions = class {
 	/**
-	* Open a session
+	* List sessions
+	*
+	* Returns sessions the caller can access, optionally filtered by agent, actor and status.
+	*/
+	static listSessions(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/sessions",
+			...options
+		});
+	}
+	/**
+	* Create a session
 	*
-	* Opens a durable session against the agent. The session accumulates messages and is resumable by id; its lifecycle (open / closed / expired) and configuration live in the backing runtime session.
+	* Creates a new session for the specified agent, along with the underlying conversation, so the caller only needs this single call to start interacting with the agent. No actor is created: pass `actor_id` to attach an existing actor as the session's end user. When it is omitted the session has no actor, and generations in it carry no end-user attribution — they are not billed to an actor in the usage meter and they match no `actor`-scoped quota.
 	*
 	*/
 	static createSession(options) {
 		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/agents/{agent_id}/sessions",
+			url: "/v1/projects/{project_id}/sessions",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -2006,38 +2270,52 @@ var Sessions = class {
 		});
 	}
 	/**
-	* Get a session
+	* Delete a session
 	*
-	* Returns the session's current state — status, activity timestamps and configuration — read live from the backing runtime session, so a resumed session reflects everything that has happened since it was opened.
+	* Deletes the session and its underlying conversation and messages. The session's actor is not deleted. Generations and traces produced by the session are not deleted either, since they are not linked to the session or conversation.
 	*
 	*/
-	static getSession(options) {
-		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/agents/{agent_id}/sessions/{session_id}",
+	static deleteSession(options) {
+		return (options.client ?? client).delete({
+			url: "/v1/projects/{project_id}/sessions/{session_id}",
 			...options
 		});
 	}
 	/**
-	* Read the session's transcript
-	*
-	* The session's messages, oldest first. naturali stores no message bodies — the dialogue lives in the backing runtime conversation the session maps to, so this reads through to the runtime. Pagination is `limit`/`offset` rather than an opaque cursor because the upstream is offset-based over a stable `position` ordering. This is the one way to read back a session opened directly through this API (no [Channels](/docs/modules/channels) conversation involved) — see `GET .../channels/{channel_id}/conversations/{conversation_id}/messages` for the channel-backed equivalent.
+	* Get a session
 	*
+	* Returns details of a single session.
 	*/
-	static listSessionMessages(options) {
+	static getSession(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/agents/{agent_id}/sessions/{session_id}/messages",
+			url: "/v1/projects/{project_id}/sessions/{session_id}",
 			...options
 		});
 	}
 	/**
-	* Add a message
+	* Update a session
 	*
-	* Appends a user message to the session — plain `message` text or a `document_id`, exactly one of the two. `idempotency_key` makes the append safe to retry: a repeat with the same key returns the original message (HTTP 200) and triggers no new work. When the session has `auto_generate` on, the response is the agent's reply (a Generation shape) instead of the saved message.
+	* Updates the session name and/or status.
+	*/
+	static updateSession(options) {
+		return (options.client ?? client).patch({
+			url: "/v1/projects/{project_id}/sessions/{session_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Add a user message
+	*
+	* Saves a user message to the session. When autoGenerate is enabled on the session and no generation is currently in progress, generation is triggered automatically and the response mirrors GenerateSessionResponse. Otherwise returns the saved user message.
 	*
 	*/
 	static addSessionMessage(options) {
 		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/agents/{agent_id}/sessions/{session_id}/messages",
+			url: "/v1/projects/{project_id}/sessions/{session_id}/messages",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -2046,20 +2324,14 @@ var Sessions = class {
 		});
 	}
 	/**
-	* Generate a response
-	*
-	* Runs the agent over the session's accumulated messages.
+	* Trigger agent generation
 	*
-	* Background by default: this returns `202` immediately and the turn runs on. The reply lands in the transcript, so poll [`GET /v1/projects/{project_id}/agents/{agent_id}/sessions/{session_id}/messages`](/docs/api/sessions/list-session-messages) for the assistant message, or read the session for its `status`.
-	*
-	* Pass `?wait=true` to block instead and receive the turn itself: `status` is `completed` with the assistant `message`, or `requires_action` with the pending `required_action` tool calls.
-	*
-	* `model` overrides the agent's default model for this turn only.
+	* 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) {
 		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/agents/{agent_id}/sessions/{session_id}/generate",
+			url: "/v1/projects/{project_id}/sessions/{session_id}/generate",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -2067,29 +2339,35 @@ var Sessions = class {
 			}
 		});
 	}
-};
-var Tasks = class {
 	/**
-	* List tasks
+	* Submit tool outputs
 	*
-	* The board query. Filter by `board_id` for one board, add `state` for one column, or use `status` / `assignee` across boards.
+	* Submits client tool outputs for a generation that returned requires_action. The agent continues its loop and returns the final or next requires_action result.
 	*
 	*/
-	static listTasks(options) {
-		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/tasks",
-			...options
+	static submitSessionToolOutputs(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/sessions/{session_id}/tool-outputs",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
 		});
 	}
 	/**
-	* Create a task
+	* Fork a session
+	*
+	* Branches a new session from a point in this session's history: same context, different continuation.
 	*
-	* Put a card on a board. It lands in the board's initial column and that column's automation fires — so a board whose first column dispatches an agent starts working on this call and keeps going, unattended, until a column needs a person.
+	* The fork gets its own conversation whose messages **reference the same documents** as the parent rather than copying them, so there is one stored copy of the content and a retention purge erases it from both. Recorded tool results ride along on those messages and are **replayed** as model input on the fork's next turn — forking never re-invokes a tool, so exploring a "what if" cannot send an email or charge a card a second time. The consequence to accept is that a forked turn sees the tool data as it was, not as it is now.
+	*
+	* The fork is created **inert**: `auto_generate` is false and no generation is triggered. Drive it with the normal message and generate endpoints. The fork has no actor — attach one only if the branch is meant to be driven by the same end user, since `single_session_per_actor` agents allow one open session per actor.
 	*
 	*/
-	static createTask(options) {
+	static forkSession(options) {
 		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/tasks",
+			url: "/v1/projects/{project_id}/sessions/{session_id}/fork",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -2098,39 +2376,36 @@ var Tasks = class {
 		});
 	}
 	/**
-	* Delete a task
+	* List a session's forks
 	*
-	* Removes the card and its transition history. Distinct from closing it: a card that reaches a terminal column closes and keeps its audit trail.
+	* Returns the sessions forked directly from this one. One level of lineage: a fork of a fork is listed under its own parent.
 	*
 	*/
-	static deleteTask(options) {
-		return (options.client ?? client).delete({
-			url: "/v1/projects/{project_id}/tasks/{task_id}",
+	static listSessionForks(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/sessions/{session_id}/forks",
 			...options
 		});
 	}
 	/**
-	* Get a task
+	* Get session tags
 	*
-	* One card, including its automation status and in-flight dispatch.
+	* Returns the session's tags object.
 	*/
-	static getTask(options) {
+	static getSessionTags(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/tasks/{task_id}",
+			url: "/v1/projects/{project_id}/sessions/{session_id}/tags",
 			...options
 		});
 	}
 	/**
-	* Update a task
-	*
-	* Edit the card's `title`, `assignee` or `payload`. At least one is required.
-	* `payload` is **shallow-merged** over what is there: keys the request omits are preserved. The merged result is validated against the board's `payload_schema`. `last_result` is read-only and lives in its own field — a payload write can never discard or forge it.
-	* `state` and `board_id` are rejected — a card moves only through `:transition`, and it never changes boards.
+	* Merge session tags
 	*
+	* Merges the provided tags into the session's existing tags.
 	*/
-	static updateTask(options) {
+	static mergeSessionTags(options) {
 		return (options.client ?? client).patch({
-			url: "/v1/projects/{project_id}/tasks/{task_id}",
+			url: "/v1/projects/{project_id}/sessions/{session_id}/tags",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -2139,15 +2414,13 @@ var Tasks = class {
 		});
 	}
 	/**
-	* Move a task
-	*
-	* Fire a named move on the card — the single path every state change takes. The move must be declared on the board and valid from the card's current column; the board's definition is what a UI renders its buttons from.
-	* Naming a move that does not exist, one that is not legal from this column, or any move at all on a closed card all answer 409 `task_transition_conflict`: it is a conflict with the card's state rather than a malformed request — the same body succeeds one column earlier.
+	* Replace session tags
 	*
+	* Replaces all tags on the session.
 	*/
-	static transitionTask(options) {
-		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/tasks/{task_id}:transition",
+	static replaceSessionTags(options) {
+		return (options.client ?? client).put({
+			url: "/v1/projects/{project_id}/sessions/{session_id}/tags",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -2155,24 +2428,12 @@ var Tasks = class {
 			}
 		});
 	}
-	/**
-	* List the task's moves
-	*
-	* The card's append-only history, oldest first: every move it made, what kind of principal made it, and what caused it. Returned whole — `next_cursor` is always null.
-	*
-	*/
-	static listTaskTransitions(options) {
-		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/tasks/{task_id}/transitions",
-			...options
-		});
-	}
 };
 var Tools = class {
 	/**
 	* List tools
 	*
-	* Lists the tools registered in the project.
+	* Returns all tools in the project.
 	*/
 	static listTools(options) {
 		return (options.client ?? client).get({
@@ -2183,8 +2444,7 @@ var Tools = class {
 	/**
 	* Create a tool
 	*
-	* Create an http or mcp tool in the project. See ToolCreate for the fields each type takes. Any auth headers are stored write-only and never returned.
-	*
+	* Creates a new tool in the project.
 	*/
 	static createTool(options) {
 		return (options.client ?? client).post({
@@ -2199,8 +2459,7 @@ var Tools = class {
 	/**
 	* Delete a tool
 	*
-	* Deletes the backing runtime tool. Returns 409 if the tool is still attached to an agent (detach it first).
-	*
+	* Deletes a tool by ID.
 	*/
 	static deleteTool(options) {
 		return (options.client ?? client).delete({
@@ -2210,6 +2469,8 @@ var Tools = class {
 	}
 	/**
 	* Get a tool
+	*
+	* Returns a single tool by ID.
 	*/
 	static getTool(options) {
 		return (options.client ?? client).get({
@@ -2220,8 +2481,7 @@ var Tools = class {
 	/**
 	* Update a tool
 	*
-	* Change the name, description, parameters, or type-specific config (incl. rotating auth headers). The tool `type` is immutable. At least one field is required.
-	*
+	* Updates an existing tool.
 	*/
 	static updateTool(options) {
 		return (options.client ?? client).patch({
@@ -2233,12 +2493,30 @@ var Tools = class {
 			}
 		});
 	}
+	/**
+	* Call a tool
+	*
+	* Directly invokes a tool and returns its output. Supported for `http`, `mcp` and `pipeline` tools. `client` tools cannot be invoked server-side and will return 422. A `pipeline` tool runs its declared steps in order and returns the mapped `output` (or the last step's output); `action` is ignored and `input` is the pipeline input.
+	* For `mcp` tools the `action` field is required and identifies which tool name to invoke. For `http` tools `action` is ignored. When an `mcp` tool declares an `actions` allowlist, an action outside it is rejected with `400 VALIDATION_FAILED` ("not available on this tool") before any outbound request is made.
+	* `preset_parameters` stored on the tool are merged with the caller-supplied `input` before execution; preset keys take lower precedence.
+	*
+	*/
+	static callTool(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/tools/{tool_id}/call",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
 };
 var Traces = class {
 	/**
 	* List traces
 	*
-	* Lists the project's execution traces, newest first.
+	* Returns a paginated list of execution traces for the project.
 	*/
 	static listTraces(options) {
 		return (options.client ?? client).get({
@@ -2249,8 +2527,7 @@ var Traces = class {
 	/**
 	* Get a trace
 	*
-	* Returns one trace. A trace belonging to another project responds `404`, not `403` — the API never confirms that an id exists elsewhere.
-	*
+	* Returns a single trace by ID.
 	*/
 	static getTrace(options) {
 		return (options.client ?? client).get({
@@ -2259,10 +2536,9 @@ var Traces = class {
 		});
 	}
 	/**
-	* Get a trace tree
+	* Get trace tree
 	*
-	* Returns the whole execution tree. Each node is one agent's execution; `children` are the traces its sub-agent tool calls started.
-	* Asking for a child returns the tree from its root, so the response is the full execution either way — pass `include=generations` and one call is enough to render a finished run.
+	* Returns the full execution tree rooted at the given trace (or its root if the given trace is a child). Each node represents one agent's execution session. The `children` array contains traces triggered by sub-agent tool calls from that trace.
 	*
 	*/
 	static getTraceTree(options) {
@@ -2272,36 +2548,13 @@ var Traces = class {
 		});
 	}
 	/**
-	* List a trace's generations
-	*
-	* Lists the generations recorded under this trace — the model loops the execution ran, including sub-agent generations linked by `initiator_generation_id`.
-	*
-	*/
-	static listTraceGenerations(options) {
-		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/traces/{trace_id}/generations",
-			...options
-		});
-	}
-	/**
-	* Get a trace's steps
+	* Purge trace content
 	*
-	* Returns the trace's step payload: every step of the execution's model loop, exactly as the runtime recorded it — tool calls, their arguments, results and cost — passed through unreshaped rather than mapped to a narrower contract, since the payload is the runtime's own step shape.
-	* Saving the payload is fire-and-forget on the runtime, so a trace can report `has_steps: false` for a short window after it finishes; this route 404s with `steps_not_available` during that window rather than returning an empty list, so a caller does not mistake "not saved yet" for "no steps ran".
-	* A trace with no payload at all answers `steps_redacted` instead — its content was purged, or its agent runs in zero-retention and nothing was ever written. The distinction is the whole point of two codes: retrying `steps_not_available` succeeds once the write lands, while retrying `steps_redacted` can never succeed. The response carries `content_redacted_at` in `details`.
+	* Deletes the trace's steps object from storage and clears its content columns (`file_id`, `error`), cascading to every descendant trace and to all of their generations. A descendant holds its own steps object covering the same run, so the cascade is what makes the erasure complete rather than merely partial.
 	*
-	*/
-	static getTraceSteps(options) {
-		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/traces/{trace_id}/steps",
-			...options
-		});
-	}
-	/**
-	* Purge a trace's content
+	* The rows survive as auditable skeletons with `content_redacted_at` set — ids, timestamps, step counts, and the generations' usage-attribution fields are preserved, because the billing and audit ledger must outlive a tenant's erasure of the content. A purged trace therefore reads back as a skeleton, not a 404: a 404 would prove nothing.
 	*
-	* Deletes the trace's step payload and clears its content columns, cascading to every descendant trace in its execution tree and to their generations. The rows survive as auditable skeletons — ids, timestamps and step counts are preserved — with `content_redacted_at` set as verifiable proof the content is gone; a purged trace still reads back with `GET /v1/projects/{project_id}/traces/{trace_id}` (a 404 there would prove nothing about what was erased).
-	* Idempotent: purging an already-purged trace succeeds and leaves the original `content_redacted_at` in place.
+	* Idempotent — purging an already-purged trace succeeds and leaves the original `content_redacted_at` in place.
 	*
 	*/
 	static purgeTraceContent(options) {
@@ -2311,82 +2564,27 @@ var Traces = class {
 		});
 	}
 };
-var Triggers = class {
-	/**
-	* List triggers
-	*
-	* The project's schedule triggers, of either fronted target kind.
-	* `total` is the runtime's count of the project's schedule triggers, so it can exceed the rows returned when a trigger was authored directly against the runtime with a target this surface doesn't front (the same bypass `getTrigger` answers `404` for). Pass `target_type` — which is filtered and counted upstream — when an exact count matters.
-	*
-	*/
-	static listTriggers(options) {
-		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/triggers",
-			...options
-		});
-	}
-	/**
-	* Create a trigger
-	*
-	* Schedules `target_id` — an agent or an orchestration in this project, per `target_type` — to run on `cron`, a 5-field cron expression evaluated in UTC.
-	*
-	*/
-	static createTrigger(options) {
-		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/triggers",
-			...options,
-			headers: {
-				"Content-Type": "application/json",
-				...options.headers
-			}
-		});
-	}
+var Users = class {
 	/**
-	* Delete a trigger
+	* Get the current user
 	*
-	* Removes the trigger. Its firing history is kept.
-	*/
-	static deleteTrigger(options) {
-		return (options.client ?? client).delete({
-			url: "/v1/projects/{project_id}/triggers/{trigger_id}",
-			...options
-		});
-	}
-	/**
-	* Get a trigger
+	* Returns the account the presented credential resolves to.
 	*/
-	static getTrigger(options) {
-		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/triggers/{trigger_id}",
+	static getCurrentUser(options) {
+		return (options?.client ?? client).get({
+			url: "/v1/users/me",
 			...options
 		});
 	}
 	/**
-	* Update a trigger
+	* Update the current user
 	*
-	* Retune the schedule, its target, or whether it fires at all. At least one field is required. `type` is immutable; `target_type` may be changed only together with `target_id`.
+	* Edits the account's display name. `name` is required in the body — send null to clear it — so a request that misspelled the field is rejected rather than answered with a silent 200.
 	*
 	*/
-	static updateTrigger(options) {
+	static updateCurrentUser(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 manually
-	*
-	* Runs the trigger's target right now, outside its schedule, and waits for the run to finish. This is the `…:fire` action; the path segment is `{trigger_id}:fire`.
-	* `input` is shallow-merged over the trigger's own stored `input` for this run only — the trigger's configuration is unchanged.
-	*
-	*/
-	static fireTrigger(options) {
-		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/triggers/{trigger_id}:fire",
+			url: "/v1/users/me",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -2394,26 +2592,6 @@ var Triggers = class {
 			}
 		});
 	}
-	/**
-	* List a trigger's firings
-	*
-	* Every time this trigger ran, newest first — scheduled and manual alike.
-	*/
-	static listTriggerFirings(options) {
-		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/triggers/{trigger_id}/firings",
-			...options
-		});
-	}
-	/**
-	* Get a trigger firing
-	*/
-	static getTriggerFiring(options) {
-		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/triggers/{trigger_id}/firings/{firing_id}",
-			...options
-		});
-	}
 };
 var Webhooks = class {
 	/**
@@ -2572,8 +2750,8 @@ const API_BASE_URL = "https://api.naturali.ai";
 * });
 *
 * const { data, error } = await naturali.sessions.addSessionMessage({
-*   path: { project_id: PROJECT_ID, agent_id: AGENT_ID, session_id: SESSION_ID },
-*   body: { role: 'user', content: 'What is the capital of France?' },
+*   path: { project_id: PROJECT_ID, session_id: SESSION_ID },
+*   body: { message: 'What is the capital of France?' },
 * });
 * ```
 *
@@ -2584,23 +2762,22 @@ const API_BASE_URL = "https://api.naturali.ai";
 var NaturaliClient = class {
 	actors;
 	agents;
+	agentVersions;
+	aiProviders;
 	apiKeys;
 	assistant;
-	auth;
-	boards;
 	channels;
+	auth;
+	conversations;
+	evaluations;
 	generations;
-	knowledge;
 	modelRoutes;
-	models;
-	orchestrations;
 	projects;
-	providers;
+	secrets;
 	sessions;
-	tasks;
 	tools;
 	traces;
-	triggers;
+	users;
 	webhooks;
 	/** The underlying HTTP client, for interceptors or one-off requests. */
 	http;
@@ -2614,47 +2791,45 @@ var NaturaliClient = class {
 		}));
 		this.actors = bindResource(Actors, this.http);
 		this.agents = bindResource(Agents, this.http);
+		this.agentVersions = bindResource(AgentVersions, this.http);
+		this.aiProviders = bindResource(AiProviders, this.http);
 		this.apiKeys = bindResource(ApiKeys, this.http);
 		this.assistant = bindResource(Assistant, this.http);
-		this.auth = bindResource(Auth, this.http);
-		this.boards = bindResource(Boards, this.http);
 		this.channels = bindResource(Channels, this.http);
+		this.auth = bindResource(Auth, this.http);
+		this.conversations = bindResource(Conversations, this.http);
+		this.evaluations = bindResource(Evaluations, this.http);
 		this.generations = bindResource(Generations, this.http);
-		this.knowledge = bindResource(Knowledge, 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.providers = bindResource(Providers, 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);
 	}
 };
 //#endregion
 exports.Actors = Actors;
+exports.AgentVersions = AgentVersions;
 exports.Agents = Agents;
+exports.AiProviders = AiProviders;
 exports.ApiKeys = ApiKeys;
 exports.Assistant = Assistant;
 exports.Auth = Auth;
-exports.Boards = Boards;
 exports.Channels = Channels;
+exports.Conversations = Conversations;
+exports.Evaluations = Evaluations;
 exports.Generations = Generations;
-exports.Knowledge = Knowledge;
 exports.ModelRoutes = ModelRoutes;
-exports.Models = Models;
 exports.NaturaliClient = NaturaliClient;
-exports.Orchestrations = Orchestrations;
 exports.Projects = Projects;
-exports.Providers = Providers;
+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.createClient = createClient;
 exports.createConfig = createConfig;