McpSchema unstable

interface McpReverseClient {
  readonly createMessage: (request: {
    readonly includeContext?: "none" | "thisServer" | "allServers";
    readonly maxTokens: number;
    readonly messages: readonly Array<SamplingMessage>;
    readonly metadata?: {
      [key: string]: unknown;
    };
    readonly modelPreferences?: {
      readonly costPriority?: number;
      readonly hints?: readonly Array<ModelHint>;
      readonly intelligencePriority?: number;
      readonly speedPriority?: number;
    };
    readonly stopSequences?: readonly Array<string>;
    readonly systemPrompt?: string;
    readonly temperature?: number;
    readonly toolChoice?: {
      readonly mode?: "required" | "auto" | "none";
    };
    readonly tools?: readonly Array<{
      readonly _meta?: {
        [key: string]: Json;
      };
      readonly annotations?: ToolAnnotations;
      readonly description?: string;
      readonly icons?: readonly Array<Icon>;
      readonly inputSchema: ToolJson;
      readonly name: string;
      readonly outputSchema?: JsonObject;
      readonly title?: string;
    }>;
  }) => Effect<CreateMessageResult, McpReverseOperationUnsupported | McpReverseOperationError>;
  readonly elicit: (request: ElicitRequestFormParams | ElicitRequestURLParams) => Effect<ElicitAcceptResult | ElicitDeclineResult, McpReverseOperationUnsupported | McpReverseOperationError>;
  readonly listRoots: (request?: RequestMeta) => Effect<ListRootsResult, McpReverseOperationUnsupported | McpReverseOperationError>;
}

declare const HEADER_MISMATCH_ERROR_CODE: -32020

declare const INTERNAL_ERROR_CODE: -32603

declare const INVALID_PARAMS_ERROR_CODE: -32602

declare const INVALID_REQUEST_ERROR_CODE: -32600

declare const METHOD_NOT_FOUND_ERROR_CODE: -32601

declare const PARSE_ERROR_CODE: -32700

declare class ElicitationBoolean extends {
  readonly default?: boolean;
  readonly description?: string;
  readonly title?: string;
  readonly type: "boolean";
} {
  constructor(...args: [props?: {
    readonly default?: boolean;
    readonly description?: string;
    readonly title?: string;
    readonly type?: "boolean";
  }, options?: MakeOptions]);
}

declare class ElicitationCompleteNotification extends {} {
  constructor(_: never);
}

declare const ElicitationEnum: Union<readonly [typeof LegacyTitledEnum, Union<readonly [typeof UntitledSingleSelectEnum, typeof TitledSingleSelectEnum]>, Union<readonly [typeof UntitledMultiSelectEnum, typeof TitledMultiSelectEnum]>]>

declare class ElicitationNumber extends {
  readonly default?: number;
  readonly description?: string;
  readonly maximum?: number;
  readonly minimum?: number;
  readonly title?: string;
  readonly type: "number" | "integer";
} {
  constructor(...args: [props: {
    readonly default?: number;
    readonly description?: string;
    readonly maximum?: number;
    readonly minimum?: number;
    readonly title?: string;
    readonly type: "number" | "integer";
  }, options?: MakeOptions]);
}

declare class ElicitationString extends {
  readonly default?: string;
  readonly description?: string;
  readonly format?: "date" | "uri" | "email" | "date-time";
  readonly maxLength?: number;
  readonly minLength?: number;
  readonly title?: string;
  readonly type: "string";
} {
  constructor(...args: [props?: {
    readonly default?: string;
    readonly description?: string;
    readonly format?: "date" | "uri" | "email" | "date-time";
    readonly maxLength?: number;
    readonly minLength?: number;
    readonly title?: string;
    readonly type?: "string";
  }, options?: MakeOptions]);
}

