@alfe.ai/agent-api-client 0.1.3 → 0.2.0

package/dist/index.d.ts

@@ -1,262 +1,7 @@
-//#region ../../packages-internal/types/dist/access.d.ts
+import { ChangelogAction, ChangelogActor, ChangelogEntry, ChangelogEntry as ChangelogEntry$1, EncryptedEnvelopeV1, EncryptedEnvelopeV1 as EncryptedEnvelopeV1$1, Field, FieldEnvelope, FieldEnvelope as FieldEnvelope$1, FieldFormat, FieldFormat as FieldFormat$1, FieldSensitivity, FieldSensitivity as FieldSensitivity$1, FieldView, GeneratedDataKey, GeneratedDataKey as GeneratedDataKey$1, IntegrationConfigResult, IntegrationConfigResult as IntegrationConfigResult$1, IntegrationConfigSchemaField, IntegrationInstall, IntegrationInstall as IntegrationInstall$1, RegistryEntry, RegistryEntry as RegistryEntry$1, ScopeInfo, ScopeInfo as ScopeInfo$1, SecretAggregate, SecretAggregate as SecretAggregate$1, SecretCategory, SecretCategory as SecretCategory$1, SecretMetadata, SecretMetadata as SecretMetadata$1, SecretScope, SecretScope as SecretScope$1 } from "@alfe/types";
 
