@mastra/mcp 1.8.0 → 1.8.1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @mastra/mcp
 
+## 1.8.1
+
+### Patch Changes
+
+- Removed zod as a required peer dependency. Internal schemas now use plain JSON Schema objects instead of zod runtime. ([#16726](https://github.com/mastra-ai/mastra/pull/16726))
+
+- Updated dependencies [[`cfa2e3a`](https://github.com/mastra-ai/mastra/commit/cfa2e3a5292322f48bb28b4d257d631da7f9d3cc), [`0cbece9`](https://github.com/mastra-ai/mastra/commit/0cbece9d832cb134a74cdbf3682d390a058215a4), [`2f5f58a`](https://github.com/mastra-ai/mastra/commit/2f5f58a9a8bb13bcdc6789db221eef7c9bf1ff02), [`7dfe1bc`](https://github.com/mastra-ai/mastra/commit/7dfe1bcfe71d261a6fd6bbf29b1dec49d78fb98f), [`ac442a4`](https://github.com/mastra-ai/mastra/commit/ac442a42fda0354ac2bcea772bf6691cb3e9dbb3), [`b7286f4`](https://github.com/mastra-ai/mastra/commit/b7286f4308267f5fd70e6bfee10dba9472640906), [`6096445`](https://github.com/mastra-ai/mastra/commit/60964459733f0ab384584d95e19c36607ffdf7b0), [`d72dc4b`](https://github.com/mastra-ai/mastra/commit/d72dc4b12d832546c05c20255fa96fe4eb515900), [`a481027`](https://github.com/mastra-ai/mastra/commit/a481027b549ba1018414990c8f045eaee7b9f413), [`1e5c067`](https://github.com/mastra-ai/mastra/commit/1e5c067d2e20a781af670578180d1ee249806d41), [`168fa09`](https://github.com/mastra-ai/mastra/commit/168fa09d6b39114cb8c13bd06f1dccb9bc81c6cd), [`df1947a`](https://github.com/mastra-ai/mastra/commit/df1947affa40f742067542251fac7ca759492ef4), [`ee59b74`](https://github.com/mastra-ai/mastra/commit/ee59b743ce73ad11784b4d9c6fbba8568edee1c8), [`a97b1a0`](https://github.com/mastra-ai/mastra/commit/a97b1a0abaed83946c3519d1e0f680d0815b8a67), [`008baaf`](https://github.com/mastra-ai/mastra/commit/008baafd8d851f831407045aebead5a2e3342eff), [`801baa0`](https://github.com/mastra-ai/mastra/commit/801baa07cccdbaec1d00942a92bdc831111744a2), [`8116436`](https://github.com/mastra-ai/mastra/commit/81164363eb225d774e41ff27da6a5ea611406688), [`c35b962`](https://github.com/mastra-ai/mastra/commit/c35b9625c7e854fcfdeee226a3338a750d0ff211), [`c27c4b9`](https://github.com/mastra-ai/mastra/commit/c27c4b9f137df5414fca4e45896aceccff6b0ed5), [`08b3b59`](https://github.com/mastra-ai/mastra/commit/08b3b590dd960dee6c9a6e39272f8927d803db6e), [`b3c3b18`](https://github.com/mastra-ai/mastra/commit/b3c3b189121489a3a51a8fd8204b569be9a89fe5), [`4084113`](https://github.com/mastra-ai/mastra/commit/408411370fc48a822e8b616b3b63f9409774e0e9), [`70cb714`](https://github.com/mastra-ai/mastra/commit/70cb7149c8f16f478e15b58498254a53181750a4), [`91cf0e0`](https://github.com/mastra-ai/mastra/commit/91cf0e027e511b871481a8576b56b7af83b15afd), [`7f9da22`](https://github.com/mastra-ai/mastra/commit/7f9da22efd5aa595e138a31de55a5f0f2f28b33d)]:
+  - @mastra/core@1.37.0
+
+## 1.8.1-alpha.0
+
+### Patch Changes
+
+- Removed zod as a required peer dependency. Internal schemas now use plain JSON Schema objects instead of zod runtime. ([#16726](https://github.com/mastra-ai/mastra/pull/16726))
+
+- Updated dependencies [[`c35b962`](https://github.com/mastra-ai/mastra/commit/c35b9625c7e854fcfdeee226a3338a750d0ff211), [`4084113`](https://github.com/mastra-ai/mastra/commit/408411370fc48a822e8b616b3b63f9409774e0e9)]:
+  - @mastra/core@1.37.0-alpha.8
+
 ## 1.8.0
 
 ### Minor Changes

package/dist/_types/hono/dist/types/client/client.d.ts

@@ -0,0 +1,4 @@
+import type { Hono } from '../hono';
+import type { UnionToIntersection } from '../utils/types';
+import type { Client, ClientRequestOptions } from './types';
+export declare const hc: <T extends Hono<any, any, any>, Prefix extends string = string>(baseUrl: Prefix, options?: ClientRequestOptions) => UnionToIntersection<Client<T, Prefix>>;

package/dist/_types/hono/dist/types/client/fetch-result-please.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @description This file is a modified version of `fetch-result-please` (`ofetch`), minimalized and adapted to Hono's custom needs.
+ *
+ * @link https://www.npmjs.com/package/fetch-result-please
+ */
+/**
+ * Smartly parses and return the consumable result from a fetch `Response`.
+ *
+ * Throwing a structured error if the response is not `ok`. ({@link DetailedError})
+ */
+export declare function fetchRP(fetchRes: Response | Promise<Response>): Promise<any>;
+export declare class DetailedError extends Error {
+    /**
+     * Additional `message` that will be logged AND returned to client
+     */
+    detail?: any;
+    /**
+     * Additional `code` that will be logged AND returned to client
+     */
+    code?: any;
+    /**
+     * Additional value that will be logged AND NOT returned to client
+     */
+    log?: any;
+    /**
+     * Optionally set the status code to return, in a web server context
+     */
+    statusCode?: any;
+    constructor(message: string, options?: {
+        detail?: any;
+        code?: any;
+        statusCode?: number;
+        log?: any;
+    });
+}

package/dist/_types/hono/dist/types/client/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @module
+ * The HTTP Client for Hono.
+ */
+export { hc } from './client';
+export { parseResponse, DetailedError } from './utils';
+export type { InferResponseType, InferRequestType, Fetch, ClientRequestOptions, ClientRequest, ClientResponse, ApplyGlobalResponse, PickResponseByStatusCode, } from './types';

package/dist/_types/hono/dist/types/client/types.d.ts

@@ -0,0 +1,229 @@
+import type { Hono } from '../hono';
+import type { HonoBase } from '../hono-base';
+import type { METHODS, METHOD_NAME_ALL_LOWERCASE } from '../router';
+import type { Endpoint, ExtractSchema, KnownResponseFormat, ResponseFormat, Schema } from '../types';
+import type { StatusCode, SuccessStatusCode } from '../utils/http-status';
+import type { HasRequiredKeys } from '../utils/types';
+/**
+ * Type representing the '$all' method name
+ */
+type MethodNameAll = `$${typeof METHOD_NAME_ALL_LOWERCASE}`;
+/**
+ * Type representing all standard HTTP methods prefixed with '$'
+ * e.g., '$get' | '$post' | '$put' | '$delete' | '$options' | '$patch'
+ */
+type StandardMethods = `$${(typeof METHODS)[number]}`;
+/**
+ * Expands '$all' into all standard HTTP methods.
+ * If the schema contains '$all', it creates a type where all standard HTTP methods
+ * point to the same endpoint definition as '$all', while removing '$all' itself.
+ */
+type ExpandAllMethod<S> = MethodNameAll extends keyof S ? {
+    [M in StandardMethods]: S[MethodNameAll];
+} & Omit<S, MethodNameAll> : S;
+type HonoRequest = (typeof Hono.prototype)['request'];
+export type BuildSearchParamsFn = (query: Record<string, string | string[]>) => URLSearchParams;
+export type ClientRequestOptions<T = unknown> = {
+    fetch?: typeof fetch | HonoRequest;
+    webSocket?: (...args: ConstructorParameters<typeof WebSocket>) => WebSocket;
+    /**
+     * Standard `RequestInit`, caution that this take highest priority
+     * and could be used to overwrite things that Hono sets for you, like `body | method | headers`.
+     *
+     * If you want to add some headers, use in `headers` instead of `init`
+     */
+    init?: RequestInit;
+    /**
+     * Custom function to serialize query parameters into URLSearchParams.
+     * By default, arrays are serialized as multiple parameters with the same key (e.g., `key=a&key=b`).
+     * You can provide a custom function to change this behavior, for example to use bracket notation (e.g., `key[]=a&key[]=b`).
+     *
+     * @example
+     * ```ts
+     * const client = hc('http://localhost', {
+     *   buildSearchParams: (query) => {
+     *     return new URLSearchParams(qs.stringify(query))
+     *   }
+     * })
+     * ```
+     */
+    buildSearchParams?: BuildSearchParamsFn;
+} & (keyof T extends never ? {
+    headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+} : {
+    headers: T | (() => T | Promise<T>);
+});
+export type ClientRequest<Prefix extends string, Path extends string, S extends Schema> = {
+    [M in keyof ExpandAllMethod<S>]: ExpandAllMethod<S>[M] extends Endpoint & {
+        input: infer R;
+    } ? R extends object ? HasRequiredKeys<R> extends true ? (args: R, options?: ClientRequestOptions) => Promise<ClientResponseOfEndpoint<ExpandAllMethod<S>[M]>> : (args?: R, options?: ClientRequestOptions) => Promise<ClientResponseOfEndpoint<ExpandAllMethod<S>[M]>> : never : never;
+} & {
+    $url: <const Arg extends (S[keyof S] extends {
+        input: infer R;
+    } ? R extends {
+        param: infer P;
+    } ? R extends {
+        query: infer Q;
+    } ? {
+        param: P;
+        query: Q;
+    } : {
+        param: P;
+    } : R extends {
+        query: infer Q;
+    } ? {
+        query: Q;
+    } : {} : {}) | undefined = undefined>(arg?: Arg) => HonoURL<Prefix, Path, Arg>;
+    $path: <const Arg extends (S[keyof S] extends {
+        input: infer R;
+    } ? R extends {
+        param: infer P;
+    } ? R extends {
+        query: infer Q;
+    } ? {
+        param: P;
+        query: Q;
+    } : {
+        param: P;
+    } : R extends {
+        query: infer Q;
+    } ? {
+        query: Q;
+    } : {} : {}) | undefined = undefined>(arg?: Arg) => BuildPath<Path, Arg>;
+} & (S['$get'] extends {
+    outputFormat: 'ws';
+} ? S['$get'] extends {
+    input: infer I;
+} ? {
+    $ws: (args?: I) => WebSocket;
+} : {} : {});
+type ClientResponseOfEndpoint<T extends Endpoint = Endpoint> = T extends {
+    output: infer O;
+    outputFormat: infer F;
+    status: infer S;
+} ? ClientResponse<O, S extends number ? S : never, F extends ResponseFormat ? F : never> : never;
+export interface ClientResponse<T, U extends number = StatusCode, F extends ResponseFormat = ResponseFormat> {
+    readonly body: ReadableStream | null;
+    readonly bodyUsed: boolean;
+    ok: U extends SuccessStatusCode ? true : U extends Exclude<StatusCode, SuccessStatusCode> ? false : boolean;
+    redirected: boolean;
+    status: U;
+    statusText: string;
+    type: 'basic' | 'cors' | 'default' | 'error' | 'opaque' | 'opaqueredirect';
+    headers: Headers;
+    url: string;
+    redirect(url: string, status: number): Response;
+    clone(): Response;
+    bytes(): Promise<Uint8Array<ArrayBuffer>>;
+    json(): F extends 'text' ? Promise<never> : F extends 'json' ? Promise<T> : Promise<unknown>;
+    text(): F extends 'text' ? (T extends string ? Promise<T> : Promise<never>) : Promise<string>;
+    blob(): Promise<Blob>;
+    formData(): Promise<FormData>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+}
+type BuildSearch<Arg, Key extends 'query'> = Arg extends {
+    [K in Key]: infer Query;
+} ? IsEmptyObject<Query> extends true ? '' : `?${string}` : '';
+type BuildPathname<P extends string, Arg> = Arg extends {
+    param: infer Param;
+} ? `${ApplyParam<TrimStartSlash<P>, Param>}` : `/${TrimStartSlash<P>}`;
+type BuildPath<P extends string, Arg> = `${BuildPathname<P, Arg>}${BuildSearch<Arg, 'query'>}`;
+type BuildTypedURL<Protocol extends string, Host extends string, Port extends string, P extends string, Arg> = TypedURL<`${Protocol}:`, Host, Port, BuildPathname<P, Arg>, BuildSearch<Arg, 'query'>>;
+type HonoURL<Prefix extends string, Path extends string, Arg> = IsLiteral<Prefix> extends true ? TrimEndSlash<Prefix> extends `${infer Protocol}://${infer Rest}` ? Rest extends `${infer Hostname}/${infer P}` ? ParseHostName<Hostname> extends [infer Host extends string, infer Port extends string] ? BuildTypedURL<Protocol, Host, Port, P, Arg> : never : ParseHostName<Rest> extends [infer Host extends string, infer Port extends string] ? BuildTypedURL<Protocol, Host, Port, Path, Arg> : never : URL : URL;
+type ParseHostName<T extends string> = T extends `${infer Host}:${infer Port}` ? [Host, Port] : [T, ''];
+type TrimStartSlash<T extends string> = T extends `/${infer R}` ? TrimStartSlash<R> : T;
+type TrimEndSlash<T extends string> = T extends `${infer R}/` ? TrimEndSlash<R> : T;
+type IsLiteral<T extends string> = [T] extends [never] ? false : string extends T ? false : true;
+type ApplyParam<Path extends string, P, Result extends string = ''> = Path extends `${infer Head}/${infer Rest}` ? Head extends `:${infer Param}` ? P extends Record<Param, infer Value extends string> ? IsLiteral<Value> extends true ? ApplyParam<Rest, P, `${Result}/${Value & string}`> : ApplyParam<Rest, P, `${Result}/${Head}`> : ApplyParam<Rest, P, `${Result}/${Head}`> : ApplyParam<Rest, P, `${Result}/${Head}`> : Path extends `:${infer Param}` ? P extends Record<Param, infer Value extends string> ? IsLiteral<Value> extends true ? `${Result}/${Value & string}` : `${Result}/${Path}` : `${Result}/${Path}` : `${Result}/${Path}`;
+type IsEmptyObject<T> = keyof T extends never ? true : false;
+export interface TypedURL<Protocol extends string, Hostname extends string, Port extends string, Pathname extends string, Search extends string> extends URL {
+    protocol: Protocol;
+    hostname: Hostname;
+    port: Port;
+    host: Port extends '' ? Hostname : `${Hostname}:${Port}`;
+    origin: `${Protocol}//${Hostname}${Port extends '' ? '' : `:${Port}`}`;
+    pathname: Pathname;
+    search: Search;
+    href: `${Protocol}//${Hostname}${Port extends '' ? '' : `:${Port}`}${Pathname}${Search}`;
+}
+export interface Response extends ClientResponse<unknown> {
+}
+export type Fetch<T> = (args?: InferRequestType<T>, opt?: ClientRequestOptions) => Promise<ClientResponseOfEndpoint<InferEndpointType<T>>>;
+type InferEndpointType<T> = T extends (args: infer R, options: any | undefined) => Promise<infer U> ? U extends ClientResponse<infer O, infer S, infer F> ? {
+    input: NonNullable<R>;
+    output: O;
+    outputFormat: F;
+    status: S;
+} extends Endpoint ? {
+    input: NonNullable<R>;
+    output: O;
+    outputFormat: F;
+    status: S;
+} : never : never : never;
+export type InferResponseType<T, U extends StatusCode = StatusCode> = InferResponseTypeFromEndpoint<InferEndpointType<T>, U>;
+type InferResponseTypeFromEndpoint<T extends Endpoint, U extends StatusCode> = T extends {
+    output: infer O;
+    status: infer S;
+} ? S extends U ? O : never : never;
+export type InferRequestType<T> = T extends (args: infer R, options: any | undefined) => Promise<ClientResponse<unknown>> ? NonNullable<R> : never;
+export type InferRequestOptionsType<T> = T extends (args: any, options: infer R) => Promise<ClientResponse<unknown>> ? NonNullable<R> : never;
+/**
+ * Filter a ClientResponse type so it only includes responses of specific status codes.
+ */
+export type FilterClientResponseByStatusCode<T extends ClientResponse<any, any, any>, U extends number = StatusCode> = T extends ClientResponse<infer RT, infer RC, infer RF> ? RC extends U ? ClientResponse<RT, RC, RF> : never : never;
+type PathToChain<Prefix extends string, Path extends string, E extends Schema, Original extends string = Path> = Path extends `/${infer P}` ? PathToChain<Prefix, P, E, Path> : Path extends `${infer P}/${infer R}` ? {
+    [K in P]: PathToChain<Prefix, R, E, Original>;
+} : {
+    [K in Path extends '' ? 'index' : Path]: ClientRequest<Prefix, Original, E extends Record<string, unknown> ? E[Original] : never>;
+};
+export type Client<T, Prefix extends string> = T extends HonoBase<any, infer S, any> ? S extends Record<infer K, Schema> ? K extends string ? PathToChain<Prefix, K, S> : never : never : never;
+export type Callback = (opts: CallbackOptions) => unknown;
+interface CallbackOptions {
+    path: string[];
+    args: any[];
+}
+export type ObjectType<T = unknown> = {
+    [key: string]: T;
+};
+type GlobalResponseDefinition = {
+    [S in StatusCode]?: {
+        [F in KnownResponseFormat]?: unknown;
+    };
+};
+type ToEndpoints<Def extends GlobalResponseDefinition, R> = {
+    [S in keyof Def & StatusCode]: {
+        [F in keyof Def[S] & KnownResponseFormat]: Omit<R, 'output' | 'status' | 'outputFormat'> & {
+            output: Def[S][F];
+            status: S;
+            outputFormat: F;
+        };
+    }[keyof Def[S] & KnownResponseFormat];
+}[keyof Def & StatusCode];
+type ModRoute<R, Def extends GlobalResponseDefinition> = R extends Endpoint ? R | ToEndpoints<Def, R> : R;
+type ModSchema<D, Def extends GlobalResponseDefinition> = {
+    [K in keyof D]: {
+        [M in keyof D[K]]: ModRoute<D[K][M], Def>;
+    };
+};
+export type ApplyGlobalResponse<App, Def extends GlobalResponseDefinition> = App extends HonoBase<infer E, infer _ extends Schema, infer B> ? ModSchema<ExtractSchema<App>, Def> extends infer S extends Schema ? Hono<E, S, B> : never : never;
+type PickRoute<R, U extends StatusCode> = R extends Endpoint ? R extends {
+    status: U;
+} ? R : never : R;
+type PickSchema<D, U extends StatusCode> = {
+    [K in keyof D]: {
+        [M in keyof D[K]]: PickRoute<D[K][M], U>;
+    };
+};
+/**
+ * Keep only specific status code responses from all routes of an app.
+ * Useful when error responses are handled centrally (e.g., via custom fetch)
+ * and you want the client to only expose success response types.
+ *
+ * @example
+ * ```ts
+ * type AppSuccessOnly = PickResponseByStatusCode<typeof app, 200>
+ * const client = hc<AppSuccessOnly>('http://localhost')
+ * ```
+ */
+export type PickResponseByStatusCode<App, U extends StatusCode> = App extends HonoBase<infer E, infer _ extends Schema, infer B> ? PickSchema<ExtractSchema<App>, U> extends infer S extends Schema ? Hono<E, S, B> : never : never;
+export {};

package/dist/_types/hono/dist/types/client/utils.d.ts

@@ -0,0 +1,18 @@
+import type { ClientErrorStatusCode, ContentfulStatusCode, ServerErrorStatusCode } from '../utils/http-status';
+import { DetailedError } from './fetch-result-please';
+import type { ClientResponse, FilterClientResponseByStatusCode } from './types';
+export { DetailedError };
+export declare const mergePath: (base: string, path: string) => string;
+export declare const replaceUrlParam: (urlString: string, params: Record<string, string | undefined>) => string;
+export declare const buildSearchParams: (query: Record<string, string | string[]>) => URLSearchParams;
+export declare const replaceUrlProtocol: (urlString: string, protocol: "ws" | "http") => string;
+export declare const removeIndexString: (urlString: string) => string;
+export declare function deepMerge<T>(target: T, source: Record<string, unknown>): T;
+/**
+ * Shortcut to get a consumable response from `hc`'s fetch calls (Response), with types inference.
+ *
+ * Smartly parse the response data, throwing a structured error if the response is not `ok`. ({@link DetailedError})
+ *
+ * @example const result = await parseResponse(client.posts.$get())
+ */
+export declare function parseResponse<T extends ClientResponse<any>>(fetchRes: T | Promise<T>): Promise<FilterClientResponseByStatusCode<T, Exclude<ContentfulStatusCode, ClientErrorStatusCode | ServerErrorStatusCode>> extends never ? undefined : FilterClientResponseByStatusCode<T, Exclude<ContentfulStatusCode, ClientErrorStatusCode | ServerErrorStatusCode>> extends ClientResponse<infer RT, infer _, infer RF> ? RF extends 'json' ? RT : RT extends string ? RT : string : undefined>;