export declare class Protocol<SendRequestT extends Request, SendNotificationT extends Notification, SendResultT extends Result> {
  private _transport?;
  private _requestMessageId;
  protected _requestHandlers: Map<string, (request: JSONRPCRequest) => Promise<SendResultT>>;
  private _notificationHandlers;
  private _responseHandlers;
  private _progressHandlers;
  /**
   * Callback for when the connection is closed for any reason.
   *
   * This is invoked when close() is called as well.
   */
  onclose?: () => void;
  /**
   * Callback for when an error occurs.
   *
   * Note that errors are not necessarily fatal; they are used for reporting any kind of exceptional condition out of band.
   */
  onerror?: (error: Error) => void;
  /**
   * A handler to invoke for any request types that do not have their own handler installed.
   */
  fallbackRequestHandler?: (request: Request) => Promise<SendResultT>;
  /**
   * A handler to invoke for any notification types that do not have their own handler installed.
   */
  fallbackNotificationHandler?: (notification: Notification) => Promise<void>;
  constructor();
  /**
   * Attaches to the given transport, starts it, and starts listening for messages.
   *
   * The Protocol object assumes ownership of the Transport, replacing any callbacks that have already been set, and expects that it is the only user of the Transport instance going forward.
   */
  connect(transport: Transport): Promise<void>;
  private _onclose;
  private _onerror;
  private _onnotification;
  private _onrequest;
  private _onprogress;
  private _onresponse;
  get transport(): Transport | undefined;
  /**
   * Closes the connection.
   */
  close(): Promise<void>;
  /**
   * Sends a request and wait for a response, with optional progress notifications in the meantime (if supported by the server).
   *
   * Do not use this method to emit notifications! Use notification() instead.
   */
  request<T extends ZodType<object>>(request: SendRequestT, resultSchema: T, onprogress?: ProgressCallback): Promise<z.infer<T>>;
  /**
   * Emits a notification, which is a one-way message that does not expect a response.
   */
  notification(notification: SendNotificationT): Promise<void>;
  /**
   * Registers a handler to invoke when this protocol object receives a request with the given method.
   *
   * Note that this will replace any previous request handler for the same method.
   */
  setRequestHandler<T extends ZodObject<{
    method: ZodLiteral<string>;
  }>>(requestSchema: T, handler: (request: z.infer<T>) => SendResultT | Promise<SendResultT>): void;
  /**
   * Removes the request handler for the given method.
   */
  removeRequestHandler(method: string): void;
  /**
   * Registers a handler to invoke when this protocol object receives a notification with the given method.
   *
   * Note that this will replace any previous notification handler for the same method.
   */
  setNotificationHandler<T extends ZodObject<{
    method: ZodLiteral<string>;
  }>>(notificationSchema: T, handler: (notification: z.infer<T>) => void | Promise<void>): void;
  /**
   * Removes the notification handler for the given method.
   */
  removeNotificationHandler(method: string): void;
}