-/**
- * The four resource scopes at which a permission can apply.
- * Order is meaningful: broader scopes first (`org`) → narrower last (`agent`).
- *
- * `IntegrationScope` in integration.ts and `SecretScope` in secrets.ts are
- * intentional aliases of this same enum — there is only one concept of
- * "scope" in Alfe.
- */
-declare const ResourceScope: {
-  readonly Org: "org";
-  readonly Team: "team";
-  readonly Project: "project";
-  readonly Agent: "agent";
-};
-type ResourceScope = (typeof ResourceScope)[keyof typeof ResourceScope];
-/** Ordered tuple of resource scope string values (broad → narrow). */
-//#endregion
-//#region ../../packages-internal/types/dist/integration.d.ts
-/** Controls where an integration appears: public (everyone), hidden (nowhere) */
-declare const IntegrationVisibility: {
-  readonly Public: "public";
-  readonly Hidden: "hidden";
-};
-type IntegrationVisibility = (typeof IntegrationVisibility)[keyof typeof IntegrationVisibility];
-/** Scope at which an integration is installed */
-declare const IntegrationScope: {
-  readonly Org: "org";
-  readonly Team: "team";
-  readonly Project: "project";
-  readonly Agent: "agent";
-};
-type IntegrationScope = ResourceScope;
-declare const IntegrationDesiredStatus: {
-  readonly Active: "active";
-  readonly Removed: "removed";
-};
-type IntegrationDesiredStatus = (typeof IntegrationDesiredStatus)[keyof typeof IntegrationDesiredStatus];
-declare const IntegrationActualStatus: {
-  readonly Installing: "installing";
-  readonly Active: "active";
-  readonly Error: "error";
-  readonly Removing: "removing";
-  readonly Inactive: "inactive";
-  readonly Unknown: "unknown";
-};
-type IntegrationActualStatus = (typeof IntegrationActualStatus)[keyof typeof IntegrationActualStatus];
-interface IntegrationInstall {
-  scope: IntegrationScope;
-  scopeId: string;
-  integrationId: string;
-  tenantId: string;
-  desiredStatus: IntegrationDesiredStatus;
-  actualStatus: IntegrationActualStatus;
-  version: string;
-  config: Record<string, unknown>;
-  errorMessage: string;
-  installedAt: string;
-  updatedAt: string;
-}
-/** @deprecated Use IntegrationInstall instead */
-
-interface IntegrationConfigSchemaField {
-  key: string;
-  label: string;
-  type: string;
-  description?: string;
-  required?: boolean;
-  default?: string | number | boolean;
-  options?: string[];
-  select_options?: {
-    value: string;
-    label: string;
-  }[];
-  oauth_provider?: string;
-  oauth_scopes?: string[];
-  oauth_integration_id?: string;
-  editable?: string;
-  hidden?: boolean;
-}
-interface IntegrationConfigResult {
-  integrationId: string;
-  config: Record<string, unknown>;
-  configSchema: IntegrationConfigSchemaField[];
-}
-interface RegistryEntry {
-  id: string;
-  name: string;
-  description: string;
-  versions: string[];
-  latest: string;
-  repository: string;
-  commit: string;
-  icon?: string;
-  author?: {
-    name: string;
-    url?: string;
-  } | string;
-  pricing?: {
-    type: "free" | "paid" | "usage";
-    price?: number;
-    currency?: string;
-    interval?: "month" | "year";
-    description?: string;
-  };
-  features?: string[];
-  preview_images?: string[];
-  config_schema?: IntegrationConfigSchemaField[];
-  supported_agents?: string[];
-  /** Scopes where this integration can be installed */
-  supported_scopes?: IntegrationScope[];
-  /** Visibility status — controls where integration appears */
-  visibility?: IntegrationVisibility;
-}
-//# sourceMappingURL=integration.d.ts.map
-//#endregion
-//#region ../../packages-internal/types/dist/secrets.d.ts
-/** Scope levels at which a secret can be owned. Aliased to ResourceScope. */
-type SecretScope = ResourceScope;
-/**
- * v1 encrypted envelope as persisted by services/secrets and exchanged with
- * agents. Values are AES-256-GCM ciphertext; iv/authTag/ciphertext/dataKeyCiphertext
- * are all base64-encoded.
- */
-interface EncryptedEnvelopeV1 {
-  version: 1;
-  iv: string;
-  ciphertext: string;
-  authTag: string;
-  dataKeyCiphertext: string;
-}
-/**
- * Display/validation hint for a field's value. `"json"` signals that the
- * string is a JSON-stringified payload that consumers should `JSON.parse`.
- */
-declare const FIELD_FORMATS: readonly ["text", "email", "url", "phone", "date", "number", "json"];
-type FieldFormat = (typeof FIELD_FORMATS)[number];
-/**
- * Whether a field is stored in plaintext (visible to anyone with read access)
- * or encrypted (requires KMS + the right encryption context to read).
- */
-declare const FIELD_SENSITIVITIES: readonly ["plaintext", "encrypted"];
-type FieldSensitivity = (typeof FIELD_SENSITIVITIES)[number];
-/**
- * A field on a secret. `value` is always a string at the wire; for encrypted
- * fields it's the plaintext at the API edge (the service encrypts before
- * persistence). Reads from the dashboard omit `value` for encrypted fields;
- * agents get a `FieldEnvelope` instead and decrypt locally.
- */
-interface Field {
-  key: string;
-  format?: FieldFormat;
-  sensitivity: FieldSensitivity;
-  value: string;
-}
-/**
- * Secret category — drives icon/template/filter behaviour. Defaults to
- * `"other"` for migrated rows.
- */
-declare const SECRET_CATEGORIES: readonly ["login", "api_key", "database", "ssh_key", "certificate", "secure_note", "credit_card", "identity", "wifi", "other"];
-type SecretCategory = (typeof SECRET_CATEGORIES)[number];
-/**
- * One field as exposed to readers. Encrypted fields have no `value` on the
- * dashboard read path; the agent-side aggregate carries `envelope` instead.
- */
-interface FieldView {
-  key: string;
-  format?: FieldFormat;
-  sensitivity: FieldSensitivity;
-  /** Present for `sensitivity: "plaintext"` only. */
-  value?: string;
-  /** Present for `sensitivity: "encrypted"` on agent-side reads only. */
-  envelope?: EncryptedEnvelopeV1;
-  /** Plaintext fields that opt into `format: "json"` are pre-parsed for callers. */
-  parsedValue?: unknown;
-  rotatedAt?: string;
-  createdAt: string;
-  updatedAt: string;
-}
-/** A secret as assembled from its multi-row aggregate. */
-interface SecretAggregate {
-  secretId: string;
-  secretName: string;
-  description?: string;
-  tags: string[];
-  category: SecretCategory;
-  fields: FieldView[];
-  changelogVersion: number;
-  createdAt: string;
-  updatedAt: string;
-}
-/** Metadata-only projection — used by list endpoints. */
-interface SecretMetadata {
-  secretId: string;
-  secretName: string;
-  description?: string;
-  tags: string[];
-  category: SecretCategory;
-  fieldKeys: string[];
-  changelogVersion: number;
-  createdAt: string;
-  updatedAt: string;
-}
-/**
- * Per-field encrypted envelope returned to agents on the agent-side aggregate.
- * Agents decrypt locally using a data key fetched from `/decrypt-data-key`.
- */
-interface FieldEnvelope {
-  key: string;
-  format?: FieldFormat;
-  envelope: EncryptedEnvelopeV1;
-  rotatedAt?: string;
-  createdAt: string;
-  updatedAt: string;
-}
-/** A scope the caller can read or write secrets in. */
-interface ScopeInfo {
-  scope: SecretScope;
-  scopeId: string;
-  name?: string;
-}
-/**
- * KMS-issued data key, returned by the secrets service's
- * `/secrets/generate-data-key` KMS proxy endpoint. The plaintext key is
- * returned base64-encoded; callers MUST decode it to a Buffer and zero the
- * Buffer after use — never keep the plaintext as a JS string.
- */
-interface GeneratedDataKey {
-  plaintextKey: string;
-  dataKeyCiphertext: string;
-}
-/**
- * Action types recorded in the secret changelog. Append-only.
- */
-declare const CHANGELOG_ACTIONS: readonly ["created", "deleted", "metadata_updated", "field_added", "field_rotated", "field_removed", "tag_added", "tag_removed"];
-type ChangelogAction = (typeof CHANGELOG_ACTIONS)[number];
-/** Who triggered a changelog entry. */
-interface ChangelogActor {
-  kind: "user" | "agent" | "system";
-  id: string;
-}
-/**
- * One audit row from the secret's changelog. Metadata only — never carries
- * field VALUES (old or new). Rolling back a rotated secret is intentionally
- * not supported.
- */
-interface ChangelogEntry {
-  changelogVersion: number;
-  action: ChangelogAction;
-  fieldKey?: string;
-  fieldSensitivity?: FieldSensitivity;
-  changedBy: ChangelogActor;
-  reason?: string;
-  timestamp: string;
-}
-//# sourceMappingURL=secrets.d.ts.map
-//#endregion
 //#region src/index.d.ts
