@poe-platform/safe-bash 0.1.803 → 0.1.804

package/dist/{safe-bash-mcp → safe-bash-command-mcp}/index.browser.d.ts

@@ -1,6 +1,7 @@
 import { Readable, Writable } from 'node:stream';
 import http from 'node:http';
-import { CommandDefinition, VirtualShellPlugin } from '@poe-platform/safe-bash/contracts';
+import * as safe_bash_contracts from "../safe-bash-contracts/index.js";
+import { CommandDefinition, VirtualShellPlugin } from "../safe-bash-contracts/index.js";
 
 type JsonSchemaRegistry = Record<string, unknown>;
 interface CompileJsonSchemaOptions {
@@ -163,7 +164,7 @@ interface McpSubscription {
     cancel(): void;
 }
 
-interface SecretStoreLockFileSystem {
+interface SecretStoreLockFileSystem$1 {
     mkdir(path: string, options?: {
         recursive?: boolean;
         mode?: number;
@@ -182,11 +183,11 @@ interface SecretStoreLockFileSystem {
     }>;
 }
 
-interface MachineIdentity {
+interface MachineIdentity$1 {
     hostname: string;
     username: string;
 }
-interface EncryptedFileStoreFileSystem {
+interface EncryptedFileStoreFileSystem$1 {
     readdir?(path: string): Promise<string[]>;
     readFile(path: string, encoding: BufferEncoding): Promise<string>;
     writeFile(path: string, data: string | NodeJS.ArrayBufferView, options?: {
@@ -204,46 +205,46 @@ interface EncryptedFileStoreFileSystem {
     unlink(path: string): Promise<void>;
     chmod(path: string, mode: number): Promise<void>;
 }
-interface EncryptedFileStoreInput {
-    fs?: EncryptedFileStoreFileSystem;
+interface EncryptedFileStoreInput$1 {
+    fs?: EncryptedFileStoreFileSystem$1;
     filePath?: string;
     salt: string;
     defaultDirectory?: string;
     defaultFileName?: string;
-    getMachineIdentity?: () => MachineIdentity | Promise<MachineIdentity>;
+    getMachineIdentity?: () => MachineIdentity$1 | Promise<MachineIdentity$1>;
     getHomeDirectory?: () => string;
     getRandomBytes?: (size: number) => Buffer;
     /** Fail closed instead of treating malformed or unauthenticated documents as absent. */
     throwOnInvalidDocument?: boolean;
 }
 
-interface KeychainCommandResult {
+interface KeychainCommandResult$1 {
     stdout: string;
     stderr: string;
     exitCode: number;
 }
-interface KeychainCommandOptions {
+interface KeychainCommandOptions$1 {
     stdin?: string;
 }
-type KeychainCommandRunner = (command: string, args: string[], options?: KeychainCommandOptions) => Promise<KeychainCommandResult>;
-interface KeychainStoreInput {
-    runCommand?: KeychainCommandRunner;
+type KeychainCommandRunner$1 = (command: string, args: string[], options?: KeychainCommandOptions$1) => Promise<KeychainCommandResult$1>;
+interface KeychainStoreInput$1 {
+    runCommand?: KeychainCommandRunner$1;
     service: string;
     account: string;
     lock?: {
-        fs?: SecretStoreLockFileSystem;
+        fs?: SecretStoreLockFileSystem$1;
         directory?: string;
     };
 }
 
-type StoreBackend = "file" | "keychain";
-interface CreateSecretStoreInput {
-    backend?: StoreBackend;
+type StoreBackend$1 = "file" | "keychain";
+interface CreateSecretStoreInput$1 {
+    backend?: StoreBackend$1;
     env?: NodeJS.ProcessEnv;
     platform?: NodeJS.Platform;
     backendEnvVar?: string;
-    fileStore?: EncryptedFileStoreInput;
-    keychainStore?: KeychainStoreInput;
+    fileStore?: EncryptedFileStoreInput$1;
+    keychainStore?: KeychainStoreInput$1;
 }
 
 type OAuthMetadataFetch$1 = (input: string | URL, init?: RequestInit) => Promise<Response>;
@@ -268,12 +269,12 @@ interface OAuthDiscoveryResult$1 {
     authorizationServerMetadataUrl: string;
     authorizationServerMetadata: OAuthAuthorizationServerMetadata$1;
 }
-interface OAuthUnauthorizedChallenge {
+interface OAuthUnauthorizedChallenge$1 {
     scheme: "Bearer";
     params: Record<string, string>;
     raw: string;
 }
-interface OAuthClientProvider {
+interface OAuthClientProvider$1 {
     /** Establish a grant explicitly, including when resource initialization is public. */
     authenticate?(input: {
         requestUrl: URL;
@@ -291,7 +292,7 @@ interface OAuthClientProvider {
     handleUnauthorized(input: {
         requestUrl: URL;
         response: Response;
-        challenge: OAuthUnauthorizedChallenge | null;
+        challenge: OAuthUnauthorizedChallenge$1 | null;
         /** Validated metadata supplied by direct callers, if already available. */
         discovery?: OAuthDiscoveryResult$1;
         /** Lazy validated metadata; invoke only when OAuth recovery needs it. */
@@ -314,7 +315,7 @@ interface OAuthClientProvider {
         error?: Error;
     };
 }
-interface OAuthClientMetadata {
+interface OAuthClientMetadata$1 {
     clientName?: string;
     scope?: string;
     softwareId?: string;
@@ -328,7 +329,7 @@ interface StoredOAuthTokens$1 {
     scope?: string;
 }
 /** Import-time lifetimes are normalized once into persisted epoch milliseconds. */
-interface ImportedOAuthTokens extends Omit<StoredOAuthTokens$1, "expiresAt"> {
+interface ImportedOAuthTokens$1 extends Omit<StoredOAuthTokens$1, "expiresAt"> {
     expiresAt?: number | null;
     /** Remaining lifetime at import, or total lifetime when issuedAt is provided. */
     expiresIn?: number;
@@ -373,7 +374,7 @@ interface StoredOAuthSession$1 {
         authorizationServerMetadata: Record<string, unknown>;
     };
 }
-interface OAuthSessionStore {
+interface OAuthSessionStore$1 {
     load(resource: string): Promise<StoredOAuthSession$1 | null>;
     save(resource: string, session: StoredOAuthSession$1): Promise<void>;
     clear(resource: string): Promise<void>;
@@ -384,12 +385,12 @@ interface OAuthSessionStore {
     }): Promise<T>;
 }
 /** Configuration values are captured at creation; selected host dependencies remain live. */
-interface DefaultOAuthClientProviderOptions {
+interface DefaultOAuthClientProviderOptions$1 {
     client: {
         mode: "dynamic";
         clientId?: string;
         clientSecret?: string;
-        metadata?: OAuthClientMetadata;
+        metadata?: OAuthClientMetadata$1;
         /** Import a complete registration owned by the caller. */
         registration?: OAuthClientRegistration$1;
         tokenEndpointAuthMethod?: OAuthTokenEndpointAuthMethod$1;
@@ -397,7 +398,7 @@ interface DefaultOAuthClientProviderOptions {
         mode: "static";
         clientId: string;
         clientSecret?: string;
-        metadata?: OAuthClientMetadata;
+        metadata?: OAuthClientMetadata$1;
         registration?: OAuthClientRegistration$1;
         tokenEndpointAuthMethod?: OAuthTokenEndpointAuthMethod$1;
     };
@@ -412,7 +413,7 @@ interface DefaultOAuthClientProviderOptions {
     /** Import an existing grant for one resource. Persisted sessions take precedence. */
     initialGrant?: {
         resource: string;
-        tokens: ImportedOAuthTokens;
+        tokens: ImportedOAuthTokens$1;
     };
     browser: {
         openBrowser?(url: string): Promise<void>;
@@ -433,13 +434,13 @@ interface DefaultOAuthClientProviderOptions {
             body: string;
         };
     };
-    sessionStore?: OAuthSessionStore;
-    authStore?: CreateSecretStoreInput;
+    sessionStore?: OAuthSessionStore$1;
+    authStore?: CreateSecretStoreInput$1;
     now?: () => number;
 }
 type OAuthClientProviderOptions = {
-    provider: OAuthClientProvider;
-} | DefaultOAuthClientProviderOptions;
+    provider: OAuthClientProvider$1;
+} | DefaultOAuthClientProviderOptions$1;
 
 interface OAuthDiscoveryCache {
     get(resourceUrl: string): OAuthDiscoveryResult$1 | null | undefined | Promise<OAuthDiscoveryResult$1 | null | undefined>;
@@ -863,19 +864,88 @@ declare function createRemoteMcpCommands(servers: readonly RemoteMcpServer[], op
 /** Register generated commands after checking all conflicts, avoiding partial setup. */
 declare function remoteMcpCommands(servers: readonly RemoteMcpServer[], options?: RemoteMcpCommandOptions): Promise<VirtualShellPlugin>;
 
-type RemoteMcpResourceRequest = {
-    readonly operation: "list" | "templates";
-    readonly cursor?: string;
-} | {
-    readonly operation: "read";
-    readonly uri: string;
-};
-interface RemoteMcpResourceOptions extends SchemaFetchOptions {
-    readonly maxInputBytes?: number;
+interface SecretStoreLockFileSystem {
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+        mode?: number;
+    }): Promise<unknown>;
+    readdir(path: string): Promise<string[]>;
+    readFile(path: string, encoding: BufferEncoding): Promise<string>;
+    writeFile(path: string, value: string, options: {
+        encoding: BufferEncoding;
+        flag: string;
+        mode: number;
+    }): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
+    unlink(path: string): Promise<void>;
+    lstat(path: string): Promise<{
+        isSymbolicLink(): boolean;
+    }>;
+}
+
+interface MachineIdentity {
+    hostname: string;
+    username: string;
+}
+interface EncryptedFileStoreFileSystem {
+    readdir?(path: string): Promise<string[]>;
+    readFile(path: string, encoding: BufferEncoding): Promise<string>;
+    writeFile(path: string, data: string | NodeJS.ArrayBufferView, options?: {
+        encoding?: BufferEncoding;
+        flag?: string;
+        mode?: number;
+    }): Promise<void>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void | string | undefined>;
+    rename(oldPath: string, newPath: string): Promise<void>;
+    lstat(path: string): Promise<{
+        isSymbolicLink(): boolean;
+    }>;
+    unlink(path: string): Promise<void>;
+    chmod(path: string, mode: number): Promise<void>;
+}
+interface EncryptedFileStoreInput {
+    fs?: EncryptedFileStoreFileSystem;
+    filePath?: string;
+    salt: string;
+    defaultDirectory?: string;
+    defaultFileName?: string;
+    getMachineIdentity?: () => MachineIdentity | Promise<MachineIdentity>;
+    getHomeDirectory?: () => string;
+    getRandomBytes?: (size: number) => Buffer;
+    /** Fail closed instead of treating malformed or unauthenticated documents as absent. */
+    throwOnInvalidDocument?: boolean;
+}
+
+interface KeychainCommandResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+interface KeychainCommandOptions {
+    stdin?: string;
+}
+type KeychainCommandRunner = (command: string, args: string[], options?: KeychainCommandOptions) => Promise<KeychainCommandResult>;
+interface KeychainStoreInput {
+    runCommand?: KeychainCommandRunner;
+    service: string;
+    account: string;
+    lock?: {
+        fs?: SecretStoreLockFileSystem;
+        directory?: string;
+    };
+}
+
+type StoreBackend = "file" | "keychain";
+interface CreateSecretStoreInput {
+    backend?: StoreBackend;
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    backendEnvVar?: string;
+    fileStore?: EncryptedFileStoreInput;
+    keychainStore?: KeychainStoreInput;
 }
-type RemoteMcpResourceResult = Awaited<ReturnType<McpClient["listResources"]>> | Awaited<ReturnType<McpClient["listResourceTemplates"]>> | Awaited<ReturnType<McpClient["readResource"]>>;
-/** Access a remote resource directly, preserving one page/result without tool discovery. */
-declare function accessRemoteMcpResources(server: RemoteMcpServer, request: RemoteMcpResourceRequest, options?: RemoteMcpResourceOptions): Promise<RemoteMcpResourceResult>;
 
 type OAuthMetadataFetch = (input: string | URL, init?: RequestInit) => Promise<Response>;
 interface OAuthProtectedResourceMetadata extends Record<string, unknown> {
@@ -899,6 +969,58 @@ interface OAuthDiscoveryResult {
     authorizationServerMetadataUrl: string;
     authorizationServerMetadata: OAuthAuthorizationServerMetadata;
 }
+interface OAuthUnauthorizedChallenge {
+    scheme: "Bearer";
+    params: Record<string, string>;
+    raw: string;
+}
+interface OAuthClientProvider {
+    /** Establish a grant explicitly, including when resource initialization is public. */
+    authenticate?(input: {
+        requestUrl: URL;
+        fetch: OAuthMetadataFetch;
+        /** Lazy validated discovery. Without it, recover/reuse known grants only. */
+        discover?: () => Promise<OAuthDiscoveryResult>;
+        signal?: AbortSignal;
+    }): Promise<StoredOAuthTokens | void>;
+    authorizeRequest?(input: {
+        requestUrl: URL;
+        headers: Headers;
+        fetch: OAuthMetadataFetch;
+        signal?: AbortSignal;
+    }): Promise<StoredOAuthTokens | void> | StoredOAuthTokens | void;
+    handleUnauthorized(input: {
+        requestUrl: URL;
+        response: Response;
+        challenge: OAuthUnauthorizedChallenge | null;
+        /** Validated metadata supplied by direct callers, if already available. */
+        discovery?: OAuthDiscoveryResult;
+        /** Lazy validated metadata; invoke only when OAuth recovery needs it. */
+        discover?: () => Promise<OAuthDiscoveryResult>;
+        fetch: OAuthMetadataFetch;
+        signal?: AbortSignal;
+        /** Headers actually attached to this rejected request. */
+        requestHeaders?: Headers;
+        /** Owned snapshot returned when this request was authorized, or null if absent. */
+        presentedTokens?: StoredOAuthTokens | null;
+    }): Promise<{
+        action: "retry";
+    } | {
+        action: "fail";
+        error?: Error;
+    }> | {
+        action: "retry";
+    } | {
+        action: "fail";
+        error?: Error;
+    };
+}
+interface OAuthClientMetadata {
+    clientName?: string;
+    scope?: string;
+    softwareId?: string;
+    softwareVersion?: string;
+}
 interface StoredOAuthTokens {
     accessToken: string;
     refreshToken?: string;
@@ -906,6 +1028,14 @@ interface StoredOAuthTokens {
     expiresAt: number | null;
     scope?: string;
 }
+/** Import-time lifetimes are normalized once into persisted epoch milliseconds. */
+interface ImportedOAuthTokens extends Omit<StoredOAuthTokens, "expiresAt"> {
+    expiresAt?: number | null;
+    /** Remaining lifetime at import, or total lifetime when issuedAt is provided. */
+    expiresIn?: number;
+    /** Original issuance time in Unix epoch milliseconds. */
+    issuedAt?: number;
+}
 /** Full RFC 7591 response, including JSON provider extensions. */
 interface OAuthClientRegistration extends Record<string, unknown> {
     client_id: string;
@@ -944,6 +1074,70 @@ interface StoredOAuthSession {
         authorizationServerMetadata: Record<string, unknown>;
     };
 }
+interface OAuthSessionStore {
+    load(resource: string): Promise<StoredOAuthSession | null>;
+    save(resource: string, session: StoredOAuthSession): Promise<void>;
+    clear(resource: string): Promise<void>;
+    /** Backend-wide lock covering a complete read/redeem/write transaction. */
+    withLock?<T>(resource: string, operation: () => Promise<T>, options: {
+        signal?: AbortSignal;
+        timeoutMs: number;
+    }): Promise<T>;
+}
+/** Configuration values are captured at creation; selected host dependencies remain live. */
+interface DefaultOAuthClientProviderOptions {
+    client: {
+        mode: "dynamic";
+        clientId?: string;
+        clientSecret?: string;
+        metadata?: OAuthClientMetadata;
+        /** Import a complete registration owned by the caller. */
+        registration?: OAuthClientRegistration;
+        tokenEndpointAuthMethod?: OAuthTokenEndpointAuthMethod;
+    } | {
+        mode: "static";
+        clientId: string;
+        clientSecret?: string;
+        metadata?: OAuthClientMetadata;
+        registration?: OAuthClientRegistration;
+        tokenEndpointAuthMethod?: OAuthTokenEndpointAuthMethod;
+    };
+    /** Disable interactive authorization while allowing cached tokens and silent refresh. */
+    allowInteractive?: boolean;
+    /** Maximum wait to acquire a session transaction lock (default 30,000 ms). */
+    sessionLockTimeoutMs?: number;
+    /** Isolate native persisted sessions and registrations for a named profile. */
+    persistenceNamespace?: string;
+    /** Native-owned durable logical server identity; changing URL retires its credentials. */
+    resourceIdentity?: string;
+    /** Import an existing grant for one resource. Persisted sessions take precedence. */
+    initialGrant?: {
+        resource: string;
+        tokens: ImportedOAuthTokens;
+    };
+    browser: {
+        openBrowser?(url: string): Promise<void>;
+        /** Return the full hosted HTTPS callback URL; the client validates redirect, state and issuer. */
+        waitForCallback?(request: {
+            authorizationUrl: string;
+            redirectUri: string;
+            signal: AbortSignal;
+        }): Promise<string>;
+        /** Exact registered HTTP loopback redirect URI. */
+        redirectUri?: string;
+        signal?: AbortSignal;
+        timeoutMs?: number;
+        readLine?: () => Promise<string>;
+        createServer?: () => http.Server;
+        landingPage?: {
+            title: string;
+            body: string;
+        };
+    };
+    sessionStore?: OAuthSessionStore;
+    authStore?: CreateSecretStoreInput;
+    now?: () => number;
+}
 
 /** Sensitive, JSON-serializable record. Store only in private, authenticated host storage. */
 interface RemoteMcpAuthorizationTransaction {
@@ -997,5 +1191,228 @@ declare function completeRemoteMcpAuthorization(options: CompleteRemoteMcpAuthor
     resource: string;
 }>;
 
-export { accessRemoteMcpResources, beginRemoteMcpAuthorization, compileToolArguments, completeRemoteMcpAuthorization, createRemoteMcpCommands, fetchRemoteMcpSchema, remoteMcpCommands, resolveRemoteMcpSchemas };
-export type { BeginRemoteMcpAuthorizationOptions, CompleteRemoteMcpAuthorizationOptions, RemoteMcpAuthorizationStore, RemoteMcpAuthorizationTransaction, RemoteMcpCommandOptions, RemoteMcpElicitationContext, RemoteMcpElicitationHandler, RemoteMcpResourceOptions, RemoteMcpResourceRequest, RemoteMcpResourceResult, RemoteMcpSchema, RemoteMcpServer, SchemaFetchOptions, ToolArgumentParseOptions, ToolArgumentParser, ToolParameter };
+interface EnvironmentReference {
+    readonly env: string;
+}
+interface PublicEnvironmentReference extends EnvironmentReference {
+    readonly fallback?: string;
+}
+interface OAuthCredentialReferences {
+    readonly clientId: EnvironmentReference;
+    readonly clientSecret: EnvironmentReference;
+    readonly scope: PublicEnvironmentReference;
+    readonly redirectUri: PublicEnvironmentReference;
+    readonly accessToken: EnvironmentReference;
+    readonly refreshToken: EnvironmentReference;
+    readonly expiresAt: EnvironmentReference;
+    readonly expiresIn?: EnvironmentReference;
+    readonly issuedAt?: EnvironmentReference;
+}
+type RemoteMcpAuthenticationConfiguration = {
+    readonly type: "bearer";
+    readonly token: EnvironmentReference;
+} | {
+    readonly type: "oauth";
+    readonly clientMode: "static" | "dynamic";
+    readonly persistenceNamespace?: string;
+    readonly clientName?: string;
+    readonly tokenEndpointAuthMethod?: OAuthTokenEndpointAuthMethod;
+    readonly credentials: OAuthCredentialReferences;
+};
+interface RemoteMcpServerConfiguration extends Omit<RemoteMcpServer, "headers" | "oauth"> {
+    readonly headers?: Readonly<Record<string, EnvironmentReference>>;
+    readonly auth?: RemoteMcpAuthenticationConfiguration;
+}
+interface RemoteMcpConfiguration {
+    readonly version: 1;
+    readonly servers: readonly RemoteMcpServerConfiguration[];
+}
+interface InitRemoteMcpServer extends Omit<RemoteMcpServerConfiguration, "auth"> {
+    readonly auth?: {
+        readonly type: "bearer";
+        readonly env?: string;
+    } | {
+        readonly type: "oauth";
+        readonly clientMode: "static" | "dynamic";
+        readonly clientName?: string;
+        readonly persistenceNamespace?: string;
+        readonly tokenEndpointAuthMethod?: OAuthTokenEndpointAuthMethod;
+        readonly env?: Partial<Record<keyof OAuthCredentialReferences, string>>;
+        readonly scope?: string;
+        readonly redirectUri?: string;
+    };
+}
+interface ConfigurationOptions {
+    readonly maxConfigurationBytes?: number;
+    readonly maxTools?: number;
+}
+interface RemoteMcpInitialization {
+    readonly configuration: RemoteMcpConfiguration;
+    readonly envTemplate: string;
+}
+/** Parse a versioned JSON-only configuration without reading credentials or connecting. */
+declare function parseRemoteMcpConfiguration(value: unknown, options?: ConfigurationOptions): RemoteMcpConfiguration;
+/** Produce declarative credential references and empty dotenv entries, with no network or secret reads. */
+declare function initRemoteMcpConfiguration(servers: readonly InitRemoteMcpServer[], options?: ConfigurationOptions): RemoteMcpInitialization;
+
+interface ConfigurationBindingOptions extends ConfigurationOptions {
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly maxCredentialBytes?: number;
+    readonly oauth?: {
+        readonly allowInteractive?: boolean;
+        readonly sessionLockTimeoutMs?: number;
+        readonly browser?: Omit<DefaultOAuthClientProviderOptions["browser"], "redirectUri">;
+        readonly sessionStore?: (server: RemoteMcpServerConfiguration) => OAuthSessionStore;
+        /** Host-owned reset must retire credentials and suppress stale initial imports durably. */
+        readonly reset?: (server: RemoteMcpServerConfiguration, options: {
+            signal?: AbortSignal;
+            timeoutMs: number;
+        }) => Promise<void>;
+        /** Atomically install a grant/client and suppress stale automatic imports durably. */
+        readonly importSession?: (server: RemoteMcpServerConfiguration, session: StoredOAuthSession, options: {
+            signal?: AbortSignal;
+            timeoutMs: number;
+        }) => Promise<void>;
+        readonly authStore?: DefaultOAuthClientProviderOptions["authStore"];
+        readonly now?: () => number;
+    };
+}
+interface BoundRemoteMcpServer extends Omit<RemoteMcpServer, "oauth"> {
+    readonly oauth?: {
+        readonly provider: OAuthClientProvider;
+    };
+}
+/** Resolve explicit environment references into runtime-only credentials without network or artifact writes. */
+declare function bindRemoteMcpConfiguration(value: unknown, options: ConfigurationBindingOptions): BoundRemoteMcpServer[];
+
+interface RemoteMcpArtifact {
+    readonly version: 1;
+    readonly configuration: RemoteMcpConfiguration;
+    readonly schemas: readonly RemoteMcpSchema[];
+    readonly schemaRegistry?: Readonly<Record<string, unknown>>;
+    readonly digest: string;
+}
+interface ArtifactOptions extends ConfigurationOptions {
+    readonly maxArtifactBytes?: number;
+}
+interface ArtifactGenerationOptions extends ArtifactOptions {
+    readonly binding?: ConfigurationBindingOptions;
+    readonly schema?: SchemaFetchOptions;
+    /** JSON-only external schema documents captured with the artifact. */
+    readonly schemaRegistry?: Readonly<Record<string, unknown>>;
+}
+interface GeneratedRemoteMcpArtifact {
+    readonly artifact: RemoteMcpArtifact;
+    readonly json: string;
+    /** Dependency-free ESM data module exporting the artifact as default. */
+    readonly module: string;
+}
+interface ArtifactPluginOptions extends ArtifactOptions {
+    readonly binding: ConfigurationBindingOptions;
+    readonly commands?: RemoteMcpCommandOptions;
+}
+/** Discover only absent schemas and produce deterministic, credential-free artifacts. */
+declare function generateRemoteMcpArtifact(value: unknown, options?: ArtifactGenerationOptions): Promise<GeneratedRemoteMcpArtifact>;
+/** Validate bounded JSON, integrity and snapshot/configuration agreement before runtime binding. */
+declare function parseRemoteMcpArtifact(value: unknown, options?: ArtifactOptions): Promise<RemoteMcpArtifact>;
+/** Prepare an artifact's commands without rediscovery, using explicit runtime credentials. */
+declare function remoteMcpArtifactPlugin(value: unknown, options: ArtifactPluginOptions): Promise<Awaited<ReturnType<typeof remoteMcpCommands>>>;
+
+interface RemoteMcpAuthorizationRequest {
+    readonly authorizationUrl: string;
+    readonly redirectUri: string;
+}
+interface RemoteMcpAuthenticationOptions extends SchemaFetchOptions {
+    readonly binding: ConfigurationBindingOptions;
+    /** Defaults to headless URL delivery. Browser launch requires an explicit false. */
+    readonly noBrowser?: boolean;
+    /** Explicitly retire old credentials before establishing access again. */
+    readonly reset?: boolean;
+    readonly onAuthorizationUrl?: (request: RemoteMcpAuthorizationRequest) => void | Promise<void>;
+}
+interface RemoteMcpAuthenticationResult {
+    readonly name: string;
+    readonly url: string;
+    readonly serverInfo?: Implementation;
+    readonly capabilities?: ServerCapabilities;
+    readonly instructions?: string;
+}
+/** Establish access explicitly, without listing tools or invoking any tool. */
+declare function authenticateRemoteMcpServer(value: RemoteMcpServerConfiguration, options: RemoteMcpAuthenticationOptions): Promise<RemoteMcpAuthenticationResult>;
+
+interface RemoteMcpCredentialImportOptions extends ConfigurationOptions {
+    readonly binding?: ConfigurationBindingOptions;
+    readonly signal?: AbortSignal;
+    readonly fetch?: SchemaFetchOptions["fetch"];
+    readonly oauthDiscoveryCache?: SchemaFetchOptions["oauthDiscoveryCache"];
+    /** Bounds discovery and the complete persistence operation. Default Infinity. */
+    readonly requestTimeoutMs?: number;
+    /** Maximum native transaction lock wait. Default Infinity. */
+    readonly timeoutMs?: number;
+    readonly maxImportBytes?: number;
+}
+interface RemoteMcpCredentialImportResult {
+    readonly name: string;
+    readonly url: string;
+    readonly imported: true;
+}
+/** Install a raw token response with its original app under validated discovery. */
+declare function importRemoteMcpAuthentication(value: RemoteMcpServerConfiguration, payload: unknown, options?: RemoteMcpCredentialImportOptions): Promise<RemoteMcpCredentialImportResult>;
+
+type RemoteMcpResourceRequest = {
+    readonly operation: "list" | "templates";
+    readonly cursor?: string;
+} | {
+    readonly operation: "read";
+    readonly uri: string;
+};
+interface RemoteMcpResourceOptions extends SchemaFetchOptions {
+    readonly maxInputBytes?: number;
+}
+type RemoteMcpResourceResult = Awaited<ReturnType<McpClient["listResources"]>> | Awaited<ReturnType<McpClient["listResourceTemplates"]>> | Awaited<ReturnType<McpClient["readResource"]>>;
+/** Access a remote resource directly, preserving one page/result without tool discovery. */
+declare function accessRemoteMcpResources(server: RemoteMcpServer, request: RemoteMcpResourceRequest, options?: RemoteMcpResourceOptions): Promise<RemoteMcpResourceResult>;
+
+interface RemoteMcpCredentialResetOptions extends ConfigurationOptions {
+    readonly binding?: Pick<ConfigurationBindingOptions, "oauth"> & {
+        readonly env?: ConfigurationBindingOptions["env"];
+    };
+    readonly signal?: AbortSignal;
+    readonly timeoutMs?: number;
+}
+interface RemoteMcpCredentialResetResult {
+    readonly name: string;
+    readonly url: string;
+    readonly reset: true;
+}
+/** Retire a named OAuth identity without resolving credentials or reading its old document. */
+declare function resetRemoteMcpAuthentication(value: RemoteMcpServerConfiguration, options?: RemoteMcpCredentialResetOptions): Promise<RemoteMcpCredentialResetResult>;
+
+interface RemoteMcpManagementOptions extends ConfigurationOptions {
+    readonly name?: string;
+    readonly signal?: AbortSignal;
+    readonly maxInputBytes?: number;
+    readonly maxOutputBytes?: number;
+    readonly generation?: ArtifactGenerationOptions;
+    readonly authentication?: Omit<RemoteMcpAuthenticationOptions, "binding"> & {
+        readonly binding?: ConfigurationBindingOptions;
+    };
+    readonly reset?: RemoteMcpCredentialResetOptions;
+    readonly credentialImport?: RemoteMcpCredentialImportOptions;
+    readonly resources?: RemoteMcpResourceOptions & {
+        readonly binding?: ConfigurationBindingOptions;
+    };
+}
+/** Create configuration and artifact commands for a host-owned static remote registry. */
+interface McpCommandsOptions extends RemoteMcpManagementOptions {
+    readonly servers?: readonly InitRemoteMcpServer[];
+    readonly replace?: boolean;
+}
+type McpLimits = Pick<RemoteMcpManagementOptions, "maxInputBytes" | "maxOutputBytes">;
+declare function createMcpCommand(options?: McpCommandsOptions): CommandDefinition;
+declare function createMcpCommand(servers: readonly InitRemoteMcpServer[], options?: RemoteMcpManagementOptions): CommandDefinition;
+declare function createMcpCommands(options?: McpCommandsOptions): readonly CommandDefinition[];
+declare function mcpCommands(options?: McpCommandsOptions): safe_bash_contracts.VirtualShellPlugin;
+
+export { accessRemoteMcpResources, authenticateRemoteMcpServer, beginRemoteMcpAuthorization, bindRemoteMcpConfiguration, compileToolArguments, completeRemoteMcpAuthorization, createMcpCommand, createMcpCommands, createRemoteMcpCommands, createMcpCommand as createRemoteMcpManagementCommand, fetchRemoteMcpSchema, generateRemoteMcpArtifact, importRemoteMcpAuthentication, initRemoteMcpConfiguration, mcpCommands, parseRemoteMcpArtifact, parseRemoteMcpConfiguration, remoteMcpArtifactPlugin, remoteMcpCommands, resetRemoteMcpAuthentication, resolveRemoteMcpSchemas };
+export type { ArtifactGenerationOptions, ArtifactOptions, ArtifactPluginOptions, BeginRemoteMcpAuthorizationOptions, BoundRemoteMcpServer, CompleteRemoteMcpAuthorizationOptions, ConfigurationBindingOptions, ConfigurationOptions, EnvironmentReference, GeneratedRemoteMcpArtifact, InitRemoteMcpServer, McpCommandsOptions, McpLimits, OAuthCredentialReferences, PublicEnvironmentReference, RemoteMcpArtifact, RemoteMcpAuthenticationConfiguration, RemoteMcpAuthenticationOptions, RemoteMcpAuthenticationResult, RemoteMcpAuthorizationRequest, RemoteMcpAuthorizationStore, RemoteMcpAuthorizationTransaction, RemoteMcpCommandOptions, RemoteMcpConfiguration, RemoteMcpCredentialImportOptions, RemoteMcpCredentialImportResult, RemoteMcpCredentialResetOptions, RemoteMcpCredentialResetResult, RemoteMcpElicitationContext, RemoteMcpElicitationHandler, RemoteMcpInitialization, RemoteMcpManagementOptions, RemoteMcpResourceOptions, RemoteMcpResourceRequest, RemoteMcpResourceResult, RemoteMcpSchema, RemoteMcpServer, RemoteMcpServerConfiguration, SchemaFetchOptions, ToolArgumentParseOptions, ToolArgumentParser, ToolParameter };