declare class ElicitRequestFormParams extends {
  readonly _meta?: {
    [key: string]: Json;
    readonly progressToken?: string | number;
  };
  readonly message: string;
  readonly mode?: "form";
  readonly requestedSchema: {
    readonly $schema?: string;
    readonly properties: {
      [key: string]: ElicitationString | ElicitationNumber | ElicitationBoolean | UntitledSingleSelectEnum | TitledSingleSelectEnum | UntitledMultiSelectEnum | TitledMultiSelectEnum | LegacyTitledEnum;
    };
    readonly required?: readonly Array<string>;
    readonly type: "object";
  };
} {
  constructor(...args: [props: {
    readonly _meta?: {
      [key: string]: unknown;
      readonly progressToken?: string | number;
    };
    readonly message: string;
    readonly mode?: "form";
    readonly requestedSchema: {
      readonly $schema?: string;
      readonly properties: {
        [key: string]: ElicitationString | ElicitationNumber | ElicitationBoolean | UntitledSingleSelectEnum | TitledSingleSelectEnum | UntitledMultiSelectEnum | TitledMultiSelectEnum | LegacyTitledEnum;
      };
      readonly required?: readonly Array<string>;
      readonly type?: "object";
    };
  }, options?: MakeOptions]);
}

declare const ElicitRequestParams: Union<readonly [typeof ElicitRequestFormParams, typeof ElicitRequestURLParams]>

declare class ElicitRequestURLParams extends {
  readonly _meta?: {
    [key: string]: Json;
    readonly progressToken?: string | number;
  };
  readonly elicitationId: string;
  readonly message: string;
  readonly mode: "url";
  readonly url: string;
} {
  constructor(...args: [props: {
    readonly _meta?: {
      [key: string]: unknown;
      readonly progressToken?: string | number;
    };
    readonly elicitationId: string;
    readonly message: string;
    readonly mode: "url";
    readonly url: string;
  }, options?: MakeOptions]);
}

declare class LegacyTitledEnum extends {
  readonly default?: string;
  readonly description?: string;
  readonly enum: readonly Array<string>;
  readonly enumNames?: readonly Array<string>;
  readonly title?: string;
  readonly type: "string";
} {
  constructor(...args: [props: {
    readonly default?: string;
    readonly description?: string;
    readonly enum: readonly Array<string>;
    readonly enumNames?: readonly Array<string>;
    readonly title?: string;
    readonly type?: "string";
  }, options?: MakeOptions]);
}

declare const MultiSelectEnum: Union<readonly [typeof UntitledMultiSelectEnum, typeof TitledMultiSelectEnum]>

declare const PrimitiveSchemaDefinition: Union<readonly [Union<readonly [typeof LegacyTitledEnum, Union<readonly [typeof UntitledSingleSelectEnum, typeof TitledSingleSelectEnum]>, Union<readonly [typeof UntitledMultiSelectEnum, typeof TitledMultiSelectEnum]>]>, typeof ElicitationString, typeof ElicitationNumber, typeof ElicitationBoolean]>

declare const SingleSelectEnum: Union<readonly [typeof UntitledSingleSelectEnum, typeof TitledSingleSelectEnum]>

declare class TitledMultiSelectEnum extends {
  readonly default?: readonly Array<string>;
  readonly description?: string;
  readonly items: {
    readonly anyOf: readonly Array<{
      readonly const: string;
      readonly title: string;
    }>;
  };
  readonly maxItems?: number;
  readonly minItems?: number;
  readonly title?: string;
  readonly type: "array";
} {
  constructor(...args: [props: {
    readonly default?: readonly Array<string>;
    readonly description?: string;
    readonly items: {
      readonly anyOf: readonly Array<{
        readonly const: string;
        readonly title: string;
      }>;
    };
    readonly maxItems?: number;
    readonly minItems?: number;
    readonly title?: string;
    readonly type?: "array";
  }, options?: MakeOptions]);
}

declare class TitledSingleSelectEnum extends {
  readonly default?: string;
  readonly description?: string;
  readonly oneOf: readonly Array<{
    readonly const: string;
    readonly title: string;
  }>;
  readonly title?: string;
  readonly type: "string";
} {
  constructor(...args: [props: {
    readonly default?: string;
    readonly description?: string;
    readonly oneOf: readonly Array<{
      readonly const: string;
      readonly title: string;
    }>;
    readonly title?: string;
    readonly type?: "string";
  }, options?: MakeOptions]);
}

