@vectros-ai/mcp-server 0.15.0 → 0.16.1

package/dist/cli.js

@@ -2515,7 +2515,7 @@ var AuthClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/admin/keys/scoped");
   }
   /**
-   * Creates a scoped API key (an `ssk_*` secret) that inherits its permissions from an existing access profile in your account. The call is idempotent on the combination of tenant, context, user, and key name: re-issuing the same request returns the existing key WITHOUT re-disclosing its raw secret. The raw key is returned ONLY in this response — store it securely, as it cannot be retrieved again. Requires the `keys:c` scope. If you use a scoped credential, `keys:c` alone is not sufficient: because the minted key is durably bound to the profile you name, the profile's effective scopes may not exceed your own, and you may only mint against a profile whose `identityOverrides` values your own identity holds. A root API key (`sk_`) is exempt from both bounds.
+   * Creates a scoped API key (an `ssk_*` secret) that inherits its permissions from an existing access profile in your account. The call is idempotent on the combination of tenant, context, user, and key name: re-issuing the same request returns the existing key WITHOUT re-disclosing its raw secret. The raw key is returned ONLY in this response — store it securely, as it cannot be retrieved again. Requires the `keys:c` scope. If you use a scoped credential, `keys:c` alone is not sufficient: because the minted key is durably bound to the profile you name, the profile's effective scopes may not exceed your own, and you may only mint against a profile whose `identityOverrides` values your own identity holds. Minting a key bound to your OWN principal needs nothing further; minting one bound to a DIFFERENT principal additionally requires the `delegate-mint` capability (`granted_capabilities`) on your credential — without it the request is refused. A root API key (`sk_`) is exempt from all three bounds.
    *
    * @param {Vectros.CreateScopedKeyRequest} request
    * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -4011,7 +4011,7 @@ var AuthClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/usage");
   }
   /**
-   * Retrieves a single registered issuer by issuerId. Requires a root API key or the bootstrap's provisioning capability. A credential confined to one app context sees only an issuer registered in that context; naming one registered in another context returns 404, identically to a nonexistent issuerId. A root API key sees every context.
+   * Retrieves a single registered issuer by issuerId. Requires a root API key or the bootstrap's provisioning capability. A credential confined to one app context sees only an issuer registered in that context; naming one registered in another context returns 404, identically to a nonexistent issuerId. A root API key sees every context. An ordinary bootstrap credential that didn't specify a context resolves to the `default` app context specifically, not every context — so this call returns 404 for an issuer registered under any other context unless you re-minted the bootstrap token pinned to that context.
    *
    * @param {Vectros.GetIssuerRequest} request
    * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -4068,6 +4068,73 @@ var AuthClient = class {
     }
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/auth/issuers/{issuerId}");
   }
+  /**
+   * Updates the mutable fields of a registered issuer: `subClaim`, `emailClaim`, `status` (`active`/`suspended` — a suspended issuer's tokens are rejected identically to an unregistered issuer at exchange time), and `selfSignupPolicies`. Fields omitted from the body are left unchanged (partial update). `issuer`, `jwksUri`, `audience`, and `contextId` are trust-anchor / routing-pin fields and are immutable via this route — supplying a value that differs from the current registration is rejected with 400; supplying the current value back is a no-op. Rotating a trust anchor requires deleting and re-registering the issuer, which is itself refused while any user is bound through it. Requires a root API key or the bootstrap's provisioning capability, gated identically to every other operation on this surface. A credential confined to one app context may only update an issuer registered in that context; naming one registered in another context returns 404, identically to a nonexistent issuerId. A root API key may update any issuer.
+   *
+   * @param {Vectros.IssuerUpdateRequest} request
+   * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link Vectros.BadRequestError}
+   * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
+   * @throws {@link Vectros.TooManyRequestsError}
+   *
+   * @example
+   *     await client.auth.updateIssuer({
+   *         issuerId: "auth0-prod"
+   *     })
+   */
+  updateIssuer(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__updateIssuer(request, requestOptions));
+  }
+  async __updateIssuer(request, requestOptions) {
+    const { issuerId, ..._body } = request;
+    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/auth/issuers/${url_exports.encodePathParam(issuerId)}`
+      ),
+      method: "PUT",
+      headers: _headers,
+      contentType: "application/json",
+      queryString: url_exports.queryBuilder().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 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/auth/issuers/{issuerId}");
+  }
   /**
    * Deregisters a trusted third-party IdP issuer. Requires a root API key or the bootstrap's provisioning capability. A credential confined to one app context may only deregister an issuer registered in that context; naming one registered in another context returns 404, identically to a nonexistent issuerId. A root API key may deregister any issuer. Refused if any user account was ever created or matched via this issuer (by a prior self-signup or accepted invite, through `POST /v1/auth/token/exchange`) — that access cannot be silently orphaned. Deactivate the affected users first if you intend to cut off their access, or register a replacement issuer before removing this one. An issuer that has never been used for an exchange (no bound users yet) can always be deregistered.
    *
@@ -4138,7 +4205,7 @@ var AuthClient = class {
     );
   }
   /**
-   * Returns the issuers registered in your tenant. Requires a root API key or the bootstrap's provisioning capability. A credential confined to one app context sees only the issuers registered in that context; a root API key sees every context. Returns a `{data, nextCursor}` envelope.
+   * Returns the issuers registered in your tenant. Requires a root API key or the bootstrap's provisioning capability. A credential confined to one app context sees only the issuers registered in that context; a root API key sees every context. An ordinary bootstrap credential that didn't specify a context resolves to the `default` app context specifically, not every context — so this call returns an empty page for a tenant whose issuers are all registered under a different context unless you re-minted the bootstrap token pinned to that context. Returns a `{data, nextCursor}` envelope.
    *
    * @param {Vectros.ListIssuersRequest} request
    * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -4195,7 +4262,7 @@ var AuthClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/auth/issuers");
   }
   /**
-   * Registers a trusted third-party IdP issuer that BYO-IdP token exchange (`POST /v1/auth/token/exchange`) may accept a `subject_token` from. Requires a root API key or the CLI bootstrap's provisioning capability — never an ordinary partner-grantable scope. Idempotent by `issuerId` within your tenant; the `(issuer, audience)` pair must not already be registered by a different issuerId/tenant. An app context may have at most one active issuer — deregister the existing one first if you need to replace it. One issuer MAY serve several contexts today, each via its own registration row with a distinct `audience`.
+   * Registers a trusted third-party IdP issuer that BYO-IdP token exchange (`POST /v1/auth/token/exchange`) may accept a `subject_token` from. Requires a root API key or the CLI bootstrap's provisioning capability — never an ordinary partner-grantable scope. A credential authorized only via the provisioning capability may register only against the app context it is bound to; naming a different one returns 403. A root API key is unaffected and may register against any of its contexts. Idempotent by `issuerId` within your tenant; the `(issuer, audience)` pair must not already be registered by a different issuerId/tenant. If `issuerId` collides with a registration owned by a different app context than the one you're confined to, the request fails with 400 rather than returning that context's configuration. An app context may have at most one active issuer — deregister the existing one first if you need to replace it. One issuer MAY serve several contexts today, each via its own registration row with a distinct `audience`.
    *
    * @param {Vectros.IssuerRequest} request
    * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -4380,6 +4447,7 @@ var AuthClient = class {
    *
    * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.NotFoundError}
    * @throws {@link Vectros.TooManyRequestsError}
    *
    * @example
@@ -4433,6 +4501,8 @@ var AuthClient = class {
           throw new BadRequestError(_response.error.body, _response.rawResponse);
         case 403:
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
+        case 404:
+          throw new NotFoundError(_response.error.body, _response.rawResponse);
         case 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
         default:
@@ -4446,7 +4516,7 @@ var AuthClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/auth/token");
   }
   /**
-   * Invite a new member to one of your app contexts by email. Creates a pending user with a pre-resolved access profile (their permissions on accept) and signs an invitation token. This call is idempotent on the combination of context and email: re-inviting the same email in the same context rotates the token and resends the invitation rather than creating a duplicate — this requires the `users:r` and `users:u` scopes in addition to `users:c`, because resending rotates a credential on an existing invitation and invalidates any link already sent. Without them the collision returns 409 instead, with no invitation details and no change to the outstanding invitation. Returns HTTP 201 on a new invite or a successful resend. Returns 409 if that email already belongs to an active or suspended member of the app context, or already has an identity elsewhere in your account (an email can currently belong to only one tenant per account, i.e. your test and live environments cannot share an email). When `sendEmail` is false, the response includes the raw token and a ready-to-use accept link so you can deliver the invitation through your own email provider. Requires the `users:c` scope.
+   * Invite a new member to one of your app contexts by email, OR grant an existing member access to an additional app context by inviting their same email again. Idempotent on the combination of context and email: re-inviting the same email into the SAME context rotates the token and resends the invitation rather than creating a duplicate — this requires the `users:r` and `users:u` scopes in addition to `users:c`, because resending rotates a credential on an existing invitation and invalidates any link already sent. Without them the collision returns 409 instead, with no invitation details and no change to the outstanding invitation. Inviting the SAME email into a DIFFERENT app context in this tenant, where that email already resolves to an existing member: if that member is active AND already has (or, once accepted, will have) a credential that works for the new context's own identity provider, this immediately grants them access to the new context (no email is sent — there is nothing to accept, `emailSent` is false) — this additionally requires the `users:r` scope (no `users:u`, since nothing is mutated), because the response names the existing member's userId, a fact about them your credential could not otherwise learn through this endpoint. If that active member's ONLY existing credential is for a DIFFERENT identity provider than the one the new context uses, a normal, independent invitation is created instead (its own new member id, a real token/accept link) — attaching them silently would leave no way for them to ever actually sign in to that context. If the existing member's original invitation is still pending, this attaches the new context's access to that same outstanding invitation and rotates its token (`users:r`+`users:u`, same as an ordinary resend — both the disclosure and the credential rotation apply here). A SUSPENDED member's email does not get new-context access this way — reactivate them explicitly first. Returns HTTP 201 in every one of those cases. Returns 409 if that email already belongs to an active or suspended member of THIS specific app context, already has a PENDING invitation for THIS specific app context, or resolves to an existing member elsewhere in the tenant and your token lacks the additional scope the grant/attach requires (`users:r`, or `users:r`+`users:u` for the still-pending case). An email that already has an identity in your OTHER tenant (test vs. live) is not a collision either — it creates an additional, independent membership in this tenant for that same identity. When `sendEmail` is false, the response includes the raw token and a ready-to-use accept link so you can deliver the invitation through your own email provider. Requires the `users:c` scope — or, for a credential scoped to a single app context, the `member-lifecycle` capability plus the matching `profiles:c`/`profiles:r`/`profiles:u` grant(s) in that context, as an equally sufficient alternative to every `users:c`/`users:r`/`users:u` requirement in this description.
    *
    * @param {Vectros.CreateInviteRequest} request
    * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -4517,7 +4587,7 @@ var AuthClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/users/invite");
   }
   /**
-   * Resend an outstanding invitation, identified by its email and app context. Rotates the invitation token and extends its expiry, then (when `sendEmail` is true) re-delivers the email. Rotating the token invalidates any previously issued link for this invitation, so only the newest link works. The invitee's pending permissions are left unchanged. Because this rotates a credential on an existing invitation, it requires the `users:c`, `users:r` and `users:u` scopes.
+   * Resend an outstanding invitation, identified by its email and app context. Rotates the invitation token and extends its expiry, then (when `sendEmail` is true) re-delivers the email. Rotating the token invalidates any previously issued link for this invitation, so only the newest link works. The invitee's pending permissions are left unchanged. Because this rotates a credential on an existing invitation, it requires the `users:c`, `users:r` and `users:u` scopes — or, for a credential scoped to a single app context, the `member-lifecycle` capability plus the matching `profiles:c`/`profiles:r`/`profiles:u` grant(s) in that context.
    *
    * @param {Vectros.CreateInviteRequest} request
    * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -4584,6 +4654,83 @@ var AuthClient = class {
     }
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/users/invite/resend");
   }
+  /**
+   * Re-mints the presented `st_*` scoped token with one or more `identity.<namespace>` values changed — for a caller whose ROLE explicitly grants assuming those values (an invited hr-admin, a multi-org case-handler) and needs to change which value new writes place records under. The request body names one or more namespaces in canonical `scope:<namespace>` form, e.g. `{"scope:org": "orgB"}` — each value must be a plain literal, never a `${{ ... }}` placeholder. When you name MORE THAN ONE namespace, a single one of your roles must grant all of them together: the combination is never assembled from two different roles, because no role author would have vouched for it. `st_*`-only — a root API key or `ssk_*` scoped API key gets 403; neither needs this (root already has full authority, and an `ssk_*`'s identity shape is not what this resolves against).
+   *
+   * **Only an original token may assume.** A token produced BY this endpoint cannot assume again (403) — every assume starts from the token you exchanged for, so the identity you end up with is always one a single role explicitly granted rather than a combination reached by chaining calls. Keep your original token if you need to switch more than once, or exchange for a new one.
+   *
+   * **Entitlement is checked LIVE, against your roles as they are right now** — not against a copy frozen into your token when it was minted. The requested value must be explicitly granted by a role's `assumable` field for that namespace: a POINT check against the one value requested, and a deliberately separate, explicitly-authored question from what the role's `data_scope` permits reading or writing. Holding broad `data_scope` reach in a namespace does NOT by itself grant assuming any value in it.
+   *
+   * **What is preserved, and what is not.** Every clause of your token that does not reference a requested namespace is preserved verbatim, as are all other claims (`partner_user_id`, `context_id`, mint attribution). Clauses that DO reference a requested namespace are kept only if they come from a role that authorized the new value. A role that does not authorize it loses all of its clauses touching that namespace — including any scoped to the value you already held. Assume into a value one role grants and you keep that role's reach, not the reach of roles that never vouched for it.
+   *
+   * The re-minted token's `exp` is IDENTICAL to the presented token's — this call can never extend a session's life. A fresh, independently-revocable `jti` is stamped on every call, and (except when the presented token predates jti support and has none to chain from) the token also carries a `root_jti` revocation-lineage claim so revoking the token you started from closes every value ever assumed from it. Uses the ordinary Vectros `{"message":...}` error shape, not the OAuth envelope `POST /v1/auth/token/exchange` uses — this endpoint's caller is always Vectros-SDK code already holding a bearer token, never generic OAuth tooling.
+   *
+   * @param {Record<string, unknown>} request
+   * @param {AuthClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @throws {@link Vectros.BadRequestError}
+   * @throws {@link Vectros.UnauthorizedError}
+   * @throws {@link Vectros.ForbiddenError}
+   * @throws {@link Vectros.ConflictError}
+   * @throws {@link Vectros.TooManyRequestsError}
+   *
+   * @example
+   *     await client.auth.assumeToken({
+   *         "scope:org": "orgB"
+   *     })
+   */
+  assumeToken(request, requestOptions) {
+    return HttpResponsePromise.fromPromise(this.__assumeToken(request, requestOptions));
+  }
+  async __assumeToken(request, requestOptions) {
+    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/auth/token/assume"
+      ),
+      method: "POST",
+      headers: _headers,
+      contentType: "application/json",
+      queryString: url_exports.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+      requestType: "json",
+      body: request,
+      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 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/auth/token/assume");
+  }
   /**
    * RFC 8693 OAuth 2.0 Token Exchange. Trades a JWT issued by a third-party identity provider you've registered (`POST /v1/auth/issuers`) for a Vectros `st_*` scoped bearer token — no Vectros credential required to call this endpoint. The exchanged token's scope is resolved entirely server-side from the matched user's access profile; this endpoint accepts no caller-supplied scope, resource, or audience parameter (RFC 8693 §2.1's `resource`/`audience`/`scope` are not used in v1 — the registered `(issuer, audience)` pair alone pins the target tenant and app context). On a first-time login (no existing Vectros identity for this subject), two opt-in binding paths exist: `invite_token` (a `PENDING` sub-user invitation), and — if the registration declares one or more self-signup policies — `signup_type` (a brand-new user is created and bound to the policy's configured role). If `invite_token` is present at all, it is the ONLY path tried — a failed invite never falls through to self-signup. Neither field is required for a subject with an existing identity. If your issuer is registered against more than one app context (each via its own audience), `context_id` selects which one to target; omit it when your token's `aud` claim matches only one registered context — the common case, unaffected by this field. Uses the OAuth-standard error envelope (`{"error":..., "error_description":...}`, RFC 6749 §5.2), NOT this API's usual `{"message":...}` shape — its client is generic OAuth tooling, not the Vectros SDK.
    *
@@ -4661,9 +4808,9 @@ var ComplianceClient = class {
    * @param {Vectros.ErasureRequest} request
    * @param {ComplianceClient.RequestOptions} requestOptions - Request-specific configuration.
    *
+   * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.TooManyRequestsError}
-   * @throws {@link Vectros.NotImplementedError}
    *
    * @example
    *     await client.compliance.createErasureRequest({
@@ -4702,12 +4849,12 @@ var ComplianceClient = class {
     }
     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 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
-        case 501:
-          throw new NotImplementedError(_response.error.body, _response.rawResponse);
         default:
           throw new VectrosError({
             statusCode: _response.error.statusCode,
@@ -4726,7 +4873,6 @@ var ComplianceClient = class {
    *
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
-   * @throws {@link Vectros.NotImplementedError}
    *
    * @example
    *     await client.compliance.getErasureRequest({
@@ -4767,8 +4913,6 @@ var ComplianceClient = class {
           throw new ForbiddenError(_response.error.body, _response.rawResponse);
         case 404:
           throw new NotFoundError(_response.error.body, _response.rawResponse);
-        case 501:
-          throw new NotImplementedError(_response.error.body, _response.rawResponse);
         default:
           throw new VectrosError({
             statusCode: _response.error.statusCode,
@@ -5316,7 +5460,21 @@ var DocumentsClient = class {
     return HttpResponsePromise.fromPromise(this.__lookupDocuments(request, requestOptions));
   }
   async __lookupDocuments(request, requestOptions) {
-    const { type: type_, field, value, from: from_, to, prefix, startFrom, limit, order, userId, scope } = request;
+    const {
+      type: type_,
+      field,
+      value,
+      from: from_,
+      to,
+      prefix,
+      sortFrom,
+      sortTo,
+      startFrom,
+      limit,
+      order,
+      userId,
+      scope
+    } = request;
     const _queryParams = {
       type: type_,
       field,
@@ -5324,6 +5482,8 @@ var DocumentsClient = class {
       from: from_,
       to,
       prefix,
+      sortFrom,
+      sortTo,
       startFrom,
       limit,
       order: order != null ? order : void 0,
@@ -6608,7 +6768,7 @@ var IdentityClient = class {
     );
   }
   /**
-   * Retrieves a single scope-namespace registration by name. The reserved built-ins `org` and `client` are always resolvable.
+   * Retrieves a single scope-namespace registration by name.
    *
    * @param {Vectros.GetNamespaceRequest} request
    * @param {IdentityClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -6801,7 +6961,7 @@ var IdentityClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "DELETE", "/v1/namespaces/{namespace}");
   }
   /**
-   * Returns the scope namespaces in your account, including `org` and `client`, which are provisioned for you when the account is created. Returns a `{data, nextCursor}` envelope.
+   * Returns the scope namespaces registered in your account. Returns a `{data, nextCursor}` envelope.
    *
    * @param {Vectros.ListNamespacesRequest} request
    * @param {IdentityClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -6852,7 +7012,7 @@ var IdentityClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/namespaces");
   }
   /**
-   * Registers a new scope namespace and declares whether its values resolve to identity entities (`entityBacked`). Also requires `specificityRank`, an explicit, account-unique position in the specificity order used to break recordType schema-resolution ties. Requires a root API key or the CLI bootstrap's provisioning capability — never an ordinary partner-grantable scope. `org` and `client` are provisioned when your account is created, so registering either returns the already-registered error.
+   * Registers a new scope namespace and declares whether its values resolve to identity entities (`entityBacked`). Also requires `specificityRank`, an explicit, account-unique position in the specificity order used to break recordType schema-resolution ties. Requires a root API key or one of the CLI bootstrap's two provisioning capabilities — never an ordinary partner-grantable scope. A bootstrap credential's registration is confined to its own app context UNLESS it additionally holds the tenant-wide namespace-provisioning capability and `contextId` is omitted, in which case it may register a TENANT-WIDE namespace (visible to every context). `org` and `client` are reserved names, registered the same way as any other namespace.
    *
    * @param {Vectros.RegisterNamespaceRequest} request
    * @param {IdentityClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -6922,7 +7082,7 @@ var IdentityClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/namespaces");
   }
   /**
-   * Returns a paginated list of the users in your account. Pass `externalId` to look up a single user by your own identifier. To filter on schema-declared lookup fields, supply `type` and `field` together with one lookup mode: `value` (exact match), `from`+`to` (range), or `prefix`. Requires the `users:r` scope.
+   * Returns a paginated list of the users in your account. Pass `externalId` to look up a single user by your own identifier. To filter on schema-declared lookup fields, supply `type` and `field` together with one lookup mode: `value` (exact match), `from`+`to` (range), or `prefix`. Requires the `users:r` scope. A context-confined credential only sees users who hold an access profile in the credential's own app context — others are silently absent from the page, not an error.
    *
    * @param {Vectros.ListUsersRequest} request
    * @param {IdentityClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -6987,7 +7147,7 @@ var IdentityClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/users");
   }
   /**
-   * Creates a user identity in your account. The operation is idempotent on `externalId`: if a user with the same `externalId` already exists, the existing record is returned instead of creating a duplicate. The response's `created` field (and the HTTP status — 201 when created, 200 when an existing user was returned) tells the two apart. To overwrite an existing user's mutable fields (email, status, payload, schema binding) instead of returning it unchanged, set `?upsert=true` (this also requires the `users:u` scope). Requires the `users:c` scope to create. Being returned the existing user on a collision is a read of that user's data and additionally requires the `users:r` scope — a credential holding `users:c` alone receives a `400` ("already exists") on collision instead of the user.
+   * Creates a user identity in your account. The operation is idempotent on `externalId`: if a user with the same `externalId` already exists, the existing record is returned instead of creating a duplicate. The response's `created` field (and the HTTP status — 201 when created, 200 when an existing user was returned) tells the two apart. To overwrite an existing user's mutable fields (email, status, payload, schema binding) instead of returning it unchanged, set `?upsert=true` (this also requires the `users:u` scope). Requires the `users:c` scope to create. Being returned the existing user on a collision is a read of that user's data and additionally requires the `users:r` scope — a credential holding `users:c` alone receives a `400` ("already exists") on collision instead of the user. A context-confined credential additionally receives the collision echo (or, with `?upsert=true`, is allowed to overwrite) only when the colliding user holds an access profile in the credential's own app context — a cross-context collision otherwise gets the same uniform `400` instead of the other context's user data. One narrow exception on the plain (non-upsert) echo only: the CLI's no-code bootstrap credential can be echoed a colliding user across app contexts, needed for a blueprint to idempotently re-apply against a service principal it provisioned in a non-default context; this does not extend to `?upsert=true`.
    *
    * @param {Vectros.CreateUserRequest} request
    * @param {IdentityClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -7111,7 +7271,7 @@ var IdentityClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/users/{id}");
   }
   /**
-   * Updates mutable fields on an existing user (such as email, status, payload, or schema binding). The `type` field is immutable after creation, and `email` cannot be changed while an invitation to that user is still outstanding — revoke the invitation, or invite the new address instead. This endpoint also activates an invited user: a PUT that moves a PENDING user to ACTIVE and carries `inviteToken`, `externalSubject`, and `emailVerifiedAttestation=true` completes the invitation. Requires the `users:u` scope.
+   * Updates mutable fields on an existing user (such as email, status, payload, or schema binding). The `type` field is immutable after creation, and `email` cannot be changed while an invitation to that user is still outstanding — revoke the invitation, or invite the new address instead. This endpoint also activates an invited user: a PUT that moves a PENDING user to ACTIVE and carries `inviteToken`, `externalSubject`, and `emailVerifiedAttestation=true` completes the invitation. **`externalSubject` set this way is NOT an authentication binding and does not enable sign-in anywhere** — not the Vectros DevPortal/Admin App/web apps, and not `/v1/auth/token/exchange` either; both are granted only by the invitee authenticating themselves. If the invitee needs dev-portal/web-app access, send them the invitation link and let them accept it directly. If the invitee needs to sign in via token exchange, have them redeem `inviteToken` themselves at `/v1/auth/token/exchange` with their own credential — Vectros verifies it there and computes its own value for this field from the verified credential. The value you send here is stored exactly as-is, with no normalization, and does NOT automatically match or deduplicate against what a later token-exchange sign-in computes for the same real-world identity. Call this endpoint directly only if you run your own backend and want Vectros to record which of your own users a given account corresponds to — treat this field as informational for that purpose, not as a way to pre-authorize sign-in. Requires the `users:u` scope.
    *
    * @param {Vectros.UpdateUserRequest} request
    * @param {IdentityClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -7178,7 +7338,7 @@ var IdentityClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "PUT", "/v1/users/{id}");
   }
   /**
-   * Permanently deletes a user identity. This cannot be undone. If the user is a pending invitation, the associated access profile created for that invitation is also removed. Requires the `users:d` scope. Deleting your account's last OWNER is refused (409) — an account must always retain at least one owner.
+   * Permanently deletes a user identity. This cannot be undone. If the user is a pending invitation, the associated access profile created for that invitation is also removed. Requires the `users:d` scope. Deleting your account's last OWNER is refused (409) — an account must always retain at least one owner. Called by a context-confined credential, deletion is also refused (409) when the user holds access in an app context other than the caller's own — remove the user from the caller's own context first, or use a credential with cross-context reach.
    *
    * @param {Vectros.DeleteUserRequest} request
    * @param {IdentityClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -7239,7 +7399,7 @@ var IdentityClient = class {
     return handleNonStatusCodeError(_response.error, _response.rawResponse, "DELETE", "/v1/users/{id}");
   }
   /**
-   * Looks up users by a schema lookup field, with the query criteria carried in the request body rather than the URL. Use this when looking up by a sensitive (blind-indexed) field: the value is blind-indexed server-side and never appears in the URL, request logs, or proxies. The query semantics are identical to the GET /v1/users lookup, which rejects sensitive-field values and directs you here. Returns a page in the `{data, nextCursor}` envelope. Requires the `users:r` scope.
+   * Looks up users by a schema lookup field, with the query criteria carried in the request body rather than the URL. Use this when looking up by a sensitive (blind-indexed) field: the value is blind-indexed server-side and never appears in the URL, request logs, or proxies. The query semantics are identical to the GET /v1/users lookup, which rejects sensitive-field values and directs you here. Returns a page in the `{data, nextCursor}` envelope. Requires the `users:r` scope. A context-confined credential only sees users who hold an access profile in the credential's own app context — others are silently absent from the page, not an error.
    *
    * @param {Vectros.IdentityLookupRequest} request
    * @param {IdentityClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -7682,14 +7842,14 @@ var RecordsClient = class {
     this._options = normalizeClientOptionsWithAuth(options);
   }
   /**
-   * Reserved endpoint for fetching multiple records by ID in one call. When available, the response will contain only the records you can see; any IDs that do not exist or are outside your scope are silently omitted (there is no per-ID existence signal), matching the not-found behavior of the single-record GET. It currently returns 501 (not implemented). The documented 200 response schema is the stable shape this endpoint will use once available. Requires the `records:r` scope.
+   * Fetches multiple records by ID in one call (`ids`, maximum 100). The response contains only the records you can access — any id that does not exist, belongs to another account/AppContext, or is outside your token's scope is silently omitted, with no per-id existence signal, matching the not-found behavior of the single-record GET. Payloads are hydrated the same way a by-id GET hydrates them (payloads externalized to object storage are rehydrated for this response). Requires the `records:r` scope (and, for a scoped token, `records:r:<type>` per record type).
    *
    * @param {Vectros.BatchGetRequest} request
    * @param {RecordsClient.RequestOptions} requestOptions - Request-specific configuration.
    *
+   * @throws {@link Vectros.BadRequestError}
    * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.TooManyRequestsError}
-   * @throws {@link Vectros.NotImplementedError}
    *
    * @example
    *     await client.records.batchGetRecords()
@@ -7726,12 +7886,12 @@ var RecordsClient = class {
     }
     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 429:
           throw new TooManyRequestsError(_response.error.body, _response.rawResponse);
-        case 501:
-          throw new NotImplementedError(_response.error.body, _response.rawResponse);
         default:
           throw new VectrosError({
             statusCode: _response.error.statusCode,
@@ -8545,7 +8705,7 @@ var SchemasClient = class {
     this._options = normalizeClientOptionsWithAuth(options);
   }
   /**
-   * Returns a paginated list of the record schemas defined in your account. Filter by `userId` or `scope` to scope to an owner, by `surface` to list the types bindable to one surface, or by `recordType` to resolve the single schema for a type directly. Filtering by an identity surface (`user` or `entity`) lists your account-wide identity schemas regardless of the calling context; filtering by record or document lists within the calling context. Requires the `schemas:r` scope.
+   * Returns a paginated list of the record schemas defined in your account. Filter by `userId` or `scope` to scope to an owner, by `surface` to list the types bindable to one surface, or by `recordType` to resolve the single schema for a type directly. Filtering by `surface=user` lists your account-wide identity schemas regardless of the calling context (a `user`-surfaced schema always has one tenant-wide home). Filtering by `surface=entity` reads your own app context's entity schemas AND the tenant-wide home together, newest first, through a single cursor — an entity schema may live in either home depending on where its namespace is placed (see `POST /v1/namespaces`). Filtering by `record` or `document` lists within the calling context only. Requires the `schemas:r` scope.
    *
    * @param {Vectros.ListSchemasRequest} request
    * @param {SchemasClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -8833,6 +8993,7 @@ var SchemasClient = class {
    * @param {Vectros.DeleteSchemaRequest} request
    * @param {SchemasClient.RequestOptions} requestOptions - Request-specific configuration.
    *
+   * @throws {@link Vectros.ForbiddenError}
    * @throws {@link Vectros.NotFoundError}
    * @throws {@link Vectros.ConflictError}
    * @throws {@link Vectros.TooManyRequestsError}
@@ -8872,6 +9033,8 @@ var SchemasClient = 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:
@@ -9081,7 +9244,7 @@ var logging;
 
 // src/server.ts
 var import_types3 = require("@modelcontextprotocol/sdk/types.js");
-var import_zod22 = require("zod");
+var import_zod23 = require("zod");
 
 // src/auth.ts
 var KEY_RE = /^(sk|ssk|st)_(live|test)_/;
@@ -9125,8 +9288,8 @@ function warnOnSuboptimalKey(key, log) {
 
 // src/build-info.ts
 var BUILD_INFO = {
-  mcpServer: true ? "0.15.0" : "dev",
-  sdk: true ? "0.40.0" : "dev"
+  mcpServer: true ? "0.16.1" : "dev",
+  sdk: true ? "0.42.0" : "dev"
 };
 function formatBuildInfo() {
   return `vectros-mcp-server ${BUILD_INFO.mcpServer} (sdk ${BUILD_INFO.sdk})`;
@@ -9811,23 +9974,70 @@ var recordGet = ({ client, log }) => ({
 });
 var record_get_default = recordGet;
 
-// src/tools/record_create.ts
+// src/tools/record_batch_get.ts
 var import_zod4 = require("zod");
+var MAX_PAYLOAD_CHARS2 = 32e3;
+var MCP_MAX_IDS = 100;
 var inputSchema4 = {
-  type: import_zod4.z.string().min(1, "type is required").describe('Record type / schema name (e.g. "task"). Must match an existing schema \u2014 see list_schemas.'),
-  fields: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).describe(
+  ids: import_zod4.z.array(import_zod4.z.string()).min(1).max(MCP_MAX_IDS).describe(
+    `Record ids to fetch in one call (1-${MCP_MAX_IDS}). Any id you cannot access \u2014 nonexistent, wrong account, or outside your token's scope \u2014 is silently omitted from the response (no per-id existence signal); compare against the response's \`missingIds\` to see which requested ids came back empty.`
+  )
+};
+var recordBatchGet = ({ client, log }) => ({
+  name: "record_batch_get",
+  title: "Get multiple records by id in one call",
+  description: "Fetch several structured records by id in a single call (1-100 ids), each with its full payload \u2014 the same hydration record_get gives a single id. Use this instead of N record_get calls when you already hold several ids (e.g. a page of record_query/hybrid_search results). Any id you can't access is silently omitted from `data`; the response also returns `missingIds` \u2014 every requested id not present in `data` \u2014 so you can tell a partial result from a complete one. As with record_get, an oversized payload is truncated into a labelled `payloadPreview` rather than shipped whole.",
+  inputSchema: inputSchema4,
+  handler: async (args) => {
+    const ids = args.ids;
+    try {
+      const response = await client.records.batchGetRecords({ ids });
+      const records = response.data ?? [];
+      const data = records.map((record) => {
+        const item = { ...record };
+        if (record.payload !== void 0) {
+          const json = JSON.stringify(record.payload);
+          if (json.length > MAX_PAYLOAD_CHARS2) {
+            delete item.payload;
+            item.payloadPreview = json.slice(0, MAX_PAYLOAD_CHARS2);
+            item.payloadTruncated = true;
+            item.payloadTotalChars = json.length;
+          }
+        }
+        return item;
+      });
+      const returnedIds = new Set(records.map((r) => r.id));
+      const missingIds = ids.filter((id) => !returnedIds.has(id));
+      log.debug(
+        { tool: "record_batch_get", requested: ids.length, returned: data.length, missing: missingIds.length },
+        "record_batch_get ok"
+      );
+      return { content: [{ type: "text", text: JSON.stringify({ data, missingIds }, null, 2) }] };
+    } catch (err) {
+      log.warn({ tool: "record_batch_get", idsCount: ids?.length, err: String(err) }, "record_batch_get failed");
+      return toolError("record_batch_get", err);
+    }
+  }
+});
+var record_batch_get_default = recordBatchGet;
+
+// src/tools/record_create.ts
+var import_zod5 = require("zod");
+var inputSchema5 = {
+  type: import_zod5.z.string().min(1, "type is required").describe('Record type / schema name (e.g. "task"). Must match an existing schema \u2014 see list_schemas.'),
+  fields: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown()).describe(
     "The record payload \u2014 a JSON object of field\u2192value, validated against the type schema. Call list_schemas to learn required fields, types, and enum values. Every number must fall within the signed 64-bit range (a value outside it, or with >38 significant digits, is refused with a 400 naming the field) \u2014 send a larger whole number (e.g. a big external id) as a STRING, which stores it exactly and supports exact-match lookup."
   ),