export declare class Server<RequestT extends Request = Request, NotificationT extends Notification = Notification, ResultT extends Result = Result> extends Protocol<ServerRequest | RequestT, ServerNotification | NotificationT, ServerResult | ResultT> {
  private _serverInfo;
  private _clientCapabilities?;
  private _clientVersion?;
  /**
   * Callback for when initialization has fully completed (i.e., the client has sent an `initialized` notification).
   */
  oninitialized?: () => void;
  /**
   * Initializes this server with the given name and version information.
   */
  constructor(_serverInfo: Implementation);
  private _oninitialize;
  /**
   * After initialization has completed, this will be populated with the client's reported capabilities.
   */
  getClientCapabilities(): ClientCapabilities | undefined;
  /**
   * After initialization has completed, this will be populated with information about the client's name and version.
   */
  getClientVersion(): Implementation | undefined;
  private getCapabilities;
  ping(): Promise<{
    _meta?: import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough"> | undefined;
  }>;
  createMessage(params: CreateMessageRequest["params"], onprogress?: ProgressCallback): Promise<import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
    _meta: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
  }, {
    model: import("zod").ZodString;
    stopReason: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodEnum<["endTurn", "stopSequence", "maxTokens"]>, import("zod").ZodString]>>;
    role: import("zod").ZodEnum<["user", "assistant"]>;
    content: import("zod").ZodDiscriminatedUnion<"type", [import("zod").ZodObject<{
      type: import("zod").ZodLiteral<"text">;
      text: import("zod").ZodString;
    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
      type: import("zod").ZodLiteral<"text">;
      text: import("zod").ZodString;
    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
      type: import("zod").ZodLiteral<"text">;
      text: import("zod").ZodString;
    }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
      type: import("zod").ZodLiteral<"image">;
      data: import("zod").ZodString;
      mimeType: import("zod").ZodString;
    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
      type: import("zod").ZodLiteral<"image">;
      data: import("zod").ZodString;
      mimeType: import("zod").ZodString;
    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
      type: import("zod").ZodLiteral<"image">;
      data: import("zod").ZodString;
      mimeType: import("zod").ZodString;
    }, import("zod").ZodTypeAny, "passthrough">>]>;
  }>, import("zod").ZodTypeAny, "passthrough">>;
  listRoots(params?: ListRootsRequest["params"], onprogress?: ProgressCallback): Promise<import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
    _meta: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
  }, {
    roots: import("zod").ZodArray<import("zod").ZodObject<{
      uri: import("zod").ZodString;
      name: import("zod").ZodOptional<import("zod").ZodString>;
    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
      uri: import("zod").ZodString;
      name: import("zod").ZodOptional<import("zod").ZodString>;
    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
      uri: import("zod").ZodString;
      name: import("zod").ZodOptional<import("zod").ZodString>;
    }, import("zod").ZodTypeAny, "passthrough">>, "many">;
  }>, import("zod").ZodTypeAny, "passthrough">>;
  sendLoggingMessage(params: LoggingMessageNotification["params"]): Promise<void>;
  sendResourceUpdated(params: ResourceUpdatedNotification["params"]): Promise<void>;
  sendResourceListChanged(): Promise<void>;
  sendToolListChanged(): Promise<void>;
  sendPromptListChanged(): Promise<void>;
}

export class Client extends Protocol {
  /**
   * Initializes this client with the given name and version information.
   */
  constructor(_clientInfo) {
    super();
    this._clientInfo = _clientInfo;
  }
  async connect(transport) {
    await super.connect(transport);
    const result = await this.request({
      method: "initialize",
      params: {
        protocolVersion: LATEST_PROTOCOL_VERSION,
        capabilities: {},
        clientInfo: this._clientInfo,
      },
    }, InitializeResultSchema);
    if (result === undefined) {
      throw new Error(`Server sent invalid initialize result: ${result}`);
    }
    if (!SUPPORTED_PROTOCOL_VERSIONS.includes(result.protocolVersion)) {
      throw new Error(`Server's protocol version is not supported: ${result.protocolVersion}`);
    }
    this._serverCapabilities = result.capabilities;
    this._serverVersion = result.serverInfo;
    await this.notification({
      method: "notifications/initialized",
    });
  }
  /**
   * After initialization has completed, this will be populated with the server's reported capabilities.
   */
  getServerCapabilities() {
    return this._serverCapabilities;
  }
  /**
   * After initialization has completed, this will be populated with information about the server's name and version.
   */
  getServerVersion() {
    return this._serverVersion;
  }
  async ping() {
    return this.request({ method: "ping" }, EmptyResultSchema);
  }
  async complete(params, onprogress) {
    return this.request({ method: "completion/complete", params }, CompleteResultSchema, onprogress);
  }
  async setLoggingLevel(level) {
    return this.request({ method: "logging/setLevel", params: { level } }, EmptyResultSchema);
  }
  async getPrompt(params, onprogress) {
    return this.request({ method: "prompts/get", params }, GetPromptResultSchema, onprogress);
  }
  async listPrompts(params, onprogress) {
    return this.request({ method: "prompts/list", params }, ListPromptsResultSchema, onprogress);
  }
  async listResources(params, onprogress) {
    return this.request({ method: "resources/list", params }, ListResourcesResultSchema, onprogress);
  }
  async listResourceTemplates(params, onprogress) {
    return this.request({ method: "resources/templates/list", params }, ListResourceTemplatesResultSchema, onprogress);
  }
  async readResource(params, onprogress) {
    return this.request({ method: "resources/read", params }, ReadResourceResultSchema, onprogress);
  }
  async subscribeResource(params) {
    return this.request({ method: "resources/subscribe", params }, EmptyResultSchema);
  }
  async unsubscribeResource(params) {
    return this.request({ method: "resources/unsubscribe", params }, EmptyResultSchema);
  }
  async callTool(params, resultSchema = CallToolResultSchema, onprogress) {
    return this.request({ method: "tools/call", params }, resultSchema, onprogress);
  }
  async listTools(params, onprogress) {
    return this.request({ method: "tools/list", params }, ListToolsResultSchema, onprogress);
  }
  async sendRootsListChanged() {
    return this.notification({ method: "notifications/roots/list_changed" });
  }
}

