@vectros-ai/mcp-server 0.18.1 → 0.19.0

package/dist/cli.js

@@ -26,7 +26,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 // src/server.ts
 var import_server = require("@modelcontextprotocol/sdk/server/index.js");
 
-// ../../node_modules/@vectros-ai/sdk/dist/index.mjs
+// node_modules/@vectros-ai/sdk/dist/index.mjs
 var __defProp2 = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -41,10 +41,13 @@ __export(api_exports, {
   BatchWriteRequest: () => BatchWriteRequest,
   BatchWriteResult: () => BatchWriteResult,
   ChatMessage: () => ChatMessage,
+  ChatRequest: () => ChatRequest,
   ConflictError: () => ConflictError,
   ContentDeltaEvent: () => ContentDeltaEvent,
   ContentTooLargeError: () => ContentTooLargeError,
+  DocumentAskRequest: () => DocumentAskRequest,
   DocumentContextEvent: () => DocumentContextEvent,
+  DocumentExtraction: () => DocumentExtraction,
   DocumentLookupRequest: () => DocumentLookupRequest,
   DocumentPatchRequest: () => DocumentPatchRequest,
   DocumentRequest: () => DocumentRequest,
@@ -74,8 +77,10 @@ __export(api_exports, {
   NotImplementedError: () => NotImplementedError,
   PaymentRequiredError: () => PaymentRequiredError,
   PingResponse: () => PingResponse,
+  RagRequest: () => RagRequest,
   RagSearch: () => RagSearch,
   ReadAccessLogResponse: () => ReadAccessLogResponse,
+  ReasoningDeltaEvent: () => ReasoningDeltaEvent,
   RecordLookupRequest: () => RecordLookupRequest,
   RecordRequest: () => RecordRequest,
   RecordResponse: () => RecordResponse,
@@ -95,6 +100,7 @@ __export(api_exports, {
   UserExistsResponse: () => UserExistsResponse,
   UserRequest: () => UserRequest,
   UserResponse: () => UserResponse,
+  agents: () => agents_exports,
   auth: () => auth_exports,
   compliance: () => compliance_exports,
   documents: () => documents_exports,
@@ -360,6 +366,7 @@ var UnprocessableEntityError = class extends VectrosError {
     this.name = this.constructor.name;
   }
 };
+var agents_exports = {};
 var auth_exports = {};
 var ErasureRequest;
 ((ErasureRequest2) => {
@@ -431,7 +438,33 @@ var ListUsersRequestOrder = {
   Asc: "asc",
   Desc: "desc"
 };
+var ChatRequest;
+((ChatRequest2) => {
+  ChatRequest2.Reasoning = {
+    Omit: "omit",
+    Stream: "stream"
+  };
+})(ChatRequest || (ChatRequest = {}));
+var DocumentAskRequest;
+((DocumentAskRequest2) => {
+  DocumentAskRequest2.Reasoning = {
+    Omit: "omit",
+    Stream: "stream"
+  };
+})(DocumentAskRequest || (DocumentAskRequest = {}));
+var RagRequest;
+((RagRequest2) => {
+  RagRequest2.Reasoning = {
+    Omit: "omit",
+    Stream: "stream"
+  };
+})(RagRequest || (RagRequest = {}));
 var inference_exports = {};
+__export(inference_exports, {
+  ChatRequest: () => ChatRequest,
+  DocumentAskRequest: () => DocumentAskRequest,
+  RagRequest: () => RagRequest
+});
 var BatchWriteRequest;
 ((BatchWriteRequest2) => {
   BatchWriteRequest2.Atomicity = {
@@ -538,6 +571,18 @@ var DocumentContextEvent;
     DocumentContext: "document_context"
   };
 })(DocumentContextEvent || (DocumentContextEvent = {}));
+var DocumentExtraction;
+((DocumentExtraction2) => {
+  DocumentExtraction2.Outcome = {
+    Ok: "OK",
+    Truncated: "TRUNCATED",
+    NoText: "NO_TEXT",
+    Encrypted: "ENCRYPTED",
+    Unsupported: "UNSUPPORTED",
+    TooLarge: "TOO_LARGE",
+    Unreadable: "UNREADABLE"
+  };
+})(DocumentExtraction || (DocumentExtraction = {}));
 var DocumentRequest;
 ((DocumentRequest2) => {
   DocumentRequest2.IndexMode = {
@@ -704,6 +749,12 @@ var ReadAccessLogResponse;
     Rag: "rag"
   };
 })(ReadAccessLogResponse || (ReadAccessLogResponse = {}));
+var ReasoningDeltaEvent;
+((ReasoningDeltaEvent2) => {
+  ReasoningDeltaEvent2.Event = {
+    ReasoningDelta: "reasoning_delta"
+  };
+})(ReasoningDeltaEvent || (ReasoningDeltaEvent = {}));
 var RecordRequest;
 ((RecordRequest2) => {
   RecordRequest2.Status = {
@@ -1837,13 +1888,13 @@ function joinPathSegments(left, right) {
   }
   return `${left}/${right}`;
 }
-function trimSlashes(str) {
-  if (!str) return str;
+function trimSlashes(str2) {
+  if (!str2) return str2;
   let start = 0;
-  let end = str.length;
-  if (str.startsWith("/")) start = 1;
-  if (str.endsWith("/")) end = str.length - 1;
-  return start === 0 && end === str.length ? str : str.slice(start, end);
+  let end = str2.length;
+  if (str2.startsWith("/")) start = 1;
+  if (str2.endsWith("/")) end = str2.length - 1;
+  return start === 0 && end === str2.length ? str2 : str2.slice(start, end);
 }
 var Supplier = {
   get: async (supplier) => {
@@ -2266,140 +2317,767 @@ var QueryStringBuilder = class {
         }
       }
     }
-    return this;
+    return this;
+  }
+  /**
+   * Returns the assembled query string (without the leading `?`).
+   * Returns an empty string when no parameters were added.
+   */
+  build() {
+    return [...this.parts.values()].join("&");
+  }
+};
+var TOKEN_PARAM = "token";
+var BearerAuthProvider = class _BearerAuthProvider {
+  constructor(options) {
+    this.options = options;
+  }
+  static canCreate(options) {
+    return options?.[TOKEN_PARAM] != null;
+  }
+  async getAuthRequest({
+    endpointMetadata
+  } = {}) {
+    const token = await Supplier.get(this.options[TOKEN_PARAM]);
+    if (token == null) {
+      throw new VectrosError({
+        message: _BearerAuthProvider.AUTH_CONFIG_ERROR_MESSAGE
+      });
+    }
+    return {
+      headers: { Authorization: `Bearer ${token}` }
+    };
+  }
+};
+((BearerAuthProvider2) => {
+  BearerAuthProvider2.AUTH_SCHEME = "BearerAuth";
+  BearerAuthProvider2.AUTH_CONFIG_ERROR_MESSAGE = `Please provide '${TOKEN_PARAM}' when initializing the client`;
+  function createInstance(options) {
+    return new BearerAuthProvider2(options);
+  }
+  BearerAuthProvider2.createInstance = createInstance;
+})(BearerAuthProvider || (BearerAuthProvider = {}));
+function mergeHeaders(...headersArray) {
+  const result = {};
+  for (const [key, value] of headersArray.filter((headers) => headers != null).flatMap((headers) => Object.entries(headers))) {
+    const insensitiveKey = key.toLowerCase();
+    if (value != null) {
+      result[insensitiveKey] = value;
+    } else if (insensitiveKey in result) {
+      delete result[insensitiveKey];
+    }
+  }
+  return result;
+}
+function mergeOnlyDefinedHeaders(...headersArray) {
+  const result = {};
+  for (const [key, value] of headersArray.filter((headers) => headers != null).flatMap((headers) => Object.entries(headers))) {
+    const insensitiveKey = key.toLowerCase();
+    if (value != null) {
+      result[insensitiveKey] = value;
+    }
+  }
+  return result;
+}
+function normalizeClientOptions(options) {
+  const headers = mergeHeaders(
+    {
+      "X-Fern-Language": "JavaScript",
+      "X-Fern-Runtime": RUNTIME.type,
+      "X-Fern-Runtime-Version": RUNTIME.version
+    },
+    options?.headers
+  );
+  return {
+    ...options,
+    logging: logging_exports.createLogger(options?.logging),
+    headers
+  };
+}
+function normalizeClientOptionsWithAuth(options) {
+  const normalized = normalizeClientOptions(options);
+  if (options.auth === false) {
+    normalized.authProvider = new NoOpAuthProvider();
+    return normalized;
+  }
+  if (options.auth != null) {
+    if (typeof options.auth === "function") {
+      normalized.authProvider = { getAuthRequest: options.auth };
+      return normalized;
+    }
+    if (isAuthProvider(options.auth)) {
+      normalized.authProvider = options.auth;
+      return normalized;
+    }
+    Object.assign(normalized, options.auth);
+  }
+  const normalizedWithNoOpAuthProvider = withNoOpAuthProvider(normalized);
+  normalized.authProvider ?? (normalized.authProvider = new BearerAuthProvider(normalizedWithNoOpAuthProvider));
+  return normalized;
+}
+function withNoOpAuthProvider(options) {
+  return {
+    ...options,
+    authProvider: new NoOpAuthProvider()
+  };
+}
+function handleNonStatusCodeError(error, rawResponse, method, path2) {
+  switch (error.reason) {
+    case "non-json":
+      throw new VectrosError({
+        statusCode: error.statusCode,
+        body: error.rawBody,
+        rawResponse
+      });
+    case "body-is-null":
+      throw new VectrosError({
+        statusCode: error.statusCode,
+        rawResponse
+      });
+    case "timeout":
+      throw new VectrosTimeoutError(`Timeout exceeded when calling ${method} ${path2}.`, {
+        cause: error.cause
+      });
+    case "unknown":
+      throw new VectrosError({
+        message: error.errorMessage,
+        rawResponse,
+        cause: error.cause
+      });
+    default:
+      throw new VectrosError({
+        message: "Unknown error",
+        rawResponse
+      });
+  }
+}
+var AgentsClient = class {
+  constructor(options) {
+    this._options = normalizeClientOptionsWithAuth(options);
+  }
+  /**
+   * Returns a page of the agents in the app context, newest first, each at its latest version. A caller holding `runs:c` but not `agents:r` gets only each agent's `id`, `name`, `description`, `latestVersion` and `status`. Retired and purged agents are left out unless `includeRetired=true`. Requires `agents:r` or `runs:c`.
+   *
+   * @param {Vectros.ListAgentsRequest} request
+   * @param {AgentsClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link Vectros.ForbiddenError}
+   *
+   * @example
+   *     await client.agents.listAgents()
+   */
+  listAgents(request = {}, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__listAgents(request, requestOptions));
+  }
+  async __listAgents(request = {}, requestOptions) {
+    const { contextId, includeRetired, startFrom, limit } = request;
+    const _queryParams = {
+      contextId,
+      includeRetired,
+      startFrom,
+      limit
+    };
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "v1/agents"
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 403:
+          throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        default:
+          throw new VectrosError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/agents");
+  }
+  /**
+   * Stores a new agent at version 1, or returns the existing agent of this name unchanged. With `?upsert=true` an existing agent whose definition differs gets a new version instead. Requires the `agents:c` scope (also `agents:u` with `?upsert=true`).
+   *
+   * @param {Vectros.CreateAgentRequest} request
+   * @param {AgentsClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link Vectros.BadRequestError}
+   * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.ConflictError}
+   * @throws {@link Vectros.TooManyRequestsError}
+   *
+   * @example
+   *     await client.agents.createAgent({
+   *         body: {
+   *             model: "claude-sonnet-5-5"
+   *         }
+   *     })
+   */
+  createAgent(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__createAgent(request, requestOptions));
+  }
+  async __createAgent(request, requestOptions) {
+    const { upsert, contextId, body: _body } = request;
+    const _queryParams = {
+      upsert,
+      contextId
+    };
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "v1/agents"
+      ),
+      method: "POST",
+      headers: _headers,
+      contentType: "application/json",
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "json",
+      body: _body,
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
+        case 403:
+          throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
+        case 429:
+          throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
+        default:
+          throw new VectrosError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/agents");
+  }
+  /**
+   * Returns the agent at its latest version, or at `version`. Requires the `agents:r` scope.
+   *
+   * @param {Vectros.GetAgentRequest} request
+   * @param {AgentsClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   *
+   * @example
+   *     await client.agents.getAgent({
+   *         id: "id"
+   *     })
+   */
+  getAgent(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getAgent(request, requestOptions));
+  }
+  async __getAgent(request, requestOptions) {
+    const { id, contextId, version } = request;
+    const _queryParams = {
+      contextId,
+      version
+    };
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        `v1/agents/${url_exports.encodePathParam(id)}`
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 403:
+          throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        default:
+          throw new VectrosError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/agents/{id}");
+  }
+  /**
+   * Stores the body as the agent's next version. Earlier versions never change. Every optional field you leave out takes its default; `model` is required. With `?restore=true` a retired agent becomes active again with this version. Requires the `agents:u` scope.
+   *
+   * @param {Vectros.UpdateAgentRequest} request
+   * @param {AgentsClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link Vectros.BadRequestError}
+   * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
+   * @throws {@link Vectros.TooManyRequestsError}
+   *
+   * @example
+   *     await client.agents.updateAgent({
+   *         id: "id",
+   *         body: {
+   *             model: "claude-sonnet-5-5"
+   *         }
+   *     })
+   */
+  updateAgent(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__updateAgent(request, requestOptions));
+  }
+  async __updateAgent(request, requestOptions) {
+    const { id, restore, contextId, body: _body } = request;
+    const _queryParams = {
+      restore,
+      contextId
+    };
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        `v1/agents/${url_exports.encodePathParam(id)}`
+      ),
+      method: "PUT",
+      headers: _headers,
+      contentType: "application/json",
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "json",
+      body: _body,
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
+        case 403:
+          throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
+        case 429:
+          throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
+        default:
+          throw new VectrosError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "PUT", "/v1/agents/{id}");
+  }
+  /**
+   * Retires the agent: its versions stay readable, it leaves the default listing, and it can be restored. With `?purge=true` a retired agent's content (every version's prompt, description, tools, model, limits and budget) is erased, leaving its id, name, version numbers and timestamps; its change history keeps only a one-way hash of the prompt, description and tools. If the agent is restored while a purge is running, the purge stops (409) and versions it already erased stay erased; purge it again after retiring it. With `?purge=true&version=N` one version that is not the latest is erased. The name of a purged agent stays reserved. Requires the `agents:d` scope.
+   *
+   * @param {Vectros.DeleteAgentRequest} request
+   * @param {AgentsClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link Vectros.BadRequestError}
+   * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
+   * @throws {@link Vectros.TooManyRequestsError}
+   *
+   * @example
+   *     await client.agents.deleteAgent({
+   *         id: "id"
+   *     })
+   */
+  deleteAgent(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__deleteAgent(request, requestOptions));
+  }
+  async __deleteAgent(request, requestOptions) {
+    const { id, purge, version, contextId } = request;
+    const _queryParams = {
+      purge,
+      version,
+      contextId
+    };
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        `v1/agents/${url_exports.encodePathParam(id)}`
+      ),
+      method: "DELETE",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
+        case 403:
+          throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
+        case 429:
+          throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
+        default:
+          throw new VectrosError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "DELETE", "/v1/agents/{id}");
+  }
+  /**
+   * Returns a page of the agent's versions, newest first: who wrote each and when, and whether it was purged. With `includeContent=true` each entry carries its full definition. Requires the `agents:r` scope.
+   *
+   * @param {Vectros.ListAgentVersionsRequest} request
+   * @param {AgentsClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   *
+   * @example
+   *     await client.agents.listAgentVersions({
+   *         id: "id"
+   *     })
+   */
+  listAgentVersions(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__listAgentVersions(request, requestOptions));
+  }
+  async __listAgentVersions(request, requestOptions) {
+    const { id, contextId, includeContent, startFrom, limit } = request;
+    const _queryParams = {
+      contextId,
+      includeContent,
+      startFrom,
+      limit
+    };
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        `v1/agents/${url_exports.encodePathParam(id)}/versions`
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 403:
+          throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        default:
+          throw new VectrosError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/agents/{id}/versions");
+  }
+  /**
+   * Stops a run. The answer is `202` with the run still `RUNNING`: read it with `GET /v1/runs/{id}` to see it end. A model call in progress is cut within a few seconds; a tool call in progress is first allowed to finish, for up to about 30 seconds, so its change is recorded and billed, and the run stops as soon as it has. The run then ends `CANCELLED` with `errorCode` `CANCELLED_BY_CALLER`, unless it had already completed, in which case it stays `COMPLETED`. Its reservation is settled once, like any run's: a model call in progress when it stopped is charged up to its maximum. A run that has ended (or that had not started, which this cancel ends) answers `200` with its final state, so a cancel can always be retried. A run can be cancelled by the credential that started it (for a token bound to a user, by that user) and by your root key. Requires the `runs:c` scope; with `runs:r` as well the answer is the whole run, otherwise only its `id`, `status`, `terminal`, `reason` and `errorCode`. Takes no body.
+   *
+   * @param {Vectros.CancelRunRequest} request
+   * @param {AgentsClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link Vectros.BadRequestError}
+   * @throws {@link Vectros.UnauthorizedError}
+   * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.TooManyRequestsError}
+   *
+   * @example
+   *     await client.agents.cancelRun({
+   *         id: "id"
+   *     })
+   */
+  cancelRun(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__cancelRun(request, requestOptions));
+  }
+  async __cancelRun(request, requestOptions) {
+    const { id, contextId } = request;
+    const _queryParams = {
+      contextId
+    };
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        `v1/runs/${url_exports.encodePathParam(id)}/cancel`
+      ),
+      method: "POST",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
+        case 401:
+          throw new UnauthorizedError(_response.error.body, _response.rawResponse);
+        case 403:
+          throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 429:
+          throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
+        default:
+          throw new VectrosError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/runs/{id}/cancel");
+  }
+  /**
+   * Returns the status and metadata of one run: the agent version that ran, how it ended, its tool calls (never their arguments or results) and what it was charged. It never returns text: the answer is delivered only in the run's stream. A run is visible to the credential that started it (for a token bound to a user, to that user) and to your root key, and is kept for 30 days after it ends. Requires the `runs:r` scope.
+   *
+   * @param {Vectros.GetRunRequest} request
+   * @param {AgentsClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link Vectros.BadRequestError}
+   * @throws {@link Vectros.UnauthorizedError}
+   * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   *
+   * @example
+   *     await client.agents.getRun({
+   *         id: "id"
+   *     })
+   */
+  getRun(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__getRun(request, requestOptions));
+  }
+  async __getRun(request, requestOptions) {
+    const { id, contextId } = request;
+    const _queryParams = {
+      contextId
+    };
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        `v1/runs/${url_exports.encodePathParam(id)}`
+      ),
+      method: "GET",
+      headers: _headers,
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return { data: _response.body, rawResponse: _response.rawResponse };
+    }
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
+        case 401:
+          throw new UnauthorizedError(_response.error.body, _response.rawResponse);
+        case 403:
+          throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        default:
+          throw new VectrosError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/runs/{id}");
   }
   /**
-   * Returns the assembled query string (without the leading `?`).
-   * Returns an empty string when no parameters were added.
+   * Starts a run of a stored agent and streams what it does as Server-Sent Events. The response is always `text/event-stream`, whatever `Accept` you send; its `X-Vectros-Run-Id` header names the run. The run's tool calls act as you, with your own permissions, and only through the tools the agent lists. On a prepaid account the run reserves its budget from your inference balance when it starts and returns what its model calls did not use when it ends; a fixed fee per run, tool calls and run time are billed separately, against your plan. Read each event's `type`; ignore types and fields you do not know; stop at the event with `terminal: true`. A stream that ends without one: read the run with `GET /v1/runs/{id}`. Closing the stream stops the run only on a best-effort basis. Requires the `runs:c` scope, and agent runs switched on for your tenant by an account owner.
    */
