eve 0.72.1 → 0.74.0

package/dist/src/compiled/@modelcontextprotocol/server/index.d.ts

@@ -6,8 +6,14 @@ export interface CallToolRequest {
   };
 }
 
+export type McpJsonObject = Readonly<Record<string, unknown>>;
+
 export interface McpRequestHandlerExtra {
   readonly mcpReq: {
+    /** The request's `_meta`, without the reserved `io.modelcontextprotocol/*` keys. */
+    readonly _meta?: Readonly<Record<string, unknown>>;
+    /** The reserved `io.modelcontextprotocol/*` keys the request carried. */
+    readonly envelope?: Readonly<Record<string, unknown>>;
     readonly signal: AbortSignal;
   };
 }
@@ -43,10 +49,35 @@ export interface StandardSchemaWithJSON<TInput = unknown, TOutput = TInput> {
   };
 }
 
+export interface StandardSchemaV1<TInput = unknown, TOutput = TInput> {
+  readonly "~standard": {
+    readonly version: 1;
+    readonly vendor: string;
+    readonly types?: { readonly input: TInput; readonly output: TOutput };
+  };
+}
+
+export interface CacheHint {
+  readonly cacheScope?: "private" | "public";
+  readonly ttlMs?: number;
+}
+
+export type CacheableResultMethod =
+  | "prompts/list"
+  | "resources/list"
+  | "resources/read"
+  | "resources/templates/list"
+  | "server/discover"
+  | "tools/list";
+
+export interface McpServerOptions {
+  readonly cacheHints?: Partial<Record<CacheableResultMethod, CacheHint>>;
+  readonly capabilities?: McpJsonObject;
+  readonly instructions?: string;
+}
+
 export declare class Server {
-  constructor(info: { readonly name: string; readonly version: string }, options?: {
-    readonly capabilities?: Readonly<Record<string, unknown>>;
-  });
+  constructor(info: { readonly name: string; readonly version: string }, options?: McpServerOptions);
   setRequestHandler<Result>(
     method: "tools/list",
     handler: (
@@ -61,13 +92,25 @@ export declare class Server {
       context: McpRequestHandlerExtra,
     ) => Result | Promise<Result>,
   ): void;
+  /** Spec methods validated by the SDK's own wire schemas. */
+  setRequestHandler<Result>(
+    method: "resources/list" | "resources/read" | "resources/templates/list",
+    handler: (
+      request: { readonly params?: McpJsonObject },
+      context: McpRequestHandlerExtra,
+    ) => Result | Promise<Result>,
+  ): void;
+  /** Custom (non-spec) methods: params are validated by the given schema. */
+  setRequestHandler<TParams, Result>(
+    method: string,
+    schemas: { readonly params: StandardSchemaV1<unknown, TParams> },
+    handler: (params: TParams, context: McpRequestHandlerExtra) => Result | Promise<Result>,
+  ): void;
 }
 
 export declare class McpServer {
-  constructor(info: { readonly name: string; readonly version: string }, options?: {
-    readonly capabilities?: Readonly<Record<string, unknown>>;
-    readonly instructions?: string;
-  });
+  readonly server: Server;
+  constructor(info: { readonly name: string; readonly version: string }, options?: McpServerOptions);
   registerTool<TInput = unknown, TOutput = TInput>(
     name: string,
     config: {
@@ -83,6 +126,24 @@ export declare class McpServer {
   ): void;
 }
 
+export declare class ProtocolError extends Error {
+  constructor(code: number, message: string, data?: unknown);
+  readonly code: number;
+  readonly data?: unknown;
+}
+
+export declare const ProtocolErrorCode: {
+  readonly InternalError: -32603;
+  readonly InvalidParams: -32602;
+  readonly InvalidRequest: -32600;
+  readonly MethodNotFound: -32601;
+};
+
+/** A resource miss, with data `{ uri }`. */
+export declare class ResourceNotFoundError extends ProtocolError {
+  constructor(uri: string, message?: string);
+}
+
 export interface McpRequestContext {
   readonly era: "legacy" | "modern";
   readonly requestInfo: Request;

package/dist/src/compiled/@vercel/schedules/index.d.ts

@@ -0,0 +1,158 @@
+interface SchedulesApiClientOptions {
+    baseUrl?: string;
+    token?: string;
+    fetch?: typeof fetch;
+}
+declare class SchedulesApiError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+declare class SchedulesApiClient {
+    private readonly baseUrl?;
+    private readonly token?;
+    private readonly fetchImpl;
+    private readonly configurationError?;
+    constructor(options?: SchedulesApiClientOptions);
+    protected getToken(): Promise<string>;
+    protected request<T>(method: string, path: string, body?: unknown): Promise<T>;
+}
+
+declare const DEFAULT_SCHEDULES_BASE_URL = "https://vercel-schedules.com";
+
+type ScheduleExpression = {
+    type: 'cron';
+    cron: string;
+} | {
+    type: 'single';
+    /** Datetime in YYYY-MM-DDTHH:mm or YYYY-MM-DDTHH:mm:00 format, with no timezone suffix. */
+    at: string;
+};
+type ScheduleTarget = {
+    type: 'queue';
+    topic: string;
+} | {
+    type: 'function';
+    function: string;
+};
+type CreateScheduleTarget = {
+    topic: string;
+};
+type ScheduleState = 'active' | 'inactive';
+type ScheduleSource = 'static' | 'dynamic';
+interface Schedule {
+    scheduleId: string;
+    ownerId: string;
+    projectId: string;
+    trackId: string;
+    name: string;
+    namespace: string;
+    expression: ScheduleExpression;
+    /** IANA timezone used for cron expressions and one-time schedules. */
+    timezone: string;
+    jitter?: number;
+    target: ScheduleTarget;
+    state: ScheduleState;
+    source: ScheduleSource;
+    createdAt: number;
+    updatedAt: number;
+}
+interface CreateScheduleParams {
+    name: string;
+    namespace?: string;
+    expression: ScheduleExpression;
+    /** IANA timezone for cron expressions and local one-time schedules. Defaults to UTC. */
+    timezone?: string;
+    jitter?: number;
+    target: CreateScheduleTarget;
+    payload?: unknown;
+}
+type CreateScheduleResponse = Schedule & {
+    target: Extract<ScheduleTarget, {
+        type: 'queue';
+    }>;
+};
+interface ScheduleIdentifier {
+    name: string;
+    namespace?: string;
+}
+interface UpdateScheduleParams extends ScheduleIdentifier {
+    expression?: ScheduleExpression;
+    timezone?: string;
+    jitter?: number | null;
+    target?: CreateScheduleTarget;
+    payload?: unknown;
+}
+type UpdateScheduleResponse = Schedule;
+type InvokeScheduleParams = ScheduleIdentifier;
+interface ListSchedulesParams {
+    namespace?: string;
+    cursor?: string;
+    limit?: number;
+}
+interface ListSchedulesResponse {
+    data: Schedule[];
+    cursor: string | null;
+}
+
+declare class SchedulesClient extends SchedulesApiClient {
+    create({ target, ...params }: CreateScheduleParams): Promise<CreateScheduleResponse>;
+    list(params?: ListSchedulesParams): Promise<ListSchedulesResponse>;
+    get({ name, namespace }: ScheduleIdentifier): Promise<Schedule>;
+    update({ name, namespace, target, ...params }: UpdateScheduleParams): Promise<UpdateScheduleResponse>;
+    delete({ name, namespace }: ScheduleIdentifier): Promise<void>;
+    enable({ name, namespace }: ScheduleIdentifier): Promise<Schedule>;
+    disable({ name, namespace }: ScheduleIdentifier): Promise<Schedule>;
+    invoke({ name, namespace }: InvokeScheduleParams): Promise<void>;
+}
+
+declare const schedules: SchedulesClient;
+
+/** CloudEvent type used for schedule function dispatches. */
+declare const SCHEDULE_CLOUD_EVENT_TYPE = "com.vercel.schedule.v1beta";
+declare const CLOUD_EVENT_SPEC_VERSION_HEADER = "ce-specversion";
+declare const CLOUD_EVENT_TYPE_HEADER = "ce-type";
+declare const CLOUD_EVENT_SOURCE_HEADER = "ce-source";
+declare const CLOUD_EVENT_ID_HEADER = "ce-id";
+declare const SCHEDULE_SCHEDULED_AT_HEADER = "ce-vssscheduledat";
+declare const SCHEDULE_ID_HEADER = "ce-vssscheduleid";
+declare const SCHEDULE_NAME_HEADER = "ce-vssschedulename";
+declare const SCHEDULE_NAMESPACE_HEADER = "ce-vssnamespace";
+declare const SCHEDULE_SOURCE_HEADER = "ce-vssschedulesource";
+interface ScheduleMetadata {
+    /** Unique identifier of the schedule. */
+    scheduleId: string;
+    /** Unique identifier for this schedule occurrence. */
+    executionId: string;
+    /** Schedule name, unique within its project and namespace. */
+    name: string;
+    /** Namespace the schedule belongs to. */
+    namespace: string;
+    /**
+     * Nominal scheduled time for this occurrence, based on the schedule expression.
+     * Does not account for jitter. The dispatch may arrive later within the jitter window.
+     */
+    scheduledAt: Date;
+    /** How the schedule was defined, such as `static`. */
+    source: string;
+}
+type ScheduleHandler = (metadata: ScheduleMetadata) => void | Promise<void>;
+declare class ScheduleEventParseError extends Error {
+    cause?: unknown;
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** Parses schedule metadata from a binary-mode schedule CloudEvent. */
+declare function parseScheduleEvent(request: Request): Promise<ScheduleMetadata>;
+/**
+ * Creates a web-standard route handler for schedule dispatches.
+ *
+ * ```ts
+ * export const POST = handleSchedule(async (metadata) => {
+ *   console.log(metadata.name, metadata.scheduledAt);
+ * });
+ * ```
+ */
+declare function handleSchedule(handler: ScheduleHandler): (request: Request) => Promise<Response>;
+
+export { CLOUD_EVENT_ID_HEADER, CLOUD_EVENT_SOURCE_HEADER, CLOUD_EVENT_SPEC_VERSION_HEADER, CLOUD_EVENT_TYPE_HEADER, type CreateScheduleParams, type CreateScheduleResponse, type CreateScheduleTarget, DEFAULT_SCHEDULES_BASE_URL, type InvokeScheduleParams, type ListSchedulesParams, type ListSchedulesResponse, SCHEDULE_CLOUD_EVENT_TYPE, SCHEDULE_ID_HEADER, SCHEDULE_NAMESPACE_HEADER, SCHEDULE_NAME_HEADER, SCHEDULE_SCHEDULED_AT_HEADER, SCHEDULE_SOURCE_HEADER, type Schedule, ScheduleEventParseError, type ScheduleExpression, type ScheduleHandler, type ScheduleIdentifier, type ScheduleMetadata, type ScheduleSource, type ScheduleState, type ScheduleTarget, schedules as Schedules, type SchedulesApiClientOptions, SchedulesApiError, SchedulesClient, type UpdateScheduleParams, type UpdateScheduleResponse, handleSchedule, parseScheduleEvent };