@vectros-ai/mcp-server 0.18.2 → 0.19.0

package/dist/index.js

@@ -42,7 +42,7 @@ module.exports = __toCommonJS(index_exports);
 // 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 __export2 = (target, all) => {
   for (var name in all)
@@ -63,6 +63,7 @@ __export2(api_exports, {
   ContentTooLargeError: () => ContentTooLargeError,
   DocumentAskRequest: () => DocumentAskRequest,
   DocumentContextEvent: () => DocumentContextEvent,
+  DocumentExtraction: () => DocumentExtraction,
   DocumentLookupRequest: () => DocumentLookupRequest,
   DocumentPatchRequest: () => DocumentPatchRequest,
   DocumentRequest: () => DocumentRequest,
@@ -115,6 +116,7 @@ __export2(api_exports, {
   UserExistsResponse: () => UserExistsResponse,
   UserRequest: () => UserRequest,
   UserResponse: () => UserResponse,
+  agents: () => agents_exports,
   auth: () => auth_exports,
   compliance: () => compliance_exports,
   documents: () => documents_exports,
@@ -380,6 +382,7 @@ var UnprocessableEntityError = class extends VectrosError {
     this.name = this.constructor.name;
   }
 };
+var agents_exports = {};
 var auth_exports = {};
 var ErasureRequest;
 ((ErasureRequest2) => {
@@ -584,6 +587,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 = {
@@ -1889,13 +1904,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) => {
@@ -2410,48 +2425,675 @@ function normalizeClientOptionsWithAuth(options) {
       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, path) {
-  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} ${path}.`, {
-        cause: error.cause
-      });
-    case "unknown":
-      throw new VectrosError({
-        message: error.errorMessage,
-        rawResponse,
-        cause: error.cause
-      });
-    default:
-      throw new VectrosError({
-        message: "Unknown error",
-        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, path) {
+  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} ${path}.`, {
+        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}");
+  }
+  /**
+   * 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.
+   */
+  createRun(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__createRun(request, requestOptions));
+  }
+  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 (_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
+          });
+      }
+    }
+    return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/runs");
   }