declare class UntitledMultiSelectEnum extends {
  readonly default?: readonly Array<string>;
  readonly description?: string;
  readonly items: {
    readonly enum: readonly Array<string>;
    readonly type: "string";
  };
  readonly maxItems?: number;
  readonly minItems?: number;
  readonly title?: string;
  readonly type: "array";
} {
  constructor(...args: [props: {
    readonly default?: readonly Array<string>;
    readonly description?: string;
    readonly items: {
      readonly enum: readonly Array<string>;
      readonly type?: "string";
    };
    readonly maxItems?: number;
    readonly minItems?: number;
    readonly title?: string;
    readonly type?: "array";
  }, options?: MakeOptions]);
}

declare class UntitledSingleSelectEnum extends {
  readonly default?: string;
  readonly description?: string;
  readonly enum: readonly Array<string>;
  readonly title?: string;
  readonly type: "string";
} {
  constructor(...args: [props: {
    readonly default?: string;
    readonly description?: string;
    readonly enum: readonly Array<string>;
    readonly title?: string;
    readonly type?: "string";
  }, options?: MakeOptions]);
}

declare class InternalError extends {
  readonly _tag: "InternalError";
  readonly code: -32603;
  readonly data?: any;
  readonly message: string;
} & YieldableError<this> {
  constructor(...args: [props: {
    readonly _tag?: "InternalError";
    readonly code?: -32603;
    readonly data?: any;
    readonly message: string;
  }, options?: MakeOptions]);
  static readonly notImplemented: InternalError;
}

declare class InvalidParams extends {
  readonly _tag: "InvalidParams";
  readonly code: -32602;
  readonly data?: any;
  readonly message: string;
} & YieldableError<this> {
  constructor(...args: [props: {
    readonly _tag?: "InvalidParams";
    readonly code?: -32602;
    readonly data?: any;
    readonly message: string;
  }, options?: MakeOptions]);
}

declare class InvalidRequest extends {
  readonly _tag: "InvalidRequest";
  readonly code: -32600;
  readonly data?: any;
  readonly message: string;
} & YieldableError<this> {
  constructor(...args: [props: {
    readonly _tag?: "InvalidRequest";
    readonly code?: -32600;
    readonly data?: any;
    readonly message: string;
  }, options?: MakeOptions]);
}

declare const McpError: Union<readonly [typeof ParseError, typeof InvalidRequest, typeof MethodNotFound, typeof InvalidParams, typeof InternalError, typeof McpErrorBase]>

declare class McpReverseOperationError extends YieldableError<this> & {
  readonly _tag: "McpReverseOperationError";
} & Readonly<{
  readonly cause: unknown;
  readonly operation: "sampling/createMessage" | "roots/list" | "elicitation/create";
}> {
  constructor(args: {
    readonly cause: unknown;
    readonly operation: "sampling/createMessage" | "roots/list" | "elicitation/create";
  });
}

declare class McpReverseOperationUnsupported extends YieldableError<this> & {
  readonly _tag: "McpReverseOperationUnsupported";
} & Readonly<{
  readonly operation: "sampling/createMessage" | "roots/list" | "elicitation/create";
  readonly protocolVersion: ProtocolVersion;
  readonly reason: string;
}> {
  constructor(args: {
    readonly operation: "sampling/createMessage" | "roots/list" | "elicitation/create";
    readonly protocolVersion: ProtocolVersion;
    readonly reason: string;
  });
}

declare class MethodNotFound extends {
  readonly _tag: "MethodNotFound";
  readonly code: -32601;
  readonly data?: any;
  readonly message: string;
} & YieldableError<this> {
  constructor(...args: [props: {
    readonly _tag?: "MethodNotFound";
    readonly code?: -32601;
    readonly data?: any;
    readonly message: string;
  }, options?: MakeOptions]);
}