-  externalId: import_zod4.z.string().optional().describe(
+  externalId: import_zod5.z.string().optional().describe(
     "Stable caller-supplied id. Immutable; unique per type. Re-creating with the same externalId returns the existing record (idempotent) \u2014 use it to make creates safely retryable."
   ),
-  indexMode: import_zod4.z.enum(["HYBRID", "SEMANTIC", "TEXT", "NONE"]).optional().describe(
+  indexMode: import_zod5.z.enum(["HYBRID", "SEMANTIC", "TEXT", "NONE"]).optional().describe(
     "Search-index strategy for this record, set at create only (immutable after). HYBRID (BM25 + dense), SEMANTIC (dense only), TEXT (BM25 only), NONE (store-only \u2014 never appears in hybrid_search/rag_ask; still retrievable by id and structured-field lookup). Omit to inherit the type schema's default; if the schema default is NONE and you want this record searchable, set it here \u2014 it cannot be changed later."
   ),
-  status: import_zod4.z.string().optional().describe("Record lifecycle status. Defaults to ACTIVE server-side."),
-  folderId: import_zod4.z.string().optional().describe("Group this record into a folder."),
-  userId: import_zod4.z.string().optional().describe("Owning user id."),
-  scopes: import_zod4.z.array(import_zod4.z.string()).optional().describe(
+  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(
     '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 values must come from the credential\'s own identity. An empty array `[]` creates a PRIVATE record owned by the calling user alone. Omit to stamp the credential\'s full identity \u2014 the default.'
   )
 };
@@ -9835,7 +10045,7 @@ var recordCreate = ({ client, log }) => ({
   name: "record_create",
   title: "Create a record",
   description: "Create a structured record of a given type. Provide `type` and `fields` (the payload, validated against the type schema \u2014 call list_schemas first to learn required fields and enums). Idempotent by `externalId`. Requires the key to allow records:c (and records:r to receive the existing record on a collision).",
-  inputSchema: inputSchema4,
+  inputSchema: inputSchema5,
   handler: async (args) => {
     const type = args.type;
     try {
@@ -9862,18 +10072,18 @@ var recordCreate = ({ client, log }) => ({
 var record_create_default = recordCreate;
 
 // src/tools/record_update.ts
-var import_zod5 = require("zod");
-var inputSchema5 = {
-  id: import_zod5.z.string().optional().describe("The Vectros record id to update. Provide this OR externalId+type."),
-  externalId: import_zod5.z.string().optional().describe(
+var import_zod6 = require("zod");
+var inputSchema6 = {
+  id: import_zod6.z.string().optional().describe("The Vectros record id to update. Provide this OR externalId+type."),
+  externalId: import_zod6.z.string().optional().describe(
     "Your caller-owned externalId \u2014 an alternative selector to `id` (requires `type`). Updates the record you created under that externalId without a manual record_query lookup first."
   ),
-  type: import_zod5.z.string().optional().describe("Record type \u2014 REQUIRED when selecting by `externalId` (externalId is unique within a type)."),
-  fields: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown()).describe(
+  type: import_zod6.z.string().optional().describe("Record type \u2014 REQUIRED when selecting by `externalId` (externalId is unique within a type)."),
+  fields: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown()).describe(
     "Field\u2192value changes DEEP-MERGED into the existing payload: keys you send overwrite (recursing into nested objects), a key set to `null` is deleted, and unspecified fields are preserved."
   ),
-  status: import_zod5.z.string().optional().describe("Set the record lifecycle status (e.g. ARCHIVED) \u2014 archive/workflow without physical deletion."),
-  expectedVersion: import_zod5.z.number().int().optional().describe(
+  status: import_zod6.z.string().optional().describe("Set the record lifecycle status (e.g. ARCHIVED) \u2014 archive/workflow without physical deletion."),
+  expectedVersion: import_zod6.z.number().int().optional().describe(
     "Optimistic concurrency: the version you last read. If the record changed since, the update is refused as a conflict (re-read and retry). Omit for last-write-wins."
   )
 };
@@ -9881,7 +10091,7 @@ var recordUpdate = ({ client, log }) => ({
   name: "record_update",
   title: "Update a record by id or externalId",
   description: "Update a record \u2014 select it by its Vectros `id` OR by your own `externalId` + `type` (the same key you passed to record_create, resolved for you). The provided `fields` are DEEP-MERGED into the existing payload (unspecified fields are preserved; a field set to `null` is deleted). Pass `expectedVersion` (the version you last read) for safe concurrent edits \u2014 a stale update is refused (409). Use `status` to archive without deleting. Requires the key to allow records:u.",
-  inputSchema: inputSchema5,
+  inputSchema: inputSchema6,
   handler: async (args) => {
     const id = args.id;
     const externalId = args.externalId;
@@ -9907,15 +10117,15 @@ var recordUpdate = ({ client, log }) => ({
 var record_update_default = recordUpdate;
 
 // src/tools/record_delete.ts
-var import_zod6 = require("zod");
-var inputSchema6 = {
-  id: import_zod6.z.string().min(1, "id is required").describe("The Vectros record id to delete.")
+var import_zod7 = require("zod");
+var inputSchema7 = {
+  id: import_zod7.z.string().min(1, "id is required").describe("The Vectros record id to delete.")
 };
 var recordDelete = ({ client, log }) => ({
   name: "record_delete",
   title: "Delete a record",
   description: "Permanently delete a record by id (leaves a tombstone). Requires the key to allow records:d \u2014 a key without it gets a permission error. To archive without deleting, use record_update to set status instead.",
-  inputSchema: inputSchema6,
+  inputSchema: inputSchema7,
   handler: async (args) => {
     const id = args.id;
     try {
@@ -9931,48 +10141,48 @@ var recordDelete = ({ client, log }) => ({
 var record_delete_default = recordDelete;
 
 // src/tools/rag_ask.ts
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
 var SEARCH_MCP_DEFAULT_LIMIT = 5;
 var SEARCH_MCP_MAX_LIMIT = 50;
-var inputSchema7 = {
-  query: import_zod7.z.string().min(1, "query must be non-empty").describe("Question to ground against retrieved content."),
-  instructions: import_zod7.z.string().optional().describe(
+var inputSchema8 = {
+  query: import_zod8.z.string().min(1, "query must be non-empty").describe("Question to ground against retrieved content."),
+  instructions: import_zod8.z.string().optional().describe(
     'System prompt that overrides the default for the generation step \u2014 e.g. "answer only from the provided context, cite sources, be concise". Default: a generic answer-from-context instruction.'
   ),
-  model: import_zod7.z.string().optional().describe(
+  model: import_zod8.z.string().optional().describe(
     "Inference model alias (e.g. claude-haiku-4-5, claude-sonnet-5, claude-opus-4-8). Default = tier-appropriate Haiku. See GET /v1/models for the catalog the calling key can reach."
   ),
-  search: import_zod7.z.object({
-    mode: import_zod7.z.enum(["HYBRID", "TEXT", "SEMANTIC"]).optional().describe("Retrieval mode. Default HYBRID."),
-    limit: import_zod7.z.number().int().min(1).max(SEARCH_MCP_MAX_LIMIT).optional().describe(
+  search: import_zod8.z.object({
+    mode: import_zod8.z.enum(["HYBRID", "TEXT", "SEMANTIC"]).optional().describe("Retrieval mode. Default HYBRID."),
+    limit: import_zod8.z.number().int().min(1).max(SEARCH_MCP_MAX_LIMIT).optional().describe(
       `Passages to retrieve before generating (the grounding-corpus size). Default ${SEARCH_MCP_DEFAULT_LIMIT}; raise up to ${SEARCH_MCP_MAX_LIMIT} (the RAG search API max) for a broader corpus when the extra grounding is worth the larger prompt.`
     ),
     // Retrieval scoping — parity with hybrid_search so an agent can ground the
     // answer on a specific owner / folder / type / metadata subset, not just the
     // whole-tenant corpus.
-    userId: import_zod7.z.string().optional().describe("Restrict retrieval to content owned by this user (Vectros UUID)."),
-    scope: import_zod7.z.string().optional().describe(
+    userId: import_zod8.z.string().optional().describe("Restrict retrieval to content owned by this user (Vectros UUID)."),
+    scope: import_zod8.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.'
     ),
-    folderId: import_zod7.z.string().optional().describe("Restrict retrieval to this exact folder."),
-    rootFolderId: import_zod7.z.string().optional().describe("Restrict retrieval to this folder and all its descendants."),
-    typeName: import_zod7.z.string().optional().describe("Restrict record retrieval to this schema type."),
-    contentTypes: import_zod7.z.array(import_zod7.z.enum(["documents", "records"])).optional().describe('Narrow retrieval to content types. ["documents"] or ["records"]; omit for both.'),
-    filters: import_zod7.z.record(import_zod7.z.unknown()).optional().describe(
+    folderId: import_zod8.z.string().optional().describe("Restrict retrieval to this exact folder."),
+    rootFolderId: import_zod8.z.string().optional().describe("Restrict retrieval to this folder and all its descendants."),
+    typeName: import_zod8.z.string().optional().describe("Restrict record retrieval to this schema type."),
+    contentTypes: import_zod8.z.array(import_zod8.z.enum(["documents", "records"])).optional().describe('Narrow retrieval to content types. ["documents"] or ["records"]; omit for both.'),
+    filters: import_zod8.z.record(import_zod8.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_zod7.z.string().optional().describe("Restrict to content created at/after this ISO 8601 UTC timestamp."),
-    createdBefore: import_zod7.z.string().optional().describe("Restrict to content created at/before this ISO 8601 UTC timestamp."),
-    requireComplete: import_zod7.z.boolean().optional().describe("Fail closed (503) on a degraded search backend instead of grounding on partial results. Default false.")
+    createdAfter: import_zod8.z.string().optional().describe("Restrict to content created at/after this ISO 8601 UTC timestamp."),
+    createdBefore: import_zod8.z.string().optional().describe("Restrict to content created at/before this ISO 8601 UTC timestamp."),
+    requireComplete: import_zod8.z.boolean().optional().describe("Fail closed (503) on a degraded search backend instead of grounding on partial results. Default false.")
   }).optional().describe("Retrieval params + scoping. Default mode HYBRID, limit " + SEARCH_MCP_DEFAULT_LIMIT + "."),
-  maxTokens: import_zod7.z.number().int().min(1).optional().describe("Max output tokens."),
-  temperature: import_zod7.z.number().min(0).max(1).optional().describe("Sampling temperature (0.0\u20131.0). Default 0.3 \u2014 lower favors deterministic, retrieval-grounded answers.")
+  maxTokens: import_zod8.z.number().int().min(1).optional().describe("Max output tokens."),
+  temperature: import_zod8.z.number().min(0).max(1).optional().describe("Sampling temperature (0.0\u20131.0). Default 0.3 \u2014 lower favors deterministic, retrieval-grounded answers.")
 };
 var ragAsk = ({ client, log }) => ({
   name: "rag_ask",
   title: "RAG ask (corpus-wide)",
   description: "Ask a question grounded against your tenant's indexed content. Vectros performs a hybrid search, injects the top-K passages into the prompt, and streams a model answer back. Scope retrieval with `search` (ownership, folder, type, metadata filters, date window) to ground on a subset \u2014 e.g. one patient or one folder \u2014 and steer generation with `instructions` / `temperature`. The full answer is returned as a single response; progress notifications keep the call alive during the 30-45s generation window. Inference runs in-perimeter against AWS Bedrock \u2014 PHI never leaves the BAA boundary.",
-  inputSchema: inputSchema7,
+  inputSchema: inputSchema8,
   handler: async (args, extra) => {
     try {
       const searchArg = args.search ?? {};
@@ -10048,20 +10258,20 @@ var ragAsk = ({ client, log }) => ({
 var rag_ask_default = ragAsk;
 
 // src/tools/document_ask.ts
-var import_zod8 = require("zod");
-var inputSchema8 = {
-  documentId: import_zod8.z.string().min(1, "documentId is required").describe("ID of the document to ask against."),
-  prompt: import_zod8.z.string().min(1, "prompt is required").describe("Question to ask about the document."),
-  model: import_zod8.z.string().optional().describe(
+var import_zod9 = require("zod");
+var inputSchema9 = {
+  documentId: import_zod9.z.string().min(1, "documentId is required").describe("ID of the document to ask against."),
+  prompt: import_zod9.z.string().min(1, "prompt is required").describe("Question to ask about the document."),
+  model: import_zod9.z.string().optional().describe(
     "Inference model alias. Default = tier-appropriate Haiku. See GET /v1/models for the catalog the calling key can reach."
   ),
-  maxTokens: import_zod8.z.number().int().min(1).optional().describe("Max output tokens.")
+  maxTokens: import_zod9.z.number().int().min(1).optional().describe("Max output tokens.")
 };
 var documentAsk = ({ client, log }) => ({
   name: "document_ask",
   title: "Document ask (single-document)",
   description: "Ask a question against a single indexed document. Returns a grounded answer with the document context that informed it. For documents exceeding the input-token cap, the API returns a structured 413 with `estimatedTokens` and `limitTokens`. Inference runs in-perimeter against AWS Bedrock \u2014 PHI never leaves the BAA boundary.",
-  inputSchema: inputSchema8,
+  inputSchema: inputSchema9,
   handler: async (args, extra) => {
     try {
       const stream = await client.inference.documentAsk({
@@ -10120,18 +10330,18 @@ var documentAsk = ({ client, log }) => ({
 var document_ask_default = documentAsk;
 
 // src/tools/list_schemas.ts
-var import_zod9 = require("zod");
-var inputSchema9 = {
-  userId: import_zod9.z.string().optional().describe(
+var import_zod10 = require("zod");
+var inputSchema10 = {
+  userId: import_zod10.z.string().optional().describe(
     "Filter to schemas visible to a specific user. Optional; default returns all schemas the credential can see."
   ),
-  scope: import_zod9.z.string().optional().describe(
+  scope: import_zod10.z.string().optional().describe(
     'Filter to schemas carrying this scope value, in `namespace:value` form (e.g. "org:<uuid>", "group:eng-team"). `org` and `client` are reserved namespace names, registered like any other. Optional; default returns all schemas the credential can see.'
   ),
-  surface: import_zod9.z.enum(["record", "document", "user", "entity"]).optional().describe(
+  surface: import_zod10.z.enum(["record", "document", "user", "entity"]).optional().describe(
     "Filter to schemas bindable to this surface \u2014 e.g. `document` to list only document types, or `record` for record types. Identity entities in any namespace (org/client/one you registered) bind under the single `entity` surface; `user` and `entity` are account-wide. Optional."
   ),
-  recordType: import_zod9.z.string().optional().describe(
+  recordType: import_zod10.z.string().optional().describe(
     'Resolve the single schema for this record type (its natural handle, e.g. "patient") instead of listing \u2014 returns a one-element result, or empty if none. Combine with `surface=user|entity` for an identity schema. Takes precedence over userId. Optional.'
   )
 };
@@ -10139,7 +10349,7 @@ var listSchemas = ({ client, log }) => ({
   name: "list_schemas",
   title: "List record schemas",
   description: 'List the structured-record schema catalog for your tenant. Each schema describes a record type (e.g. "patient", "clinical_note") \u2014 its fields, lookup-indexed fields, and capabilities. Use this to discover what record types exist before calling `record_query`. Filter with `surface` (record/document/user/entity \u2014 e.g. only document types), `recordType` (resolve one schema by its type name), or `userId`/`scope`; default returns everything the credential can see.',
-  inputSchema: inputSchema9,
+  inputSchema: inputSchema10,
   handler: async (args) => {
     const userId = args.userId;
     const scope = args.scope;
@@ -10165,18 +10375,18 @@ var listSchemas = ({ client, log }) => ({
 var list_schemas_default = listSchemas;
 
 // src/tools/document_get.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 var MAX_TEXT_CHARS = 32e3;
-var inputSchema10 = {
-  documentId: import_zod10.z.string().optional().describe("The document ID returned by document_ingest or hybrid_search. Provide this OR externalId+type."),
-  externalId: import_zod10.z.string().optional().describe(
+var inputSchema11 = {
+  documentId: import_zod11.z.string().optional().describe("The document ID returned by document_ingest or hybrid_search. Provide this OR externalId+type."),
+  externalId: import_zod11.z.string().optional().describe(
     "Your caller-owned externalId \u2014 an alternative selector to `documentId` (requires `type`). Fetches the document you ingested under that externalId without a manual lookup first."
   ),
-  type: import_zod10.z.string().optional().describe("Document type \u2014 REQUIRED when selecting by `externalId` (externalId is unique within a type)."),
-  includeText: import_zod10.z.boolean().optional().describe(
+  type: import_zod11.z.string().optional().describe("Document type \u2014 REQUIRED when selecting by `externalId` (externalId is unique within a type)."),
+  includeText: import_zod11.z.boolean().optional().describe(
     "If true, fetch and include the document text (capped at ~8K tokens, truncated: true flag if cut). Default false \u2014 metadata only. For larger documents, prefer `document_ask` over dumping text into context."
   ),
-  includeDownloadUrl: import_zod10.z.boolean().optional().describe(
+  includeDownloadUrl: import_zod11.z.boolean().optional().describe(
     "If true, also return a short-lived presigned `downloadUrl` for the original file (file-backed documents only \u2014 the way to retrieve the raw bytes of a document ingested via file mode). Default false. Unavailable for text-only documents \u2014 `downloadAvailable: false` is set instead."
   )
 };
@@ -10193,7 +10403,7 @@ 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.",
-  inputSchema: inputSchema10,
+  inputSchema: inputSchema11,
   handler: async (args) => {
     const documentId = args.documentId;
     const externalId = args.externalId;
@@ -10258,28 +10468,28 @@ var documentGet = ({ client, log }) => ({
 var document_get_default = documentGet;
 
 // src/tools/document_query.ts
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 var MCP_DEFAULT_LIMIT3 = 3;
 var MCP_MAX_LIMIT3 = 100;
-var inputSchema11 = {
+var inputSchema12 = {
   // Lookup-mode args — provide `field` plus EXACTLY ONE of: value | from+to | prefix.
-  field: import_zod11.z.string().optional().describe("Lookup mode: name of the lookup-indexed field to query by."),
-  value: import_zod11.z.string().optional().describe("Lookup mode (equality): exact-match value for `field`. Works on sensitive fields too."),
-  from: import_zod11.z.string().optional().describe("Lookup mode (range): inclusive lower bound; requires `to`. Range-enabled, non-sensitive fields only."),
-  to: import_zod11.z.string().optional().describe("Lookup mode (range): inclusive upper bound; requires `from`."),
-  prefix: import_zod11.z.string().optional().describe("Lookup mode (prefix): match values starting with this. Range-enabled string fields only."),
-  order: import_zod11.z.enum(["asc", "desc"]).optional().describe(
+  field: import_zod12.z.string().optional().describe("Lookup mode: name of the lookup-indexed field to query by."),
+  value: import_zod12.z.string().optional().describe("Lookup mode (equality): exact-match value for `field`. Works on sensitive fields too."),
+  from: import_zod12.z.string().optional().describe("Lookup mode (range): inclusive lower bound; requires `to`. Range-enabled, non-sensitive fields only."),
+  to: import_zod12.z.string().optional().describe("Lookup mode (range): inclusive upper bound; requires `from`."),
+  prefix: import_zod12.z.string().optional().describe("Lookup mode (prefix): match values starting with this. Range-enabled string fields only."),
+  order: import_zod12.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."
   ),
-  type: import_zod11.z.string().optional().describe("Lookup mode: the document type (the bound schema's type). Required with `field`."),
+  type: import_zod12.z.string().optional().describe("Lookup mode: the document type (the bound schema's type). Required with `field`."),
   // List-mode args:
-  folderId: import_zod11.z.string().optional().describe("List mode: only documents in this folder (Vectros folder id)."),
-  userId: import_zod11.z.string().optional().describe("List mode: scope to documents owned by this user."),
-  scope: import_zod11.z.string().optional().describe(
+  folderId: import_zod12.z.string().optional().describe("List mode: only documents in this folder (Vectros folder id)."),
+  userId: import_zod12.z.string().optional().describe("List mode: scope to documents owned by this user."),
+  scope: import_zod12.z.string().optional().describe(
     'List mode: filter to documents 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.'
   ),
-  startFrom: import_zod11.z.string().optional().describe("Pagination cursor \u2014 pass the `nextCursor` from the previous page to fetch the next. Works in both list and lookup mode."),
-  limit: import_zod11.z.number().int().min(1).max(MCP_MAX_LIMIT3).optional().describe(
+  startFrom: import_zod12.z.string().optional().describe("Pagination cursor \u2014 pass the `nextCursor` from the previous page to fetch the next. Works in both list and lookup mode."),
+  limit: import_zod12.z.number().int().min(1).max(MCP_MAX_LIMIT3).optional().describe(
     `Max documents per page. Defaults to a low ${MCP_DEFAULT_LIMIT3} to protect the agent context window; raise up to ${MCP_MAX_LIMIT3} (the documents API max) in one call when you can accept the larger payload, or page with \`startFrom\` instead.`
   )
 };
@@ -10287,7 +10497,7 @@ 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.",
-  inputSchema: inputSchema11,
+  inputSchema: inputSchema12,
   handler: async (args) => {
     const limit = args.limit ?? MCP_DEFAULT_LIMIT3;
     const field = args.field;
@@ -10367,29 +10577,29 @@ var documentQuery = ({ client, log }) => ({
 var document_query_default = documentQuery;
 
 // src/tools/document_update.ts
-var import_zod12 = require("zod");
-var inputSchema12 = {
-  documentId: import_zod12.z.string().optional().describe("The Vectros document id to update. Provide this OR externalId+type."),
-  externalId: import_zod12.z.string().optional().describe(
+var import_zod13 = require("zod");
+var inputSchema13 = {
+  documentId: import_zod13.z.string().optional().describe("The Vectros document id to update. Provide this OR externalId+type."),
+  externalId: import_zod13.z.string().optional().describe(
     "Your caller-owned externalId \u2014 an alternative selector to `documentId` (requires `type`). Updates the document you ingested under that externalId without a manual lookup first."
   ),
-  type: import_zod12.z.string().optional().describe("Document type \u2014 REQUIRED when selecting by `externalId` (externalId is unique within a type)."),
-  title: import_zod12.z.string().optional().describe("New title. Omit to keep the current title."),
-  fields: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.unknown()).optional().describe(
+  type: import_zod13.z.string().optional().describe("Document type \u2014 REQUIRED when selecting by `externalId` (externalId is unique within a type)."),
+  title: import_zod13.z.string().optional().describe("New title. Omit to keep the current title."),
+  fields: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.unknown()).optional().describe(
     "Typed-payload field\u2192value changes DEEP-MERGED into the existing payload (a field set to `null` is deleted; unspecified fields preserved). Omit to leave the payload unchanged."
   ),
-  text: import_zod12.z.string().optional().describe(
+  text: import_zod13.z.string().optional().describe(
     "New raw text body. Supplying it re-ingests the document body and re-queues it for indexing, so the search index reflects the edit (text-ingested documents only \u2014 not file-backed ones). Omit to leave the stored text unchanged. This is the in-place alternative to re-ingesting with upsert:true."
   ),
-  folderId: import_zod12.z.string().optional().describe("Move the document into this folder (cannot be cleared once set)."),
-  status: import_zod12.z.enum(["ACTIVE", "ARCHIVED"]).optional().describe(
+  folderId: import_zod13.z.string().optional().describe("Move the document into this folder (cannot be cleared once set)."),
+  status: import_zod13.z.enum(["ACTIVE", "ARCHIVED"]).optional().describe(
     "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_zod12.z.string().optional().describe("Reassign the owning user (Vectros UUID)."),
-  scopes: import_zod12.z.array(import_zod12.z.string()).optional().describe(
+  userId: import_zod13.z.string().optional().describe("Reassign the owning user (Vectros UUID)."),
+  scopes: import_zod13.z.array(import_zod13.z.string()).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_zod12.z.number().int().optional().describe(
+  expectedVersion: import_zod13.z.number().int().optional().describe(
     "Optimistic concurrency: the version you last read. If the document changed since, the update is refused as a conflict (re-read and retry). Omit for last-write-wins."
   )
 };
@@ -10397,7 +10607,7 @@ var documentUpdate = ({ client, log }) => ({
   name: "document_update",
   title: "Update a document",
   description: 'Update a document \u2014 select it by its Vectros `documentId` OR by your own `externalId` + `type` (resolved for you). `fields` are DEEP-MERGED into the existing typed payload (unspecified fields preserved; a field set to `null` is deleted); title/folderId/status/ownership are updated when provided and preserved otherwise. Supply `text` to re-ingest and re-index the document body in place (text documents only). Set `status: "ARCHIVED"` to soft-retract a document (pulled from search, kept and recoverable) and `status: "ACTIVE"` to restore it. Pass `expectedVersion` (the version you last read) for safe concurrent edits \u2014 a stale update is refused (409). Requires the key to allow documents:u.',
-  inputSchema: inputSchema12,
+  inputSchema: inputSchema13,
   handler: async (args) => {
     const documentId = args.documentId;
     const externalId = args.externalId;
@@ -10437,15 +10647,15 @@ var documentUpdate = ({ client, log }) => ({
 var document_update_default = documentUpdate;
 
 // src/tools/document_delete.ts
-var import_zod13 = require("zod");
-var inputSchema13 = {
-  documentId: import_zod13.z.string().min(1, "documentId is required").describe("The Vectros document id to delete.")
+var import_zod14 = require("zod");
+var inputSchema14 = {
+  documentId: import_zod14.z.string().min(1, "documentId is required").describe("The Vectros document id to delete.")
 };
 var documentDelete = ({ client, log }) => ({
   name: "document_delete",
   title: "Delete a document",
   description: 'Permanently delete a document by id (removes it and its indexed content). Requires the key to allow documents:d \u2014 a key without it gets a permission error. To archive without deleting, use document_update to set status: "ARCHIVED" instead (recoverable, and needs no delete authority).',
-  inputSchema: inputSchema13,
+  inputSchema: inputSchema14,
   handler: async (args) => {
     const documentId = args.documentId;
     try {
@@ -10463,18 +10673,18 @@ var documentDelete = ({ client, log }) => ({
 var document_delete_default = documentDelete;
 
 // src/tools/folder_query.ts
-var import_zod14 = require("zod");
+var import_zod15 = require("zod");
 var MCP_DEFAULT_LIMIT4 = 10;
 var MCP_MAX_LIMIT4 = 100;
-var inputSchema14 = {
-  id: import_zod14.z.string().optional().describe("Get mode: fetch this single folder by id."),
-  parentId: import_zod14.z.string().optional().describe("List mode: direct children of this folder (tree navigation). Omit for a flat tenant list."),
-  userId: import_zod14.z.string().optional().describe("List mode: scope to folders owned by this user."),
-  scope: import_zod14.z.string().optional().describe(
+var inputSchema15 = {
+  id: import_zod15.z.string().optional().describe("Get mode: fetch this single folder by id."),
+  parentId: import_zod15.z.string().optional().describe("List mode: direct children of this folder (tree navigation). Omit for a flat tenant list."),
+  userId: import_zod15.z.string().optional().describe("List mode: scope to folders owned by this user."),
+  scope: import_zod15.z.string().optional().describe(
     'List mode: filter to folders 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.'
   ),
-  startFrom: import_zod14.z.string().optional().describe("List mode: pagination cursor \u2014 pass the `nextCursor` from the previous page to fetch the next."),
-  limit: import_zod14.z.number().int().min(1).max(MCP_MAX_LIMIT4).optional().describe(
+  startFrom: import_zod15.z.string().optional().describe("List mode: pagination cursor \u2014 pass the `nextCursor` from the previous page to fetch the next."),
+  limit: import_zod15.z.number().int().min(1).max(MCP_MAX_LIMIT4).optional().describe(
     `List mode: max folders per page. Default 10; raise up to ${MCP_MAX_LIMIT4} (the folders API max) in one call when you can accept the larger page, or page with \`startFrom\`.`
   )
 };
@@ -10482,7 +10692,7 @@ var folderQuery = ({ client, log }) => ({
   name: "folder_query",
   title: "Folder query (list or get)",
   description: "Read folders. Two modes:\n  \u2022 Get: pass `id` \u2192 returns the single folder.\n  \u2022 List: omit `id`; pass `parentId` for a folder's direct children (tree navigation) or omit for a flat tenant list. Optionally filter by `userId` or `scope` (`namespace:value`).\nList mode returns `{ data, nextCursor }` (default 10, max 100 per page \u2014 raise it in one call when you can accept the larger page); a non-null `nextCursor` means more remain \u2014 pass it back as `startFrom` to page through all folders. Get mode returns the single folder object.",
-  inputSchema: inputSchema14,
+  inputSchema: inputSchema15,
   handler: async (args) => {
     const id = args.id;
     try {
@@ -10512,14 +10722,14 @@ var folderQuery = ({ client, log }) => ({
 var folder_query_default = folderQuery;
 
 // src/tools/folder_create.ts
-var import_zod15 = require("zod");
-var inputSchema15 = {
-  name: import_zod15.z.string().min(1, "name is required").describe("Folder display name."),
-  description: import_zod15.z.string().optional().describe("Optional description of the folder's purpose."),
-  parentId: import_zod15.z.string().optional().describe("Parent folder id \u2014 places the folder under this parent. Omit for the context default root. Create-only."),
-  slug: import_zod15.z.string().optional().describe("Optional stable slug (sibling-unique; idempotency key). Lowercase letters/digits/hyphens. Derived from name when omitted."),
-  userId: import_zod15.z.string().optional().describe("Owning user (Vectros UUID)."),
-  scopes: import_zod15.z.array(import_zod15.z.string()).optional().describe(
+var import_zod16 = require("zod");
+var inputSchema16 = {
+  name: import_zod16.z.string().min(1, "name is required").describe("Folder display name."),
+  description: import_zod16.z.string().optional().describe("Optional description of the folder's purpose."),
+  parentId: import_zod16.z.string().optional().describe("Parent folder id \u2014 places the folder under this parent. Omit for the context default root. Create-only."),
+  slug: import_zod16.z.string().optional().describe("Optional stable slug (sibling-unique; idempotency key). Lowercase letters/digits/hyphens. Derived from name when omitted."),
+  userId: import_zod16.z.string().optional().describe("Owning user (Vectros UUID)."),
+  scopes: import_zod16.z.array(import_zod16.z.string()).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.'
   )
 };
@@ -10527,7 +10737,7 @@ var folderCreate = ({ client, log }) => ({
   name: "folder_create",
   title: "Create a folder",
   description: "Create a folder to organize documents and records. Pass `parentId` to nest it (create-only \u2014 folders cannot be moved later). Idempotent by `slug` within the parent. Requires the key to allow folders:c (and folders:r to receive the existing folder on a collision).",
-  inputSchema: inputSchema15,
+  inputSchema: inputSchema16,
   handler: async (args) => {
     try {
       const folder = await client.folders.createFolder({
@@ -10551,16 +10761,16 @@ var folderCreate = ({ client, log }) => ({
 var folder_create_default = folderCreate;
 
 // src/tools/folder_update.ts
-var import_zod16 = require("zod");
-var inputSchema16 = {
-  id: import_zod16.z.string().min(1, "id is required").describe("The Vectros folder id to update."),
-  name: import_zod16.z.string().optional().describe("New folder name. Omit to keep the current name."),
-  description: import_zod16.z.string().optional().describe("New description. Omit to leave unchanged."),
-  userId: import_zod16.z.string().optional().describe("Reassign the owning user (Vectros UUID)."),
-  scopes: import_zod16.z.array(import_zod16.z.string()).optional().describe(
+var import_zod17 = require("zod");
+var inputSchema17 = {
+  id: import_zod17.z.string().min(1, "id is required").describe("The Vectros folder id to update."),
+  name: import_zod17.z.string().optional().describe("New folder name. Omit to keep the current name."),
+  description: import_zod17.z.string().optional().describe("New description. Omit to leave unchanged."),
+  userId: import_zod17.z.string().optional().describe("Reassign the owning user (Vectros UUID)."),
+  scopes: import_zod17.z.array(import_zod17.z.string()).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_zod16.z.number().int().optional().describe(
+  expectedVersion: import_zod17.z.number().int().optional().describe(
     "Optimistic concurrency: the version you last read. If the folder changed since, the update is refused as a conflict (re-read and retry). Omit for last-write-wins."
   )
 };
@@ -10568,7 +10778,7 @@ var folderUpdate = ({ client, log }) => ({
   name: "folder_update",
   title: "Update a folder",
   description: "Update a folder's name / description / ownership by id (RFC-7386 merge \u2014 omitted fields preserved). Pass `expectedVersion` (the version you last read) for safe concurrent edits \u2014 a stale update is refused (409). Folders cannot be moved (re-parenting is not supported by the API). Requires the key to allow folders:u.",
-  inputSchema: inputSchema16,
+  inputSchema: inputSchema17,
   handler: async (args) => {
     const id = args.id;
     const name = args.name;
@@ -10595,15 +10805,15 @@ var folderUpdate = ({ client, log }) => ({
 var folder_update_default = folderUpdate;
 
 // src/tools/folder_delete.ts
-var import_zod17 = require("zod");
-var inputSchema17 = {
-  id: import_zod17.z.string().min(1, "id is required").describe("The Vectros folder id to delete.")
+var import_zod18 = require("zod");
+var inputSchema18 = {
+  id: import_zod18.z.string().min(1, "id is required").describe("The Vectros folder id to delete.")
 };
 var folderDelete = ({ client, log }) => ({
   name: "folder_delete",
   title: "Delete a folder",
   description: "Permanently delete a folder by id. 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.",
-  inputSchema: inputSchema17,
+  inputSchema: inputSchema18,
   handler: async (args) => {
     const id = args.id;
     try {
@@ -10619,14 +10829,14 @@ var folderDelete = ({ client, log }) => ({
 var folder_delete_default = folderDelete;
 
 // src/tools/current_identity.ts
-var inputSchema18 = {
+var inputSchema19 = {
   // No args — current_identity describes the current credential.
 };
 var currentIdentity = ({ log, apiKey, environment }) => ({
   name: "current_identity",
   title: "Current identity (tenant + principal scope)",
-  description: "Describe the credential the MCP server is operating under. Returns tenantId, environment (staging|production), principalType (root_key|scoped_key|token), principalKeyId, principalLabel, and (for scoped credentials) allowedActions plus dataScope \u2014 the credential's verb+ownership reach as { userId, scopes[] }, where each scope is a `namespace:value` string (e.g. \"org:<uuid>\"). Note: this does not yet include granted_capabilities (member-lifecycle / forensic-read / context-directory-read / delegate-mint) \u2014 a separate reach dimension a scope clause can carry as of API 0.40.0 that /v1/ping does not report yet, so allowedActions+dataScope may understate a credential's true reach. Also reports mcpServerVersion (this server's own package version) and sdkVersion (the bundled @vectros-ai/sdk version) so a caller can tell what build it's talking to. Use this when the user asks 'what can you do here?', 'what tenant am I in?', or 'what version is this?'. Calls GET /v1/ping under the hood.",
-  inputSchema: inputSchema18,
+  description: "Describe the credential the MCP server is operating under. Returns tenantId, environment (staging|production), principalType (root_key|scoped_key|token), principalKeyId, principalLabel, and (for scoped credentials) allowedActions plus dataScope \u2014 the credential's verb+ownership reach as { userId, scopes[] }, where each scope is a `namespace:value` string (e.g. \"org:<uuid>\"). Note: this does not yet include granted_capabilities (member-lifecycle / forensic-read / context-directory-read / delegate-mint, as of API 0.40.0, joined by delegate-principal-stamp in 0.42.0) \u2014 a separate reach dimension a scope clause can carry that /v1/ping does not report yet, so allowedActions+dataScope may understate a credential's true reach. Also reports mcpServerVersion (this server's own package version) and sdkVersion (the bundled @vectros-ai/sdk version) so a caller can tell what build it's talking to. Use this when the user asks 'what can you do here?', 'what tenant am I in?', or 'what version is this?'. Calls GET /v1/ping under the hood.",
+  inputSchema: inputSchema19,
   handler: async () => {
     try {
       const identity = await resolveIdentity({ log, apiKey, environment });
@@ -10642,7 +10852,7 @@ var currentIdentity = ({ log, apiKey, environment }) => ({
 var current_identity_default = currentIdentity;
 
 // src/tools/document_ingest.ts
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 var import_promises = require("fs/promises");
 var import_node_path = require("path");
 var IngestPathError = class extends Error {
@@ -10717,37 +10927,37 @@ function inferMimeType(filePath) {
   const ext = (0, import_node_path.extname)(filePath).toLowerCase();
   return EXT_TO_MIME[ext] ?? "application/octet-stream";
 }
-var inputSchema19 = {
-  title: import_zod18.z.string().min(1, "title is required").describe("Human-readable document title \u2014 appears in search results and the UI."),
-  indexMode: import_zod18.z.enum(["HYBRID", "SEMANTIC", "TEXT", "NONE"]).optional().describe(
+var inputSchema20 = {
+  title: import_zod19.z.string().min(1, "title is required").describe("Human-readable document title \u2014 appears in search results and the UI."),
+  indexMode: import_zod19.z.enum(["HYBRID", "SEMANTIC", "TEXT", "NONE"]).optional().describe(
     "Index strategy. HYBRID (BM25 + dense, default; best for general retrieval), SEMANTIC (dense only; concept-driven queries), TEXT (BM25 only; exact-match / keyword), NONE (store-only / archival \u2014 retrievable by id and structured-field lookup but never in search results). Omit to inherit the bound schema's default."
   ),
-  externalId: import_zod18.z.string().optional().describe(
+  externalId: import_zod19.z.string().optional().describe(
     'Stable caller-supplied id. Immutable; unique per type within your context. Re-ingesting with the same externalId returns the existing document (idempotent) instead of creating a duplicate \u2014 use it to make ingests safely retryable and as the key other records reference. Mirrors record_create. Receiving the existing document back is a read of it and needs documents:r in addition to documents:c; a create-only key gets an "already exists" error instead of the document.'
   ),
-  upsert: import_zod18.z.boolean().optional().describe(
+  upsert: import_zod19.z.boolean().optional().describe(
     "When true, re-ingesting an existing externalId OVERWRITES that document and re-indexes the new body (text mode) / re-uploads and re-indexes the new file (file mode), instead of returning the existing one unchanged. This is the curation/re-sync primitive: edit a source, re-ingest with upsert:true, and the search index reflects the new content. Requires the documents:u scope. IMPORTANT: pass the SAME schemaId (and type) you used originally \u2014 externalId is unique WITHIN a type, so omitting schemaId resolves in the untyped namespace and mints a duplicate instead of updating. The response `created` flag confirms which happened (created:true = a new document was minted)."
   ),
-  schemaId: import_zod18.z.string().optional().describe(
+  schemaId: import_zod19.z.string().optional().describe(
     "Bind this document to a record schema. When set, `payload` is validated against the schema and its lookup fields become directly queryable via document_query (records parity). Resolve a schema id from its type via list_schemas. Omit for an untyped document."
   ),
-  payload: import_zod18.z.record(import_zod18.z.string(), import_zod18.z.unknown()).optional().describe(
+  payload: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.unknown()).optional().describe(
     "The document's structured data \u2014 a flat key/value object. With `schemaId`, declared fields are validated and lookup fields indexed; undeclared keys pass through as free-form and are searchable via the hybrid_search `filters` param. Without a schema it is stored as free-form metadata. Every number must fall within the signed 64-bit range \u2014 send a larger whole number as a STRING (stored exactly, exact-match lookup), else the ingest is refused with a 400 naming the field."
   ),
   // Inline text mode (mutually exclusive with filePath):
-  text: import_zod18.z.string().min(1).optional().describe("Text body to ingest inline. Mutually exclusive with filePath. Either text or filePath is required."),
-  storeText: import_zod18.z.boolean().optional().describe(
+  text: import_zod19.z.string().min(1).optional().describe("Text body to ingest inline. Mutually exclusive with filePath. Either text or filePath is required."),
+  storeText: import_zod19.z.boolean().optional().describe(
     "FILE MODE ONLY. Whether the uploaded file's EXTRACTED text is retained after indexing (default true), fixed at ingest. true keeps the extracted text retrievable via document_get(includeText:true) and usable by document_ask; false discards it once indexing completes \u2014 search still works and the original file remains downloadable, but includeText returns textAvailable:false and document_ask is unavailable. NOT accepted with `text`: a text-ingested body is the document itself and is ALWAYS retained, so the backend has no storeText knob on the text path \u2014 passing it with `text` is rejected rather than silently ignored."
   ),
   // File upload mode (mutually exclusive with text; stdio-transport-only):
-  filePath: import_zod18.z.string().min(1).optional().describe(
+  filePath: import_zod19.z.string().min(1).optional().describe(
     "Local filesystem path to upload. Mutually exclusive with text. STDIO TRANSPORT ONLY \u2014 rejected on HTTP transport (remote MCP servers can't read your filesystem; use text mode or call the SDK's uploadDocument directly). Must resolve INSIDE the configured ingest root (VECTROS_MCP_INGEST_ROOT, else the server's working directory); paths that escape it (traversal/absolute/symlink) or match a sensitive pattern are rejected."
   ),
-  fileType: import_zod18.z.string().optional().describe('MIME type of the file (e.g. "application/pdf"). Inferred from filePath extension if omitted.'),
+  fileType: import_zod19.z.string().optional().describe('MIME type of the file (e.g. "application/pdf"). Inferred from filePath extension if omitted.'),
   // Common (both modes):
-  folderId: import_zod18.z.string().optional().describe("Optional folder to ingest into. Default: tenant root."),
-  userId: import_zod18.z.string().optional().describe("Owning user ID. Optional."),
-  scopes: import_zod18.z.array(import_zod18.z.string()).optional().describe(
+  folderId: import_zod19.z.string().optional().describe("Optional folder to ingest into. Default: tenant root."),
+  userId: import_zod19.z.string().optional().describe("Owning user ID. Optional."),
+  scopes: import_zod19.z.array(import_zod19.z.string()).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."
   )
 };
@@ -10755,7 +10965,7 @@ 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 with `document_get` until indexStatus is INDEXED.\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). 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). 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: inputSchema19,
+  inputSchema: inputSchema20,
   handler: async (args) => {
     const title = args.title;
     const text = args.text;
@@ -10907,29 +11117,29 @@ var documentIngest = ({ client, log, transport, ingestRoot }) => ({
 var document_ingest_default = documentIngest;
 
 // src/tools/lookup_principal.ts
-var import_zod19 = require("zod");
+var import_zod20 = require("zod");
 var MCP_DEFAULT_LIMIT5 = 10;
 var MCP_MAX_LIMIT5 = 100;
-var inputSchema20 = {
-  kind: import_zod19.z.string().describe(
+var inputSchema21 = {
+  kind: import_zod20.z.string().describe(
     'Which principal to look up: "user" (the fixed principal surface), or an entity namespace \u2014 "org", "client" (reserved, registered like any other), or a namespace you registered.'
   ),
-  externalId: import_zod19.z.string().optional().describe(
+  externalId: import_zod20.z.string().optional().describe(
     "Resolve mode: your own stable identifier for the principal. Returns the single matching principal (with its Vectros UUID), or an empty array if none. The fastest path to the UUID the ownership filters need. Takes precedence if both this and a `field` lookup are supplied."
   ),
-  contextId: import_zod19.z.string().optional().describe(
+  contextId: import_zod20.z.string().optional().describe(
     "Entity kinds only (not `user`, which is always tenant-wide): the app context to look up entities in, for a namespace registered as context-owned rather than tenant-wide. A context-confined credential's own context is used automatically without this; supply it to name a context explicitly (required for an unconfined/root credential to reach a context-owned namespace). Rejected if the namespace turns out to be tenant-wide."
   ),
   // Lookup-mode args — provide `field` plus EXACTLY ONE of: value | from+to | prefix.
-  type: import_zod19.z.string().optional().describe('Lookup mode: the identity schema\'s record type (e.g. "person_v1"). Required with `field`.'),
-  field: import_zod19.z.string().optional().describe('Lookup mode: name of the schema-declared lookup field to query by (e.g. "email").'),
-  value: import_zod19.z.string().optional().describe("Lookup mode (equality): exact-match value for `field`. Works on sensitive fields."),
-  from: import_zod19.z.string().optional().describe("Lookup mode (range): inclusive lower bound; requires `to`. Non-sensitive fields only."),
-  to: import_zod19.z.string().optional().describe("Lookup mode (range): inclusive upper bound; requires `from`."),
-  prefix: import_zod19.z.string().optional().describe("Lookup mode (prefix): match values starting with this. Range-enabled string fields only."),
-  order: import_zod19.z.enum(["asc", "desc"]).optional().describe("Lookup mode: sort direction by the looked-up field. `asc` (default) or `desc`."),
-  startFrom: import_zod19.z.string().optional().describe("Lookup mode: pagination cursor \u2014 pass the `nextCursor` from the previous page to fetch the next."),
-  limit: import_zod19.z.number().int().min(1).max(MCP_MAX_LIMIT5).optional().describe(
+  type: import_zod20.z.string().optional().describe('Lookup mode: the identity schema\'s record type (e.g. "person_v1"). Required with `field`.'),
+  field: import_zod20.z.string().optional().describe('Lookup mode: name of the schema-declared lookup field to query by (e.g. "email").'),
+  value: import_zod20.z.string().optional().describe("Lookup mode (equality): exact-match value for `field`. Works on sensitive fields."),
+  from: import_zod20.z.string().optional().describe("Lookup mode (range): inclusive lower bound; requires `to`. Non-sensitive fields only."),
+  to: import_zod20.z.string().optional().describe("Lookup mode (range): inclusive upper bound; requires `from`."),
+  prefix: import_zod20.z.string().optional().describe("Lookup mode (prefix): match values starting with this. Range-enabled string fields only."),
+  order: import_zod20.z.enum(["asc", "desc"]).optional().describe("Lookup mode: sort direction by the looked-up field. `asc` (default) or `desc`."),
+  startFrom: import_zod20.z.string().optional().describe("Lookup mode: pagination cursor \u2014 pass the `nextCursor` from the previous page to fetch the next."),
+  limit: import_zod20.z.number().int().min(1).max(MCP_MAX_LIMIT5).optional().describe(
     `Max principals per page. Defaults to ${MCP_DEFAULT_LIMIT5}; raise up to ${MCP_MAX_LIMIT5} (the principals API max) in one call when you can accept the payload, or page with \`startFrom\`.`
   )
 };
@@ -10937,7 +11147,7 @@ var lookupPrincipal = ({ client, log }) => ({
   name: "lookup_principal",
   title: "Look up a user identity or a namespaced identity entity",
   description: "Resolve a user, or an identity entity in a namespace (org/client/one you registered). Two modes:\n  \u2022 Resolve by your own id: pass `externalId` \u2192 the matching principal incl. its Vectros UUID (the id the ownership filters on record_query / hybrid_search / rag_ask expect).\n  \u2022 Lookup by a schema field: pass `type` and `field` plus exactly one of `value` (exact), `from`+`to` (range), or `prefix`. Sensitive-field-safe. (If both `externalId` and a `field` lookup are given, `externalId` wins.) For an entity kind, `contextId` names a specific app context when the namespace is context-owned rather than tenant-wide; a context-confined credential's own context is used automatically without it. Returns a `{ data, nextCursor }` page (default 10, max 100 \u2014 raise it in one call when you can accept the payload); a non-null `nextCursor` means more remain \u2014 pass it back as `startFrom`. Read-only \u2014 does not create or modify identities.",
-  inputSchema: inputSchema20,
+  inputSchema: inputSchema21,
   handler: async (args) => {
     const kind = args.kind;
     const isUser = kind === "user";
@@ -11011,17 +11221,17 @@ var lookupPrincipal = ({ client, log }) => ({
 var lookup_principal_default = lookupPrincipal;
 
 // src/tools/version_history.ts
-var import_zod20 = require("zod");
-var inputSchema21 = {
-  resourceType: import_zod20.z.enum(["record", "document"]).describe("Which kind of entity the id refers to: a record or a document."),
-  id: import_zod20.z.string().min(1, "id is required").describe("The Vectros id of the record or document whose history you want."),
-  startFrom: import_zod20.z.string().optional().describe("Pagination cursor \u2014 pass the `nextCursor` from the previous page to fetch older entries.")
+var import_zod21 = require("zod");
+var inputSchema22 = {
+  resourceType: import_zod21.z.enum(["record", "document"]).describe("Which kind of entity the id refers to: a record or a document."),
+  id: import_zod21.z.string().min(1, "id is required").describe("The Vectros id of the record or document whose history you want."),
+  startFrom: import_zod21.z.string().optional().describe("Pagination cursor \u2014 pass the `nextCursor` from the previous page to fetch older entries.")
 };
 var versionHistory = ({ client, log }) => ({
   name: "version_history",
   title: "Version history (record or document)",
   description: "Read the audit/version trail (CREATE/UPDATE/DELETE, with actor, timestamp, and diff) for a single record or document. Pass `resourceType` (record|document) and `id`. Returns `{ data, nextCursor }`; pass `nextCursor` back as `startFrom` to page through older entries. Entities without audit history (untyped) return an empty trail. Read-only.",
-  inputSchema: inputSchema21,
+  inputSchema: inputSchema22,
   handler: async (args) => {
     const resourceType = args.resourceType;
     const id = args.id;
@@ -11048,6 +11258,7 @@ var TOOL_NAMES = [
   "hybrid_search",
   "record_query",
   "record_get",
+  "record_batch_get",
   "record_create",
   "record_update",
   "record_delete",
@@ -11073,6 +11284,7 @@ var ALL_TOOL_FACTORIES = {
   hybrid_search: hybrid_search_default,
   record_query: record_query_default,
   record_get: record_get_default,
+  record_batch_get: record_batch_get_default,
   record_create: record_create_default,
   record_update: record_update_default,
   record_delete: record_delete_default,
@@ -11114,7 +11326,7 @@ var identityResource = ({ log, apiKey, environment }) => ({
   name: "identity",
   uri: "vectros://identity",
   title: "Current identity (tenant + principal scope)",
-  description: "The tenant + principal scope the MCP server is authenticated as. Returns the same payload as the `current_identity` tool: status, tenantId, environment, principalType, principalKeyId, principalLabel, (for scoped credentials) allowedActions + dataScope ({ userId, scopes[] }). Note: this does not yet include granted_capabilities (member-lifecycle / forensic-read / context-directory-read / delegate-mint) \u2014 a separate reach dimension a scope clause can carry as of API 0.40.0 that /v1/ping does not report yet, so allowedActions+dataScope may understate a credential's true reach. Also reports mcpServerVersion and sdkVersion (this build's own version and the bundled @vectros-ai/sdk version). The /v1/ping backing call ships the extended shape today; the version fields are always client-derived.",
+  description: "The tenant + principal scope the MCP server is authenticated as. Returns the same payload as the `current_identity` tool: status, tenantId, environment, principalType, principalKeyId, principalLabel, (for scoped credentials) allowedActions + dataScope ({ userId, scopes[] }). Note: this does not yet include granted_capabilities (member-lifecycle / forensic-read / context-directory-read / delegate-mint, as of API 0.40.0, joined by delegate-principal-stamp in 0.42.0) \u2014 a separate reach dimension a scope clause can carry that /v1/ping does not report yet, so allowedActions+dataScope may understate a credential's true reach. Also reports mcpServerVersion and sdkVersion (this build's own version and the bundled @vectros-ai/sdk version). The /v1/ping backing call ships the extended shape today; the version fields are always client-derived.",
   mimeType: "application/json",
   read: async () => {
     const identity = await resolveIdentity({ log, apiKey, environment });
@@ -11133,7 +11345,7 @@ var ALL_RESOURCE_FACTORIES = {
 };
 
 // src/zod-to-json-schema.ts
-var import_zod21 = require("zod");
+var import_zod22 = require("zod");
 function zodShapeToJsonSchema(shape) {
   const properties = {};
   const required = [];
@@ -11148,40 +11360,40 @@ function zodShapeToJsonSchema(shape) {
 function zodTypeToJsonSchema(schema) {
   const description = schema.description;
   let current = schema;
-  while (current instanceof import_zod21.z.ZodOptional || current instanceof import_zod21.z.ZodDefault || current instanceof import_zod21.z.ZodNullable) {
+  while (current instanceof import_zod22.z.ZodOptional || current instanceof import_zod22.z.ZodDefault || current instanceof import_zod22.z.ZodNullable) {
     current = current._def.innerType;
   }
   const base = description ? { description } : {};
-  if (current instanceof import_zod21.z.ZodString) {
+  if (current instanceof import_zod22.z.ZodString) {
     return { ...base, type: "string" };
   }
-  if (current instanceof import_zod21.z.ZodNumber) {
+  if (current instanceof import_zod22.z.ZodNumber) {
     return { ...base, type: "number" };
   }
-  if (current instanceof import_zod21.z.ZodBoolean) {
+  if (current instanceof import_zod22.z.ZodBoolean) {
     return { ...base, type: "boolean" };
   }
-  if (current instanceof import_zod21.z.ZodEnum) {
+  if (current instanceof import_zod22.z.ZodEnum) {
     return {
       ...base,
       type: "string",
       enum: current.options
     };
   }
-  if (current instanceof import_zod21.z.ZodArray) {
+  if (current instanceof import_zod22.z.ZodArray) {
     return {
       ...base,
       type: "array",
       items: zodTypeToJsonSchema(current.element)
     };
   }
-  if (current instanceof import_zod21.z.ZodObject) {
+  if (current instanceof import_zod22.z.ZodObject) {
     return {
       ...base,
       ...zodShapeToJsonSchema(current.shape)
     };
   }
-  if (current instanceof import_zod21.z.ZodRecord) {
+  if (current instanceof import_zod22.z.ZodRecord) {
     const valueType = current._def.valueType;
     return {
       ...base,
@@ -11305,7 +11517,7 @@ var VectrosMCPServer = class {
       if (!tool) {
         result = toolError(req.params.name ?? "unknown", new Error("No such tool."));
       } else {
-        const parsed = import_zod22.z.object(tool.inputSchema).strict().safeParse(req.params.arguments ?? {});
+        const parsed = import_zod23.z.object(tool.inputSchema).strict().safeParse(req.params.arguments ?? {});
         if (!parsed.success) {
           result = toolError(tool.name, new Error(formatArgError(tool, parsed.error)));
         } else {