-  build() {
-    return [...this.parts.values()].join("&");
-  }
-};
-var TOKEN_PARAM = "token";
-var BearerAuthProvider = class _BearerAuthProvider {
-  constructor(options) {
-    this.options = options;
-  }
-  static canCreate(options) {
-    return options?.[TOKEN_PARAM] != null;
-  }
-  async getAuthRequest({
-    endpointMetadata
-  } = {}) {
-    const token = await Supplier.get(this.options[TOKEN_PARAM]);
-    if (token == null) {
-      throw new VectrosError({
-        message: _BearerAuthProvider.AUTH_CONFIG_ERROR_MESSAGE
-      });
-    }
-    return {
-      headers: { Authorization: `Bearer ${token}` }
-    };
-  }
-};
-((BearerAuthProvider2) => {
-  BearerAuthProvider2.AUTH_SCHEME = "BearerAuth";
-  BearerAuthProvider2.AUTH_CONFIG_ERROR_MESSAGE = `Please provide '${TOKEN_PARAM}' when initializing the client`;
-  function createInstance(options) {
-    return new BearerAuthProvider2(options);
-  }
-  BearerAuthProvider2.createInstance = createInstance;
-})(BearerAuthProvider || (BearerAuthProvider = {}));
-function mergeHeaders(...headersArray) {
-  const result = {};
-  for (const [key, value] of headersArray.filter((headers) => headers != null).flatMap((headers) => Object.entries(headers))) {
-    const insensitiveKey = key.toLowerCase();
-    if (value != null) {
-      result[insensitiveKey] = value;
-    } else if (insensitiveKey in result) {
-      delete result[insensitiveKey];
-    }
-  }
-  return result;
-}
-function mergeOnlyDefinedHeaders(...headersArray) {
-  const result = {};
-  for (const [key, value] of headersArray.filter((headers) => headers != null).flatMap((headers) => Object.entries(headers))) {
-    const insensitiveKey = key.toLowerCase();
-    if (value != null) {
-      result[insensitiveKey] = value;
-    }
-  }
-  return result;
-}
-function normalizeClientOptions(options) {
-  const headers = mergeHeaders(
-    {
-      "X-Fern-Language": "JavaScript",
-      "X-Fern-Runtime": RUNTIME.type,
-      "X-Fern-Runtime-Version": RUNTIME.version
-    },
-    options?.headers
-  );
-  return {
-    ...options,
-    logging: logging_exports.createLogger(options?.logging),
-    headers
-  };
-}
-function normalizeClientOptionsWithAuth(options) {
-  const normalized = normalizeClientOptions(options);
-  if (options.auth === false) {
-    normalized.authProvider = new NoOpAuthProvider();
-    return normalized;
+  createRun(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__createRun(request, requestOptions));
   }
-  if (options.auth != null) {
-    if (typeof options.auth === "function") {
-      normalized.authProvider = { getAuthRequest: options.auth };
-      return normalized;
+  async __createRun(request, requestOptions) {
+    const { "Idempotency-Key": idempotencyKey, ..._body } = request;
+    const _authRequest = await this._options.authProvider.getAuthRequest();
+    const _headers = mergeHeaders(
+      _authRequest.headers,
+      this._options?.headers,
+      mergeOnlyDefinedHeaders({ "Idempotency-Key": idempotencyKey }),
+      requestOptions?.headers
+    );
+    const _response = await fetcher({
+      url: url_exports.join(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "v1/runs"
+      ),
+      method: "POST",
+      headers: _headers,
+      contentType: "application/json",
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "json",
+      body: _body,
+      responseType: "sse",
+      timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
+      maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+      abortSignal: requestOptions?.abortSignal,
+      fetchFn: this._options?.fetch,
+      logging: this._options.logging
+    });
+    if (_response.ok) {
+      return {
+        data: new Stream({
+          stream: _response.body,
+          parse: (data) => data,
+          signal: requestOptions?.abortSignal,
+          eventShape: {
+            type: "sse"
+          }
+        }),
+        rawResponse: _response.rawResponse
+      };
     }
-    if (isAuthProvider(options.auth)) {
-      normalized.authProvider = options.auth;
-      return normalized;
+    if (_response.error.reason === "status-code") {
+      switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
+        case 401:
+          throw new UnauthorizedError(_response.error.body, _response.rawResponse);
+        case 402:
+          throw new PaymentRequiredError(_response.error.body, _response.rawResponse);
+        case 403:
+          throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
+        case 413:
+          throw new ContentTooLargeError(_response.error.body, _response.rawResponse);
+        case 422:
+          throw new UnprocessableEntityError(_response.error.body, _response.rawResponse);
+        case 429:
+          throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
+        case 503:
+          throw new ServiceUnavailableError(_response.error.body, _response.rawResponse);
+        default:
+          throw new VectrosError({
+            statusCode: _response.error.statusCode,
+            body: _response.error.body,
+            rawResponse: _response.rawResponse
+          });
+      }
     }
-    Object.assign(normalized, options.auth);
-  }
-  const normalizedWithNoOpAuthProvider = withNoOpAuthProvider(normalized);
-  normalized.authProvider ?? (normalized.authProvider = new BearerAuthProvider(normalizedWithNoOpAuthProvider));
-  return normalized;
-}
-function withNoOpAuthProvider(options) {
-  return {
-    ...options,
-    authProvider: new NoOpAuthProvider()
-  };
-}
-function handleNonStatusCodeError(error, rawResponse, method, path2) {
-  switch (error.reason) {
-    case "non-json":
-      throw new VectrosError({
-        statusCode: error.statusCode,
-        body: error.rawBody,
-        rawResponse
-      });
-    case "body-is-null":
-      throw new VectrosError({
-        statusCode: error.statusCode,
-        rawResponse
-      });
-    case "timeout":
-      throw new VectrosTimeoutError(`Timeout exceeded when calling ${method} ${path2}.`, {
-        cause: error.cause
-      });
-    case "unknown":
-      throw new VectrosError({
-        message: error.errorMessage,
-        rawResponse,
-        cause: error.cause
-      });
-    default:
-      throw new VectrosError({
-        message: "Unknown error",
-        rawResponse
-      });
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/runs");
   }
-}
+};
 var AuthClient = class {
   constructor(options) {
     this._options = normalizeClientOptionsWithAuth(options);
@@ -2598,7 +3276,7 @@ var AuthClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/admin/keys/scoped");
   }
   /**
-   * Creates a scoped API key (an `ssk_*` secret) that inherits its permissions from an existing access profile in your account. The call is idempotent on the combination of tenant, context, user, and key name: re-issuing the same request returns the existing key WITHOUT re-disclosing its raw secret. The raw key is returned ONLY in this response — store it securely, as it cannot be retrieved again. Requires the `keys:c` scope. If you use a scoped credential, `keys:c` alone is not sufficient: because the minted key is durably bound to the profile you name, the profile's effective scopes may not exceed your own, and you may only mint against a profile whose `identityOverrides` values your own identity holds. Minting a key bound to your OWN principal needs nothing further; minting one bound to a DIFFERENT principal additionally requires the `delegate-mint` capability (`granted_capabilities`) on your credential — without it the request is refused. A root API key (`sk_`) is exempt from all three bounds. The profile you name must be `active` AND the user you name must not be `SUSPENDED`: either is refused with `409`, and no root exemption applies to that. Both refusals stop ISSUANCE only. Suspending the profile additionally stops credentials already bound to it, within about five minutes; suspending the user does not stop their existing keys at all. A `PENDING` user is fine.
+   * Creates a scoped API key (an `ssk_*` secret) that inherits its permissions from an existing access profile in your account. The call is idempotent on the combination of tenant, context, user, and key name: re-issuing the same request returns the existing key WITHOUT re-disclosing its raw secret. The raw key is returned ONLY in this response — store it securely, as it cannot be retrieved again. Requires the `keys:c` scope. If you use a scoped credential, `keys:c` alone is not sufficient: because the minted key is durably bound to the profile you name, the profile's effective scopes may not exceed your own, and you may only mint against a profile whose `identityOverrides` values your own identity holds. Minting a key bound to your OWN principal needs nothing further; minting one bound to a DIFFERENT principal additionally requires the `delegate-mint` capability (`granted_capabilities`) on your credential — without it the request is refused. A root API key (`sk_`) is exempt from all three bounds. The profile you name must be `active` AND the user you name must not be `SUSPENDED`: either is refused with `409`, and no root exemption applies to that. Both refusals stop ISSUANCE only. Suspending the profile or the user additionally stops credentials already bound to it, within about five minutes. A `PENDING` user is fine.
    *
    * @param {Vectros.CreateScopedKeyRequest} request
    * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -2941,14 +3619,13 @@ var AuthClient = class {
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
    *     await client.auth.createAccessProfile({
    *         contextId: "contextId",
-   *         body: {
-   *             principalId: "usr_6ba7b810-9dad-11d1-80b4-00c04fd430c8"
-   *         }
+   *         body: {}
    *     })
    */
   createAccessProfile(request, requestOptions) {
@@ -2993,6 +3670,8 @@ var AuthClient = class {
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -3076,14 +3755,13 @@ var AuthClient = class {
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.PaymentRequiredError}
    * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
    *     await client.auth.createAppContext({
-   *         body: {
-   *             contextId: "myapp",
-   *             name: "My Internal App"
-   *         }
+   *         body: {}
    *     })
    */
   createAppContext(request, requestOptions) {
@@ -3128,6 +3806,10 @@ var AuthClient = class {
           throw new PaymentRequiredError(_response.error.body, _response.rawResponse);
         case 403:
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -3216,18 +3898,13 @@ var AuthClient = class {
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
    *     await client.auth.createRole({
    *         contextId: "contextId",
-   *         body: {
-   *             roleId: "engineering-member",
-   *             name: "Engineering Team Member",
-   *             scopes: [{
-   *                     allowed_actions: ["records:cru", "search:r"]
-   *                 }]
-   *         }
+   *         body: {}
    *     })
    */
   createRole(request, requestOptions) {
@@ -3272,6 +3949,8 @@ var AuthClient = class {
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -3362,15 +4041,14 @@ var AuthClient = class {
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
    *     await client.auth.updateAccessProfile({
    *         contextId: "contextId",
    *         principalId: "principalId",
-   *         body: {
-   *             principalId: "usr_6ba7b810-9dad-11d1-80b4-00c04fd430c8"
-   *         }
+   *         body: {}
    *     })
    */
   updateAccessProfile(request, requestOptions) {
@@ -3412,6 +4090,8 @@ var AuthClient = class {
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -3558,22 +4238,20 @@ var AuthClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/app-contexts/{contextId}");
   }
   /**
-   * Updates an app context. This is a partial update: any field you omit (or send as null) keeps its existing value. The `contextId` is immutable and is taken from the URL path, so any `contextId` in the request body is ignored. Patchable fields: `name`, `description`, `companyName`; the per-principal metering trio (`meteringAxis`, `principalBurstLimit`, `principalUsageCap` — only takes effect for a partner with the corresponding account-level feature enabled); `readAccessLogDefault` (the PHI read-access-logging context default); and `identityProjectionClaims` (requires the platform provisioning capability on top of the ordinary scope below — see its own field description). Requires the `app-contexts:u` scope.
+   * Updates an app context. This is a partial update: any field you omit (or send as null) keeps its existing value. The `contextId` is immutable and is taken from the URL path, so any `contextId` in the request body is ignored. Patchable fields: `name`, `description`, `companyName`; the per-principal metering trio (`meteringAxis`, `principalBurstLimit`, `principalUsageCap` — only takes effect for an account with the corresponding feature enabled); `readAccessLogDefault` (the PHI read-access-logging context default); and `identityProjectionClaims` (requires the platform provisioning capability on top of the ordinary scope below — see its own field description). Requires the `app-contexts:u` scope.
    *
    * @param {Vectros.UpdateAppContextRequest} request
    * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
    *
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
    *     await client.auth.updateAppContext({
    *         contextId: "contextId",
-   *         body: {
-   *             contextId: "myapp",
-   *             name: "My Internal App"
-   *         }
+   *         body: {}
    *     })
    */
   updateAppContext(request, requestOptions) {
@@ -3613,6 +4291,8 @@ var AuthClient = class {
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -3769,19 +4449,14 @@ var AuthClient = class {
    *
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
    *     await client.auth.updateRole({
    *         contextId: "contextId",
    *         roleId: "roleId",
-   *         body: {
-   *             roleId: "engineering-member",
-   *             name: "Engineering Team Member",
-   *             scopes: [{
-   *                     allowed_actions: ["records:cru", "search:r"]
-   *                 }]
-   *         }
+   *         body: {}
    *     })
    */
   updateRole(request, requestOptions) {
@@ -3821,6 +4496,8 @@ var AuthClient = class {
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -3846,6 +4523,7 @@ var AuthClient = class {
    *
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -3888,6 +4566,8 @@ var AuthClient = class {
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -4169,6 +4849,7 @@ var AuthClient = class {
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -4215,6 +4896,8 @@ var AuthClient = class {
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -4228,7 +4911,7 @@ var AuthClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "PUT", "/v1/auth/issuers/{issuerId}");
   }
   /**
-   * Deregisters a trusted third-party IdP issuer. Requires a root API key or the bootstrap's provisioning capability. A credential confined to one app context may only deregister an issuer registered in that context; naming one registered in another context returns 404, identically to a nonexistent issuerId. A root API key may deregister any issuer. Refused if any user account was ever created or matched via this issuer (by a prior self-signup or accepted invite, through `POST /v1/auth/token/exchange`) — that access cannot be silently orphaned. This is unconditional on the affected users' `status`: suspending them first does not lift the refusal. **A bound registration cannot be replaced, self-service, within its own app context**: registering a replacement issuer under a different issuerId in the SAME context also fails, because the context's one-active-issuer claim is released only when THIS registration is deleted. Two real options: suspend this issuer (stops new exchanges immediately) and register a replacement under a DIFFERENT app context — note that targets a different context, so this context's existing users/roles/access profiles are not carried over; or contact your platform operator, who can force-release this registration so a replacement may be registered in the SAME context under a new issuerId. **The operator path is not a lighter-weight alternative to the first — it PERMANENTLY RETIRES this issuerId and leaves every bound user unable to ever exchange through it again; it does not preserve continuity for them any better than registering under a different context does.** An issuer that has never been used for an exchange (no bound users yet) can always be deregistered.
+   * Deregisters a trusted third-party IdP issuer. Requires a root API key or the bootstrap's provisioning capability. A credential confined to one app context may only deregister an issuer registered in that context; naming one registered in another context returns 404, identically to a nonexistent issuerId. A root API key may deregister any issuer. Refused if any user account was ever created or matched via this issuer (by a prior self-signup or accepted invite, through `POST /v1/auth/token/exchange`) — that access cannot be silently orphaned. This is unconditional on the affected users' `status`: suspending them first does not lift the refusal. **A bound registration cannot be replaced, self-service, within its own app context**: registering a replacement issuer under a different issuerId in the SAME context also fails, because the context's one-active-issuer claim is released only when THIS registration is deleted. Two real options: suspend this issuer (stops new exchanges immediately) and register a replacement under a DIFFERENT app context — note that targets a different context, so this context's existing users/roles/access profiles are not carried over; or contact support, who can force-release this registration so a replacement may be registered in the SAME context under a new issuerId. **The support path is not a lighter-weight alternative to the first — it PERMANENTLY RETIRES this issuerId and leaves every bound user unable to ever exchange through it again; it does not preserve continuity for them any better than registering under a different context does.** An issuer that has never been used for an exchange (no bound users yet) can always be deregistered.
    *
    * @param {Vectros.DeleteIssuerRequest} request
    * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -4354,7 +5037,7 @@ var AuthClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/auth/issuers");
   }
   /**
-   * Registers a trusted third-party IdP issuer that BYO-IdP token exchange (`POST /v1/auth/token/exchange`) may accept a `subject_token` from. Requires a root API key or the CLI bootstrap's provisioning capability — never an ordinary partner-grantable scope. A credential authorized only via the provisioning capability may register only against the app context it is bound to; naming a different one returns 403. A root API key is unaffected and may register against any of its contexts. A registration without `restrictedToDomain` is created `pending_verification` with a one-time challenge (`verificationClaim`, `verificationNonce`, `verificationExpiresAt`) and accepts no token until you prove you control the issuer with `POST /v1/auth/issuers/{issuerId}/verify`; it claims no `(issuer, audience)` pair until then, so registering never reveals whether another tenant holds one. A registration scoped to an already-verified domain with `restrictedToDomain` is `active` at once. Idempotent by `issuerId` within your tenant. If `issuerId` collides with a registration owned by a different app context than the one you're confined to, the request fails with 400 rather than returning that context's configuration. An app context may have at most one active issuer — deregister the existing one first if you need to replace it. One issuer MAY serve several contexts today, each via its own registration row with a distinct `audience`. Optionally name `restrictedToDomain` to scope this registration's (issuer, audience) uniqueness to a specific VERIFIED domain rather than the bare pair — see that field's own description. A domain-scoped registration proves control of the DOMAIN, not of the issuer itself: it routes only tokens carrying that domain's `hd` claim.
+   * Registers a trusted third-party IdP issuer that BYO-IdP token exchange (`POST /v1/auth/token/exchange`) may accept a `subject_token` from. Requires a root API key or the CLI bootstrap's provisioning capability — never an ordinary grantable scope. A credential authorized only via the provisioning capability may register only against the app context it is bound to; naming a different one returns 403. A root API key is unaffected and may register against any of its contexts. A registration without `restrictedToDomain` is created `pending_verification` with a one-time challenge (`verificationClaim`, `verificationNonce`, `verificationExpiresAt`) and accepts no token until you prove you control the issuer with `POST /v1/auth/issuers/{issuerId}/verify`; it claims no `(issuer, audience)` pair until then, so registering never reveals whether another tenant holds one. A registration scoped to an already-verified domain with `restrictedToDomain` is `active` at once. Idempotent by `issuerId` within your tenant. If `issuerId` collides with a registration owned by a different app context than the one you're confined to, the request fails with 400 rather than returning that context's configuration. An app context may have at most one active issuer — deregister the existing one first if you need to replace it. One issuer MAY serve several contexts, each via its own registration row with a distinct `audience`. Optionally name `restrictedToDomain` to scope this registration's (issuer, audience) uniqueness to a specific VERIFIED domain rather than the bare pair — see that field's own description. A domain-scoped registration proves control of the DOMAIN, not of the issuer itself: it routes only tokens carrying that domain's `hd` claim.
    *
    * @param {Vectros.IssuerRequest} request
    * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -4763,6 +5446,7 @@ var AuthClient = class {
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -4810,6 +5494,8 @@ var AuthClient = class {
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -4909,6 +5595,7 @@ var AuthClient = class {
    * @throws {@link Vectros.UnauthorizedError}
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ContentTooLargeError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -4953,6 +5640,8 @@ var AuthClient = class {
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 413:
+          throw new ContentTooLargeError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -5092,7 +5781,7 @@ var ComplianceClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/erasure-requests/{id}");
   }
   /**
-   * Submits an asynchronous job to export your account's data, or a single end-subject's data, across the requested contexts. The request returns 202 with an `exportJobId`; poll `GET /v1/admin/export/{id}` until the job completes to obtain a short-lived presigned download URL and a manifest describing the payload. Requires a root API key — a scoped credential is rejected with 403.
+   * Reserved: with a root API key this operation answers `501` and starts no job. The request and response shapes are published so that integrations can be written against them: a request names the contexts, or a single end-subject, to export, and the response carries an `exportJobId` that `GET /v1/admin/export/{id}` reports on. Requires a root API key — a scoped credential is rejected with 403.
    *
    * @param {Vectros.ExportRequest} request
    * @param {ComplianceClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -5153,7 +5842,7 @@ var ComplianceClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/admin/export");
   }
   /**
-   * Polls an export job by id. While the job is still running this returns its status only; once it completes, the response also includes a short-lived presigned download URL and a manifest (format version and per-context counts). Requires a root API key.
+   * Reserved: with a root API key this operation answers `501`. Its response shape is the one the export operation above refers to: the job status, and a short-lived presigned download URL and a manifest (format version and per-context counts) for a completed job. Requires a root API key.
    *
    * @param {Vectros.GetExportRequest} request
    * @param {ComplianceClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -5219,7 +5908,7 @@ var DocumentsClient = class {
     this._options = normalizeClientOptionsWithAuth(options);
   }
   /**
-   * Returns a paginated list of your documents, optionally filtered by folder (`folderId`) and/or owner (`userId` or `scope`). The response is a `{data, nextCursor}` envelope; pass `nextCursor` back as `startFrom` to fetch the next page. Requires the `documents:r` scope.
+   * Returns a paginated list of your documents, optionally filtered by folder (`folderId`), owner (`userId` or `scope`) and/or type (`type`). The response is a `{data, nextCursor}` envelope; pass `nextCursor` back as `startFrom` to fetch the next page. A page can hold fewer documents than `limit`, or none, while `nextCursor` is still set: keep paging until `nextCursor` is null. Requires the `documents:r` scope.
    *
    * @param {Vectros.ListDocumentsRequest} request
    * @param {DocumentsClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -5229,6 +5918,7 @@ var DocumentsClient = class {
    *         userId: "550e8400-e29b-41d4-a716-446655440000",
    *         scope: "group:eng-team",
    *         folderId: "f47ac10b-58cc-4372-a567-0e02b2c3d479",
+   *         type: "investigation_report",
    *         startFrom: "b3BhcXVlLWN1cnNvci1mcm9tLXRoZS1wcmV2aW91cy1wYWdl"
    *     })
    */
@@ -5236,11 +5926,12 @@ var DocumentsClient = class {
     return HttpResponsePromise.fromPromise(this.__listDocuments(request, requestOptions));
   }
   async __listDocuments(request = {}, requestOptions) {
-    const { userId, scope, folderId, startFrom, limit } = request;
+    const { userId, scope, folderId, type: type_, startFrom, limit } = request;
     const _queryParams = {
       userId,
       scope,
       folderId,
+      type: type_,
       startFrom,
       limit
     };
@@ -5284,13 +5975,13 @@ var DocumentsClient = class {
    *
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
    *     await client.documents.ingestDocument({
-   *         body: {
-   *             title: "Patient Intake Form \u2014 Jane Doe"
-   *         }
+   *         body: {}
    *     })
    */
   ingestDocument(request, requestOptions) {
@@ -5335,6 +6026,10 @@ var DocumentsClient = class {
           throw new BadRequestError(_response.error.body, _response.rawResponse);
         case 403:
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -5416,9 +6111,7 @@ var DocumentsClient = class {
    * @example
    *     await client.documents.updateDocument({
    *         id: "id",
-   *         body: {
-   *             title: "Patient Intake Form \u2014 Jane Doe"
-   *         }
+   *         body: {}
    *     })
    */
   updateDocument(request, requestOptions) {
@@ -5482,6 +6175,7 @@ var DocumentsClient = class {
    * @param {DocumentsClient.RequestOptions} requestOptions - Request-specific configuration.
    *
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -5521,6 +6215,8 @@ var DocumentsClient = class {
       switch (_response.error.statusCode) {
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -5813,11 +6509,12 @@ var DocumentsClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/documents/{id}/download");
   }
   /**
-   * Returns the document's full text body when it is retained: always available for text-ingested documents, and for file-uploaded documents unless they were uploaded with `storeText=false` (which discards the extracted text once indexing completes — the original file remains available via `GET /{id}/download`). Returns 404 when the document does not exist, its text was not retained, or extraction has not yet completed. Requires the `documents:r` scope.
+   * Returns the document's full text body when it is retained: retained for text-ingested documents, and for file-uploaded documents unless they were uploaded with `storeText=false` (which discards the extracted text once indexing completes — the original file remains available via `GET /v1/documents/{id}/download`). Returns 404 when the document does not exist, its text was not retained, extraction has not yet completed, or no text could be extracted from its file (see the document's `extraction`). To read a long text in parts, pass `limit` (and `offset` from the second part on): offsets and lengths count Unicode characters (code points), `totalLength` is the length of the whole text, and `nextOffset` is where the next part starts, absent once the end is reached. Requires the `documents:r` scope.
    *
    * @param {Vectros.GetDocumentTextRequest} request
    * @param {DocumentsClient.RequestOptions} requestOptions - Request-specific configuration.
    *
+   * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.NotFoundError}
    *
    * @example
@@ -5829,7 +6526,11 @@ var DocumentsClient = class {
     return HttpResponsePromise.fromPromise(this.__getDocumentText(request, requestOptions));
   }
   async __getDocumentText(request, requestOptions) {
-    const { id } = request;
+    const { id, offset, limit } = request;
+    const _queryParams = {
+      offset,
+      limit
+    };
     const _authRequest = await this._options.authProvider.getAuthRequest();
     const _headers = mergeHeaders(
       _authRequest.headers,
@@ -5843,7 +6544,7 @@ var DocumentsClient = class {
       ),
       method: "GET",
       headers: _headers,
-      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      queryString: url_exports.queryBuilder().addMany(_queryParams).mergeAdditional(requestOptions?.queryParams).build(),
       timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1e3,
       maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
       abortSignal: requestOptions?.abortSignal,
@@ -5855,6 +6556,8 @@ var DocumentsClient = class {
     }
     if (_response.error.reason === "status-code") {
       switch (_response.error.statusCode) {
+        case 400:
+          throw new BadRequestError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
         default:
@@ -5933,6 +6636,7 @@ var DocumentsClient = class {
    *
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -5982,6 +6686,8 @@ var DocumentsClient = class {
           throw new BadRequestError(_response.error.body, _response.rawResponse);
         case 403:
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -6065,13 +6771,13 @@ var FoldersClient = class {
    *
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
    *     await client.folders.createFolder({
-   *         body: {
-   *             name: "Patient Records 2024"
-   *         }
+   *         body: {}
    *     })
    */
   createFolder(request, requestOptions) {
@@ -6114,6 +6820,10 @@ var FoldersClient = class {
           throw new BadRequestError(_response.error.body, _response.rawResponse);
         case 403:
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -6189,14 +6899,13 @@ var FoldersClient = class {
    *
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
    *     await client.folders.updateFolder({
    *         id: "id",
-   *         body: {
-   *             name: "Patient Records 2024"
-   *         }
+   *         body: {}
    *     })
    */
   updateFolder(request, requestOptions) {
@@ -6236,6 +6945,8 @@ var FoldersClient = class {
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -6256,6 +6967,7 @@ var FoldersClient = class {
    *
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -6297,6 +7009,8 @@ var FoldersClient = class {
           throw new BadRequestError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -6310,7 +7024,7 @@ var FoldersClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "DELETE", "/v1/folders/{id}");
   }
   /**
-   * Partially updates a folder using an RFC 7386 JSON Merge Patch. The `name`, `description`, and ownership fields (`userId`, `scopes`) are applied when present and left unchanged when omitted; sending any of these as null is rejected, because clearing a field is not supported in this release (omit it instead). `slug` and `parentFolderId` are immutable — a folder cannot be re-slugged or moved via the API — and the request is rejected if either is present. Pass `expectedVersion` for optimistic concurrency (you get a 409 if the folder changed since you last read it). Requires the `folders:u` scope.
+   * Partially updates a folder using an RFC 7386 JSON Merge Patch. The `name`, `description`, and ownership fields (`userId`, `scopes`) are applied when present and left unchanged when omitted; sending any of these as null is rejected, because clearing a field is not supported (omit it instead). `slug` and `parentFolderId` are immutable — a folder cannot be re-slugged or moved via the API — and the request is rejected if either is present. Pass `expectedVersion` for optimistic concurrency (you get a 409 if the folder changed since you last read it). Requires the `folders:u` scope.
    *
    * @param {Vectros.PatchFolderRequest} request
    * @param {FoldersClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -6324,9 +7038,7 @@ var FoldersClient = class {
    * @example
    *     await client.folders.patchFolder({
    *         id: "id",
-   *         body: {
-   *             name: "Patient Records 2024"
-   *         }
+   *         body: {}
    *     })
    */
   patchFolder(request, requestOptions) {
@@ -6533,15 +7245,15 @@ var IdentityClient = class {
    *
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
    *     await client.identity.createEntity({
    *         namespace: "team",
    *         contextId: "myapp",
-   *         body: {
-   *             externalId: "team_eng_platform"
-   *         }
+   *         body: {}
    *     })
    */
   createEntity(request, requestOptions) {
@@ -6585,6 +7297,10 @@ var IdentityClient = class {
           throw new BadRequestError(_response.error.body, _response.rawResponse);
         case 403:
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -6665,6 +7381,7 @@ var IdentityClient = class {
    *
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -6672,9 +7389,7 @@ var IdentityClient = class {
    *         namespace: "team",
    *         id: "id",
    *         contextId: "myapp",
-   *         body: {
-   *             externalId: "team_eng_platform"
-   *         }
+   *         body: {}
    *     })
    */
   updateEntity(request, requestOptions) {
@@ -6717,6 +7432,8 @@ var IdentityClient = class {
           throw new BadRequestError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -6736,6 +7453,7 @@ var IdentityClient = class {
    * @param {IdentityClient.RequestOptions} requestOptions - Request-specific configuration.
    *
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -6780,6 +7498,8 @@ var IdentityClient = class {
       switch (_response.error.statusCode) {
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -7003,15 +7723,13 @@ var IdentityClient = class {
    *
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
    *     await client.identity.updateNamespace({
    *         namespace: "team",
-   *         body: {
-   *             namespace: "team",
-   *             specificityRank: 1500
-   *         }
+   *         body: {}
    *     })
    */
   updateNamespace(request, requestOptions) {
@@ -7054,6 +7772,8 @@ var IdentityClient = class {
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -7074,6 +7794,7 @@ var IdentityClient = class {
    *
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -7118,6 +7839,8 @@ var IdentityClient = class {
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -7182,7 +7905,7 @@ var IdentityClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/namespaces");
   }
   /**
-   * Registers a new scope namespace and declares whether its values resolve to identity entities (`entityBacked`). Also requires `specificityRank`, an explicit, account-unique position in the specificity order used to break recordType schema-resolution ties. Requires a root API key or one of the CLI bootstrap's two provisioning capabilities — never an ordinary partner-grantable scope. A bootstrap credential's registration is confined to its own app context UNLESS it additionally holds the tenant-wide namespace-provisioning capability and `contextId` is omitted, in which case it may register a TENANT-WIDE namespace (visible to every context). `org` and `client` are reserved names, registered the same way as any other namespace.
+   * Registers a new scope namespace and declares whether its values resolve to identity entities (`entityBacked`). Also requires `specificityRank`, an explicit, account-unique position in the specificity order used to break recordType schema-resolution ties. Requires a root API key or one of the CLI bootstrap's two provisioning capabilities — never an ordinary grantable scope. A bootstrap credential's registration is confined to its own app context UNLESS it additionally holds the tenant-wide namespace-provisioning capability and `contextId` is omitted, in which case it may register a TENANT-WIDE namespace (visible to every context). `org` and `client` are reserved names, registered the same way as any other namespace.
    *
    * @param {Vectros.RegisterNamespaceRequest} request
    * @param {IdentityClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -7193,10 +7916,7 @@ var IdentityClient = class {
    *
    * @example
    *     await client.identity.registerNamespace({
-   *         body: {
-   *             namespace: "team",
-   *             specificityRank: 1500
-   *         }
+   *         body: {}
    *     })
    */
   registerNamespace(request, requestOptions) {
@@ -7324,13 +8044,12 @@ var IdentityClient = class {
    *
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
    *     await client.identity.createUser({
-   *         body: {
-   *             externalId: "usr_12345"
-   *         }
+   *         body: {}
    *     })
    */
   createUser(request, requestOptions) {
@@ -7373,6 +8092,8 @@ var IdentityClient = class {
           throw new BadRequestError(_response.error.body, _response.rawResponse);
         case 403:
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -7441,21 +8162,21 @@ var IdentityClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/users/{id}");
   }
   /**
-   * Updates mutable fields on an existing user (such as email, status, payload, or schema binding). The `type` field is immutable after creation, and `email` cannot be changed while an invitation to that user is still outstanding — revoke the invitation, or invite the new address instead. This endpoint also activates an invited user: a PUT that moves a PENDING user to ACTIVE and carries `inviteToken`, `externalSubject`, and `emailVerifiedAttestation=true` completes the invitation. **`externalSubject` set this way is NOT an authentication binding and does not enable sign-in anywhere** — not the Vectros DevPortal/Admin App/web apps, and not `/v1/auth/token/exchange` either; both are granted only by the invitee authenticating themselves. If the invitee needs dev-portal/web-app access, send them the invitation link and let them accept it directly. If the invitee needs to sign in via token exchange, have them redeem `inviteToken` themselves at `/v1/auth/token/exchange` with their own credential — Vectros verifies it there and computes its own value for this field from the verified credential. The value you send here is stored exactly as-is, with no normalization, and does NOT automatically match or deduplicate against what a later token-exchange sign-in computes for the same real-world identity. Call this endpoint directly only if you run your own backend and want Vectros to record which of your own users a given account corresponds to — treat this field as informational for that purpose, not as a way to pre-authorize sign-in. Requires the `users:u` scope.
+   * Updates mutable fields on an existing user (such as email, status, payload, or schema binding). The `type` field is immutable after creation, and `email` cannot be changed while an invitation to that user is still outstanding — revoke the invitation, or invite the new address instead. This endpoint also activates an invited user: a PUT that moves a PENDING user to ACTIVE and carries `inviteToken`, `externalSubject`, and `emailVerifiedAttestation=true` completes the invitation. **`externalSubject` set this way is NOT an authentication binding and does not enable sign-in anywhere** — not the Vectros DevPortal/Admin App/web apps, and not `/v1/auth/token/exchange` either; both are granted only by the invitee authenticating themselves. A subject stored through `PUT /v1/users/{id}` does not make the person a member of your account: it is ignored for the tenant claims in sign-in tokens, the developer portal's memberships list and tenant switching, and an ownership transfer. To give such a person access, delete the user and invite them again; accepting the invitation binds the subject and counts it. If the invitee needs dev-portal/web-app access, send them the invitation link and let them accept it directly. If the invitee needs to sign in via token exchange, have them redeem `inviteToken` themselves at `/v1/auth/token/exchange` with their own credential — Vectros verifies it there and computes its own value for this field from the verified credential. The value you send here is stored exactly as-is, with no normalization, and does NOT automatically match or deduplicate against what a later token-exchange sign-in computes for the same real-world identity. Call this endpoint directly only if you run your own backend and want Vectros to record which of your own users a given account corresponds to — treat this field as informational for that purpose, not as a way to pre-authorize sign-in. Requires the `users:u` scope.
    *
    * @param {Vectros.UpdateUserRequest} request
    * @param {IdentityClient.RequestOptions} requestOptions - Request-specific configuration.
    *
    * @throws {@link Vectros.BadRequestError}
+   * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
    *     await client.identity.updateUser({
    *         id: "550e8400-e29b-41d4-a716-446655440000",
-   *         body: {
-   *             externalId: "usr_12345"
-   *         }
+   *         body: {}
    *     })
    */
   updateUser(request, requestOptions) {
@@ -7493,8 +8214,12 @@ var IdentityClient = class {
       switch (_response.error.statusCode) {
         case 400:
           throw new BadRequestError(_response.error.body, _response.rawResponse);
+        case 403:
+          throw new ForbiddenError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -7513,6 +8238,7 @@ var IdentityClient = class {
    * @param {Vectros.DeleteUserRequest} request
    * @param {IdentityClient.RequestOptions} requestOptions - Request-specific configuration.
    *
+   * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
    * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
@@ -7552,6 +8278,8 @@ var IdentityClient = class {
     }
     if (_response.error.reason === "status-code") {
       switch (_response.error.statusCode) {
+        case 403:
+          throw new ForbiddenError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
         case 409:
@@ -7756,7 +8484,7 @@ var InferenceClient = class {
     this._options = normalizeClientOptionsWithAuth(options);
   }
   /**
-   * Returns every inference model available to you, including each model's context window, the plan tiers it's available on, and the exact credit rates charged per 1K input and output tokens. Use this to populate model pickers and to validate a request before calling `/v1/chat`, `/v1/rag`, or `/v1/documents/{id}/ask`.
+   * Returns the whole platform model catalog, whatever your plan: `availableOn` names each model's plan tiers. Each entry also carries the context window and the credit rates per 1K input and output tokens: `regionPricing.base` for global-region requests, `regionPricing.us` for default requests, `longContext` for prompts over its threshold, and `cachePricing` for prompt-cache tokens on a model that has cache prices. A model reached through a `providerAlias` is not listed. Use this to populate model pickers and to validate a request before calling `/v1/chat`, `/v1/rag`, or `/v1/documents/{id}/ask`.
    *
    * @param {InferenceClient.RequestOptions} requestOptions - Request-specific configuration.
    *
@@ -7800,7 +8528,7 @@ var InferenceClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/models");
   }
   /**
-   * Streams a model response as Server-Sent Events (SSE). Send the full conversation history in the `messages` array; a message with role `system` is extracted and used as the system prompt. Token cost is debited from your pre-paid inference balance (in cents), and a small per-call flat fee is debited from your monthly platform credit allowance. Requires the `inference:r` scope.
+   * Streams a model response as Server-Sent Events (SSE). Send the full conversation history in the `messages` array; a message with role `system` is extracted and used as the system prompt. On a pre-paid account, token cost is debited from your inference balance; usage-billed accounts accrue it for post-billing. A request routed through your own `providerAlias` incurs no Vectros token cost. A per-call platform fee is charged to your monthly credit allowance, except when the call fails on the server side: 0.2 credits for a call of up to 60 seconds, then 1 credit per 5 minutes of the call's duration. Requires the `inference:r` scope.
    */
   chatInference(request, requestOptions) {
     return HttpResponsePromise.fromPromise(this.__chatInference(request, requestOptions));
@@ -7853,10 +8581,14 @@ var InferenceClient = class {
           throw new PaymentRequiredError(_response.error.body, _response.rawResponse);
         case 403:
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
         case 413:
           throw new ContentTooLargeError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
+        case 503:
+          throw new ServiceUnavailableError(_response.error.body, _response.rawResponse);
         default:
           throw new VectrosError({
             statusCode: _response.error.statusCode,
@@ -7868,7 +8600,7 @@ var InferenceClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/chat");
   }
   /**
-   * Loads a single document's extracted text, supplies it as context, and streams a model answer about it. The document must be fully indexed. If the document exceeds the 32K-token cap, the call returns 413 with no credits charged — use `POST /v1/rag` instead to answer over larger or multi-document collections. Requires the `inference:r` scope.
+   * Loads a single document's extracted text, supplies it as context, and streams a model answer about it. The document must have finished processing and have text. If the document exceeds the 32K-token cap, the call returns 413 with no credits charged — use `POST /v1/rag` instead to answer over larger or multi-document collections. Requires the `inference:r` scope.
    */
   documentAsk(request, requestOptions) {
     return HttpResponsePromise.fromPromise(this.__documentAsk(request, requestOptions));
@@ -7930,6 +8662,8 @@ var InferenceClient = class {
           throw new ContentTooLargeError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
+        case 503:
+          throw new ServiceUnavailableError(_response.error.body, _response.rawResponse);
         default:
           throw new VectrosError({
             statusCode: _response.error.statusCode,
@@ -7994,12 +8728,16 @@ var InferenceClient = class {
           throw new PaymentRequiredError(_response.error.body, _response.rawResponse);
         case 403:
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
         case 413:
           throw new ContentTooLargeError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         case 500:
           throw new InternalServerError(_response.error.body, _response.rawResponse);
+        case 503:
+          throw new ServiceUnavailableError(_response.error.body, _response.rawResponse);
         default:
           throw new VectrosError({
             statusCode: _response.error.statusCode,
@@ -8077,7 +8815,7 @@ var RecordsClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/records/batch-get");
   }
   /**
-   * Reserved endpoint for batch lookup and reference resolution. The published response shape correlates results to each input and carries a per-item status envelope. It currently returns 501 (not implemented). The documented 200 response schema is the stable shape this endpoint will use once available. Requires the `records:r` scope.
+   * Reserved endpoint for batch lookup and reference resolution. With the `records:r` scope it answers 501 (not implemented). The published response shape correlates results to each input and carries a per-item status envelope. Requires the `records:r` scope.
    *
    * @param {Vectros.BatchLookupRequest} request
    * @param {RecordsClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -8138,7 +8876,7 @@ var RecordsClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/records/lookup/batch");
   }
   /**
-   * Writes up to 50 records (or 50 with `atomicity: all_or_nothing`) in a single request. Each item in `items` has exactly the same shape, and goes through exactly the same validation, authorization and idempotency rules, as the body of a single `POST /v1/records` — including schema validation, `externalId` idempotency, unique-field enforcement, and the `records:c:<type>` scope check, which is applied per item against that item's own record type. A batch is not a way to write a type your credential could not write one at a time.
+   * Writes up to 50 records per request in `best_effort` mode and up to 50 with `atomicity: all_or_nothing`, in a single request. Each item in `items` has exactly the same shape, and goes through exactly the same validation, authorization and idempotency rules, as the body of a single `POST /v1/records` — including schema validation, `externalId` idempotency, unique-field enforcement, and the `records:c:<type>` scope check, which is applied per item against that item's own record type. A batch is not a way to write a type your credential could not write one at a time.
    *
    * `atomicity` selects how the batch commits. `best_effort` (the default) writes each item independently: some can succeed while others fail, and each item's own outcome is reported. `all_or_nothing` commits every item in one transaction — if any item fails, no record is created or updated at all, and every item that was itself fine reports `not_committed` while the ones that failed report why. Because the transaction is bounded by the number of underlying storage rows rather than by the number of records, a large `all_or_nothing` batch can be refused as too large to commit atomically even when it is within the item limit; the error says so, and nothing is written when it happens.
    *
@@ -8277,6 +9015,8 @@ var RecordsClient = class {
    *
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -8333,6 +9073,10 @@ var RecordsClient = class {
           throw new BadRequestError(_response.error.body, _response.rawResponse);
         case 403:
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -8481,6 +9225,7 @@ var RecordsClient = class {
    * @param {RecordsClient.RequestOptions} requestOptions - Request-specific configuration.
    *
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -8520,6 +9265,8 @@ var RecordsClient = class {
       switch (_response.error.statusCode) {
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -8533,7 +9280,7 @@ var RecordsClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "DELETE", "/v1/records/{id}");
   }
   /**
-   * Partially updates a record using an RFC 7386 JSON Merge Patch. The `payload` object is deep-merged into the existing payload: keys you send overwrite (recursing into nested objects), a key set to null is deleted, and keys you omit are left unchanged — so you can change a single field without re-sending the rest (unlike the full-replacement PUT). Top-level fields (`status`, `folderId`, `userId`, `scopes`) are set when present and left unchanged when omitted; sending a top-level field as null is rejected (clearing a top-level field is not supported in this release — omit it instead). `typeName`, `schemaId`, `externalId`, and `indexMode` are immutable and rejected if present. The merged result is validated against the schema. Pass `expectedVersion` to make the patch conditional (optimistic concurrency, 409 on conflict). Requires the `records:u:<type>` scope.
+   * Partially updates a record using an RFC 7386 JSON Merge Patch. The `payload` object is deep-merged into the existing payload: keys you send overwrite (recursing into nested objects), a key set to null is deleted, and keys you omit are left unchanged — so you can change a single field without re-sending the rest (unlike the full-replacement PUT). Top-level fields (`status`, `folderId`, `userId`, `scopes`) are set when present and left unchanged when omitted; sending a top-level field as null is rejected (clearing a top-level field is not supported — omit it instead). `typeName`, `schemaId`, `externalId`, and `indexMode` are immutable and rejected if present. The merged result is validated against the schema. Pass `expectedVersion` to make the patch conditional (optimistic concurrency, 409 on conflict). Requires the `records:u:<type>` scope.
    *
    * @param {Vectros.PatchRecordRequest} request
    * @param {RecordsClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -8962,6 +9709,8 @@ var SchemasClient = class {
    *
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -8986,8 +9735,7 @@ var SchemasClient = class {
    *                 }],
    *             capabilities: {
    *                 "auditHistory": true
-   *             },
-   *             allowedSurfaces: ["record"]
+   *             }
    *         }
    *     })
    */
@@ -9031,6 +9779,10 @@ var SchemasClient = class {
           throw new BadRequestError(_response.error.body, _response.rawResponse);
         case 403:
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -9113,11 +9865,7 @@ var SchemasClient = class {
    * @example
    *     await client.schemas.updateSchema({
    *         id: "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
-   *         body: {
-   *             typeName: "intake_form",
-   *             displayName: "Client Intake Form",
-   *             allowedSurfaces: ["record"]
-   *         }
+   *         body: {}
    *     })
    */
   updateSchema(request, requestOptions) {
@@ -9174,7 +9922,7 @@ var SchemasClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "PUT", "/v1/schemas/{id}");
   }
   /**
-   * Permanently deletes a record schema. The request is refused with 409 if records of this type still exist — delete those records first, since every record must reference a live schema. The same applies to documents bound to this schema (for a schema declaring the `document` surface) — delete those documents first. A lineage base (a schema other schemas declare `basedOn`) also cannot be deleted while any such variant still exists — delete the variant schema(s) first. It is likewise refused while any trigger rule fires off this schema — delete those trigger rules first. Requires the `schemas:d` scope.
+   * Permanently deletes a record schema. The request is refused with 409 if records of this type still exist — delete those records first, since every record must reference a live schema. The same applies to documents bound to this schema (for a schema declaring the `document` surface) — delete those documents first. A lineage base (a schema other schemas declare `basedOn`) also cannot be deleted while any such variant still exists — delete the variant schema(s) first. It is likewise refused while any trigger rule fires off this schema — delete those trigger rules first — and, for a schema declaring the `user` or `entity` surface, while any user or entity bound to it still exists. Requires the `schemas:d` scope.
    *
    * @param {Vectros.DeleteSchemaRequest} request
    * @param {SchemasClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -9301,7 +10049,7 @@ var ScriptsClient = class {
     this._options = normalizeClientOptionsWithAuth(options);
   }
   /**
-   * Runs a script you previously pushed to `POST /v1/scripts`, under your own credential, and returns what it returned. Every write the script makes is buffered and committed as ONE transaction after the script finishes: either all of them land or none do, and the response is sent only after they have committed — so everything in `result` is committed state or the script's own computation over it. On any failure the body is the standard error envelope and nothing the script staged is committed: its rows are written only when the transaction commits, and a document body or a large payload is DECIDED at that point and WRITTEN to storage only after the commit, so an aborted execution leaves nothing behind. The one residual sits after a successful commit, outside this response: if storing a body fails then, the row exists and the body does not until the platform's repair lands — so a `200` guarantees the rows, and a document's text should be read before it is relied on.
+   * Runs a script you previously pushed to `POST /v1/scripts`, under your own credential, and returns what it returned. Every write the script makes is buffered and committed as ONE transaction after the script finishes: either all of them land or none do, and the response is sent only after they have committed — so everything in `result` is committed state or the script's own computation over it. On any failure the body is the standard error envelope and nothing the script staged is committed: its rows are written only when the transaction commits, and a document body or a large payload is DECIDED at that point and WRITTEN to storage only after the commit, so an aborted execution leaves nothing behind. The one residual sits after a successful commit, outside this response: if storing a body fails then, the row exists and the body may not — so a `200` guarantees the rows, and a document's text should be read before it is relied on.
    *
    * **Permission.** Requires the `scripts:x` scope — the permission to *execute* — separate from the `scripts:c` permission to push scripts. Bare `scripts:x` grants every script in the context; `scripts:x:<name>` grants exactly that script name, every version of it. Execution discloses no source, so `scripts:r` is not needed. Inside the script, every read and write is enforced by your credential's data scopes exactly as the equivalent REST call would be — `scripts:x` alone can read and write nothing.
    *
@@ -9657,7 +10405,7 @@ var ScriptsClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "PUT", "/v1/scripts/{id}");
   }
   /**
-   * Permanently deletes one script version by ID. Deleting one version does not affect any other version of the same name. Requires the `scripts:d` scope. Refused with 409 if a live trigger rule still references this version — either directly (a pinned `scriptRef`), or via `"latest"` when this IS the newest version of its name. Delete or re-point those rules first.
+   * Permanently deletes one script version by ID. Deleting one version does not affect any other version of the same name. Requires the `scripts:d` scope. Refused with 409 if a live trigger rule still references this version — either directly (a pinned `scriptRef`), or via `"latest"` when this IS the newest version of its name. Delete or re-point those rules first. Also refused with a retryable 409, deleting nothing, when it cannot be told yet whether this is the newest version (for example just after several of this name's newest versions were deleted, or while its first version is gone and the listing has not caught up) and a `"latest"` rule depends on the script: try again shortly.
    *
    * @param {Vectros.DeleteScriptRequest} request
    * @param {ScriptsClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -9915,21 +10663,13 @@ var TriggersClient = class {
    *
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
    *     await client.triggers.createTrigger({
-   *         body: {
-   *             name: "on-intake-create",
-   *             firingSource: {
-   *                 schemaId: "sch_9f8e7d6c",
-   *                 event: "CREATE"
-   *             },
-   *             scriptRef: {
-   *                 name: "notify-assignee",
-   *                 version: "3"
-   *             }
-   *         }
+   *         body: {}
    *     })
    */
   createTrigger(request, requestOptions) {
@@ -9972,6 +10712,10 @@ var TriggersClient = class {
           throw new BadRequestError(_response.error.body, _response.rawResponse);
         case 403:
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -10048,22 +10792,13 @@ var TriggersClient = class {
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
    *     await client.triggers.updateTrigger({
    *         id: "id",
-   *         body: {
-   *             name: "on-intake-create",
-   *             firingSource: {
-   *                 schemaId: "sch_9f8e7d6c",
-   *                 event: "CREATE"
-   *             },
-   *             scriptRef: {
-   *                 name: "notify-assignee",
-   *                 version: "3"
-   *             }
-   *         }
+   *         body: {}
    *     })
    */
   updateTrigger(request, requestOptions) {
@@ -10105,6 +10840,8 @@ var TriggersClient = class {
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -10124,6 +10861,7 @@ var TriggersClient = class {
    * @param {TriggersClient.RequestOptions} requestOptions - Request-specific configuration.
    *
    * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -10163,6 +10901,8 @@ var TriggersClient = class {
       switch (_response.error.statusCode) {
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
+        case 409:
+          throw new ConflictError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -10183,6 +10923,9 @@ var VectrosClient = class {
   get auth() {
     return this._auth ?? (this._auth = new AuthClient(this._options));
   }
+  get agents() {
+    return this._agents ?? (this._agents = new AgentsClient(this._options));
+  }
   get documents() {
     return this._documents ?? (this._documents = new DocumentsClient(this._options));
   }
@@ -10248,7 +10991,7 @@ var logging;
 
 // src/server.ts
 var import_types3 = require("@modelcontextprotocol/sdk/types.js");
-var import_zod25 = require("zod");
+var import_zod28 = require("zod");
 
 // src/auth.ts
 var KEY_RE = /^(sk|ssk|st)_(live|test)_/;
@@ -10292,8 +11035,8 @@ function warnOnSuboptimalKey(key, log) {
 
 // src/build-info.ts
 var BUILD_INFO = {
-  mcpServer: true ? "0.18.1" : "dev",
-  sdk: true ? "0.47.0" : "dev"
+  mcpServer: true ? "0.19.0" : "dev",
+  sdk: true ? "0.49.0" : "dev"
 };
 function formatBuildInfo() {
   return `vectros-mcp-server ${BUILD_INFO.mcpServer} (sdk ${BUILD_INFO.sdk})`;
@@ -10552,6 +11295,11 @@ ${detail}${trailer}`
   };
 }
 
+// src/tools/limits.ts
+var MAX_OWNERSHIP_SCOPES = 2;
+var MAX_SCOPE_FILTERS = 16;
+var MAX_CONTENT_TYPES = 2;
+
 // src/tools/hybrid_search.ts
 var MCP_DEFAULT_LIMIT = 3;
 var MCP_MAX_LIMIT = 50;
@@ -10594,11 +11342,11 @@ var inputSchema = {
   folderId: import_zod.z.string().optional().describe("Scope to content in this EXACT folder (Vectros folder id)."),
   rootFolderId: import_zod.z.string().optional().describe("Scope to content under this folder AND all its descendants (subtree-root folder id)."),
   // Content narrowing.
-  contentTypes: import_zod.z.array(import_zod.z.enum(["documents", "records"])).optional().describe('Narrow to content types. ["documents"] or ["records"]; omit for unified (both).'),
+  contentTypes: import_zod.z.array(import_zod.z.enum(["documents", "records"])).max(MAX_CONTENT_TYPES, `contentTypes accepts at most ${MAX_CONTENT_TYPES} entries`).optional().describe('Narrow to content types. ["documents"] or ["records"]; omit for unified (both).'),
   typeName: import_zod.z.string().optional().describe(
     'Restrict hits to this schema type (e.g. "patient", "runbook"). Applies to BOTH documents and records \u2014 combine with contentTypes to scope within one content type. Untyped content never matches.'
   ),
-  filters: import_zod.z.record(import_zod.z.unknown()).optional().describe(
+  filters: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional().describe(
     'Field-level metadata filters (AND-combined). Value = scalar (equality), array (OR-set), or operator map: $eq/$ne/$gt/$gte/$lt/$lte (scalar) or $in/$nin (array). e.g. {"status":"open"} or {"price":{"$gte":100,"$lte":500}}.'
   ),
   // Ownership.
@@ -10606,7 +11354,7 @@ var inputSchema = {
   scope: import_zod.z.string().optional().describe(
     'Restrict to content carrying this scope value, in `namespace:value` form (e.g. "org:<uuid>", "client:<uuid>", "group:eng-team"). `org` and `client` are reserved namespace names, registered like any other; others are namespaces you registered yourself. Mutually exclusive with `scopeFilters` \u2014 use this for ONE dimension.'
   ),
-  scopeFilters: import_zod.z.array(import_zod.z.string()).min(1, "scopeFilters must name at least one dimension when supplied").optional().describe(
+  scopeFilters: import_zod.z.array(import_zod.z.string()).min(1, "scopeFilters must name at least one dimension when supplied").max(MAX_SCOPE_FILTERS, `scopeFilters accepts at most ${MAX_SCOPE_FILTERS} entries`).optional().describe(
     'Restrict to content matching ALL of these scope values \u2014 one per namespace \u2014 for a credential whose access spans more than one ownership dimension. e.g. ["org:<uuid>", "client:<uuid>"] narrows to one specific client WITHIN one specific org, which `scope` alone cannot express. Same `namespace:value` form as `scope`; naming the same namespace twice is rejected. Mutually exclusive with `scope` \u2014 use `scope` for a single dimension.'
   ),
   // Date window.
@@ -11127,7 +11875,7 @@ var inputSchema5 = {
   status: import_zod5.z.string().optional().describe("Record lifecycle status. Defaults to ACTIVE server-side."),
   folderId: import_zod5.z.string().optional().describe("Group this record into a folder."),
   userId: import_zod5.z.string().optional().describe("Owning user id."),
-  scopes: import_zod5.z.array(import_zod5.z.string()).optional().describe(
+  scopes: import_zod5.z.array(import_zod5.z.string()).max(MAX_OWNERSHIP_SCOPES, `scopes accepts at most ${MAX_OWNERSHIP_SCOPES} entries`).optional().describe(
     'Scope ownership as `namespace:value` entries, at most 2 (e.g. ["org:<uuid>", "group:eng-team"]). `org` and `client` are reserved namespace names, registered like any other; others are namespaces you registered yourself. This is the record\'s COMPLETE scope declaration, and each entry must fall inside the `data_scope` of a single clause of your credential that also grants this write \u2014 your identity supplies the DEFAULT when you state none, it does not limit which value you may state. An empty array `[]` creates a PRIVATE record owned by the calling user alone. Omit to stamp the credential\'s full identity \u2014 the default.'
   )
 };
@@ -11185,7 +11933,7 @@ var itemSchema = import_zod6.z.strictObject({
   status: import_zod6.z.string().optional().describe("Record lifecycle status. Defaults to ACTIVE server-side."),
   folderId: import_zod6.z.string().optional().describe("Group this record into a folder."),
   userId: import_zod6.z.string().optional().describe("Owning user id."),
-  scopes: import_zod6.z.array(import_zod6.z.string()).optional().describe(
+  scopes: import_zod6.z.array(import_zod6.z.string()).max(MAX_OWNERSHIP_SCOPES, `scopes accepts at most ${MAX_OWNERSHIP_SCOPES} entries`).optional().describe(
     "Scope ownership as `namespace:value` entries, at most 2 namespaces. When supplied this is the record's COMPLETE scope declaration, and each entry must fall inside the `data_scope` of a single clause of your credential that also grants this write \u2014 your identity supplies the DEFAULT when you state none, it does not limit which value you may state. `[]` creates a PRIVATE record owned by the calling user alone. Omit to inherit the credential's full identity."
   )
 });
@@ -11272,7 +12020,7 @@ var inputSchema7 = {
   ),
   status: import_zod7.z.string().optional().describe("Set the record lifecycle status (e.g. ARCHIVED) \u2014 archive/workflow without physical deletion."),
   expectedVersion: import_zod7.z.number().int().optional().describe(
-    "Optimistic concurrency: the version you last read. If the record changed since, the update is refused as a conflict (re-read and retry). Omit for last-write-wins."
+    "Optimistic concurrency: the version you last read. If the record changed since, the update is refused as a conflict (re-read and retry). Omit it to update whatever version is current: an update that meets another change to the same record at the same moment is still refused as a conflict."
   )
 };
 var recordUpdate = ({ client, log }) => ({
@@ -11342,7 +12090,7 @@ var import_zod10 = require("zod");
 // src/tools/provider-alias.ts
 var import_zod9 = require("zod");
 var providerAliasInput = import_zod9.z.string().min(1, "providerAlias must be non-empty when supplied").optional().describe(
-  "Route THIS call through your own model provider instead of the platform-hosted default, by the alias of a provider config your account has activated. It works only after your account has set up that provider and signed the platform's risk-acceptance waiver; without both, the platform refuses the call with a 403, which is returned to you as written. If your account has accepted the Business Associate Agreement with Vectros in the developer portal, an account owner must also have attested that provider config in the developer portal (Model Providers); until then the platform refuses the call with a 403 that says it needs a BAA-holder attestation. A call served by your own provider leaves the Vectros perimeter. Omit it (the default) to use the platform-hosted path. When set, `model` names the model on your provider's own id space, and falls back to that provider config's default model when omitted."
+  "Route THIS call through your own model provider instead of the platform-hosted default, by the alias of a provider config your account has activated. It works only after your account has set up that provider and signed the platform's risk-acceptance waiver; without both, the platform refuses the call with a 403, which is returned to you as written. When the waiver is the cause, the 403 carries an `errorCode` that says which case it is: `WAIVER_NOT_SIGNED` (the waiver has not been signed), `WAIVER_TEXT_CHANGED` (Vectros now requires a newer version of the waiver than the one in force for your account), or `WAIVER_REVOKED` (an owner revoked it). An account owner resolves each in the developer portal (Model Providers); retrying the call does not help. If your account has accepted the Business Associate Agreement with Vectros in the developer portal, an account owner must also have attested that provider config in the developer portal (Model Providers); until then the platform refuses the call with a 403 that says it needs a BAA-holder attestation. A call served by your own provider leaves the Vectros perimeter. Omit it (the default) to use the platform-hosted path. When set, `model` names the model on your provider's own id space, and falls back to that provider config's default model when omitted."
 );
 
 // src/tools/rag_ask.ts
@@ -11369,14 +12117,14 @@ var inputSchema9 = {
     scope: import_zod10.z.string().optional().describe(
       'Restrict retrieval to content carrying this scope value, in `namespace:value` form (e.g. "org:<uuid>", "client:<uuid>", "group:eng-team"). `org` and `client` are reserved namespace names, registered like any other; others are namespaces you registered yourself. Mutually exclusive with `scopeFilters` \u2014 use this for ONE dimension.'
     ),
-    scopeFilters: import_zod10.z.array(import_zod10.z.string()).min(1, "scopeFilters must name at least one dimension when supplied").optional().describe(
+    scopeFilters: import_zod10.z.array(import_zod10.z.string()).min(1, "scopeFilters must name at least one dimension when supplied").max(MAX_SCOPE_FILTERS, `scopeFilters accepts at most ${MAX_SCOPE_FILTERS} entries`).optional().describe(
       'Restrict retrieval to content matching ALL of these scope values \u2014 one per namespace \u2014 for a credential whose access spans more than one ownership dimension. e.g. ["org:<uuid>", "client:<uuid>"] grounds the answer on one specific client WITHIN one specific org, which `scope` alone cannot express. Naming the same namespace twice is rejected. Mutually exclusive with `scope`.'
     ),
     folderId: import_zod10.z.string().optional().describe("Restrict retrieval to this exact folder."),
     rootFolderId: import_zod10.z.string().optional().describe("Restrict retrieval to this folder and all its descendants."),
     typeName: import_zod10.z.string().optional().describe("Restrict record retrieval to this schema type."),
-    contentTypes: import_zod10.z.array(import_zod10.z.enum(["documents", "records"])).optional().describe('Narrow retrieval to content types. ["documents"] or ["records"]; omit for both.'),
-    filters: import_zod10.z.record(import_zod10.z.unknown()).optional().describe(
+    contentTypes: import_zod10.z.array(import_zod10.z.enum(["documents", "records"])).max(MAX_CONTENT_TYPES, `contentTypes accepts at most ${MAX_CONTENT_TYPES} entries`).optional().describe('Narrow retrieval to content types. ["documents"] or ["records"]; omit for both.'),
+    filters: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.unknown()).optional().describe(
       'Field-level metadata filters (AND-combined). Value = scalar (equality), array (OR-set), or operator map ($eq/$ne/$gt/$gte/$lt/$lte, $in/$nin). e.g. {"status":"open"}.'
     ),
     createdAfter: import_zod10.z.string().optional().describe(
@@ -11651,7 +12399,7 @@ function isNotAvailable(err) {
 var documentGet = ({ client, log }) => ({
   name: "document_get",
   title: "Get document metadata (and optionally text)",
-  description: "Fetch metadata for a single document \u2014 select it by its Vectros `documentId` OR by your own `externalId` + `type` (resolved for you). Pass `includeText: true` to also fetch the text body (capped at ~8K tokens; `truncated: true` flag if cut). Text is available for every text-ingested document and for file-ingested documents unless they were uploaded with `storeText: false` (extracted text discarded after indexing) \u2014 then `textAvailable: false` is set; the original file is still retrievable via `includeDownloadUrl`. Pass `includeDownloadUrl: true` to also get a short-lived presigned `downloadUrl` for the original file (file-backed documents only). Returns the full document metadata, including its lifecycle `status` (ACTIVE, or ARCHIVED when soft-retracted from search \u2014 restorable via document_update) and its processing `indexStatus`. When `indexStatus` is FAILED the response also carries `indexFailure` with a machine-readable `code` telling you whether the content is still findable \u2014 e.g. TEXT_INDEX_FAILED / VECTOR_LIMIT_EXCEEDED (one leg still serves it) vs INDEXING_FAILED (not findable by search at all). Branch on `code`, not on the message.",
+  description: "Fetch metadata for a single document \u2014 select it by its Vectros `documentId` OR by your own `externalId` + `type` (resolved for you). Pass `includeText: true` to also fetch the text body (capped at ~8K tokens; `truncated: true` flag if cut). Text is available for every text-ingested document and for file-ingested documents unless they were uploaded with `storeText: false` (extracted text discarded after indexing) or no text could be extracted from the file (`extraction.outcome` other than OK/TRUNCATED, e.g. an image or a scanned page) \u2014 then `textAvailable: false` is set; the original file is still retrievable via `includeDownloadUrl`. Pass `includeDownloadUrl: true` to also get a short-lived presigned `downloadUrl` for the original file (file-backed documents only). Returns the full document metadata, including its lifecycle `status` (ACTIVE, or ARCHIVED when soft-retracted from search \u2014 restorable via document_update) and its processing `indexStatus`. When `indexStatus` is FAILED the response also carries `indexFailure` with a machine-readable `code` telling you whether the content is still findable \u2014 e.g. TEXT_INDEX_FAILED / VECTOR_LIMIT_EXCEEDED (one leg still serves it) vs INDEXING_FAILED (not findable by search at all). Branch on `code`, not on the message.",
   inputSchema: inputSchema12,
   // A pure read — never creates, modifies, or deletes anything server-side.
   annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
@@ -11677,7 +12425,7 @@ var documentGet = ({ client, log }) => ({
           if (isNotAvailable(textErr)) {
             log.debug(
               { tool: "document_get", id },
-              "document_get text unavailable (not retained \u2014 storeText:false upload)"
+              "document_get text unavailable (not retained, or no text could be extracted from the file)"
             );
             extra = { ...extra, textAvailable: false };
           } else {
@@ -11730,10 +12478,12 @@ var inputSchema13 = {
   to: import_zod14.z.string().optional().describe("Lookup mode (range): inclusive upper bound; requires `from`."),
   prefix: import_zod14.z.string().optional().describe("Lookup mode (prefix): match values starting with this. Range-enabled string fields only."),
   order: import_zod14.z.enum(["asc", "desc"]).optional().describe(
-    "Lookup mode: sort direction by the looked-up field. `asc` (default) or `desc` \u2014 use `desc` with a range/prefix lookup to get the most-recent / highest values first (e.g. latest-N). Ignored in list mode."
+    "Lookup mode: sort direction by the looked-up field. `asc` (default) or `desc` \u2014 use `desc` with a range/prefix lookup to get the most-recent / highest values first (e.g. latest-N). Refused without `field`."
   ),
-  type: import_zod14.z.string().optional().describe("Lookup mode: the document type (the bound schema's type). Required with `field`."),
-  // List-mode args:
+  type: import_zod14.z.string().min(1, "type must be non-empty: omit it to list every type").optional().describe(
+    "The document type (the bound schema's type). Required with `field` (lookup mode); in list mode it narrows the list to documents of this type. The list filter applies page by page: a page can hold fewer documents than `limit`, or none, while `nextCursor` is set, so keep paging until `nextCursor` is null before concluding there are none. For a large collection, hybrid_search with `typeName` finds documents of one type directly."
+  ),
+  // List-mode args (`type` above applies to both modes):
   folderId: import_zod14.z.string().optional().describe("List mode: only documents in this folder (Vectros folder id)."),
   userId: import_zod14.z.string().optional().describe("List mode: scope to documents owned by this user."),
   scope: import_zod14.z.string().optional().describe(
@@ -11747,7 +12497,7 @@ var inputSchema13 = {
 var documentQuery = ({ client, log }) => ({
   name: "document_query",
   title: "Document query (list or lookup)",
-  description: "Query document metadata. Two modes:\n  \u2022 Lookup on a lookup-indexed field: pass `type` and `field` plus exactly one of `value` (exact), `from`+`to` (range), or `prefix`. Works on sensitive fields (equality only there); range/prefix need a range-enabled field.\n  \u2022 List: omit `field`; optionally filter by `folderId`/`userId`/`scope` (`namespace:value`).\nReturns a `{ data, nextCursor }` page: `data` holds up to `limit` documents (default 3, max 100 \u2014 raise it in one call when you can accept the payload), and a non-null `nextCursor` means more remain \u2014 pass it back as `startFrom` to page. Mode is auto-detected. Use document_get for the full text/download URL of one document.",
+  description: "Query document metadata. Two modes:\n  \u2022 Lookup on a lookup-indexed field: pass `type` and `field` plus exactly one of `value` (exact), `from`+`to` (range), or `prefix`. Works on sensitive fields (equality only there); range/prefix need a range-enabled field.\n  \u2022 List: omit `field`; optionally filter by `type`/`folderId`/`userId`/`scope` (`namespace:value`). The `type` filter is applied page by page, so a page can be short or empty while `nextCursor` is set: keep paging before concluding there are none.\nReturns a `{ data, nextCursor }` page: `data` holds up to `limit` documents (default 3, max 100 \u2014 raise it in one call when you can accept the payload), and a non-null `nextCursor` means more remain \u2014 pass it back as `startFrom` to page. Mode is auto-detected. Use document_get for the full text/download URL of one document.",
   inputSchema: inputSchema13,
   // A pure read — never creates, modifies, or deletes anything server-side.
   annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
@@ -11806,7 +12556,19 @@ var documentQuery = ({ client, log }) => ({
           "document_query lookup ok"
         );
       } else {
+        const strayLookupArgs = ["value", "from", "to", "prefix", "order"].filter(
+          (k) => args[k] !== void 0
+        );
+        if (strayLookupArgs.length > 0) {
+          return toolError(
+            "document_query",
+            new Error(
+              `Lookup arguments need 'field' (and 'type'): ${strayLookupArgs.map((k) => `'${k}'`).join(", ")}. Without 'field' the call lists documents: filter the list with 'type', 'folderId', 'userId' or 'scope'.`
+            )
+          );
+        }
         page = await client.documents.listDocuments({
+          type,
           folderId: args.folderId,
           userId: args.userId,
           scope: args.scope,
@@ -11814,7 +12576,7 @@ var documentQuery = ({ client, log }) => ({
           limit
         });
         log.debug(
-          { tool: "document_query", mode: "list", limit, returned: pageItems(page).length },
+          { tool: "document_query", mode: "list", type, limit, returned: pageItems(page).length },
           "document_query list ok"
         );
       }
@@ -11849,11 +12611,11 @@ var inputSchema14 = {
     "Lifecycle status. `ARCHIVED` soft-retracts the document \u2014 it is pulled from search and recall but kept and recoverable; set it back to `ACTIVE` to re-index and restore it. The way to retire superseded content when the credential has no delete authority. Omit to leave unchanged."
   ),
   userId: import_zod15.z.string().optional().describe("Reassign the owning user (Vectros UUID)."),
-  scopes: import_zod15.z.array(import_zod15.z.string()).optional().describe(
+  scopes: import_zod15.z.array(import_zod15.z.string()).max(MAX_OWNERSHIP_SCOPES, `scopes accepts at most ${MAX_OWNERSHIP_SCOPES} entries`).optional().describe(
     'Reassign scope ownership as `namespace:value` entries, at most 2 (e.g. ["org:<uuid>", "group:eng-team"]) \u2014 the COMPLETE new parent set. `org`/`client` are reserved namespace names, registered like any other. Omit to leave ownership unchanged; `[]` clears it (private to the owning user).'
   ),
   expectedVersion: import_zod15.z.number().int().optional().describe(
-    "Optimistic concurrency: the version you last read. If the document changed since, the update is refused as a conflict (re-read and retry). Omit for last-write-wins."
+    "Optimistic concurrency: the version you last read. If the document changed since, the update is refused as a conflict (re-read and retry). Omit it to update whatever version is current: an update that meets another change to the same document at the same moment is still refused as a conflict."
   )
 };
 var documentUpdate = ({ client, log }) => ({
@@ -11993,7 +12755,7 @@ var inputSchema17 = {
     "Optional stable slug (sibling-unique; idempotency key). Lowercase letters/digits/hyphens. SUPPLY THIS to make a retry safe \u2014 if omitted, a derived slug is only ever a freshly-proved-free one, so a redelivered call creates a new sibling folder every time rather than matching the first."
   ),
   userId: import_zod18.z.string().optional().describe("Owning user (Vectros UUID)."),
-  scopes: import_zod18.z.array(import_zod18.z.string()).optional().describe(
+  scopes: import_zod18.z.array(import_zod18.z.string()).max(MAX_OWNERSHIP_SCOPES, `scopes accepts at most ${MAX_OWNERSHIP_SCOPES} entries`).optional().describe(
     'Scope ownership as `namespace:value` entries, at most 2 (e.g. ["org:<uuid>", "group:eng-team"]). `org` and `client` are reserved namespace names, registered like any other; others are namespaces you registered yourself. This is the folder\'s COMPLETE scope declaration and values must come from the credential\'s own identity. An empty array `[]` creates a PRIVATE folder owned by the calling user alone. Omit to stamp the credential\'s full identity \u2014 the default.'
   )
 };
@@ -12007,10 +12769,8 @@ var folderCreate = ({ client, log }) => ({
   // freshly-proved-free value, so the idempotency check running after that derivation can never
   // match on the default path. `slug` is optional, so this is annotated for the less-safe default —
   // the same standard applied to record_create/document_ingest/record_batch_write's identical
-  // optional-dedupe-key shape. (A prior version of this annotation claimed unconditional
-  // idempotency, reasoning that the derived slug made this tool "genuinely structurally different"
-  // from the optional-externalId tools — that reasoning was wrong: the derivation is unconditional,
-  // but it is unconditionally NON-colliding by construction, which is the opposite property.)
+  // optional-dedupe-key shape. (The slug derivation being unconditional does not make the tool
+  // idempotent: it is unconditionally NON-colliding by construction, which is the opposite property.)
   annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false },
   handler: async (args) => {
     try {
@@ -12041,11 +12801,11 @@ var inputSchema18 = {
   name: import_zod19.z.string().optional().describe("New folder name. Omit to keep the current name."),
   description: import_zod19.z.string().optional().describe("New description. Omit to leave unchanged."),
   userId: import_zod19.z.string().optional().describe("Reassign the owning user (Vectros UUID)."),
-  scopes: import_zod19.z.array(import_zod19.z.string()).optional().describe(
+  scopes: import_zod19.z.array(import_zod19.z.string()).max(MAX_OWNERSHIP_SCOPES, `scopes accepts at most ${MAX_OWNERSHIP_SCOPES} entries`).optional().describe(
     'Reassign scope ownership as `namespace:value` entries, at most 2 (e.g. ["org:<uuid>", "group:eng-team"]) \u2014 the COMPLETE new parent set. `org`/`client` are reserved namespace names, registered like any other. Omit to leave ownership unchanged; `[]` clears it (private to the owning user).'
   ),
   expectedVersion: import_zod19.z.number().int().optional().describe(
-    "Optimistic concurrency: the version you last read. If the folder changed since, the update is refused as a conflict (re-read and retry). Omit for last-write-wins."
+    "Optimistic concurrency: the version you last read. If the folder changed since, the update is refused as a conflict (re-read and retry). Omit it to update whatever version is current: an update that meets another change to the same folder at the same moment is still refused as a conflict."
   )
 };
 var folderUpdate = ({ client, log }) => ({
@@ -12090,7 +12850,7 @@ var inputSchema19 = {
 var folderDelete = ({ client, log }) => ({
   name: "folder_delete",
   title: "Delete a folder",
-  description: 'Permanently delete a folder by id. The folder must be EMPTY first \u2014 it must contain no documents, no records, and no sub-folders \u2014 and a non-empty folder is refused, which is the most common way this call fails. Use record_query with this folderId, and document_query, to see what is in it. Clearing it differs by content type: a document can be moved out (document_update with a different folderId) or deleted. A RECORD can also be re-filed into another folder \u2014 the API supports it \u2014 but THIS SERVER does not expose that yet: record_update has no folderId argument, so from here your only option is record_delete (needs records:d). Do NOT read that as "the record cannot be moved" and delete the record on that basis: if the record should be kept, tell the user to move it with the Vectros API/SDK directly rather than deleting it here. A sub-folder cannot be re-parented at all, so nested folders have to be emptied and deleted innermost-first. Note the emptiness check counts everything in the folder, INCLUDING items your credential cannot read \u2014 so a refusal you cannot account for from what you can list is expected behaviour, not a bug, and retrying will not clear it. Requires the key to allow folders:d \u2014 a key without it gets a permission error. Protected folders (e.g. a context root) cannot be deleted at all, however empty.',
+  description: 'Permanently delete a folder by id. The folder must be EMPTY first \u2014 it must contain no documents, no records, and no sub-folders \u2014 and a non-empty folder is refused, which is the most common way this call fails. Use record_query with this folderId, and document_query, to see what is in it. Clearing it differs by content type: a document can be moved out (document_update with a different folderId) or deleted. A RECORD can also be re-filed into another folder \u2014 the API supports it \u2014 but THIS SERVER does not expose that: record_update has no folderId argument, so from here your only option is record_delete (needs records:d). Do NOT read that as "the record cannot be moved" and delete the record on that basis: if the record should be kept, tell the user to move it with the Vectros API/SDK directly rather than deleting it here. A sub-folder cannot be re-parented at all, so nested folders have to be emptied and deleted innermost-first. Note the emptiness check counts everything in the folder, INCLUDING items your credential cannot read \u2014 so a refusal you cannot account for from what you can list is expected behaviour, not a bug, and retrying will not clear it. Requires the key to allow folders:d \u2014 a key without it gets a permission error. Protected folders (e.g. a context root) cannot be deleted at all, however empty.',
   inputSchema: inputSchema19,
   // Deletes. Idempotent in the standard REST sense: the end state ("this id no longer
   // resolves") is the same whether this is the first delete or a repeat of one.
@@ -12116,7 +12876,7 @@ var inputSchema20 = {
 var currentIdentity = ({ log, apiKey, environment }) => ({
   name: "current_identity",
   title: "Current identity (tenant + principal scope)",
-  description: "Describe the credential the MCP server is operating under. Returns tenantId, environment (staging|production), principalType (root_key|scoped_key|token), principalKeyId, principalLabel, and (for scoped credentials) allowedActions plus dataScope \u2014 the credential's verb+ownership reach as { userId, scopes[] }, where each scope is a `namespace:value` string (e.g. \"org:<uuid>\"). Note: this does not yet include granted_capabilities (member-lifecycle / forensic-read / context-directory-read / delegate-mint, as of API 0.40.0, joined by delegate-principal-stamp in 0.42.0) \u2014 a separate reach dimension a scope clause can carry that /v1/ping does not report yet, so allowedActions+dataScope may understate a credential's true reach. Also reports mcpServerVersion (this server's own package version) and sdkVersion (the bundled @vectros-ai/sdk version) so a caller can tell what build it's talking to. Use this when the user asks 'what can you do here?', 'what tenant am I in?', or 'what version is this?'. Calls GET /v1/ping under the hood.",
+  description: "Describe the credential the MCP server is operating under. Returns tenantId, environment (staging|production), principalType (root_key|scoped_key|token), principalKeyId, principalLabel, and (for scoped credentials) allowedActions plus dataScope \u2014 the credential's verb+ownership reach as { userId, scopes[] }, where each scope is a `namespace:value` string (e.g. \"org:<uuid>\"). Note: this does not include granted_capabilities (member-lifecycle / forensic-read / context-directory-read / delegate-mint, as of API 0.40.0, joined by delegate-principal-stamp in 0.42.0 and trigger-control-plane-grant in 0.44.0) \u2014 a separate reach dimension a scope clause can carry that /v1/ping does not report, so allowedActions+dataScope may understate a credential's true reach. Also reports mcpServerVersion (this server's own package version) and sdkVersion (the bundled @vectros-ai/sdk version) so a caller can tell what build it's talking to. Use this when the user asks 'what can you do here?', 'what tenant am I in?', or 'what version is this?'. Calls GET /v1/ping under the hood.",
   inputSchema: inputSchema20,
   // A pure read (/v1/ping) — never creates, modifies, or deletes anything server-side.
   annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
@@ -12243,14 +13003,14 @@ var inputSchema21 = {
   // Common (both modes):
   folderId: import_zod21.z.string().optional().describe("Optional folder to ingest into. Default: tenant root."),
   userId: import_zod21.z.string().optional().describe("Owning user ID. Optional."),
-  scopes: import_zod21.z.array(import_zod21.z.string()).optional().describe(
+  scopes: import_zod21.z.array(import_zod21.z.string()).max(MAX_OWNERSHIP_SCOPES, `scopes accepts at most ${MAX_OWNERSHIP_SCOPES} entries`).optional().describe(
     "TEXT MODE ONLY. Scope ownership as `namespace:value` entries, at most 2 (e.g. [\"org:<uuid>\", \"group:eng-team\"]). `org` and `client` are reserved namespace names, registered like any other; others are namespaces you registered yourself. This is the document's COMPLETE scope declaration and values must come from the credential's own identity. An empty array `[]` creates a PRIVATE document owned by the calling user alone. Omit to stamp the credential's full identity \u2014 the default. Rejected with `filePath` (file uploads do not accept a scope declaration): a file-uploaded document is stamped with the credential's full identity."
   )
 };
 var documentIngest = ({ client, log, transport, ingestRoot }) => ({
   name: "document_ingest",
   title: "Ingest a new document (text body or file upload)",
-  description: "Create a new document in your Vectros tenant. Two modes:\n  \u2022 Text mode: pass `text` (string body). Single-call. Use for crawled content, notes, generated text.\n  \u2022 File mode: pass `filePath` (local path on the MCP server's host machine). STDIO-TRANSPORT ONLY \u2014 rejected on HTTP transport. MCP server reads the bytes, requests a presigned upload URL, and PUTs them. Returns when the upload is accepted (indexStatus: PENDING_INDEX); poll `document_get` until indexStatus is INDEXED. EXCEPTION \u2014 re-ingesting file mode against an externalId that already has a document (response `created:false`): the file body is replaced by ANY such re-ingest, whether or not `upsert` was set (`upsert` there only additionally applies `payload`/`title` to the matched document). The document keeps serving the OLD file's bytes until the new one is adopted, and indexStatus already reads INDEXED left over from that old file, so polling it returns immediately without waiting for the new content. Poll `document_get` and watch `fileItemId` instead \u2014 once it differs from the value it held before this call, the new file has been adopted. Re-request any download URL after that: one minted before adoption can stop working even within its stated `downloadExpires`.\nEither `text` or `filePath` must be present; both is an error. Idempotent by `externalId` (re-ingest returns the existing document, not a duplicate \u2014 requires documents:r in addition to documents:c, since being handed the existing document is a read of it; in FILE MODE a re-ingest against an existing externalId needs documents:u). TEXT MODE: without `upsert`, the existing document's content is genuinely unchanged. FILE MODE: as noted above, a re-ingest against an existing externalId always replaces the file body regardless of `upsert` \u2014 only the `payload`/`title` metadata overwrite is gated by it. To UPDATE an existing document instead \u2014 re-index an edited body \u2014 pass `upsert:true` with the same `externalId` (and the same `schemaId`); this is the re-sync primitive for keeping a knowledge base current. Pass `schemaId` + `payload` for a typed, lookup-queryable document (records parity). An `externalId` with no `schemaId` is refused (400) unless you also pass `confirmUntyped:true` to confirm that an untyped document is intended. indexMode defaults to HYBRID for untyped documents (omit to inherit a bound schema's default). storeText is a FILE-MODE knob (default true): false discards the uploaded file's extracted text after indexing (search + file download keep working; text retrieval and document_ask do not). Text-mode bodies are always retained, so storeText is not accepted with `text`.",
+  description: "Create a new document in your Vectros tenant. Two modes:\n  \u2022 Text mode: pass `text` (string body). Single-call. Use for crawled content, notes, generated text.\n  \u2022 File mode: pass `filePath` (local path on the MCP server's host machine). STDIO-TRANSPORT ONLY \u2014 rejected on HTTP transport. MCP server reads the bytes, requests a presigned upload URL, and PUTs them. Returns when the upload is accepted (indexStatus: PENDING_INDEX); poll `document_get` until indexStatus is terminal: INDEXED, SKIPPED (no indexable text: `extraction.outcome` says why, e.g. NO_TEXT for an image or a scanned page), STORED (indexMode NONE) or FAILED. EXCEPTION \u2014 re-ingesting file mode against an externalId that already has a document (response `created:false`): the file body is replaced by ANY such re-ingest, whether or not `upsert` was set (`upsert` there only additionally applies `payload`/`title` to the matched document). The document keeps serving the OLD file's bytes until the new one is adopted, and indexStatus already reads INDEXED left over from that old file, so polling it returns immediately without waiting for the new content. Poll `document_get` and watch `fileItemId` instead \u2014 once it differs from the value it held before this call, the new file has been adopted. Re-request any download URL after that: one minted before adoption can stop working even within its stated `downloadExpires`.\nEither `text` or `filePath` must be present; both is an error. Idempotent by `externalId` (re-ingest returns the existing document, not a duplicate \u2014 requires documents:r in addition to documents:c, since being handed the existing document is a read of it; in FILE MODE a re-ingest against an existing externalId needs documents:u). TEXT MODE: without `upsert`, the existing document's content is genuinely unchanged. FILE MODE: as noted above, a re-ingest against an existing externalId always replaces the file body regardless of `upsert` \u2014 only the `payload`/`title` metadata overwrite is gated by it. To UPDATE an existing document instead \u2014 re-index an edited body \u2014 pass `upsert:true` with the same `externalId` (and the same `schemaId`); this is the re-sync primitive for keeping a knowledge base current. Pass `schemaId` + `payload` for a typed, lookup-queryable document (records parity). An `externalId` with no `schemaId` is refused (400) unless you also pass `confirmUntyped:true` to confirm that an untyped document is intended. indexMode defaults to HYBRID for untyped documents (omit to inherit a bound schema's default). storeText is a FILE-MODE knob (default true): false discards the uploaded file's extracted text after indexing (search + file download keep working; text retrieval and document_ask do not). Text-mode bodies are always retained, so storeText is not accepted with `text`.",
   inputSchema: inputSchema21,
   // Creates by default, idempotent ONLY when the caller supplies `externalId` (optional,
   // per the doc comment above) — re-ingest then returns the existing document rather than
@@ -12392,7 +13152,7 @@ var documentIngest = ({ client, log, transport, ingestRoot }) => ({
         "document_ingest file ok"
       );
       const uploadCreated = upload?.created;
-      const note = uploadCreated === false ? "File replaced: this re-ingest matched an existing externalId, which always replaces that document's file body (upsert or not \u2014 upsert only additionally applies payload/title to it). The next document_get call may already show indexStatus: INDEXED \u2014 that is left over from the PREVIOUS file, not confirmation the new one is ready, and the document keeps serving the old file's bytes until adoption completes. Poll document_get(id) and watch fileItemId instead: once it differs from the value it held before this call, the new file has been adopted. Any download URL already held for this document was minted for the old file and can stop working before its stated downloadExpires once adoption happens \u2014 request a fresh one after fileItemId changes." : "File uploaded; indexing is asynchronous. Poll document_get(id) until indexStatus is INDEXED.";
+      const note = uploadCreated === false ? "File replaced: this re-ingest matched an existing externalId, which always replaces that document's file body (upsert or not \u2014 upsert only additionally applies payload/title to it). The next document_get call may already show indexStatus: INDEXED \u2014 that is left over from the PREVIOUS file, not confirmation the new one is ready, and the document keeps serving the old file's bytes until adoption completes. Poll document_get(id) and watch fileItemId instead: once it differs from the value it held before this call, the new file has been adopted. Any download URL already held for this document was minted for the old file and can stop working before its stated downloadExpires once adoption happens \u2014 request a fresh one after fileItemId changes." : "File uploaded; indexing is asynchronous. Poll document_get(id) until indexStatus is INDEXED, SKIPPED (no indexable text; see extraction.outcome), STORED or FAILED.";
       return {
         content: [
           {
@@ -12565,6 +13325,365 @@ var versionHistory = ({ client, log }) => ({
 });
 var version_history_default = versionHistory;
 
+// src/tools/agent_list.ts
+var import_zod24 = require("zod");
+var MCP_DEFAULT_LIMIT6 = 10;
+var MCP_MAX_LIMIT6 = 100;
+function toAgentSummary(agent) {
+  return {
+    id: agent.id,
+    name: agent.name,
+    description: agent.description,
+    latestVersion: agent.latestVersion,
+    status: agent.status
+  };
+}
+var inputSchema24 = {
+  includeRetired: import_zod24.z.boolean().optional().describe("Also list retired and purged agents (neither can be run). Default false."),
+  startFrom: import_zod24.z.string().optional().describe("Pagination cursor: pass the `nextCursor` from the previous page to fetch the next."),
+  limit: import_zod24.z.number().int().min(1).max(MCP_MAX_LIMIT6).optional().describe(`Max agents per page. Default ${MCP_DEFAULT_LIMIT6}, max ${MCP_MAX_LIMIT6}.`)
+};
+var agentList = ({ client, log }) => ({
+  name: "agent_list",
+  title: "List agents",
+  description: "List the stored agents you can run with agent_run, newest first. Each is returned as its `id`, `name`, `description`, `latestVersion` and `status`; only an `ACTIVE` agent can be run. Retired and purged agents are left out unless `includeRetired` is true. Returns a `{ data, nextCursor }` page: a non-null `nextCursor` means more remain, pass it back as `startFrom`. Needs the `runs:c` or `agents:r` scope; running a listed agent needs `runs:c`, so a credential with only `agents:r` can list agents but not run them.",
+  inputSchema: inputSchema24,
+  // A pure read: it lists definitions and changes nothing.
+  annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
+  handler: async (args) => {
+    const limit = args.limit ?? MCP_DEFAULT_LIMIT6;
+    try {
+      const page = await client.agents.listAgents({
+        includeRetired: args.includeRetired,
+        startFrom: args.startFrom,
+        limit
+      });
+      const data = (page.data ?? []).map(toAgentSummary);
+      const nextCursor = page.nextCursor ?? null;
+      log.debug({ tool: "agent_list", limit, returned: data.length }, "agent_list ok");
+      return { content: [{ type: "text", text: JSON.stringify({ data, nextCursor }, null, 2) }] };
+    } catch (err) {
+      log.warn({ tool: "agent_list", err: String(err) }, "agent_list failed");
+      return toolError("agent_list", err);
+    }
+  }
+});
+var agent_list_default = agentList;
+
+// src/tools/agent_run.ts
+var import_node_crypto = require("crypto");
+var import_zod25 = require("zod");
+
+// src/run-stream.ts
+var TEXT_PROGRESS_CHARS = 256;
+var HEARTBEAT_MS = 15e3;
+var TERMINAL_STATUS = {
+  "run.completed": "COMPLETED",
+  "run.failed": "FAILED",
+  "run.cancelled": "CANCELLED"
+};
+function str(v) {
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+async function consumeRunStream(stream, initialRunId, onProgress, heartbeatMs = HEARTBEAT_MS) {
+  const result = {
+    runId: initialRunId,
+    terminal: false,
+    status: "UNKNOWN",
+    text: "",
+    toolCalls: []
+  };
+  const blocks = [];
+  let pending = "";
+  let unsentChars = 0;
+  const emit = async (message) => {
+    if (!onProgress) return;
+    try {
+      await onProgress(message);
+    } catch {
+    }
+  };
+  let heartbeat;
+  let lastEventAt = Date.now();
+  if (onProgress) {
+    heartbeat = setInterval(() => {
+      if (Date.now() - lastEventAt >= heartbeatMs) {
+        lastEventAt = Date.now();
+        void emit("run still working");
+      }
+    }, Math.max(1, Math.floor(heartbeatMs / 3)));
+    heartbeat.unref?.();
+  }
+  try {
+    for await (const raw of stream) {
+      lastEventAt = Date.now();
+      if (!raw || typeof raw !== "object") continue;
+      const ev = raw;
+      result.runId ??= str(ev.runId);
+      const type = typeof ev.type === "string" ? ev.type : "";
+      switch (type) {
+        case "run.started":
+          result.agentId = str(ev.agentId) ?? result.agentId;
+          result.agentVersion = num(ev.agentVersion) ?? result.agentVersion;
+          await emit("run started");
+          break;
+        case "message.delta": {
+          const piece = typeof ev.text === "string" ? ev.text : "";
+          pending += piece;
+          unsentChars += piece.length;
+          if (unsentChars >= TEXT_PROGRESS_CHARS) {
+            unsentChars = 0;
+            await emit(`answer: ${blocks.join("\n\n").length + pending.length} characters so far`);
+          }
+          break;
+        }
+        case "message.completed": {
+          const full = str(ev.text) ?? pending;
+          if (full.length > 0) blocks.push(full);
+          pending = "";
+          unsentChars = 0;
+          await emit("model call completed");
+          break;
+        }
+        case "tool.completed": {
+          const call = {
+            tool: str(ev.tool),
+            outcome: str(ev.outcome),
+            code: str(ev.code)
+          };
+          result.toolCalls.push(call);
+          await emit(`tool ${call.tool ?? "call"}: ${call.outcome ?? "ended"}`);
+          break;
+        }
+        default:
+          break;
+      }
+      if (ev.terminal === true || Object.hasOwn(TERMINAL_STATUS, type)) {
+        result.terminal = true;
+        result.status = str(ev.status) ?? TERMINAL_STATUS[type] ?? "ENDED";
+        result.reason = str(ev.reason);
+        result.errorCode = str(ev.errorCode);
+        if (typeof ev.settled === "boolean" || ev.inferenceBalanceCentsChargedMilli !== void 0 || ev.inferenceBalanceCentsRefundedMilli !== void 0) {
+          result.charged = {
+            settled: typeof ev.settled === "boolean" ? ev.settled : void 0,
+            inferenceBalanceCentsChargedMilli: num(ev.inferenceBalanceCentsChargedMilli),
+            inferenceBalanceCentsRefundedMilli: num(ev.inferenceBalanceCentsRefundedMilli)
+          };
+        }
+        break;
+      }
+    }
+  } catch (err) {
+    result.streamError = err instanceof Error ? err.message : String(err);
+  } finally {
+    if (heartbeat) clearInterval(heartbeat);
+  }
+  if (pending.length > 0) blocks.push(pending);
+  result.text = blocks.join("\n\n");
+  return result;
+}
+
+// src/tools/agent_run.ts
+var RUN_ID_HEADER = "x-vectros-run-id";
+var MAX_INPUT_CHARS = 1e5;
+var MAX_INPUT_BYTES = 24e4;
+function encodedInputBytes(v) {
+  return Buffer.byteLength(JSON.stringify(v), "utf8");
+}
+var TERMINAL_EVENT_TYPES = /* @__PURE__ */ new Set(["run.completed", "run.failed", "run.cancelled"]);
+var ENDED_STATUSES = /* @__PURE__ */ new Set(["COMPLETED", "FAILED", "CANCELLED", "EXPIRED"]);
+var inputSchema25 = {
+  agentId: import_zod25.z.string().min(1, "agentId must be non-empty").describe("The agent to run: an `id` from agent_list."),
+  input: import_zod25.z.string().min(1, "input must be non-empty").max(MAX_INPUT_CHARS, `input accepts at most ${MAX_INPUT_CHARS} characters`).refine(
+    (v) => encodedInputBytes(v) <= MAX_INPUT_BYTES,
+    `input accepts at most ${MAX_INPUT_BYTES} bytes as sent (a JSON string in UTF-8)`
+  ).describe(
+    `What the agent is asked, 1 to ${MAX_INPUT_CHARS} characters and at most ${MAX_INPUT_BYTES} bytes as sent (a JSON string in UTF-8; most control characters other than newline and tab count six bytes).`
+  ),
+  agentVersion: import_zod25.z.number().int().min(1).optional().describe("The agent version to run. Default: its latest version."),
+  maxInferenceCents: import_zod25.z.number().int().min(1).optional().describe(
+    "The most this run's model calls may cost, in US cents. It can only lower the agent's own budget (a higher value is refused); a value below the platform minimum is refused with errorCode `BUDGET_TOO_LOW`, whose message names the minimum. Default: the agent's budget. A run that reaches it ends `FAILED` with errorCode `BUDGET_EXCEEDED`."
+  ),
+  readOnly: import_zod25.z.boolean().optional().describe("When true, every tool call that would change data is refused in this run. Default false."),
+  idempotencyKey: import_zod25.z.string().regex(/^[A-Za-z0-9._:-]{1,128}$/, "idempotencyKey is 1 to 128 letters, digits, `.`, `_`, `:` or `-`").optional().describe(
+    "Makes a retried call safe: the same key with the same arguments never starts a second run; the retry returns that run's id and status (`alreadyStarted: true`) instead. Its answer text is not returned again; read how it ended with run_get. Default: a new key per call."
+  )
+};
+var agentRun = ({ client, log }) => ({
+  name: "agent_run",
+  title: "Run an agent",
+  description: "Run a stored agent (from agent_list) on one `input` and return its answer. The agent's tool calls act as you, with your own permissions, and only through the tools the agent lists; set `readOnly` to refuse every tool call that would change data. Cap the run's model cost with `maxInferenceCents` (it can only lower the agent's own budget). The run is billed: model calls against your inference balance, and a fee per run, tool calls and run time against your plan. An agent can search the web or fetch a page when its definition lists that web tool (web fetch also needs your tenant's owner to switch it on, and a run of an agent that lists `web_search` is refused while the platform has web search disabled). Returns `{ runId, agentId, agentVersion, status, terminal, reason, errorCode, text, toolCalls, charged }`; `charged` carries the run's charge and refund in milli-cents (1 cent = 1000). Progress notifications keep the call alive while the run works for a client that resets its timeout on progress; cancelling the call cancels the run once the run is named (almost at once). If `terminal` is false the result arrived before the run ended: read it with run_get, which needs `runs:r` as well. Calling again without `idempotencyKey` starts a new, billed run. Needs the `runs:c` scope.",
+  inputSchema: inputSchema25,
+  // Not a read: a run is billed, and its tool calls may create, change or delete data with the
+  // caller's permissions, so a host should confirm it. Not idempotent: each call is a new paid run
+  // unless the same idempotencyKey is passed again.
+  annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+  handler: async (args, extra) => {
+    const agentId = args.agentId;
+    const maxInferenceCents = args.maxInferenceCents;
+    const idempotencyKey = args.idempotencyKey ?? (0, import_node_crypto.randomUUID)();
+    const request = {
+      "Idempotency-Key": idempotencyKey,
+      agentId,
+      agentVersion: args.agentVersion,
+      input: { text: args.input },
+      budget: maxInferenceCents !== void 0 ? { maxInferenceCents } : void 0,
+      readOnly: args.readOnly
+    };
+    const progressToken = extra._meta?.progressToken;
+    let progressCount = 0;
+    const onProgress = progressToken !== void 0 && extra.sendNotification ? async (message) => {
+      progressCount += 1;
+      await extra.sendNotification({
+        method: "notifications/progress",
+        params: { progressToken, progress: progressCount, message }
+      });
+    } : void 0;
+    const streamAbort = new AbortController();
+    const callSignal = extra.signal;
+    let knownRunId;
+    let headersReceived = false;
+    let cancelRequested = false;
+    let cancelSent = false;
+    let runEnded = false;
+    const sendCancel = () => {
+      if (!cancelRequested || cancelSent || !knownRunId || runEnded) return;
+      cancelSent = true;
+      const id = knownRunId;
+      client.agents.cancelRun({ id }).then(
+        () => log.info({ tool: "agent_run", runId: id }, "agent_run cancelled by the client"),
+        (err) => log.warn({ tool: "agent_run", runId: id, err: String(err) }, "agent_run cancel failed")
+      );
+    };
+    const cancelIfNamed = () => {
+      if (!cancelRequested || !headersReceived || !knownRunId) return;
+      sendCancel();
+      streamAbort.abort();
+    };
+    const onCancel = () => {
+      cancelRequested = true;
+      cancelIfNamed();
+    };
+    if (callSignal?.aborted) {
+      return toolError("agent_run", new Error("The call was cancelled before the run started."));
+    }
+    callSignal?.addEventListener("abort", onCancel, { once: true });
+    try {
+      const { data: stream, rawResponse } = await client.agents.createRun(request, { abortSignal: streamAbort.signal }).withRawResponse();
+      headersReceived = true;
+      knownRunId = rawResponse.headers.get(RUN_ID_HEADER) ?? void 0;
+      cancelIfNamed();
+      const naming = async function* () {
+        for await (const ev of stream) {
+          if (!knownRunId && ev && typeof ev === "object") {
+            const id = ev.runId;
+            if (typeof id === "string" && id.length > 0) {
+              knownRunId = id;
+              cancelIfNamed();
+            }
+          }
+          if (ev && typeof ev === "object") {
+            const e = ev;
+            if (e.terminal === true || typeof e.type === "string" && TERMINAL_EVENT_TYPES.has(e.type)) runEnded = true;
+          }
+          yield ev;
+        }
+      };
+      const run = await consumeRunStream(naming(), knownRunId, onProgress);
+      knownRunId ??= run.runId;
+      if (run.terminal) runEnded = true;
+      sendCancel();
+      log.debug(
+        {
+          tool: "agent_run",
+          runId: run.runId,
+          status: run.status,
+          terminal: run.terminal,
+          toolCalls: run.toolCalls.length,
+          textLength: run.text.length
+        },
+        "agent_run ok"
+      );
+      const body = {
+        runId: run.runId,
+        agentId: run.agentId ?? agentId,
+        agentVersion: run.agentVersion,
+        status: run.status,
+        terminal: run.terminal,
+        reason: run.reason,
+        errorCode: run.errorCode,
+        text: run.text,
+        toolCalls: run.toolCalls,
+        charged: run.charged
+      };
+      if (!run.terminal) {
+        body.note = cancelRequested ? "The call was cancelled and the run was asked to stop. Read it with run_get (needs the `runs:r` scope) to see how it ended." : "The stream ended before the run did" + (run.streamError ? ` (${run.streamError})` : "") + ". The run may still be working: read it with run_get until `terminal` is true (run_get needs the `runs:r` scope).";
+      }
+      return { content: [{ type: "text", text: JSON.stringify(body, null, 2) }] };
+    } catch (err) {
+      const e = err;
+      if (e?.body?.errorCode === "IDEMPOTENCY_IN_PROGRESS") {
+        const runId = (typeof e.body.runId === "string" ? e.body.runId : void 0) ?? e.rawResponse?.headers?.get?.(RUN_ID_HEADER) ?? void 0;
+        if (runId) {
+          const status = typeof e.body.status === "string" ? e.body.status : void 0;
+          log.info({ tool: "agent_run", runId }, "agent_run: the idempotency key already started a run");
+          const body = {
+            runId,
+            agentId,
+            status,
+            // The 409 names the run's status at the time; an ended status is final.
+            terminal: status !== void 0 && ENDED_STATUSES.has(status),
+            alreadyStarted: true,
+            note: "This idempotency key already started this run, so no new run was started. Its answer text is not returned again and cannot be read back: run_get (needs the `runs:r` scope) shows how the run ended and what it was charged, never its text. To start another run, pass a new idempotencyKey."
+          };
+          return { content: [{ type: "text", text: JSON.stringify(body, null, 2) }] };
+        }
+      }
+      log.warn({ tool: "agent_run", agentId, err: String(err) }, "agent_run failed");
+      const result = toolError("agent_run", err);
+      const statusCode = err?.statusCode;
+      if (typeof statusCode !== "number" || statusCode === 408 || statusCode >= 500) {
+        result.content[0].text += `
+idempotencyKey: ${idempotencyKey}
+A run may have started before this error. Call agent_run again with the same arguments and this idempotencyKey: if a run started, the call names it; if not, it starts one.` + (cancelRequested ? " (The call was cancelled; a run that started could not be cancelled.)" : "");
+      }
+      return result;
+    } finally {
+      callSignal?.removeEventListener("abort", onCancel);
+    }
+  }
+});
+var agent_run_default = agentRun;
+
+// src/tools/run_get.ts
+var import_zod26 = require("zod");
+var inputSchema26 = {
+  runId: import_zod26.z.string().min(1, "runId must be non-empty").describe("The run id agent_run returned (`runId`).")
+};
+var runGet = ({ client, log }) => ({
+  name: "run_get",
+  title: "Get an agent run",
+  description: "Read one agent run by id: `status` (`RUNNING`, `COMPLETED`, `FAILED`, `CANCELLED` or `EXPIRED`), `terminal` (whether it has ended; poll until true), `reason`, `errorCode`, `steps`, its `toolCalls` (each tool and how it ended, never its arguments or result) and `usage` (what it was charged, in milli-cents). It does not return the answer text: agent_run returns that. Use it when agent_run returned `terminal: false`. Needs the `runs:r` scope, which starting a run (`runs:c`) does not include: a credential with only `runs:c` gets `403` here, and learns how its runs end only from agent_run's own result.",
+  inputSchema: inputSchema26,
+  // A pure read: polling a run does not change it.
+  annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
+  handler: async (args) => {
+    const runId = args.runId;
+    try {
+      const run = await client.agents.getRun({ id: runId });
+      log.debug({ tool: "run_get", runId, status: run.status, terminal: run.terminal }, "run_get ok");
+      return { content: [{ type: "text", text: JSON.stringify(run, null, 2) }] };
+    } catch (err) {
+      log.warn({ tool: "run_get", runId, err: String(err) }, "run_get failed");
+      return toolError("run_get", err);
+    }
+  }
+});
+var run_get_default = runGet;
+
 // src/tools/types.ts
 var TOOL_NAMES = [
   "hybrid_search",
@@ -12589,7 +13708,10 @@ var TOOL_NAMES = [
   "current_identity",
   "document_ingest",
   "lookup_principal",
-  "version_history"
+  "version_history",
+  "agent_list",
+  "agent_run",
+  "run_get"
 ];
 
 // src/tools/index.ts
@@ -12616,7 +13738,10 @@ var ALL_TOOL_FACTORIES = {
   current_identity: current_identity_default,
   document_ingest: document_ingest_default,
   lookup_principal: lookup_principal_default,
-  version_history: version_history_default
+  version_history: version_history_default,
+  agent_list: agent_list_default,
+  agent_run: agent_run_default,
+  run_get: run_get_default
 };
 
 // src/resources/schemas.ts
@@ -12640,7 +13765,7 @@ var identityResource = ({ log, apiKey, environment }) => ({
   name: "identity",
   uri: "vectros://identity",
   title: "Current identity (tenant + principal scope)",
-  description: "The tenant + principal scope the MCP server is authenticated as. Returns the same payload as the `current_identity` tool: status, tenantId, environment, principalType, principalKeyId, principalLabel, (for scoped credentials) allowedActions + dataScope ({ userId, scopes[] }). Note: this does not yet include granted_capabilities (member-lifecycle / forensic-read / context-directory-read / delegate-mint, as of API 0.40.0, joined by delegate-principal-stamp in 0.42.0) \u2014 a separate reach dimension a scope clause can carry that /v1/ping does not report yet, so allowedActions+dataScope may understate a credential's true reach. Also reports mcpServerVersion and sdkVersion (this build's own version and the bundled @vectros-ai/sdk version). The /v1/ping backing call ships the extended shape today; the version fields are always client-derived.",
+  description: "The tenant + principal scope the MCP server is authenticated as. Returns the same payload as the `current_identity` tool: status, tenantId, environment, principalType, principalKeyId, principalLabel, (for scoped credentials) allowedActions + dataScope ({ userId, scopes[] }). Note: this does not include granted_capabilities (member-lifecycle / forensic-read / context-directory-read / delegate-mint, as of API 0.40.0, joined by delegate-principal-stamp in 0.42.0 and trigger-control-plane-grant in 0.44.0) \u2014 a separate reach dimension a scope clause can carry that /v1/ping does not report, so allowedActions+dataScope may understate a credential's true reach. Also reports mcpServerVersion and sdkVersion (this build's own version and the bundled @vectros-ai/sdk version). The /v1/ping backing call ships the extended shape today; the version fields are always client-derived.",
   mimeType: "application/json",
   read: async () => {
     const identity = await resolveIdentity({ log, apiKey, environment });
@@ -12659,11 +13784,12 @@ var ALL_RESOURCE_FACTORIES = {
 };
 
 // src/zod-to-json-schema.ts
-var import_zod24 = require("zod");
+var import_zod27 = require("zod");
 function zodShapeToJsonSchema(shape) {
   const properties = {};
   const required = [];
-  for (const [name, schema] of Object.entries(shape)) {
+  for (const [name, entry] of Object.entries(shape)) {
+    const schema = entry;
     properties[name] = zodTypeToJsonSchema(schema);
     if (!schema.isOptional()) required.push(name);
   }
@@ -12672,43 +13798,45 @@ function zodShapeToJsonSchema(shape) {
   return out;
 }
 function zodTypeToJsonSchema(schema) {
-  const description = schema.description;
+  const descriptionOf = (s) => s.description;
+  let description = descriptionOf(schema);
   let current = schema;
-  while (current instanceof import_zod24.z.ZodOptional || current instanceof import_zod24.z.ZodDefault || current instanceof import_zod24.z.ZodNullable) {
+  while (current instanceof import_zod27.z.ZodOptional || current instanceof import_zod27.z.ZodDefault || current instanceof import_zod27.z.ZodNullable) {
     current = current._def.innerType;
+    description ??= descriptionOf(current);
   }
   const base = description ? { description } : {};
-  if (current instanceof import_zod24.z.ZodString) {
+  if (current instanceof import_zod27.z.ZodString) {
     return { ...base, type: "string" };
   }
-  if (current instanceof import_zod24.z.ZodNumber) {
+  if (current instanceof import_zod27.z.ZodNumber) {
     return { ...base, type: "number" };
   }
-  if (current instanceof import_zod24.z.ZodBoolean) {
+  if (current instanceof import_zod27.z.ZodBoolean) {
     return { ...base, type: "boolean" };
   }
-  if (current instanceof import_zod24.z.ZodEnum) {
+  if (current instanceof import_zod27.z.ZodEnum) {
     return {
       ...base,
       type: "string",
       enum: current.options
     };
   }
-  if (current instanceof import_zod24.z.ZodArray) {
+  if (current instanceof import_zod27.z.ZodArray) {
     return {
       ...base,
       type: "array",
       items: zodTypeToJsonSchema(current.element)
     };
   }
-  if (current instanceof import_zod24.z.ZodObject) {
+  if (current instanceof import_zod27.z.ZodObject) {
     return {
       ...base,
       ...zodShapeToJsonSchema(current.shape)
     };
   }
-  if (current instanceof import_zod24.z.ZodRecord) {
-    const valueType = current._def.valueType;
+  if (current instanceof import_zod27.z.ZodRecord) {
+    const valueType = current.valueType;
     return {
       ...base,
       type: "object",
@@ -12836,7 +13964,7 @@ var VectrosMCPServer = class {
       if (!tool) {
         result = toolError(req.params.name ?? "unknown", new Error("No such tool."));
       } else {
-        const parsed = import_zod25.z.object(tool.inputSchema).strict().safeParse(req.params.arguments ?? {});
+        const parsed = import_zod28.z.object(tool.inputSchema).strict().safeParse(req.params.arguments ?? {});
         if (!parsed.success) {
           result = toolError(tool.name, new Error(formatArgError(tool, parsed.error)));
         } else {
@@ -12899,7 +14027,7 @@ var VectrosMCPServer = class {
    *
    * If `validateOnStart` (default true) is enabled, performs a
    * GET /v1/ping check BEFORE wiring the transport. On failure,
-   * throws — the partner's MCP client sees a startup error instead
+   * throws — your MCP client sees a startup error instead
    * of a confusing "tools work but the first call 401s" experience.
    */
   async connect(transport) {