import { JSONRPCMessage } from "../types.js";
import { Transport } from "../shared/transport.js";
export type StdioServerParameters = {
    /**
     * The executable to run to start the server.
     */
    command: string;
    /**
     * Command line arguments to pass to the executable.
     */
    args?: string[];
    /**
     * The environment to use when spawning the process.
     *
     * If not specified, the result of getDefaultEnvironment() will be used.
     */
    env?: Record<string, string>;
};
/**
 * Environment variables to inherit by default, if an environment is not explicitly given.
 */
export declare const DEFAULT_INHERITED_ENV_VARS: string[];
/**
 * Returns a default environment object including only environment variables deemed safe to inherit.
 */
export declare function getDefaultEnvironment(): Record<string, string>;
/**
 * Client transport for stdio: this will connect to a server by spawning a process and communicating with it over stdin/stdout.
 *
 * This transport is only available in Node.js environments.
 */
export declare class StdioClientTransport implements Transport {
    private _process?;
    private _abortController;
    private _readBuffer;
    private _serverParams;
    onclose?: () => void;
    onerror?: (error: Error) => void;
    onmessage?: (message: JSONRPCMessage) => void;
    constructor(server: StdioServerParameters);
    /**
     * Starts the server process and prepares to communicate with it.
     */
    start(): Promise<void>;
    private processReadBuffer;
    close(): Promise<void>;
    send(message: JSONRPCMessage): Promise<void>;
}
//# sourceMappingURL=stdio.d.ts.map

import { Transport } from "../shared/transport.js";
import { JSONRPCMessage } from "../types.js";
/**
 * Client transport for WebSocket: this will connect to a server over the WebSocket protocol.
 */
export declare class WebSocketClientTransport implements Transport {
  private _socket?;
  private _url;
  onclose?: () => void;
  onerror?: (error: Error) => void;
  onmessage?: (message: JSONRPCMessage) => void;
  constructor(url: URL);
  start(): Promise<void>;
  close(): Promise<void>;
  send(message: JSONRPCMessage): Promise<void>;
}
//# sourceMappingURL=websocket.d.ts.map

import { Transport } from "../shared/transport.js";
import { JSONRPCMessage } from "../types.js";
/**
 * Client transport for SSE: this will connect to a server using Server-Sent Events for receiving
 * messages and make separate POST requests for sending messages.
 *
 * This uses the EventSource API in browsers. You can install the `eventsource` package for Node.js.
 */
export declare class SSEClientTransport implements Transport {
  private _eventSource?;
  private _endpoint?;
  private _abortController?;
  private _url;
  onclose?: () => void;
  onerror?: (error: Error) => void;
  onmessage?: (message: JSONRPCMessage) => void;
  constructor(url: URL);
  start(): Promise<void>;
  close(): Promise<void>;
  send(message: JSONRPCMessage): Promise<void>;
}
//# sourceMappingURL=sse.d.ts.map