@poe-platform/safe-bash 0.1.787 → 0.1.789

package/dist/safe-bash-mcp/index.browser.d.ts

@@ -0,0 +1,875 @@
+import { Readable, Writable } from 'node:stream';
+import http from 'node:http';
+import { CommandDefinition, VirtualShellPlugin } from '@poe-platform/safe-bash/contracts';
+
+type JsonSchemaRegistry = Record<string, unknown>;
+interface CompileJsonSchemaOptions {
+    registry?: JsonSchemaRegistry;
+    formats?: Readonly<Record<string, (value: string) => boolean>>;
+}
+
+interface Implementation {
+    name: string;
+    title?: string;
+    version: string;
+    description?: string;
+    websiteUrl?: string;
+    icons?: Icon[];
+}
+interface Tool$1 {
+    name: string;
+    title?: string;
+    description?: string;
+    inputSchema: JSONSchema;
+    outputSchema?: OutputSchema;
+    annotations?: ToolAnnotations;
+    execution?: ToolExecution;
+    icons?: Icon[];
+    _meta?: Record<string, unknown>;
+}
+interface ToolAnnotations {
+    title?: string;
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+}
+interface ToolExecution {
+    taskSupport?: "optional" | "required" | "forbidden";
+}
+interface Icon {
+    src: string;
+    mimeType?: string;
+    sizes?: string[];
+    theme?: "light" | "dark";
+}
+interface ContentAnnotations {
+    audience?: Array<"user" | "assistant">;
+    priority?: number;
+    lastModified?: string;
+}
+interface ResourceLink extends Resource {
+    type: "resource_link";
+}
+interface PromptArgument {
+    name: string;
+    title?: string;
+    description?: string;
+    required?: boolean;
+}
+interface Prompt {
+    name: string;
+    title?: string;
+    description?: string;
+    arguments?: PromptArgument[];
+    icons?: Icon[];
+    _meta?: Record<string, unknown>;
+}
+interface Resource {
+    uri: string;
+    name: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
+    size?: number;
+    annotations?: ContentAnnotations;
+    icons?: Icon[];
+    _meta?: Record<string, unknown>;
+}
+interface ResourceTemplate {
+    uriTemplate: string;
+    name: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
+    annotations?: ContentAnnotations;
+    icons?: Icon[];
+    _meta?: Record<string, unknown>;
+}
+type ResourceContents$1 = {
+    uri: string;
+    mimeType?: string;
+    text: string;
+    _meta?: Record<string, unknown>;
+} | {
+    uri: string;
+    mimeType?: string;
+    blob: string;
+    _meta?: Record<string, unknown>;
+};
+type PromptContentItem = {
+    type: "text";
+    text: string;
+    annotations?: ContentAnnotations;
+    _meta?: Record<string, unknown>;
+} | {
+    type: "image";
+    data: string;
+    mimeType: string;
+    annotations?: ContentAnnotations;
+    _meta?: Record<string, unknown>;
+} | {
+    type: "audio";
+    data: string;
+    mimeType: string;
+    annotations?: ContentAnnotations;
+    _meta?: Record<string, unknown>;
+} | {
+    type: "resource";
+    annotations?: ContentAnnotations;
+    _meta?: Record<string, unknown>;
+    resource: {
+        uri: string;
+        mimeType?: string;
+        text: string;
+        _meta?: Record<string, unknown>;
+    } | {
+        uri: string;
+        mimeType?: string;
+        blob: string;
+        _meta?: Record<string, unknown>;
+    };
+};
+type ContentItem$1 = PromptContentItem | ResourceLink;
+interface JSONSchema {
+    type: "object";
+    properties?: Record<string, JSONSchemaProperty>;
+    required?: string[];
+    [keyword: string]: unknown;
+}
+interface OutputSchema {
+    $schema?: string;
+    [keyword: string]: unknown;
+}
+interface JSONSchemaProperty extends Record<string, unknown> {
+    type?: string | string[];
+    description?: string;
+    [keyword: string]: unknown;
+}
+
+interface NotificationFilter {
+    toolsListChanged?: boolean;
+    promptsListChanged?: boolean;
+    resourcesListChanged?: boolean;
+    resourceSubscriptions?: string[];
+}
+interface SubscriptionOptions {
+    signal?: AbortSignal;
+}
+interface McpSubscription {
+    readonly id: RequestId;
+    readonly notifications: NotificationFilter;
+    readonly closed: Promise<void>;
+    cancel(): void;
+}
+
+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 OAuthMetadataFetch = (input: string | URL, init?: RequestInit) => Promise<Response>;
+interface OAuthProtectedResourceMetadata extends Record<string, unknown> {
+    resource: string;
+    authorization_servers: string[];
+}
+interface OAuthAuthorizationServerMetadata extends Record<string, unknown> {
+    issuer: string;
+    authorization_endpoint: string;
+    token_endpoint: string;
+    registration_endpoint?: string;
+    response_types_supported: string[];
+    code_challenge_methods_supported: string[];
+    authorization_response_iss_parameter_supported?: boolean;
+}
+interface OAuthDiscoveryResult {
+    resource: string;
+    resourceMetadataUrl: string;
+    resourceMetadata: OAuthProtectedResourceMetadata;
+    authorizationServer: string;
+    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;
+    tokenType: "Bearer";
+    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;
+    client_secret?: string | null;
+    redirect_uris?: string[] | null;
+    grant_types?: string[] | null;
+    response_types?: string[] | null;
+    contacts?: string[] | null;
+    client_id_issued_at?: number | null;
+    client_secret_expires_at?: number | null;
+    token_endpoint_auth_method?: string | null;
+}
+interface StoredOAuthClient {
+    clientId: string;
+    /** Externally registered apps must never be replaced by native DCR on reload. */
+    registrationOwnership?: "caller";
+    /** Actual listener URI submitted when this native client was registered. */
+    requestedRedirectUri?: string;
+    clientSecret?: string;
+    registration?: OAuthClientRegistration;
+    tokenEndpointAuthMethod?: OAuthTokenEndpointAuthMethod;
+}
+type OAuthTokenEndpointAuthMethod = "none" | "client_secret_post" | "client_secret_basic";
+interface StoredOAuthSession {
+    resource: string;
+    authorizationServer: string;
+    client: StoredOAuthClient;
+    tokens?: StoredOAuthTokens;
+    /** A refresh was begun; its winning response may not have been persisted. */
+    refreshState?: "pending";
+    /** Canonical explicitly requested scope set when the server omits token scope. */
+    requestedScope?: string;
+    discovery: {
+        resourceMetadataUrl: string;
+        resourceMetadata: Record<string, unknown>;
+        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>;
+        /** 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;
+}
+type OAuthClientProviderOptions = {
+    provider: OAuthClientProvider;
+} | DefaultOAuthClientProviderOptions;
+
+interface OAuthDiscoveryCache {
+    get(resourceUrl: string): OAuthDiscoveryResult | null | undefined | Promise<OAuthDiscoveryResult | null | undefined>;
+    set(resourceUrl: string, value: OAuthDiscoveryResult): void | Promise<void>;
+    delete?(resourceUrl: string): void | Promise<void>;
+}
+
+type RequestId = number | string;
+interface ClientCapabilities {
+    extensions?: Record<string, Record<string, unknown>>;
+    elicitation?: {
+        form?: Record<string, unknown>;
+        url?: Record<string, unknown>;
+    };
+    roots?: {
+        listChanged?: boolean;
+        [key: string]: unknown;
+    };
+    sampling?: {
+        [key: string]: unknown;
+    };
+    experimental?: Record<string, unknown>;
+}
+interface ServerCapabilities {
+    extensions?: Record<string, Record<string, unknown>>;
+    prompts?: {
+        listChanged?: boolean;
+        [key: string]: unknown;
+    };
+    resources?: {
+        subscribe?: boolean;
+        listChanged?: boolean;
+        [key: string]: unknown;
+    };
+    tools?: {
+        listChanged?: boolean;
+        [key: string]: unknown;
+    };
+    logging?: {
+        [key: string]: unknown;
+    };
+    completions?: {
+        [key: string]: unknown;
+    };
+    experimental?: Record<string, unknown>;
+}
+interface ConnectResult {
+    protocolVersion: string;
+    capabilities: ServerCapabilities;
+    serverInfo?: Implementation;
+    instructions?: string;
+}
+type ElicitationParams = {
+    mode?: "form";
+    message: string;
+    requestedSchema: Record<string, unknown>;
+} | {
+    mode: "url";
+    message: string;
+    url: string;
+    elicitationId: string;
+};
+interface ElicitationResult {
+    _meta?: Record<string, unknown>;
+    action: "accept" | "decline" | "cancel";
+    content?: Record<string, string | number | boolean | string[]>;
+}
+declare const MCP_PROTOCOL_VERSIONS: readonly ["2025-03-26", "2025-06-18", "2025-11-25", "2026-07-28"];
+type McpProtocolVersion = typeof MCP_PROTOCOL_VERSIONS[number];
+interface McpClientOptions {
+    clientInfo: Implementation;
+    requestTimeoutMs?: number;
+    maxConcurrentRequests?: number;
+    protocolVersion?: McpProtocolVersion;
+    capabilities?: ClientCapabilities;
+    onToolsChanged?: () => void | Promise<void>;
+    onResourcesChanged?: () => void | Promise<void>;
+    onResourceUpdated?: (uri: string) => void | Promise<void>;
+    onPromptsChanged?: () => void | Promise<void>;
+    onLog?: (message: LogMessage) => void | Promise<void>;
+    onProgress?: (params: ProgressParams) => void | Promise<void>;
+    onSamplingRequest?: (params: CreateMessageParams, context: McpRequestContext) => CreateMessageResult | Promise<CreateMessageResult>;
+    onRootsList?: (context: McpRequestContext) => Root[] | Promise<Root[]>;
+    onElicitationRequest?: (params: ElicitationParams, context: McpRequestContext) => ElicitationResult | Promise<ElicitationResult>;
+}
+declare class McpClient {
+    private currentState;
+    private currentServerCapabilities;
+    private currentClientCapabilities;
+    private currentServerInfo;
+    private currentInstructions;
+    private readonly subscribedResourceUris;
+    private readonly activeProgressTokens;
+    private readonly options;
+    private transport;
+    private messageLayer;
+    private subscriptions;
+    private readonly resourceSubscriptions;
+    constructor(options: McpClientOptions);
+    get state(): "disconnected" | "initializing" | "ready" | "closed";
+    get serverCapabilities(): ServerCapabilities | null;
+    get serverInfo(): Implementation | null;
+    get instructions(): string | undefined;
+    private getMessageLayerOrThrow;
+    connect(transport: McpTransport, options?: {
+        signal?: AbortSignal;
+    }): Promise<ConnectResult>;
+    private getServerCapabilitiesOrThrow;
+    listTools(params?: PaginatedParams, options?: {
+        signal?: AbortSignal;
+    }): Promise<PaginatedResult & {
+        tools: Tool[];
+    }>;
+    callTool(params: CallToolParams, options?: CallToolOptions): Promise<CallToolResult>;
+    listResources(params?: PaginatedParams, options?: {
+        signal?: AbortSignal;
+    }): Promise<PaginatedResult & {
+        resources: Resource[];
+    }>;
+    listResourceTemplates(params?: PaginatedParams, options?: {
+        signal?: AbortSignal;
+    }): Promise<PaginatedResult & {
+        resourceTemplates: ResourceTemplate[];
+    }>;
+    readResource(params: ReadResourceParams, options?: {
+        signal?: AbortSignal;
+    }): Promise<CacheableResultMetadata & {
+        contents: ResourceContents[];
+    }>;
+    listenNotifications(filter: NotificationFilter, options?: SubscriptionOptions): Promise<McpSubscription>;
+    subscribe(uri: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    unsubscribe(uri: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    listPrompts(params?: PaginatedParams, options?: {
+        signal?: AbortSignal;
+    }): Promise<PaginatedResult & {
+        prompts: Prompt[];
+    }>;
+    getPrompt(params: GetPromptParams, options?: {
+        signal?: AbortSignal;
+    }): Promise<GetPromptResult>;
+    complete(params: CompleteParams, options?: {
+        signal?: AbortSignal;
+    }): Promise<CompleteResult>;
+    setLogLevel(level: LogLevel, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    cancel(requestId: RequestId, reason?: string): Promise<void>;
+    sendRootsChanged(): Promise<void>;
+    ping(options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    close(): Promise<void>;
+}
+interface Tool extends Omit<Tool$1, "inputSchema" | "outputSchema"> {
+    inputSchema: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+}
+interface CallToolParams {
+    name: string;
+    arguments?: Record<string, unknown>;
+}
+interface CallToolOptions {
+    signal?: AbortSignal;
+    progressToken?: ProgressToken;
+}
+interface ReadResourceParams {
+    uri: string;
+}
+interface PaginatedParams {
+    cursor?: string;
+}
+interface ResultMetadata {
+    resultType?: "complete";
+    _meta?: Record<string, unknown>;
+}
+interface CacheableResultMetadata extends ResultMetadata {
+    ttlMs?: number;
+    cacheScope?: "public" | "private";
+}
+interface PaginatedResult extends CacheableResultMetadata {
+    nextCursor?: string;
+}
+type ResourceContents = ResourceContents$1;
+type TextContent = Extract<ContentItem$1, {
+    type: "text";
+}>;
+type ImageContent = Extract<ContentItem$1, {
+    type: "image";
+}>;
+type AudioContent = Extract<ContentItem$1, {
+    type: "audio";
+}>;
+type ContentItem = ContentItem$1;
+interface PromptMessage {
+    role: "user" | "assistant";
+    content: ContentItem;
+}
+interface GetPromptResult extends ResultMetadata {
+    description?: string;
+    messages: PromptMessage[];
+}
+interface GetPromptParams {
+    name: string;
+    arguments?: Record<string, string>;
+}
+interface CallToolResult extends ResultMetadata {
+    content: ContentItem[];
+    structuredContent?: unknown;
+    isError?: boolean;
+}
+interface Root {
+    _meta?: Record<string, unknown>;
+    uri: string;
+    name?: string;
+}
+type LogLevel = "debug" | "info" | "notice" | "warning" | "error" | "critical" | "alert" | "emergency";
+interface LogMessage {
+    level: LogLevel;
+    logger?: string;
+    data: unknown;
+}
+type ProgressToken = RequestId;
+interface ProgressParams {
+    progressToken: ProgressToken;
+    progress: number;
+    total?: number;
+    message?: string;
+}
+interface ModelHint {
+    name?: string;
+}
+interface ModelPreferences {
+    hints?: ModelHint[];
+    costPriority?: number;
+    speedPriority?: number;
+    intelligencePriority?: number;
+}
+interface ToolUseContent {
+    _meta?: Record<string, unknown>;
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+interface ToolResultContent {
+    _meta?: Record<string, unknown>;
+    type: "tool_result";
+    toolUseId: string;
+    content: ContentItem[];
+    structuredContent?: unknown;
+    isError?: boolean;
+}
+type SamplingContent = TextContent | ImageContent | AudioContent | ToolUseContent | ToolResultContent;
+interface SamplingMessage {
+    _meta?: Record<string, unknown>;
+    role: "user" | "assistant";
+    content: SamplingContent | SamplingContent[];
+}
+type IncludeContext = "none" | "thisServer" | "allServers";
+interface CreateMessageParams {
+    messages: SamplingMessage[];
+    modelPreferences?: ModelPreferences;
+    systemPrompt?: string;
+    includeContext?: IncludeContext;
+    temperature?: number;
+    maxTokens: number;
+    tools?: Tool[];
+    toolChoice?: {
+        mode: "auto" | "required" | "none";
+    };
+    stopSequences?: string[];
+    metadata?: Record<string, unknown>;
+}
+interface CreateMessageResult {
+    _meta?: Record<string, unknown>;
+    model: string;
+    content: SamplingContent | SamplingContent[];
+    role: "user" | "assistant";
+    stopReason?: string;
+}
+interface PromptReference {
+    type: "ref/prompt";
+    name: string;
+}
+interface ResourceReference {
+    type: "ref/resource";
+    uri: string;
+}
+interface CompleteArgument {
+    name: string;
+    value: string;
+}
+interface CompleteParams {
+    context?: {
+        arguments?: Record<string, string>;
+    };
+    ref: PromptReference | ResourceReference;
+    argument: CompleteArgument;
+}
+interface Completion {
+    values: string[];
+    hasMore?: boolean;
+    total?: number;
+}
+interface CompleteResult extends ResultMetadata {
+    completion: Completion;
+}
+interface McpTransportClosedEvent {
+    reason: Error;
+    code?: number;
+    signal?: NodeJS.Signals;
+}
+interface McpTransport {
+    readable: Readable;
+    writable: Writable;
+    closed: Promise<McpTransportClosedEvent>;
+    /** Primary close reason, available before asynchronous transport cleanup finishes. */
+    readonly closeReason?: Promise<Error>;
+    dispose(reason?: Error): void;
+    filterTools?(tools: Tool[], reset?: boolean): Tool[];
+    /** Complete a legacy initialization handshake before the client reports ready. */
+    completeInitialization?(options: {
+        signal?: AbortSignal;
+        timeoutMs: number;
+        protocolVersion?: string;
+    }): Promise<void>;
+}
+type HttpTransportFetch = (input: string | URL, init?: RequestInit) => Promise<Response>;
+interface HttpTransportOptions {
+    url: string;
+    /** Legacy SSE uses a GET stream that announces the RPC POST endpoint. */
+    mode?: "streamable-http" | "sse";
+    headers?: RequestInit["headers"];
+    fetch?: HttpTransportFetch;
+    oauth?: OAuthClientProviderOptions;
+    oauthDiscoveryCache?: OAuthDiscoveryCache;
+    onWarning?: (message: string) => void;
+    /** Maximum JSON response bytes or individual SSE event bytes; not a stream lifetime cap. */
+    maxResponseBytes?: number;
+}
+interface McpRequestContext {
+    readonly id: RequestId;
+    readonly method: string;
+    readonly signal: AbortSignal;
+}
+
+/** A caller-owned remote registry entry. An empty tools array disables discovery. */
+interface RemoteMcpServer {
+    readonly name: string;
+    readonly url: string;
+    readonly transport?: "http" | "sse";
+    readonly tools?: readonly Tool[];
+    readonly instructions?: string;
+    readonly headers?: HttpTransportOptions["headers"];
+    readonly oauth?: HttpTransportOptions["oauth"];
+    readonly protocolVersion?: McpProtocolVersion;
+}
+interface RemoteMcpSchema {
+    readonly name: string;
+    readonly url: string;
+    readonly source: "provided" | "discovered";
+    readonly tools: Tool[];
+    readonly serverInfo?: Implementation;
+    readonly capabilities?: ServerCapabilities;
+    readonly instructions?: string;
+}
+interface SchemaFetchOptions {
+    readonly signal?: AbortSignal;
+    readonly fetch?: HttpTransportOptions["fetch"];
+    readonly oauthDiscoveryCache?: HttpTransportOptions["oauthDiscoveryCache"];
+    readonly onWarning?: HttpTransportOptions["onWarning"];
+    readonly maxPages?: number;
+    readonly maxTools?: number;
+    /** Bounds each complete JSON response body or individual SSE event. */
+    readonly maxResponseBytes?: number;
+    readonly requestTimeoutMs?: number;
+    /** Handle server input explicitly. Without a hook, input is declined. */
+    readonly onElicitationRequest?: RemoteMcpElicitationHandler;
+}
+interface RemoteMcpElicitationContext extends McpRequestContext {
+    readonly server: {
+        readonly name: string;
+        readonly url: string;
+    };
+}
+type RemoteMcpElicitationHandler = (params: ElicitationParams, context: RemoteMcpElicitationContext) => ElicitationResult | Promise<ElicitationResult>;
+/** Discover every tool page, or return an isolated copy of authoritative supplied schemas. */
+declare function fetchRemoteMcpSchema(server: RemoteMcpServer, options?: SchemaFetchOptions): Promise<RemoteMcpSchema>;
+/** Validate the complete registry before connecting, then preserve caller order. */
+declare function resolveRemoteMcpSchemas(servers: readonly RemoteMcpServer[], options?: SchemaFetchOptions): Promise<RemoteMcpSchema[]>;
+
+interface ToolParameter {
+    readonly name: string;
+    readonly flag: string;
+    readonly required: boolean;
+    readonly schemas: readonly unknown[];
+    readonly description?: string;
+}
+interface ToolArgumentParseOptions {
+    readonly yes?: boolean;
+    readonly maxInputBytes?: number;
+}
+interface ToolArgumentParser {
+    readonly toolName: string;
+    readonly parameters: readonly ToolParameter[];
+    parse(args: readonly string[], options?: ToolArgumentParseOptions): Record<string, unknown>;
+}
+/** Compile a tool's complete JSON Schema plus stable, collision-safe flag metadata. */
+declare function compileToolArguments(tool: Tool, options?: CompileJsonSchemaOptions): ToolArgumentParser;
+
+interface RemoteMcpCommandOptions extends SchemaFetchOptions, ToolArgumentParseOptions {
+    readonly maxOutputBytes?: number;
+    readonly schemaValidation?: CompileJsonSchemaOptions;
+}
+/** Generate a safe-bash command for each server, discovering only absent schemas. */
+declare function createRemoteMcpCommands(servers: readonly RemoteMcpServer[], options?: RemoteMcpCommandOptions): Promise<CommandDefinition[]>;
+/** 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;
+}
+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>;
+
+export { accessRemoteMcpResources, compileToolArguments, createRemoteMcpCommands, fetchRemoteMcpSchema, remoteMcpCommands, resolveRemoteMcpSchemas };
+export type { RemoteMcpCommandOptions, RemoteMcpElicitationContext, RemoteMcpElicitationHandler, RemoteMcpResourceOptions, RemoteMcpResourceRequest, RemoteMcpResourceResult, RemoteMcpSchema, RemoteMcpServer, SchemaFetchOptions, ToolArgumentParseOptions, ToolArgumentParser, ToolParameter };