-}
+};
 var AuthClient = class {
   constructor(options) {
     this._options = normalizeClientOptionsWithAuth(options);
@@ -2999,9 +3641,7 @@ var AuthClient = class {
    * @example
    *     await client.auth.createAccessProfile({
    *         contextId: "contextId",
-   *         body: {
-   *             principalId: "usr_6ba7b810-9dad-11d1-80b4-00c04fd430c8"
-   *         }
+   *         body: {}
    *     })
    */
   createAccessProfile(request, requestOptions) {
@@ -3137,10 +3777,7 @@ var AuthClient = class {
    *
    * @example
    *     await client.auth.createAppContext({
-   *         body: {
-   *             contextId: "myapp",
-   *             name: "My Internal App"
-   *         }
+   *         body: {}
    *     })
    */
   createAppContext(request, requestOptions) {
@@ -3283,13 +3920,7 @@ var AuthClient = class {
    * @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) {
@@ -3433,9 +4064,7 @@ var AuthClient = class {
    *     await client.auth.updateAccessProfile({
    *         contextId: "contextId",
    *         principalId: "principalId",
-   *         body: {
-   *             principalId: "usr_6ba7b810-9dad-11d1-80b4-00c04fd430c8"
-   *         }
+   *         body: {}
    *     })
    */
   updateAccessProfile(request, requestOptions) {
@@ -3638,10 +4267,7 @@ var AuthClient = class {
    * @example
    *     await client.auth.updateAppContext({
    *         contextId: "contextId",
-   *         body: {
-   *             contextId: "myapp",
-   *             name: "My Internal App"
-   *         }
+   *         body: {}
    *     })
    */
   updateAppContext(request, requestOptions) {
@@ -3846,13 +4472,7 @@ var AuthClient = class {
    *     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) {
@@ -5304,7 +5924,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.
@@ -5314,6 +5934,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"
    *     })
    */
@@ -5321,11 +5942,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
     };
@@ -5375,9 +5997,7 @@ var DocumentsClient = class {
    *
    * @example
    *     await client.documents.ingestDocument({
-   *         body: {
-   *             title: "Patient Intake Form \u2014 Jane Doe"
-   *         }
+   *         body: {}
    *     })
    */
   ingestDocument(request, requestOptions) {
@@ -5507,9 +6127,7 @@ var DocumentsClient = class {
    * @example
    *     await client.documents.updateDocument({
    *         id: "id",
-   *         body: {
-   *             title: "Patient Intake Form \u2014 Jane Doe"
-   *         }
+   *         body: {}
    *     })
    */
   updateDocument(request, requestOptions) {
@@ -5907,11 +6525,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: 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, 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
@@ -5923,7 +6542,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,
@@ -5937,7 +6560,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,
@@ -5949,6 +6572,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:
@@ -6168,9 +6793,7 @@ var FoldersClient = class {
    *
    * @example
    *     await client.folders.createFolder({
-   *         body: {
-   *             name: "Patient Records 2024"
-   *         }
+   *         body: {}
    *     })
    */
   createFolder(request, requestOptions) {
@@ -6298,9 +6921,7 @@ var FoldersClient = class {
    * @example
    *     await client.folders.updateFolder({
    *         id: "id",
-   *         body: {
-   *             name: "Patient Records 2024"
-   *         }
+   *         body: {}
    *     })
    */
   updateFolder(request, requestOptions) {
@@ -6433,9 +7054,7 @@ var FoldersClient = class {
    * @example
    *     await client.folders.patchFolder({
    *         id: "id",
-   *         body: {
-   *             name: "Patient Records 2024"
-   *         }
+   *         body: {}
    *     })
    */
   patchFolder(request, requestOptions) {
@@ -6650,9 +7269,7 @@ var IdentityClient = class {
    *     await client.identity.createEntity({
    *         namespace: "team",
    *         contextId: "myapp",
-   *         body: {
-   *             externalId: "team_eng_platform"
-   *         }
+   *         body: {}
    *     })
    */
   createEntity(request, requestOptions) {
@@ -6788,9 +7405,7 @@ var IdentityClient = class {
    *         namespace: "team",
    *         id: "id",
    *         contextId: "myapp",
-   *         body: {
-   *             externalId: "team_eng_platform"
-   *         }
+   *         body: {}
    *     })
    */
   updateEntity(request, requestOptions) {
@@ -7130,10 +7745,7 @@ var IdentityClient = class {
    * @example
    *     await client.identity.updateNamespace({
    *         namespace: "team",
-   *         body: {
-   *             namespace: "team",
-   *             specificityRank: 1500
-   *         }
+   *         body: {}
    *     })
    */
   updateNamespace(request, requestOptions) {
@@ -7320,10 +7932,7 @@ var IdentityClient = class {
    *
    * @example
    *     await client.identity.registerNamespace({
-   *         body: {
-   *             namespace: "team",
-   *             specificityRank: 1500
-   *         }
+   *         body: {}
    *     })
    */
   registerNamespace(request, requestOptions) {
@@ -7456,9 +8065,7 @@ var IdentityClient = class {
    *
    * @example
    *     await client.identity.createUser({
-   *         body: {
-   *             externalId: "usr_12345"
-   *         }
+   *         body: {}
    *     })
    */
   createUser(request, requestOptions) {
@@ -7577,6 +8184,7 @@ var IdentityClient = class {
    * @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}
@@ -7584,9 +8192,7 @@ var IdentityClient = class {
    * @example
    *     await client.identity.updateUser({
    *         id: "550e8400-e29b-41d4-a716-446655440000",
-   *         body: {
-   *             externalId: "usr_12345"
-   *         }
+   *         body: {}
    *     })
    */
   updateUser(request, requestOptions) {
@@ -7624,6 +8230,8 @@ 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:
@@ -7646,6 +8254,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}
@@ -7685,6 +8294,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:
@@ -7889,7 +8500,7 @@ var InferenceClient = class {
     this._options = normalizeClientOptionsWithAuth(options);
   }
   /**
-   * 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, and `longContext` for prompts over its threshold. 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`.
+   * 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.
    *
@@ -7933,7 +8544,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. 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 small per-call flat fee is charged to your monthly credit allowance, except when the call fails on the server side. 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));
@@ -8005,7 +8616,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));
@@ -9140,8 +9751,7 @@ var SchemasClient = class {
    *                 }],
    *             capabilities: {
    *                 "auditHistory": true
-   *             },
-   *             allowedSurfaces: ["record"]
+   *             }
    *         }
    *     })
    */
@@ -9271,11 +9881,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) {
@@ -9815,7 +10421,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.
@@ -10079,17 +10685,7 @@ var TriggersClient = class {
    *
    * @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) {
@@ -10218,17 +10814,7 @@ var TriggersClient = class {
    * @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) {
@@ -10353,6 +10939,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));
   }
@@ -10418,7 +11007,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)_/;
@@ -10462,8 +11051,8 @@ function warnOnSuboptimalKey(key, log) {
 
 // src/build-info.ts
 var BUILD_INFO = {
-  mcpServer: true ? "0.18.2" : "dev",
-  sdk: true ? "0.48.0" : "dev"
+  mcpServer: true ? "0.19.0" : "dev",
+  sdk: true ? "0.49.0" : "dev"
 };
 
 // src/log.ts
@@ -10719,6 +11308,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;
@@ -10761,11 +11355,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.
@@ -10773,7 +11367,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.
@@ -11294,7 +11888,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.'
   )
 };
@@ -11352,7 +11946,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."
   )
 });
@@ -11509,7 +12103,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. 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` (it was signed, but its text changed afterwards, so the earlier signature no longer counts), 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."
+  "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
@@ -11536,14 +12130,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(
@@ -11818,7 +12412,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 },
@@ -11844,7 +12438,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 {
@@ -11897,10 +12491,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(
@@ -11914,7 +12510,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 },
@@ -11973,7 +12569,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,
@@ -11981,7 +12589,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"
         );
       }
@@ -12016,7 +12624,7 @@ 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(
@@ -12160,7 +12768,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.'
   )
 };
@@ -12206,7 +12814,7 @@ 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(
@@ -12255,7 +12863,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.
@@ -12408,14 +13016,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
@@ -12557,7 +13165,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: [
           {
@@ -12730,6 +13338,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",
@@ -12754,7 +13721,10 @@ var TOOL_NAMES = [
   "current_identity",
   "document_ingest",
   "lookup_principal",
-  "version_history"
+  "version_history",
+  "agent_list",
+  "agent_run",
+  "run_get"
 ];
 
 // src/tools/index.ts
@@ -12781,7 +13751,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
@@ -12824,11 +13797,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);
   }
@@ -12837,43 +13811,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",
@@ -13001,7 +13977,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 {
@@ -13064,7 +14040,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) {