declare class ParseError extends {
  readonly _tag: "ParseError";
  readonly code: -32700;
  readonly data?: any;
  readonly message: string;
} & YieldableError<this> {
  constructor(...args: [props: {
    readonly _tag?: "ParseError";
    readonly code?: -32700;
    readonly data?: any;
    readonly message: string;
  }, options?: MakeOptions]);
}

declare function isParam(schema: Constraint): schema is Param<string, Top>

declare const LoggingLevel: Schema.Literals<["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"]>

type LoggingLevel = typeof LoggingLevel.Type

declare class LoggingMessageNotification extends {} {
  constructor(_: never);
}

declare class SetLevel extends {} {
  constructor(_: never);
}

declare class McpServerClientMiddleware extends Shape<"effect/ai/McpSchema/McpServerClientMiddleware", RpcMiddleware<McpServerClient, never, never>, this> & {
  readonly "~effect/rpc/RpcMiddleware": {
    readonly clientError: never;
    readonly error: Never;
    readonly provides: McpServerClient;
    readonly requires: never;
  };
} {
  constructor(_: never);
}

type ContentBlock = typeof ContentBlock.Type

type Cursor = typeof Cursor.Type

type ElicitationEnum = typeof ElicitationEnum.Type

type ElicitRequestParams = typeof ElicitRequestParams.Type

type ElicitResult = typeof ElicitResult.Type

declare class InputRequired extends Readonly<{
  readonly inputRequests?: Readonly<Record<string, McpInputRequest>>;
  readonly requestState?: string;
}> & {
  readonly _tag: "InputRequired";
} & Pipeable {
  constructor(fields: {
    readonly inputRequests: Readonly<Record<string, McpInputRequest>>;
    readonly requestState?: string;
  } | {
    readonly inputRequests?: Readonly<Record<string, McpInputRequest>>;
    readonly requestState: string;
  });
}

type McpError = typeof McpError.Type

type McpInputRequest = {
  readonly method: "roots/list";
  readonly params?: Schema.JsonObject;
} | {
  readonly method: "sampling/createMessage";
  readonly params: Schema.JsonObject;
} | {
  readonly method: "elicitation/create";
  readonly params: Schema.JsonObject;
}

type McpInputResponse = Schema.JsonObject

type MultiSelectEnum = typeof MultiSelectEnum.Type

interface optionalWithDefault<S extends Schema.Constraint & Schema.WithoutConstructorDefault> extends withConstructorDefault<Schema.decodeTo<Schema.toType<Schema.optionalKey<S>>, Schema.optionalKey<S>>> {
  constructor(_: never);
}

type PrimitiveSchemaDefinition = typeof PrimitiveSchemaDefinition.Type

type ProgressToken = typeof ProgressToken.Type

type RequestId = typeof RequestId.Type

type Role = typeof Role.Type

type SamplingMessageContentBlock = typeof SamplingMessageContentBlock.Type

type SingleSelectEnum = typeof SingleSelectEnum.Type

declare function param<Name extends string, S extends Constraint>(name: Name, schema: S): Param<Name, S>

interface Param<Name extends string, S extends Schema.Constraint> extends BottomLazy<S["ast"], Param<Name, S>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
  constructor(_: never);
  readonly "~effect/ai/McpSchema/ParamSchema": "~effect/ai/McpSchema/ParamSchema";
  readonly "~type.make": S["~type.make"];
  readonly "~type.make.in": S["~type.make.in"];
  readonly DecodingServices: S["DecodingServices"];
  readonly Encoded: S["Encoded"];
  readonly EncodingServices: S["EncodingServices"];
  readonly Iso: S["Iso"];
  readonly name: Name;
  readonly Rebuild: Param<Name, S>;
  readonly schema: S;
  readonly Type: S["Type"];
}

declare class CallTool extends {} {
  constructor(_: never);
}

declare class CancelledNotification extends {} {
  constructor(_: never);
}