+
 interface AgentApiClientConfig {
   apiKey: string;
   apiUrl: string;
@@ -402,14 +147,14 @@ declare class AgentApiClient {
     downloadUrl: string;
     expiresIn: number;
   }>;
-  listIntegrations(): Promise<IntegrationInstall[]>;
-  getIntegrationConfig(integrationId: string): Promise<IntegrationConfigResult>;
+  listIntegrations(): Promise<IntegrationInstall$1[]>;
+  getIntegrationConfig(integrationId: string): Promise<IntegrationConfigResult$1>;
   updateIntegrationConfig(integrationId: string, config: Record<string, unknown>): Promise<void>;
   installIntegration(integrationId: string, options?: {
     version?: string;
     config?: Record<string, unknown>;
-  }): Promise<IntegrationInstall>;
-  removeIntegration(integrationId: string): Promise<IntegrationInstall>;
+  }): Promise<IntegrationInstall$1>;
+  removeIntegration(integrationId: string): Promise<IntegrationInstall$1>;
   getOAuthUrl(provider: string, scopes?: string[]): Promise<{
     url: string;
     provider: string;
@@ -421,37 +166,33 @@ declare class AgentApiClient {
     config?: Record<string, string>;
   }>;
   getRegistry(): Promise<{
-    integrations: RegistryEntry[];
+    integrations: RegistryEntry$1[];
   }>;
+  /**
+   * Returns every connected Google account for the agent. Multi-account by
+   * design — the openclaw-google plugin requires the LLM to pass `email`
+   * explicitly to `google_run_command` so an account is always selected
+   * deliberately.
+   *
+   * 2026-05-14 (connections-redesign PR 1): the legacy flat shape (`email`,
+   * `refreshToken`, `accessToken`, etc., populated from the default account)
+   * is gone. Iterate over `accounts`.
+   */
   getGoogleCredentials(): Promise<{
-    accounts?: {
+    accounts: {
       email: string;
       refreshToken: string;
       clientId: string;
       clientSecret: string;
-      enabledServices?: string[];
-      isDefault: boolean;
       displayName?: string;
+      connectedAt?: string;
     }[];
-    email: string;
-    refreshToken: string;
-    clientId: string;
-    clientSecret: string;
-    projectId: string;
-    enabledServices?: string[];
   }>;
   disconnectGoogleAccount(email: string): Promise<{
     accounts: {
       email: string;
       displayName?: string;
-      isDefault: boolean;
-    }[];
-  }>;
-  setDefaultGoogleAccount(email: string): Promise<{
-    accounts: {
-      email: string;
-      displayName?: string;
-      isDefault: boolean;
+      connectedAt?: string;
     }[];
   }>;
   getGoogleChatCredentials(): Promise<{
@@ -461,24 +202,125 @@ declare class AgentApiClient {
     clientSecret: string;
     displayName?: string;
   }>;
+  /**
+   * @deprecated Returns a single primary credential blob (legacy "pick-the-
+   * default-connection" shape). Use `getGithubAccounts()` for the multi-
+   * account shape required by Pattern A — explicit selector args on every
+   * tool. Retained because the `@alfe.ai/openclaw-github` proxy is the
+   * only consumer that knows about Pattern A; legacy env-interpolation
+   * callers will keep hitting `/credentials` until they move to the proxy.
+   */
   getGithubCredentials(): Promise<{
     login: string;
     accessToken: string;
   }>;
+  /**
+   * Pattern A: multi-account credential fetch for GitHub.
+   *
+   * Returns every agent-scoped GitHub connection. The caller is expected
+   * to require a `login` selector on every credential-touching tool and
+   * look up the matching account at dispatch time.
+   *
+   * GitHub OAuth tokens have no expiry (`tokenLifecycle: "no_expiry"`),
+   * so there is intentionally no `refreshGithubAccountToken` method — if
+   * a token is revoked the user must re-run the OAuth flow.
+   *
+   * Returned `accounts[i].login` is the GitHub username — the stable
+   * cross-session identifier the LLM should pass.
+   */
+  getGithubAccounts(): Promise<{
+    accounts: {
+      connectionId: string;
+      accountIdentifier: string;
+      displayName: string | null;
+      connectedAt: string;
+      accessToken: string;
+      login: string;
+      scopes: string;
+    }[];
+  }>;
+  /**
+   * @deprecated Returns a single primary credential blob (legacy "pick-the-
+   * default-connection" shape). Use `getXeroAccounts()` for the multi-
+   * account shape required by Pattern A — explicit selector args on every
+   * tool. This method will be removed once all consumers migrate.
+   */
   getXeroCredentials(): Promise<{
     accessToken: string;
     accessTokenExpiresAt: string;
     xeroTenantId: string;
   }>;
+  /**
+   * Pattern A: multi-account credential fetch for Xero. Returns every
+   * agent-scoped Xero connection. The caller is expected to require a
+   * selector arg (e.g. `xeroTenantId`) on every credential-touching tool
+   * and look up the matching account by that selector at dispatch time.
+   *
+   * Returned `accounts[i].accountIdentifier` is the Xero tenantId — the
+   * stable cross-session identifier the LLM should pass.
+   */
+  getXeroAccounts(): Promise<{
+    accounts: {
+      connectionId: string;
+      accountIdentifier: string;
+      displayName: string | null;
+      connectedAt: string;
+      accessToken: string;
+      accessTokenExpiresAt: string;
+      xeroTenantId: string;
+    }[];
+  }>;
   refreshXeroToken(): Promise<{
     accessToken: string;
     expiresAt: string;
   }>;
+  /**
+   * Pattern A: refresh a specific Xero connection by its `accountIdentifier`
+   * (the Xero `tenantId`). The legacy `refreshXeroToken()` only refreshes
+   * the *primary* connection, which is wrong for multi-tenant Xero where
+   * each tenant has its own non-interchangeable access token.
+   */
+  refreshXeroAccountToken(xeroTenantId: string): Promise<{
+    accessToken: string;
+    accessTokenExpiresAt: string;
+    expiresAt: string;
+  }>;
+  /**
+   * @deprecated Returns a single primary credential blob (legacy "pick-the-
+   * default-connection" shape). Use `getNotionAccounts()` for the multi-
+   * account shape required by Pattern A.
+   */
   getNotionCredentials(): Promise<{
     accessToken: string;
     workspaceId: string;
     workspaceName: string;
   }>;
+  /**
+   * Pattern A: multi-account credential fetch for Notion. Returns every
+   * agent-scoped Notion connection. The caller is expected to require a
+   * selector arg (e.g. `workspaceId`) on every credential-touching tool.
+   *
+   * Returned `accounts[i].accountIdentifier` is the Notion workspaceId.
+   */
+  getNotionAccounts(): Promise<{
+    accounts: {
+      connectionId: string;
+      accountIdentifier: string;
+      displayName: string | null;
+      connectedAt: string;
+      accessToken: string;
+      workspaceId: string;
+      workspaceName: string;
+    }[];
+  }>;
+  /**
+   * @deprecated Returns a single primary Atlassian Connection's credentials
+   * (one OAuth user, one cloudId) — the legacy "pick-the-default-connection"
+   * shape. Atlassian is multi-site by nature (each OAuth user may have
+   * access to multiple Cloud sites), so Pattern A plugins MUST use
+   * `getAtlassianAccounts()` to discover the full set and dispatch via
+   * the `cloudId` selector arg.
+   */
   getAtlassianCredentials(): Promise<{
     accessToken: string;
     refreshToken: string;
@@ -495,16 +337,177 @@ declare class AgentApiClient {
     accessToken: string;
     expiresAt: string;
   }>;
+  /**
+   * Pattern A: multi-account / multi-site credential fetch for Atlassian.
+   *
+   * Returns every agent-scoped Atlassian Connection. Each Connection is
+   * one OAuth user with a single access token and N accessible Cloud
+   * sites (`availableSites`). The caller is expected to:
+   *
+   *   1. Flatten (connection × cloudId) into one MCP child per site.
+   *   2. Require a `cloudId` selector on every credential-touching tool.
+   *   3. Use the access token bound to the Connection that owns the
+   *      requested `cloudId` (Atlassian shares one access token across
+   *      all sites accessible to the OAuth user).
+   *
+   * Per-account token refresh uses `refreshAtlassianAccountToken(email)`
+   * — refreshing one Connection rotates its single access token, which
+   * then applies to every cloudId for that Connection.
+   *
+   * Returned `accounts[i].accountIdentifier` is the OAuth user's email
+   * — the stable cross-session identifier for refresh purposes. The LLM
+   * never sees this directly: it picks a site via the `cloudId` arg
+   * instead.
+   */
+  getAtlassianAccounts(): Promise<{
+    accounts: {
+      connectionId: string;
+      accountIdentifier: string;
+      displayName: string | null;
+      connectedAt: string;
+      accessToken: string;
+      accessTokenExpiresAt: string;
+      clientId: string;
+      clientSecret: string;
+      cloudId: string;
+      siteName: string;
+      siteUrl: string;
+      availableSites: {
+        id: string;
+        url: string;
+        name: string;
+        scopes?: string[];
+        avatarUrl?: string;
+      }[];
+    }[];
+  }>;
+  /**
+   * Pattern A: refresh a specific Atlassian Connection by `accountIdentifier`
+   * (the OAuth user's email).
+   *
+   * Atlassian rotates refresh tokens (`rotatesRefreshToken: true`); the
+   * server-side per-account refresh endpoint handles rotation and
+   * persistence. Refreshing one Connection updates its single access
+   * token, which applies to every accessible Cloud site (cloudId) for
+   * that OAuth user.
+   *
+   * Returns the new access token + expiry. The proxy is responsible for
+   * fanning the new token out to every child server it spawned for
+   * cloudIds owned by this Connection.
+   */
+  refreshAtlassianAccountToken(accountIdentifier: string): Promise<{
+    accessToken: string;
+    accessTokenExpiresAt: string;
+    expiresAt: string;
+  }>;
+  /**
+   * @deprecated Returns a single primary credential blob (legacy "pick-the-
+   * default-connection" shape). Use `getMYOBAccounts()` for the multi-
+   * account shape required by Pattern A.
+   */
   getMYOBCredentials(): Promise<{
     accessToken: string;
     accessTokenExpiresAt: string;
     myobBusinessId: string;
     clientId: string;
   }>;
+  /**
+   * Pattern A: multi-account credential fetch for MYOB. Returns every
+   * agent-scoped MYOB connection. The caller is expected to require a
+   * selector arg (e.g. `myobBusinessId` / `accountIdentifier`) on every
+   * credential-touching tool.
+   *
+   * Returned `accounts[i].accountIdentifier` is the MYOB businessId.
+   */
+  getMYOBAccounts(): Promise<{
+    accounts: {
+      connectionId: string;
+      accountIdentifier: string;
+      displayName: string | null;
+      connectedAt: string;
+      accessToken: string;
+      accessTokenExpiresAt: string;
+      myobBusinessId: string;
+      clientId: string;
+    }[];
+  }>;
   refreshMYOBToken(): Promise<{
     accessToken: string;
     expiresAt: string;
   }>;
+  /**
+   * Microsoft 365 (delegated OAuth) credential fetch — single-account shape.
+   *
+   * @deprecated Use `getMicrosoftAccounts()` and dispatch via the `email`
+   *   selector once per-account plugins land. Retained because the existing
+   *   `integrations/connect/microsoft/hooks/post_activate.mjs` writes
+   *   `mgc` credentials for the single (default) Microsoft account.
+   *
+   * Returns the agent's effective Microsoft delegated-OAuth credentials.
+   * Distinct from `getTeamsCredentials()` (Azure bot credentials for the
+   * Teams adapter, which is admin-consent flow on services/microsoft, not
+   * delegated OAuth on services/connect).
+   */
+  getMicrosoftCredentials(): Promise<{
+    accessToken: string;
+    accessTokenExpiresAt?: string;
+    refreshToken: string;
+    clientId: string;
+    clientSecret: string;
+    email?: string;
+    microsoftTenantId?: string;
+    workspaceDomain?: string;
+  }>;
+  /**
+   * Pattern A: multi-account credential fetch for Microsoft 365.
+   *
+   * Returns every agent-scoped Microsoft connection. The caller is expected
+   * to require an `email` selector on every credential-touching tool and
+   * look up the matching account at dispatch time.
+   *
+   * Returned `accounts[i].accountIdentifier` is the user's primary email
+   * (or the tid claim as fallback) — the stable cross-session identifier
+   * the LLM should pass.
+   *
+   * Per-account token refresh is exposed via `refreshMicrosoftAccountToken`,
+   * NOT `refreshXeroAccountToken` — Microsoft refresh tokens are not
+   * interchangeable across (tenant, user) pairs.
+   */
+  getMicrosoftAccounts(): Promise<{
+    accounts: {
+      connectionId: string;
+      accountIdentifier: string;
+      displayName: string | null;
+      connectedAt: string;
+      accessToken: string;
+      accessTokenExpiresAt: string;
+      refreshToken: string;
+      clientId: string;
+      clientSecret: string;
+      email: string;
+      microsoftTenantId: string;
+      workspaceDomain: string;
+    }[];
+  }>;
+  /**
+   * Pattern A: refresh a specific Microsoft 365 connection by its
+   * `accountIdentifier`. For Microsoft, `accountIdentifier` is the user's
+   * email when the Graph profile fetch succeeded at connect time, and the
+   * Azure tenant id (`tid` claim) as fallback. Callers should pass the
+   * value returned by `getMicrosoftAccounts()` rather than synthesising
+   * an email locally.
+   *
+   * Microsoft refresh tokens are bound to a specific (tenant, user) pair —
+   * they are NOT interchangeable across accounts, so per-account refresh
+   * is mandatory. The generic /accounts/{accountIdentifier}/refresh
+   * endpoint walks the agent's full visible scope chain to find a matching
+   * connection (works for inherited team/project Microsoft connections).
+   */
+  refreshMicrosoftAccountToken(accountIdentifier: string): Promise<{
+    accessToken: string;
+    accessTokenExpiresAt: string;
+    expiresAt: string;
+  }>;
   getTeamsCredentials(): Promise<{
     agentId: string;
     tenantId: string;
@@ -559,11 +562,11 @@ declare class AgentApiClient {
    * to reach them.
    */
   generateSecretDataKey(args: {
-    scope: SecretScope;
+    scope: SecretScope$1;
     scopeId: string;
     secretId: string;
     fieldKey: string;
-  }): Promise<GeneratedDataKey>;
+  }): Promise<GeneratedDataKey$1>;
   /**
    * Unwrap a wrapped data key so the agent can decrypt the envelope locally.
    * `fieldKey` MUST match the value supplied when the data key was generated
@@ -571,7 +574,7 @@ declare class AgentApiClient {
    * `InvalidCiphertextException`.
    */
   decryptSecretDataKey(args: {
-    scope: SecretScope;
+    scope: SecretScope$1;
     scopeId: string;
     secretId: string;
     fieldKey: string;
@@ -586,57 +589,57 @@ declare class AgentApiClient {
    * Plaintext fields ship the value inline.
    */
   createSecret(args: {
-    scope: SecretScope;
+    scope: SecretScope$1;
     scopeId: string;
     secretId: string;
     secretName: string;
-    category?: SecretCategory;
+    category?: SecretCategory$1;
     description?: string;
     tags?: string[];
     fields: {
       key: string;
-      format?: FieldFormat;
-      sensitivity: FieldSensitivity;
+      format?: FieldFormat$1;
+      sensitivity: FieldSensitivity$1;
       value?: string;
-      envelope?: EncryptedEnvelopeV1;
+      envelope?: EncryptedEnvelopeV1$1;
     }[];
     reason?: string;
-  }): Promise<SecretAggregate>;
+  }): Promise<SecretAggregate$1>;
   /** Fetch the secret aggregate plus per-field encrypted envelopes. */
   getSecret(args: {
-    scope: SecretScope;
+    scope: SecretScope$1;
     scopeId: string;
     secretId: string;
   }): Promise<{
-    aggregate: SecretAggregate;
-    envelopes: FieldEnvelope[];
+    aggregate: SecretAggregate$1;
+    envelopes: FieldEnvelope$1[];
   }>;
   /** Fetch one field. Plaintext: value inline. Encrypted: envelope. */
   getSecretField(args: {
-    scope: SecretScope;
+    scope: SecretScope$1;
     scopeId: string;
     secretId: string;
     fieldKey: string;
   }): Promise<{
     key: string;
-    sensitivity: FieldSensitivity;
-    format?: FieldFormat;
+    sensitivity: FieldSensitivity$1;
+    format?: FieldFormat$1;
     value?: string;
-    envelope?: EncryptedEnvelopeV1;
+    envelope?: EncryptedEnvelopeV1$1;
     rotatedAt?: string;
     createdAt: string;
     updatedAt: string;
   }>;
   /** Add OR rotate one field. */
   setSecretField(args: {
-    scope: SecretScope;
+    scope: SecretScope$1;
     scopeId: string;
     secretId: string;
     fieldKey: string;
-    sensitivity: FieldSensitivity;
-    format?: FieldFormat;
+    sensitivity: FieldSensitivity$1;
+    format?: FieldFormat$1;
     value?: string;
-    envelope?: EncryptedEnvelopeV1;
+    envelope?: EncryptedEnvelopeV1$1;
     reason?: string;
   }): Promise<{
     fieldKey: string;
@@ -644,49 +647,49 @@ declare class AgentApiClient {
   }>;
   /** Remove one field. */
   removeSecretField(args: {
-    scope: SecretScope;
+    scope: SecretScope$1;
     scopeId: string;
     secretId: string;
     fieldKey: string;
   }): Promise<void>;
   /** Update secret-level metadata (name/description/tags/category). */
   updateSecretMetadata(args: {
-    scope: SecretScope;
+    scope: SecretScope$1;
     scopeId: string;
     secretId: string;
     secretName?: string;
     description?: string;
     tags?: string[];
-    category?: SecretCategory;
+    category?: SecretCategory$1;
     reason?: string;
-  }): Promise<SecretAggregate>;
+  }): Promise<SecretAggregate$1>;
   /** List metadata for secrets in a scope. Optional filters route through the byFacet GSI. */
   listSecrets(args: {
-    scope: SecretScope;
+    scope: SecretScope$1;
     scopeId: string;
-    category?: SecretCategory;
+    category?: SecretCategory$1;
     tag?: string;
     fieldKey?: string;
-  }): Promise<SecretMetadata[]>;
+  }): Promise<SecretMetadata$1[]>;
   /** Bounded changelog read — metadata-only audit entries. */
   getSecretHistory(args: {
-    scope: SecretScope;
+    scope: SecretScope$1;
     scopeId: string;
     secretId: string;
     limit?: number;
     cursor?: string;
   }): Promise<{
-    entries: ChangelogEntry[];
+    entries: ChangelogEntry$1[];
     nextCursor?: string;
   }>;
   /** Delete a secret (and all its field rows + tag rows + changelog rows). */
   deleteSecret(args: {
-    scope: SecretScope;
+    scope: SecretScope$1;
     scopeId: string;
     secretId: string;
   }): Promise<void>;
   /** Enumerate scopes (org/team/project/agent) this agent can access. */
-  listSecretScopes(): Promise<ScopeInfo[]>;
+  listSecretScopes(): Promise<ScopeInfo$1[]>;
   /**
    * Returns the calling agent's own identity context — `{ agentId, tenantId }`
    * decoded server-side from the agent API token. Used by the