@naturali/sdk 0.65.0 → 0.67.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,12 +1026,11 @@ var Agents = class {
 		});
 	}
 	/**
-	* 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 update an agent
 	*
+	* Partially updates an existing agent. Identical to PUT — both perform partial updates.
 	*/
-	static updateAgent(options) {
+	static patchAgent(options) {
 		return (options.client ?? client).patch({
 			url: "/v1/projects/{project_id}/agents/{agent_id}",
 			...options,
@@ -1006,29 +1040,14 @@ var Agents = class {
 			}
 		});
 	}
-};
-var ApiKeys = class {
-	/**
-	* List API keys
-	*
-	* Lists API keys accessible to the caller. A project-scoped credential sees only keys in its project; an account-scoped credential sees all keys in the account. Raw secrets are never returned.
-	*
-	*/
-	static listApiKeys(options) {
-		return (options?.client ?? client).get({
-			url: "/v1/api-keys",
-			...options
-		});
-	}
 	/**
-	* 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.
+	* Update an agent
 	*
+	* Updates an existing agent. Identical to PATCH — both perform partial updates.
 	*/
-	static createApiKey(options) {
-		return (options.client ?? client).post({
-			url: "/v1/api-keys",
+	static updateAgent(options) {
+		return (options.client ?? client).put({
+			url: "/v1/projects/{project_id}/agents/{agent_id}",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1037,35 +1056,14 @@ var ApiKeys = class {
 		});
 	}
 	/**
-	* Revoke an API key
-	*
-	* Revokes an API key immediately. Subsequent use returns 401.
-	*/
-	static deleteApiKey(options) {
-		return (options.client ?? client).delete({
-			url: "/v1/api-keys/{api_key_id}",
-			...options
-		});
-	}
-	/**
-	* Get an API key
+	* Run an agent generation
 	*
-	* Returns metadata for an API key. The raw secret is never returned after creation.
-	*/
-	static getApiKey(options) {
-		return (options.client ?? client).get({
-			url: "/v1/api-keys/{api_key_id}",
-			...options
-		});
-	}
-	/**
-	* Update an API key
+	* 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.
 	*
-	* Rename an API key or replace its capability set. The scope (project vs account) is immutable.
 	*/
-	static updateApiKey(options) {
-		return (options.client ?? client).patch({
-			url: "/v1/api-keys/{api_key_id}",
+	static createAgentGeneration(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/agents/{agent_id}/generate",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1074,66 +1072,58 @@ var ApiKeys = class {
 		});
 	}
 	/**
-	* Rotate an API key
+	* Submit tool outputs for a paused generation
 	*
-	* Issues a new secret for the same key record (same id, scope and capabilities) and invalidates the previous secret. The new raw `key` is returned only in this response.
+	* Resumes a generation that was paused due to client tool calls. Provide tool outputs for each pending tool call.
 	*
 	*/
-	static rotateApiKey(options) {
+	static submitAgentToolOutputs(options) {
 		return (options.client ?? client).post({
-			url: "/v1/api-keys/{api_key_id}:rotate",
-			...options
+			url: "/v1/projects/{project_id}/agents/{agent_id}/generate/{generation_id}/tool-outputs",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
 		});
 	}
 };
-var Assistant = class {
-	/**
-	* List linked identities
-	*
-	* Lists the caller's assistant grants — one per channel identity that may operate their account. Grants belong to the account, so this is the caller's own set regardless of which projects they own.
-	*
-	*/
-	static listAssistantGrants(options) {
-		return (options?.client ?? client).get({
-			url: "/v1/assistant/grants",
-			...options
-		});
-	}
+var AgentVersions = class {
 	/**
-	* Revoke a linked identity
+	* List an agent's config versions
 	*
-	* Revokes the grant, disabling the Assistant for that identity. The grant is resolved on every inbound message, so the next one from that identity is refused before the agent is invoked — revocation is immediate, not eventual. The identity is free to link again afterwards.
+	* 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 revokeAssistantGrant(options) {
-		return (options.client ?? client).delete({
-			url: "/v1/assistant/grants/{grant_id}",
+	static listAgentVersions(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/agents/{agent_id}/versions",
 			...options
 		});
 	}
 	/**
-	* Resolve a pending link
+	* Get an archived agent config version
 	*
-	* Resolves a link token **without consuming it**, so the confirmation screen can name the identity being linked ("@user on Discord") before anyone commits to it. Naming it is what makes a link pasted into the wrong hands fail the human check as well as the server-side binding.
-	* Reading is deliberately separate from redeeming: a single-use nonce must not be burned by a link preview, a URL scanner or a browser prefetch.
+	* 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 previewAssistantLink(options) {
+	static getAgentVersion(options) {
 		return (options.client ?? client).get({
-			url: "/v1/assistant/link",
+			url: "/v1/projects/{project_id}/agents/{agent_id}/versions/{version}",
 			...options
 		});
 	}
 	/**
-	* Redeem a link token
+	* Restore an archived config as a new version
 	*
-	* Redeems a link token and creates the grant, binding the channel identity the token carries to the authenticated account. The identity is read from the token server-side — nothing in this request can point the link at a different one.
-	* The token is the idempotency key: it is single-use, so a replay of this request fails rather than creating a second grant.
+	* 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 redeemAssistantLink(options) {
+	static restoreAgentVersion(options) {
 		return (options.client ?? client).post({
-			url: "/v1/assistant/link",
+			url: "/v1/projects/{project_id}/agents/{agent_id}/versions/{version}/restore",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1141,17 +1131,19 @@ var Assistant = class {
 			}
 		});
 	}
-};
-var Auth = class {
 	/**
-	* Email a sign-in code
+	* Set or replace a staged rollout
 	*
-	* Emails a short numeric code to the address. Always responds 200 with the same body whether or not the address has an account, so it never leaks existence. A first-time address gets an account on its first successful verification, so this is both sign-up and log-in. Issuing a code invalidates any previous one for the same address.
+	* 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 requestSignInCode(options) {
-		return (options.client ?? client).post({
-			url: "/v1/auth/code",
+	static setAgentRelease(options) {
+		return (options.client ?? client).put({
+			url: "/v1/projects/{project_id}/agents/{agent_id}/release",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1160,86 +1152,92 @@ var Auth = class {
 		});
 	}
 	/**
-	* Redeem a sign-in code
+	* Promote the canary and end the rollout
 	*
-	* Exchanges an emailed code for a session, creating the account if the address is new. The code is single-use and short-lived. A code is destroyed after too many wrong guesses, since six digits is small enough to guess given unlimited attempts — the client must then request a new one rather than retry.
+	* 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 verifySignInCode(options) {
+	static promoteAgentRelease(options) {
 		return (options.client ?? client).post({
-			url: "/v1/auth/code/verify",
-			...options,
-			headers: {
-				"Content-Type": "application/json",
-				...options.headers
-			}
+			url: "/v1/projects/{project_id}/agents/{agent_id}/release/promote",
+			...options
 		});
 	}
 	/**
-	* Refresh a session
+	* Abort the rollout and roll back to stable
 	*
-	* Exchanges a valid refresh token for a new access JWT and a rotated refresh token, taken from the body or from the `refresh_token` cookie set at sign-in — a browser sends an empty body and the cookie carries the credential. Refresh tokens are single-use; presenting a previously-rotated token is treated as reuse and revokes the whole session family (createRefreshRotation reuse detection), except within a few seconds of the rotation, where it is treated as two tabs racing on one cookie and rotated again.
+	* 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 refreshSession(options) {
+	static abortAgentRelease(options) {
 		return (options.client ?? client).post({
-			url: "/v1/auth/refresh",
-			...options,
-			headers: {
-				"Content-Type": "application/json",
-				...options.headers
-			}
+			url: "/v1/projects/{project_id}/agents/{agent_id}/release/abort",
+			...options
 		});
 	}
+};
+var AiProviders = class {
 	/**
-	* Log out
+	* List AI providers
 	*
-	* Revokes the current refresh token (and its rotation family) and clears the `refresh_token` cookie. Pass `all: true` to revoke every active session for the user.
+	* 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 logout(options) {
-		return (options?.client ?? client).post({
-			url: "/v1/auth/logout",
+	static createAiProvider(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/ai-providers",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
-				...options?.headers
+				...options.headers
 			}
 		});
 	}
 	/**
-	* Get the current identity
+	* 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.
 	*
-	* Returns the user behind the presented access token.
 	*/
-	static getCurrentUser(options) {
-		return (options?.client ?? client).get({
-			url: "/v1/auth/me",
+	static deleteAiProvider(options) {
+		return (options.client ?? client).delete({
+			url: "/v1/projects/{project_id}/ai-providers/{ai_provider_id}",
 			...options
 		});
 	}
-};
-var Boards = class {
 	/**
-	* List boards
+	* Get an AI provider
 	*
-	* Lists the boards defined in the project, newest first.
+	* Returns a specific AI provider configuration
 	*/
-	static listBoards(options) {
+	static getAiProvider(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/boards",
+			url: "/v1/projects/{project_id}/ai-providers/{ai_provider_id}",
 			...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`.
+	* Update an AI provider
 	*
+	* Updates an AI provider configuration
 	*/
-	static createBoard(options) {
-		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/boards",
+	static updateAiProvider(options) {
+		return (options.client ?? client).patch({
+			url: "/v1/projects/{project_id}/ai-providers/{ai_provider_id}",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1248,39 +1246,42 @@ var Boards = class {
 		});
 	}
 	/**
-	* Delete a board
+	* List the models this provider can run
 	*
-	* 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.
+	* 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 deleteBoard(options) {
-		return (options.client ?? client).delete({
-			url: "/v1/projects/{project_id}/boards/{board_id}",
+	static listAiProviderModels(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/ai-providers/{ai_provider_id}/models",
 			...options
 		});
 	}
 	/**
-	* Get a board
+	* List per-provider price overrides
 	*
-	* 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.
+	* 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 getBoard(options) {
+	static getAiProviderPrices(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/boards/{board_id}",
+			url: "/v1/projects/{project_id}/ai-providers/{ai_provider_id}/prices",
 			...options
 		});
 	}
 	/**
-	* Update a board
+	* Upsert per-provider price overrides
 	*
-	* 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.
+	* 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 updateBoard(options) {
-		return (options.client ?? client).patch({
-			url: "/v1/projects/{project_id}/boards/{board_id}",
+	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",
@@ -1289,34 +1290,29 @@ var Boards = class {
 		});
 	}
 };
-var Generations = class {
+var ApiKeys = class {
 	/**
-	* List an agent's generations
+	* List API keys
 	*
-	* 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.
+	* Lists API keys accessible to the caller. A project-scoped credential sees only keys in its project; an account-scoped credential sees all keys in the account. Raw secrets are never returned.
 	*
 	*/
-	static listAgentGenerations(options) {
-		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/agents/{agent_id}/generations",
+	static listApiKeys(options) {
+		return (options?.client ?? client).get({
+			url: "/v1/api-keys",
 			...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`.
+	* Create an API key
 	*
-	* 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`.
+	* 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 createGeneration(options) {
+	static createApiKey(options) {
 		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/agents/{agent_id}/generations",
+			url: "/v1/api-keys",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1325,107 +1321,103 @@ var Generations = class {
 		});
 	}
 	/**
-	* Get a generation
-	*
-	* 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.
+	* Revoke an API key
 	*
+	* Revokes an API key immediately. Subsequent use returns 401.
 	*/
-	static getGeneration(options) {
-		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/generations/{generation_id}",
+	static deleteApiKey(options) {
+		return (options.client ?? client).delete({
+			url: "/v1/api-keys/{api_key_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.
+	* Get an API key
 	*
+	* Returns metadata for an API key. The raw secret is never returned after creation.
 	*/
-	static purgeGenerationContent(options) {
-		return (options.client ?? client).delete({
-			url: "/v1/projects/{project_id}/generations/{generation_id}/content",
+	static getApiKey(options) {
+		return (options.client ?? client).get({
+			url: "/v1/api-keys/{api_key_id}",
 			...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`.
+	* Update an API key
 	*
+	* Rename an API key or replace its capability set. The scope (project vs account) is immutable.
 	*/
-	static getGenerationUsage(options) {
-		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/generations/{generation_id}/usage",
-			...options
+	static updateApiKey(options) {
+		return (options.client ?? client).patch({
+			url: "/v1/api-keys/{api_key_id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
 		});
 	}
-};
-var Knowledge = class {
 	/**
-	* List collections
+	* Rotate an API key
+	*
+	* Issues a new secret for the same key record (same id, scope and capabilities) and invalidates the previous secret. The new raw `key` is returned only in this response.
 	*
-	* Lists the knowledge collections in the project.
 	*/
-	static listKnowledgeCollections(options) {
-		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/knowledge/collections",
+	static rotateApiKey(options) {
+		return (options.client ?? client).post({
+			url: "/v1/api-keys/{api_key_id}:rotate",
 			...options
 		});
 	}
+};
+var Assistant = class {
 	/**
-	* Create a collection
+	* List linked identities
 	*
-	* Create a knowledge collection. The name is the key manifests reference (an agent's `knowledge:` block) and must be unique within the project.
+	* Lists the caller's assistant grants — one per channel identity that may operate their account. Grants belong to the account, so this is the caller's own set regardless of which projects they own.
 	*
 	*/
-	static createKnowledgeCollection(options) {
-		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/knowledge/collections",
-			...options,
-			headers: {
-				"Content-Type": "application/json",
-				...options.headers
-			}
+	static listAssistantGrants(options) {
+		return (options?.client ?? client).get({
+			url: "/v1/assistant/grants",
+			...options
 		});
 	}
 	/**
-	* Delete a collection
+	* Revoke a linked identity
 	*
-	* Deletes an empty collection. Returns 409 if the collection still has documents (delete them first).
+	* Revokes the grant, disabling the Assistant for that identity. The grant is resolved on every inbound message, so the next one from that identity is refused before the agent is invoked — revocation is immediate, not eventual. The identity is free to link again afterwards.
 	*
 	*/
-	static deleteKnowledgeCollection(options) {
+	static revokeAssistantGrant(options) {
 		return (options.client ?? client).delete({
-			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}",
+			url: "/v1/assistant/grants/{grant_id}",
 			...options
 		});
 	}
 	/**
-	* Get a collection
+	* Resolve a pending link
+	*
+	* Resolves a link token **without consuming it**, so the confirmation screen can name the identity being linked ("@user on Discord") before anyone commits to it. Naming it is what makes a link pasted into the wrong hands fail the human check as well as the server-side binding.
+	* Reading is deliberately separate from redeeming: a single-use nonce must not be burned by a link preview, a URL scanner or a browser prefetch.
+	*
 	*/
-	static getKnowledgeCollection(options) {
+	static previewAssistantLink(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}",
+			url: "/v1/assistant/link",
 			...options
 		});
 	}
 	/**
-	* Update a collection
+	* Redeem a link token
+	*
+	* Redeems a link token and creates the grant, binding the channel identity the token carries to the authenticated account. The identity is read from the token server-side — nothing in this request can point the link at a different one.
+	* The token is the idempotency key: it is single-use, so a replay of this request fails rather than creating a second grant.
 	*
-	* Rename the collection or edit its description. At least one field is required.
 	*/
-	static updateKnowledgeCollection(options) {
-		return (options.client ?? client).patch({
-			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}",
+	static redeemAssistantLink(options) {
+		return (options.client ?? client).post({
+			url: "/v1/assistant/link",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1433,15 +1425,17 @@ var Knowledge = class {
 			}
 		});
 	}
+};
+var Auth = class {
 	/**
-	* Query a collection (retrieval preview)
+	* Email a sign-in code
 	*
-	* Retrieval preview (API.md §4, K5): 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`.
+	* Emails a short numeric code to the address. Always responds 200 with the same body whether or not the address has an account, so it never leaks existence. A first-time address gets an account on its first successful verification, so this is both sign-up and log-in. Issuing a code invalidates any previous one for the same address.
 	*
 	*/
-	static queryKnowledgeCollection(options) {
+	static requestSignInCode(options) {
 		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}:query",
+			url: "/v1/auth/code",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1450,29 +1444,30 @@ var Knowledge = class {
 		});
 	}
 	/**
-	* List documents
+	* Redeem a sign-in code
+	*
+	* Exchanges an emailed code for a session, creating the account if the address is new. The code is single-use and short-lived. A code is destroyed after too many wrong guesses, since six digits is small enough to guess given unlimited attempts — the client must then request a new one rather than retry.
 	*
-	* Lists the documents in the collection, with their ingestion status.
 	*/
-	static listKnowledgeDocuments(options) {
-		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}/documents",
-			...options
+	static verifySignInCode(options) {
+		return (options.client ?? client).post({
+			url: "/v1/auth/code/verify",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
 		});
 	}
 	/**
-	* 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.
+	* Refresh a session
 	*
-	* 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.
+	* Exchanges a valid refresh token for a new access JWT and a rotated refresh token, taken from the body or from the `refresh_token` cookie set at sign-in — a browser sends an empty body and the cookie carries the credential. Refresh tokens are single-use; presenting a previously-rotated token is treated as reuse and revokes the whole session family (createRefreshRotation reuse detection), except within a few seconds of the rotation, where it is treated as two tabs racing on one cookie and rotated again.
 	*
 	*/
-	static createKnowledgeDocument(options) {
+	static refreshSession(options) {
 		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}/documents",
+			url: "/v1/auth/refresh",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1481,73 +1476,79 @@ var Knowledge = class {
 		});
 	}
 	/**
-	* Delete a document
+	* Log out
+	*
+	* Revokes the current refresh token (and its rotation family) and clears the `refresh_token` cookie. Pass `all: true` to revoke every active session for the user.
+	*
 	*/
-	static deleteKnowledgeDocument(options) {
-		return (options.client ?? client).delete({
-			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}/documents/{document_id}",
-			...options
+	static logout(options) {
+		return (options?.client ?? client).post({
+			url: "/v1/auth/logout",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options?.headers
+			}
 		});
 	}
+};
+var Conversations = class {
 	/**
-	* Get a document
+	* List conversations
 	*
-	* Returns the document, including its text content when ingestion is complete.
+	* 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 getKnowledgeDocument(options) {
+	static listConversations(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}/documents/{document_id}",
+			url: "/v1/projects/{project_id}/conversations",
 			...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 (API.md §4, K1). This is the `…:reingest` action; the path segment is `{document_id}:reingest`.
+	* Create a conversation
+	*
+	* Creates a new conversation. project keys automatically infer the project from the key's scope; JWT callers must supply projectId.
+	*/
+	static createConversation(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/conversations",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a conversation
 	*
+	* Deletes a conversation by its ID
 	*/
-	static reingestKnowledgeDocument(options) {
-		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/knowledge/collections/{collection_id}/documents/{document_id}:reingest",
+	static deleteConversation(options) {
+		return (options.client ?? client).delete({
+			url: "/v1/projects/{project_id}/conversations/{conversation_id}",
 			...options
 		});
 	}
 	/**
-	* List converters
+	* Get a conversation by ID
 	*
-	* Lists the media converters registered in the project.
+	* Returns a conversation by its ID
 	*/
-	static listKnowledgeConverters(options) {
+	static getConversation(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/knowledge/converters",
+			url: "/v1/projects/{project_id}/conversations/{conversation_id}",
 			...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.
+	* Update a conversation
 	*
+	* Updates the status of a conversation
 	*/
-	static createKnowledgeConverter(options) {
-		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/knowledge/converters",
+	static updateConversation(options) {
+		return (options.client ?? client).patch({
+			url: "/v1/projects/{project_id}/conversations/{conversation_id}",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1556,35 +1557,24 @@ var Knowledge = class {
 		});
 	}
 	/**
-	* Delete a converter
+	* List conversation messages
 	*
-	* Removes the converter. Documents already ingested through it are untouched; new files of that media type stop being ingestable until another converter covers them.
-	*
-	*/
-	static deleteKnowledgeConverter(options) {
-		return (options.client ?? client).delete({
-			url: "/v1/projects/{project_id}/knowledge/converters/{converter_id}",
-			...options
-		});
-	}
-	/**
-	* Get a converter
+	* Returns all messages (documents) attached to a conversation, ordered by position
 	*/
-	static getKnowledgeConverter(options) {
+	static listConversationMessages(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/knowledge/converters/{converter_id}",
+			url: "/v1/projects/{project_id}/conversations/{conversation_id}/messages",
 			...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.
+	* 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 updateKnowledgeConverter(options) {
-		return (options.client ?? client).patch({
-			url: "/v1/projects/{project_id}/knowledge/converters/{converter_id}",
+	static addConversationMessage(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/conversations/{conversation_id}/messages",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1592,50 +1582,60 @@ var Knowledge = class {
 			}
 		});
 	}
-};
-var Models = class {
 	/**
-	* List models
+	* Generate the next message in a conversation
 	*
-	* 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.
+	* 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 listModels(options) {
-		return (options?.client ?? client).get({
-			url: "/v1/models",
-			...options
+	static generateConversationMessage(options) {
+		return (options.client ?? client).post({
+			url: "/v1/projects/{project_id}/conversations/{conversation_id}/generate",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
 		});
 	}
 	/**
-	* Get a model
+	* Remove a message from a conversation
+	*
+	* Removes a document from a conversation
 	*/
-	static getModel(options) {
-		return (options.client ?? client).get({
-			url: "/v1/models/{model_id}",
+	static removeConversationMessage(options) {
+		return (options.client ?? client).delete({
+			url: "/v1/projects/{project_id}/conversations/{conversation_id}/messages/{document_id}",
 			...options
 		});
 	}
-};
-var Orchestrations = class {
 	/**
-	* List orchestrations
+	* Get conversation tags
 	*
-	* Lists the project's orchestration definitions.
+	* Returns all tags attached to the conversation
 	*/
-	static listOrchestrations(options) {
+	static getConversationTags(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/orchestrations",
+			url: "/v1/projects/{project_id}/conversations/{conversation_id}/tags",
 			...options
 		});
 	}
 	/**
-	* Create an orchestration
+	* Merge conversation tags
 	*
-	* Creates a new orchestration (pipeline) definition in the project.
+	* Merges provided tags with existing tags
 	*/
-	static createOrchestration(options) {
-		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/orchestrations",
+	static mergeConversationTags(options) {
+		return (options.client ?? client).patch({
+			url: "/v1/projects/{project_id}/conversations/{conversation_id}/tags",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1644,14 +1644,13 @@ var Orchestrations = class {
 		});
 	}
 	/**
-	* Validate an orchestration graph
-	*
-	* 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`.
+	* Replace conversation tags
 	*
+	* Replaces all tags on the conversation with the provided tags
 	*/
-	static validateOrchestration(options) {
-		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/orchestrations/validate",
+	static replaceConversationTags(options) {
+		return (options.client ?? client).put({
+			url: "/v1/projects/{project_id}/conversations/{conversation_id}/tags",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1659,37 +1658,41 @@ var Orchestrations = class {
 			}
 		});
 	}
+};
+var Generations = class {
 	/**
-	* Delete an orchestration
+	* 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).
 	*
-	* Deletes the orchestration definition and all of its runs.
 	*/
-	static deleteOrchestration(options) {
-		return (options.client ?? client).delete({
-			url: "/v1/projects/{project_id}/orchestrations/{orchestration_id}",
+	static listGenerations(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/generations",
 			...options
 		});
 	}
 	/**
-	* Get an orchestration
+	* Get a generation
 	*
-	* Returns one orchestration with its nodes and edges. Belonging to another project responds `404`, not `403` — existence is not leaked.
+	* 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).
 	*
 	*/
-	static getOrchestration(options) {
+	static getGeneration(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/orchestrations/{orchestration_id}",
+			url: "/v1/projects/{project_id}/generations/{generation_id}",
 			...options
 		});
 	}
 	/**
-	* Update an orchestration
+	* Update generation metadata
+	*
+	* 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.
 	*
-	* Partially updates an orchestration's definition.
 	*/
-	static updateOrchestration(options) {
+	static updateGeneration(options) {
 		return (options.client ?? client).patch({
-			url: "/v1/projects/{project_id}/orchestrations/{orchestration_id}",
+			url: "/v1/projects/{project_id}/generations/{generation_id}",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -1698,73 +1701,97 @@ var Orchestrations = class {
 		});
 	}
 	/**
-	* List orchestration runs
+	* Purge generation content
 	*
-	* 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.
+	* 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.
 	*
 	*/
-	static listOrchestrationRuns(options) {
-		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/orchestration-runs",
+	static purgeGenerationContent(options) {
+		return (options.client ?? client).delete({
+			url: "/v1/projects/{project_id}/generations/{generation_id}/content",
 			...options
 		});
 	}
 	/**
-	* Start an orchestration run
+	* Get a generation's transcript
+	*
+	* 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.
 	*
-	* 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.
 	*/
-	static startOrchestrationRun(options) {
-		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/orchestration-runs",
-			...options,
-			headers: {
-				"Content-Type": "application/json",
-				...options.headers
-			}
+	static getGenerationTranscript(options) {
+		return (options.client ?? client).get({
+			url: "/v1/projects/{project_id}/generations/{generation_id}/transcript",
+			...options
 		});
 	}
+};
+var ModelRoutes = class {
 	/**
-	* Get an orchestration run
+	* List model routes
 	*
-	* Returns the status, state, and artifacts of one run.
+	* Returns the model routes defined in a project
 	*/
-	static getOrchestrationRun(options) {
+	static listModelRoutes(options) {
 		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/orchestration-runs/{orchestration_run_id}",
+			url: "/v1/projects/{project_id}/model-routes",
 			...options
 		});
 	}
 	/**
-	* Cancel an orchestration run
+	* Create a model route
 	*
-	* Cancels a run that has not yet reached a terminal state.
+	* 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 cancelOrchestrationRun(options) {
+	static createModelRoute(options) {
 		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/orchestration-runs/{orchestration_run_id}/cancel",
+			url: "/v1/projects/{project_id}/model-routes",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Delete a model route
+	*
+	* 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 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",
@@ -1777,7 +1804,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({
@@ -1804,6 +1832,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) {
@@ -1815,8 +1844,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) {
@@ -1829,6 +1858,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.
 	*
 	*/
@@ -1843,6 +1873,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.
@@ -1857,27 +1900,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",
@@ -1886,35 +1928,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",
@@ -1925,14 +1967,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",
@@ -1941,38 +1994,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
+	*
+	* 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
 	*
-	* 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.
+	* 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",
@@ -1981,20 +2048,14 @@ var Sessions = class {
 		});
 	}
 	/**
-	* Generate a response
+	* Trigger agent generation
 	*
-	* Runs the agent over the session's accumulated messages.
-	*
-	* 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",
@@ -2002,29 +2063,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
 	*
-	* 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.
+	* Branches a new session from a point in this session's history: same context, different continuation.
+	*
+	* 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",
@@ -2033,39 +2100,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",
@@ -2074,15 +2138,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",
@@ -2090,24 +2152,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({
@@ -2118,8 +2168,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({
@@ -2134,8 +2183,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({
@@ -2145,6 +2193,8 @@ var Tools = class {
 	}
 	/**
 	* Get a tool
+	*
+	* Returns a single tool by ID.
 	*/
 	static getTool(options) {
 		return (options.client ?? client).get({
@@ -2155,8 +2205,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({
@@ -2168,107 +2217,17 @@ var Tools = class {
 			}
 		});
 	}
-};
-var Traces = class {
-	/**
-	* List traces
-	*
-	* Lists the project's execution traces, newest first.
-	*/
-	static listTraces(options) {
-		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/traces",
-			...options
-		});
-	}
-	/**
-	* 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.
-	*
-	*/
-	static getTrace(options) {
-		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/traces/{trace_id}",
-			...options
-		});
-	}
-	/**
-	* Get a 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.
-	*
-	*/
-	static getTraceTree(options) {
-		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/traces/{trace_id}/tree",
-			...options
-		});
-	}
-	/**
-	* 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
+	* Call a tool
 	*
-	* 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`.
+	* 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 getTraceSteps(options) {
-		return (options.client ?? client).get({
-			url: "/v1/projects/{project_id}/traces/{trace_id}/steps",
-			...options
-		});
-	}
-	/**
-	* Purge a trace's content
-	*
-	* 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.
-	*
-	*/
-	static purgeTraceContent(options) {
-		return (options.client ?? client).delete({
-			url: "/v1/projects/{project_id}/traces/{trace_id}/content",
-			...options
-		});
-	}
-};
-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) {
+	static callTool(options) {
 		return (options.client ?? client).post({
-			url: "/v1/projects/{project_id}/triggers",
+			url: "/v1/projects/{project_id}/tools/{tool_id}/call",
 			...options,
 			headers: {
 				"Content-Type": "application/json",
@@ -2276,52 +2235,28 @@ var Triggers = class {
 			}
 		});
 	}
+};
+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",
@@ -2329,26 +2264,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 {
 	/**
@@ -2507,8 +2422,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?' },
 * });
 * ```
 *
@@ -2519,22 +2434,20 @@ const API_BASE_URL = "https://api.naturali.ai";
 var NaturaliClient = class {
 	actors;
 	agents;
+	agentVersions;
+	aiProviders;
 	apiKeys;
 	assistant;
-	auth;
-	boards;
 	channels;
+	auth;
+	conversations;
 	generations;
-	knowledge;
-	models;
-	orchestrations;
+	modelRoutes;
 	projects;
-	providers;
+	secrets;
 	sessions;
-	tasks;
 	tools;
-	traces;
-	triggers;
+	users;
 	webhooks;
 	/** The underlying HTTP client, for interceptors or one-off requests. */
 	http;
@@ -2548,45 +2461,41 @@ 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.generations = bindResource(Generations, this.http);
-		this.knowledge = bindResource(Knowledge, this.http);
-		this.models = bindResource(Models, this.http);
-		this.orchestrations = bindResource(Orchestrations, this.http);
+		this.modelRoutes = bindResource(ModelRoutes, 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.Generations = Generations;
-exports.Knowledge = Knowledge;
-exports.Models = Models;
+exports.ModelRoutes = ModelRoutes;
 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;