type ClientFailureEncoded = FailureEncoded<typeof ServerRequestRpcs>

type ClientNotificationEncoded = NotificationEncoded<typeof ClientNotificationRpcs>

declare class ClientNotificationRpcs extends {} {
  constructor(_: never);
}

type ClientRequestEncoded = RequestEncoded<typeof ClientRequestRpcs>

declare class ClientRequestRpcs extends {} {
  constructor(_: never);
}

declare class ClientRpcs extends {} {
  constructor(_: never);
}

type ClientSuccessEncoded = SuccessEncoded<typeof ServerRequestRpcs>

declare class Complete extends {} {
  constructor(_: never);
}

declare class CreateMessage extends {} {
  constructor(_: never);
}

declare class Elicit extends {} {
  constructor(_: never);
}

type FailureEncoded<Group extends RpcGroup.Any> = RpcGroup.Rpcs<Group> extends infer Rpc ? Rpc extends Rpc.Rpc<infer _Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware> ? {
  readonly _tag: "Failure";
  readonly error: _Error["Encoded"];
  readonly id: string | number;
} : never : never

type FromClientEncoded = ClientRequestEncoded | ClientNotificationEncoded

type FromServerEncoded = ServerResultEncoded | ServerNotificationEncoded

declare class GetPrompt extends {} {
  constructor(_: never);
}

declare class Initialize extends {} {
  constructor(_: never);
}

declare class InitializedNotification extends {} {
  constructor(_: never);
}

declare class ListPrompts extends {} {
  constructor(_: never);
}

declare class ListResources extends {} {
  constructor(_: never);
}

declare class ListResourceTemplates extends {} {
  constructor(_: never);
}

declare class ListRoots extends {} {
  constructor(_: never);
}

declare class ListTools extends {} {
  constructor(_: never);
}

type NotificationEncoded<Group extends RpcGroup.Any> = RpcGroup.Rpcs<Group> extends infer Rpc ? Rpc extends Rpc.Rpc<infer _Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware> ? {
  readonly _tag: "Notification";
  readonly method: _Tag;
  readonly payload: _Payload["Encoded"];
} : never : never

declare class Ping extends {} {
  constructor(_: never);
}

declare class ProgressNotification extends {} {
  constructor(_: never);
}

declare class PromptListChangedNotification extends {} {
  constructor(_: never);
}

declare class ReadResource extends {} {
  constructor(_: never);
}

type RequestEncoded<Group extends RpcGroup.Any> = RpcGroup.Rpcs<Group> extends infer Rpc ? Rpc extends Rpc.Rpc<infer _Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware> ? {
  readonly _tag: "Request";
  readonly id: string | number;
  readonly method: _Tag;
  readonly payload: _Payload["Encoded"];
} : never : never

declare class ResourceListChangedNotification extends {} {
  constructor(_: never);
}

declare class ResourceUpdatedNotification extends {} {
  constructor(_: never);
}

declare class RootsListChangedNotification extends {} {
  constructor(_: never);
}

type ServerFailureEncoded = FailureEncoded<typeof ClientRequestRpcs>

type ServerNotificationEncoded = NotificationEncoded<typeof ServerNotificationRpcs>

declare class ServerNotificationRpcs extends {} {
  constructor(_: never);
}

type ServerRequestEncoded = RequestEncoded<typeof ServerRequestRpcs>

declare class ServerRequestRpcs extends {} {
  constructor(_: never);
}

type ServerResultEncoded = ServerSuccessEncoded | ServerFailureEncoded

type ServerSuccessEncoded = SuccessEncoded<typeof ClientRequestRpcs>

declare class Subscribe extends {} {
  constructor(_: never);
}

type SuccessEncoded<Group extends RpcGroup.Any> = RpcGroup.Rpcs<Group> extends infer Rpc ? Rpc extends Rpc.Rpc<infer _Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware> ? {
  readonly _tag: "Success";
  readonly id: string | number;
  readonly result: _Success["Encoded"];
} : never : never