@revoengine/sdk 1.6.2 → 1.6.3

package/README.md

@@ -1,12 +1,12 @@
 # @revoengine/sdk
 
 Official Node.js SDK for RevoEngine. It provides the modern `api`, `utils`,
-`storage`, `transport`, and `agents` namespaces, top-level `execute()`, and the `batch` controller in both
+`storage`, `transport`, `vault`, and `agents` namespaces, top-level `execute()`, and the `batch` controller in both
 Revo-hosted `CUSTOM_NODEJS` components and standalone Node.js applications.
 
 Requirements: Node.js 22 or newer.
 
-## SDK 1.6.2 compatibility
+## SDK 1.6.3 compatibility
 
 This release synchronizes the complete public SDK contract with the current
 platform low-code declarations. Remote calls require a platform runtime that admits
@@ -28,7 +28,7 @@ Legacy SFTP helpers and the removed thread-goal methods are not exposed by the
 current SDK contract. Refer to the [transfer guide](https://docs.revoengine.com/low-code/sftp)
 for Secret formats and file-transfer examples.
 
-SDK 1.6.2 retains portable Component digest declarations and one readable-relation
+SDK 1.6.3 retains portable Component digest declarations and one readable-relation
 contract for Databases, live Views, and Materialized Views. Use `api.exportDatabase()`
 for all three relation types. `api.getDatabaseViewData()` remains a deprecated
 read alias; `api.exportDatabaseView()` and separate REST View export operations
@@ -41,6 +41,9 @@ returns its job ID for operation tracking. The import workflow starts with
 describe the current request and response shapes; the platform still enforces
 permissions and validates source and target state before committing an import.
 
+Assistant model inputs follow the current platform: `gpt-6.1-sol` and
+`gpt-6-luna`; Fast mode is supported for Luna. Update older Sol model identifiers.
+
 Remote MCP server configurations in this contract use public HTTPS destinations.
 Private-network access is not an accepted SDK setting; review the server URL,
 provider consent, Vault binding, and tool permissions before enabling a plugin.
@@ -52,14 +55,14 @@ provider consent, Vault binding, and tool permissions before enabling a plugin.
 | Revo-hosted `CUSTOM_NODEJS` | Export `async function init(runtime)` | Revo injects an execution-bound runtime; user code receives no API key. |
 | Standalone Node.js | Create `new RevoClient(options)` | Supply a RevoEngine API key explicitly or through an environment variable. |
 
-Both modes expose the same `api`, `utils`, `storage`, `transport`, `agents`, `execute`, and `batch`
+Both modes expose the same `api`, `utils`, `storage`, `transport`, `vault`, `agents`, `execute`, and `batch`
 properties, but return types reflect where the work happens:
 
 | Call kind | Revo-hosted | Standalone |
 | --- | --- | --- |
 | Execution snapshot, cache, debug, and logging | Synchronous | Throws synchronously because no execution context exists |
 | Current user and instance | Synchronous injected snapshot | Asynchronous lazy `/api/v1/me` discovery |
-| Remote `api`, `storage`, `agents`, and `execute()` calls | Asynchronous | Asynchronous |
+| Remote `api`, `storage`, `transport`, `vault`, `agents`, and `execute()` calls | Asynchronous | Asynchronous |
 | Local `utils` and `batch.configure()` | Synchronous unless the utility is inherently asynchronous | Same |
 
 ## Installation
@@ -76,7 +79,7 @@ RevoEngine pins that version again in the deployment package and injects the
 runtime into the component entrypoint. Component code does not construct a
 `RevoClient`.
 
-The platform chooses the hosted package version; publishing SDK 1.6.2 does not
+The platform chooses the hosted package version; publishing SDK 1.6.3 does not
 upgrade existing hosted deployments or their generated package pins.
 
 Hosted user code receives neither a tenant API key nor the private runtime
@@ -95,7 +98,7 @@ separate initialization method.
 ```js
 /** @param {import('@revoengine/sdk').RevoRuntime} runtime */
 export async function init(runtime) {
-  const { api, utils, storage, agents, execute, batch } = runtime;
+  const { api, utils, storage, vault, agents, execute, batch } = runtime;
   const { data: rows, next } = await api.getDatabaseData('Sales', {
     fields: ['saleId', 'customerId', 'total', 'createdAt'],
     sort: ['-createdAt'],
@@ -787,3 +790,85 @@ Common subclasses include:
 - Deprecated low-code methods and aliases are excluded.
 - `api.transactionDatabaseData` is excluded.
 - Runtime batches are non-transactional and are not retried automatically.
+
+## Vault manager
+
+The native `client.vault` manager uses the same get/create/update/delete/rotate
+contract for instance (default) and verified user scope. Get alone returns
+`secret.revision.value` as a Buffer containing the stored UTF-8 text; Rotate returns metadata without values.
+Revision versions are normalized validFrom timestamps. validFrom accepts null,
+Date, ISO or epoch milliseconds; a future Rotate preserves current availability.
+`listRevisions` exposes paginated metadata history.
+
+```ts
+const secret = await client.vault.get('TOKEN', { scope: 'user' });
+const token = secret.revision.value.toString('utf8');
+await client.vault.rotate('TOKEN', { value: replacement }, { scope: 'user', validFrom: null });
+```
+
+Do not log values or access tokens. Instance access requires Secret roles and
+creator ownership or administrator rights. User scope uses the verified account;
+management requires owner rights and does not inherit saved Component/Tool grants.
+Writes return null in debug/read-only execution. See the
+[Vault guide](https://docs.revoengine.com/low-code/reference/vault) for all methods.
+
+The same flat manager exposes `getAccessToken`, `getIntegrationMetadata`,
+`discoverIntegration`, `connectIntegration`, and `disconnectIntegration`. Token reads
+return the access token with its matching ISO expiry and refresh when necessary.
+Connect requires nullable `expectedRevision` (null to create) and returns an
+authorization URL for interactive consent through the existing frontend callback.
+Disconnect retains definition/history/grants and does not revoke provider access.
+Saved Component/Tool reads preserve exact personal grants; direct SDK owner/admin
+reads and management are authorized separately.
+
+
+## Bulk Jobs and Webhooks
+
+Use `api.cancelJobs`, `retryJobs`, `deleteJobs`, `cancelWebhooks`, `retryWebhooks`,
+and `deleteWebhooks` with exactly one non-empty platform `filter` or an ID array
+(`jobIds` / `webhookIds`, 1–1000 IDs). A filter selects every matching row beyond
+list pagination. An optional actor-scoped `idempotencyKey` protects repeat admission.
+The SDK never automatically retries mutations.
+
+```ts
+const input = {
+  filter: { field: 'status', op: 'eq', value: 'ERROR' },
+  idempotencyKey: 'retry-errors-2026-10-01',
+};
+const preview = await client.api.previewAutomationOperation('jobs', 'retry', input);
+// Review advisory preview.matched / preview.eligible before submitting.
+const operation = await client.api.retryJobs(input);
+const progress = await client.api.getAutomationOperation(operation.operationId);
+const outcomes = await client.api.getAutomationOperationItems(operation.operationId);
+// Fetch subsequent pages with outcomes.nextCursor as the second argument.
+```
+
+Operations report `PENDING`, `PROCESSING`, `FINISHED`, or `ERROR`, plus
+`total`, `processed`, `skipped`, and `failed`. `FINISHED` means lifecycle requests
+were processed; downstream execution/delivery may continue and failed can be non-zero.
+Item pages contain safe source/result IDs and error codes. Preview is advisory;
+admission freezes selection and the worker rechecks state and permissions.
+Cancel/delete require Automation Admin; retry accepts Automation Runner/Admin.
+
+`retryWebhooks` accepts `requestPatch`: url/method/body replace whole fields;
+headers/query accept `set` and `remove`, and `maskDetails` adds masks while preserving
+existing masks. Masked original values cannot be recovered: provide explicit
+replacements or the item fails with `REPLAY_PAYLOAD_UNAVAILABLE`. If the entire
+headers section was masked, `headers.set` supplies its complete replacement.
+Request patches are limited to 1 MiB of serialized JSON. Never log replacement
+credentials. The operation result does not expose saved request bodies.
+
+```ts
+await client.api.retryWebhooks({
+  webhookIds: selectedWebhookIds,
+  idempotencyKey: retryAdmissionKey,
+  requestPatch: {
+    headers: { set: { Authorization: `Bearer ${replacementToken}` }, remove: ['X-Old-Key'] },
+    query: { set: { apiVersion: '2' }, remove: ['legacy'] },
+    maskDetails: ['headers.Authorization'],
+  },
+});
+```
+
+The target platform requires the bulk-operation migration and an active API worker
+lane. Publishing this SDK does not deploy them or change the hosted SDK pin.

package/dist/{errors-CYOB1Jvd.d.cts → errors-BF0cw_Ut.d.cts}

@@ -1,9 +1,10 @@
 import * as node_worker_threads from 'node:worker_threads';
+import { Buffer as Buffer$1 } from 'node:buffer';
 
-declare const SDK_VERSION: "1.6.2";
+declare const SDK_VERSION: "1.6.3";
 declare const PROTOCOL_VERSION: 1;
-declare const CONTRACT_REVISION: "904f6aea1cacfc32b7fda4e976b2e01f73202462f8a4785dc12deac7c4563e38";
-type RuntimeSurfaceName = 'api' | 'storage' | 'transport' | 'agents' | 'lowCode';
+declare const CONTRACT_REVISION: "8083c90249a517982be7395a44c016ab08dcd047eb9b12231211e496c842120d";
+type RuntimeSurfaceName = 'api' | 'storage' | 'transport' | 'vault' | 'agents' | 'lowCode';
 
 // AUTO-GENERATED FILE. DO NOT EDIT DIRECTLY.
 // Sources: api.swagger-contracts.generated.d.ts, api.public.d.ts
@@ -43,7 +44,7 @@ interface SwaggerAgentCheapTurnPolicyDto {
 }
 interface SwaggerAgentConfigDto {
     /** Supported assistant model used when the agent starts a thread. */
-    "model"?: "gpt-6-sol" | "gpt-6-luna";
+    "model"?: "gpt-6.1-sol" | "gpt-6-luna";
     /** Reasoning effort passed to assistant threads. */
     "reasoningEffort"?: "none" | "low" | "medium" | "high" | "xhigh";
     /** Durable execution-mode default used for agent-loop turns. Per-turn fast-path routing and prompt-tier selection are derived by runtime, not configured here. */
@@ -587,6 +588,10 @@ interface SwaggerStorageTabularSchemaPolicyDto {
     /** How undeclared source columns are handled. allow retains them, strip omits them from structured rows, and reject fails indexing. Defaults to allow for fallback and reject for strict. The raw file is preserved. */
     "additionalProperties"?: "allow" | "strip" | "reject";
 }
+interface SwaggerWebhookMapPatchDto {
+    "set"?: Record<string, string>;
+    "remove"?: Array<string>;
+}
 interface SwaggerWebhookRequestDetailsDto {
     "url": string;
     "method": "POST" | "GET" | "HEAD" | "PUT" | "DELETE" | "PATCH" | "OPTIONS";
@@ -595,6 +600,16 @@ interface SwaggerWebhookRequestDetailsDto {
     /** Headers. */
     "headers"?: Record<string, unknown>;
 }
+interface SwaggerWebhookRequestPatchDto {
+    "url"?: string;
+    "method"?: "POST" | "GET" | "HEAD" | "PUT" | "DELETE" | "PATCH" | "OPTIONS";
+    "headers"?: SwaggerWebhookMapPatchDto;
+    "query"?: SwaggerWebhookMapPatchDto;
+    /** Additional request paths to mask in the new attempt. Existing masks are always preserved. */
+    "maskDetails"?: Array<string>;
+    /** Explicit replacement of the whole body. Omitted body reuses the saved body. */
+    "body"?: Record<string, unknown> | Array<unknown>;
+}
 interface AgentRunCancelInput {
     /** Optional cancellation reason for audit traces. */
     "reason"?: string;
@@ -694,9 +709,9 @@ interface AssistantMessageInput {
     "content": string;
     /** Optional hidden draft user message id created before attachment uploads. When provided, the send operation finalizes that draft instead of creating a new user message. */
     "preflightMessageId"?: string;
-    /** Optional assistant execution-model override. GPT-6 Luna is the default; GPT-6 Sol and Luna are supported. */
-    "model"?: "gpt-6-sol" | "gpt-6-luna";
-    /** Optional GPT-6 Sol or Luna Fast mode. Defaults to false and remains opt-in per thread. */
+    /** Optional assistant execution-model override. GPT-6 Luna is the default; GPT-6.1 Sol and GPT-6 Luna are supported. */
+    "model"?: "gpt-6.1-sol" | "gpt-6-luna";
+    /** Optional GPT-6 Luna Fast mode. Defaults to false and remains opt-in per thread. */
     "fastMode"?: boolean;
     /** Optional assistant reasoning effort override: none, low, medium, high, or xhigh. Defaults to medium. */
     "reasoningEffort"?: "none" | "low" | "medium" | "high" | "xhigh";
@@ -815,6 +830,13 @@ interface AssistantForkMessageInput {
     /** Optional explicit title for the forked thread. When omitted, orchestration will generate the new thread title. */
     "title"?: string;
 }
+interface JobsBulkInput {
+    /** Existing platform filter tree. Exactly one of filter and resource IDs is required. */
+    "filter"?: Record<string, unknown>;
+    /** Caller-generated key: repeated admission returns the same operation. Maximum 200 characters. */
+    "idempotencyKey"?: string;
+    "jobIds"?: Array<string>;
+}
 interface StorageEntryMoveInput {
     /** Destination parent folder id. Omit or pass null for root. */
     "parentStorageEntryId"?: string;
@@ -881,8 +903,8 @@ interface AssistantActionResolutionInput {
     /** Optional flag selecting deadline-bounded background provider recovery. On the SSE route it also allows the resumed turn to continue after client disconnect. Streamed action resolution defaults this to true. */
     "backgroundProcessing"?: boolean;
     /** Optional assistant model override for the resumed turn after this action is resolved. */
-    "model"?: "gpt-6-sol" | "gpt-6-luna";
-    /** Optional Fast-mode override for the resumed turn. Available on GPT-6 Sol and Luna. */
+    "model"?: "gpt-6.1-sol" | "gpt-6-luna";
+    /** Optional Fast-mode override for the resumed turn. Available only on GPT-6 Luna. */
     "fastMode"?: boolean;
     /** Optional assistant reasoning effort override for the resumed turn: none, low, medium, high, or xhigh. */
     "reasoningEffort"?: "none" | "low" | "medium" | "high" | "xhigh";
@@ -1022,6 +1044,8 @@ interface WebhookInput {
     "proxy"?: boolean;
     /** Save entire request. */
     "saveDetails"?: boolean;
+    /** Stop delivery on a supported attempt status. Processing of delivery logs is asynchronous. */
+    "stopOnStatuses"?: Array<"UNAUTHENTICATED">;
     /** Max attempts. */
     "maxAttempts"?: number;
     /** Provide data */
@@ -1033,6 +1057,25 @@ interface WebhookInput {
     /** Optional key/value metadata for grouping and querying webhooks. Values may use any JSON type. Maximum 16 KiB and 64 top-level keys. Top-level keys starting with "__" are reserved for backend use. */
     "metadata"?: Record<string, unknown> | null;
 }
+interface WebhooksBulkInput {
+    /** Existing platform filter tree. Exactly one of filter and resource IDs is required. */
+    "filter"?: Record<string, unknown>;
+    /** Caller-generated key: repeated admission returns the same operation. Maximum 200 characters. */
+    "idempotencyKey"?: string;
+    "webhookIds"?: Array<string>;
+    /** Only allowed for retry. Missing masked values must be supplied explicitly. */
+    "requestPatch"?: SwaggerWebhookRequestPatchDto;
+}
+interface AutomationOperation {
+    operationId: string;
+    resource: 'jobs' | 'webhooks';
+    action: 'cancel' | 'retry' | 'delete';
+    status: 'PENDING' | 'PROCESSING' | 'FINISHED' | 'ERROR';
+    total: number;
+    processed: number;
+    skipped: number;
+    failed: number;
+}
 /**
  * Canonical public low-code API declarations shared by Monaco and local editors.
  * Lifecycle input DTOs are generated from Swagger in api.swagger-contracts.generated.d.ts.
@@ -1564,7 +1607,8 @@ interface LogInterface {
 }
 interface TemplateFormData {
     key: string;
-    value?: string;
+    /** Numbers and booleans are sent as text. Read credentials explicitly with vault.get/getAccessToken. */
+    value?: string | number | boolean;
     /** Storage entry to append as this multipart part. Use this instead of value for binary content. */
     storageEntryId?: string;
     /** Storage namespace for storageEntryId. Defaults to explorer. */
@@ -1617,18 +1661,22 @@ interface HttpRevoResponseScope {
 }
 interface HttpRequestInterface {
     url: string;
+    /** Replaces complete `{name}` path segments with URL-encoded bound values. */
+    pathParams?: Record<string, string>;
     method: 'POST' | 'PUT' | 'DELETE' | 'GET' | 'PATCH' | 'OPTIONS' | 'HEAD' | 'PURGE' | 'LINK' | 'UNLINK';
     timeout?: number;
-    /** Vault references are resolved only by the trusted HTTP sender, never in low-code. */
-    headers?: LooseObject<string | VaultBoundValue>;
+    /** HTTP headers; use an explicitly awaited vault.get/getAccessToken result for credentials. */
+    headers?: LooseObject<string>;
     params?: TemplateParameters[];
+    /** Integration-owned payload. Credential values and provider echoes are caller-managed data. */
     data?: any;
     //@default: undefined
     formData?: TemplateFormData[];
 }
 interface TemplateParameters {
     key: string;
-    value: string | LooseObject<boolean | number | string>;
+    /** Numbers and booleans are sent as text. Legacy plain maps retain '[object Object]' conversion; serialize structured queries explicitly. */
+    value: string | number | boolean | LooseObject<boolean | number | string>;
 }
 interface ProcessLog {
     time: string;
@@ -2750,6 +2798,145 @@ interface AssistantThreadCompactionRequest {
     keepContext?: boolean;
     content?: string;
 }
+// ApiInterface
+/** Owner selection; omitted means instance. User scope uses the verified execution account. */
+interface SecretScopeOptions {
+    scope?: 'instance' | 'user';
+}
+/** Null or omission selects NOW at write time. Numbers are Unix epoch milliseconds. */
+type SecretDate = string | Date | number | null;
+interface SecretRotateOptions extends SecretScopeOptions {
+    validFrom?: SecretDate;
+}
+interface SecretGetOptions extends SecretRotateOptions {
+    /** Exact validFrom timestamp. If both selectors are supplied they must agree. */
+    version?: SecretDate;
+}
+interface SecretDeleteOptions extends SecretGetOptions {
+}
+interface SecretRevisionListOptions extends SecretScopeOptions {
+    cursor?: string;
+    limit?: number;
+}
+interface SecretProperties {
+    category?: string | null;
+    description?: string | null;
+    /** Replacement JSON object, at most 16 KiB and 64 top-level keys. Backend keys are reserved. */
+    metadata?: Record<string, unknown>;
+}
+interface SecretCreateInput extends SecretProperties {
+    /** Nonempty text, at most 65,536 characters. */
+    value: string;
+    validFrom?: SecretDate;
+    enabled?: boolean;
+}
+interface SecretRotateInput {
+    value: string;
+}
+interface SecretUpdateInput extends SecretProperties {
+    /** Parent metadata counter, distinct from a revision's timestamp version. */
+    version: number;
+}
+/** Unified metadata-only parent. */
+interface Secret {
+    name: string;
+    scope: 'instance' | 'user';
+    category: string | null;
+    description: string | null;
+    metadata: Record<string, unknown>;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SecretRevision {
+    name: string;
+    scope: 'instance' | 'user';
+    /** Stable version identity: the unique validFrom timestamp, normalized to ISO. */
+    version: string;
+    enabled: boolean;
+    validFrom: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SecretWithRevision extends Secret {
+    revision: SecretRevision;
+}
+interface SecretValueRevision extends SecretRevision {
+    value: Buffer;
+}
+interface SecretWithValue extends Secret {
+    revision: SecretValueRevision;
+}
+interface SecretRevisionPage {
+    items: SecretRevision[];
+    nextCursor: string | null;
+}
+interface VaultIntegrationConfig {
+    resourceUrl: string;
+    scopes: string[];
+    issuer?: string;
+    clientId?: string;
+    clientSecret?: string;
+    tenantId?: string;
+    metadataScopeAliases?: Record<string, string>;
+}
+interface VaultConnectIntegrationInput extends VaultIntegrationConfig {
+    /** Null creates a definition; otherwise use its exact revision from getIntegrationMetadata. */
+    expectedRevision: string | null;
+}
+interface VaultAccessToken {
+    accessToken: string;
+    expiresAt: string;
+    tokenType: 'Bearer';
+}
+interface VaultIntegrationMetadata {
+    name: string;
+    scope: 'instance' | 'user';
+    revision: string | null;
+    resourceUrl: string;
+    issuer: string;
+    scopes: string[];
+    tenantId: string | null;
+    metadataScopeAliases: Record<string, string>;
+    clientId: string | null;
+    hasClientSecret: boolean;
+    registrationMode: 'dynamic_public' | 'byo_public' | 'byo_confidential';
+    authorizationEndpoint: string;
+    registrationEndpoint: string | null;
+}
+interface VaultIntegrationDiscovery {
+    issuers: string[];
+    requiresIssuerSelection: boolean;
+    supportedScopes: string[];
+    issuer?: string;
+    authorizationEndpoint?: string;
+    registrationEndpoint?: string | null;
+    registrationMode?: 'dynamic_public' | 'byo_public' | 'byo_confidential';
+    requiresClientId?: boolean;
+    redirectUri?: string;
+}
+interface VaultIntegrationConnectResult {
+    name: string;
+    scope: 'instance' | 'user';
+    revision: string;
+    authorizationUrl: string;
+}
+interface RevoVault$1 {
+    get(name: string, options?: SecretGetOptions): Promise<SecretWithValue>;
+    create(name: string, data: SecretCreateInput, options?: SecretScopeOptions): Promise<Secret | null>;
+    update(name: string, data: SecretUpdateInput, options?: SecretScopeOptions): Promise<Secret | null>;
+    delete(name: string, options?: SecretDeleteOptions): Promise<void | null>;
+    rotate(name: string, data: SecretRotateInput, options?: SecretRotateOptions): Promise<SecretWithRevision | null>;
+    listRevisions(name: string, options?: SecretRevisionListOptions): Promise<SecretRevisionPage>;
+    getAccessToken(name: string, options?: SecretScopeOptions): Promise<VaultAccessToken>;
+    getIntegrationMetadata(name: string, options?: SecretScopeOptions): Promise<VaultIntegrationMetadata>;
+    discoverIntegration(name: string, data: VaultIntegrationConfig, options?: SecretScopeOptions): Promise<VaultIntegrationDiscovery>;
+    connectIntegration(name: string, data: VaultConnectIntegrationInput, options?: SecretScopeOptions): Promise<VaultIntegrationConnectResult | null>;
+    disconnectIntegration(name: string, options?: SecretScopeOptions): Promise<{
+        name: string;
+        disabled: boolean;
+    } | null>;
+}
 interface RevoApi {
     createDatabase(data: DatabaseCreateInput): Promise<Database>;
     cloneDatabase<TAsync extends boolean = false>(name: string, options?: DatabaseCloneInput & {
@@ -2847,6 +3034,26 @@ interface RevoApi {
     triggerTarget(targetType: ExecutionTargetType, targetId: string, input?: Record<string, JsonValue>, options?: AutomationScheduleOptions): Promise<string>;
     triggerJob(templateIdOrName: string, templateInputs?: Record<string, JsonValue>, options?: AutomationScheduleOptions): Promise<string>;
     triggerWebhook(webhook: WebhookInput, options?: AutomationScheduleOptions): Promise<Webhook>;
+    cancelJobs(input: JobsBulkInput): Promise<AutomationOperation>;
+    retryJobs(input: JobsBulkInput): Promise<AutomationOperation>;
+    deleteJobs(input: JobsBulkInput): Promise<AutomationOperation>;
+    cancelWebhooks(input: WebhooksBulkInput): Promise<AutomationOperation>;
+    retryWebhooks(input: WebhooksBulkInput): Promise<AutomationOperation>;
+    deleteWebhooks(input: WebhooksBulkInput): Promise<AutomationOperation>;
+    previewAutomationOperation(resource: 'jobs' | 'webhooks', action: 'cancel' | 'retry' | 'delete', input: JobsBulkInput | WebhooksBulkInput): Promise<{
+        matched: number;
+        eligible: number;
+    }>;
+    getAutomationOperation(operationId: string): Promise<AutomationOperation>;
+    getAutomationOperationItems(operationId: string, after?: string): Promise<{
+        data: Array<{
+            resourceId: string;
+            status: string;
+            resultId: string | null;
+            errorCode: string | null;
+        }>;
+        nextCursor: string | null;
+    }>;
     httpCall(config: HttpRequestInterface, options: HttpRequestOptionsInterface & {
         responseType: 'storage';
         target: HttpStorageTargetRef;
@@ -3098,16 +3305,6 @@ interface RevoUtils {
     rsaSign(privateKey: string, payload: string, passphrase?: string): Promise<string>;
     rsaVerify(publicKey: string, payload: string, signature: string): Promise<boolean>;
 }
-type VaultScope = 'instance' | 'user' | 'organization';
-type VaultSource = 'secret' | 'integration';
-type VaultBoundValue = Readonly<{
-    __revoBoundValue: 'vault-v1';
-    name: string;
-    scope: VaultScope;
-    source: VaultSource;
-    prefix: string;
-    suffix: string;
-}>;
 /** Low-code byte payloads; REST JSON callers retain the base64 option. */
 /** Text arrays retain their existing joining rules; bytes are snapshotted before asynchronous upload. */
 type StorageBinaryPutObjectInput = Omit<StoragePutObjectInput, 'data'> & {
@@ -3135,6 +3332,15 @@ interface RevoLowCode {
     execute<T = LooseObject<any>>(code: string, options?: LowCodeExecuteOptions): Promise<ComponentExecuteResult<T>>;
 }
 
+type VaultReadResult = Awaited<ReturnType<RevoVault$1['get']>>;
+/** Wire decoding returns a full Node.js Buffer, extending the portable low-code type. */
+type RevoVault = Omit<RevoVault$1, 'get'> & {
+    get(...args: Parameters<RevoVault$1['get']>): Promise<Omit<VaultReadResult, 'revision'> & {
+        revision: Omit<VaultReadResult['revision'], 'value'> & {
+            value: Buffer$1;
+        };
+    }>;
+};
 type RevoExecute = RevoLowCode['execute'];
 type RevoExecuteOptions = NonNullable<Parameters<RevoExecute>[1]>;
 type RevoExecutionDefaults = Omit<RevoExecuteOptions, 'inputs'>;
@@ -3222,6 +3428,7 @@ interface RevoRuntime {
     readonly api: RevoApi;
     readonly utils: RevoUtils;
     readonly storage: RevoStorage;
+    readonly vault: RevoVault;
     readonly transport: RevoTransport;
     readonly agents: RevoAgents;
     readonly execute: RevoExecute;
@@ -3320,4 +3527,4 @@ declare class RevoHttpResponseError extends RevoError {
     constructor(statusCode: number, body?: unknown);
 }
 
-export { RevoRuntimeContextUnavailableError as A, type BatchFailureMode as B, CONTRACT_REVISION as C, RevoTransportError as D, type RuntimeBatchRequest as E, type RuntimeBatchResponse as F, type RuntimeCall as G, type HostedRuntimeBootstrap as H, type RuntimeCallResult as I, type SerializedRevoError as J, PROTOCOL_VERSION as P, type RevoRuntime as R, SDK_VERSION as S, RevoExecutionExit as a, RevoHttpResponseError as b, type RevoRuntimeBridgeRequest as c, type RevoRuntimeBridgeResponse as d, type RevoRuntimeBridgeTransportError as e, type RevoStandaloneApi as f, type RevoUtils as g, type RevoStorage as h, type RevoTransport as i, type RevoAgents as j, type RevoExecute as k, type RevoBatchController as l, type RevoClientOptions as m, type RevoApi as n, RevoAuthenticationError as o, RevoBatchConfigurationError as p, RevoBatchLimitError as q, type RevoBatchLimits as r, type RevoBatchOptions as s, RevoConfigurationError as t, RevoError as u, type RevoExecuteOptions as v, type RevoExecutionDefaults as w, RevoPermissionDeniedError as x, RevoProtocolError as y, RevoRemoteError as z };
+export { RevoRemoteError as A, type BatchFailureMode as B, CONTRACT_REVISION as C, RevoRuntimeContextUnavailableError as D, RevoTransportError as E, type RuntimeBatchRequest as F, type RuntimeBatchResponse as G, type HostedRuntimeBootstrap as H, type RuntimeCall as I, type RuntimeCallResult as J, type SerializedRevoError as K, PROTOCOL_VERSION as P, type RevoRuntime as R, SDK_VERSION as S, RevoExecutionExit as a, RevoHttpResponseError as b, type RevoRuntimeBridgeRequest as c, type RevoRuntimeBridgeResponse as d, type RevoRuntimeBridgeTransportError as e, type RevoStandaloneApi as f, type RevoUtils as g, type RevoStorage as h, type RevoVault as i, type RevoTransport as j, type RevoAgents as k, type RevoExecute as l, type RevoBatchController as m, type RevoClientOptions as n, type RevoApi as o, RevoAuthenticationError as p, RevoBatchConfigurationError as q, RevoBatchLimitError as r, type RevoBatchLimits as s, type RevoBatchOptions as t, RevoConfigurationError as u, RevoError as v, type RevoExecuteOptions as w, type RevoExecutionDefaults as x, RevoPermissionDeniedError as y, RevoProtocolError as z };