@mastra/mcp 1.8.0 → 1.8.1

package/dist/_types/hono/dist/types/hono-base.d.ts

@@ -0,0 +1,220 @@
+/**
+ * @module
+ * This module is the base module for the Hono object.
+ */
+import { Context } from './context';
+import type { ExecutionContext } from './context';
+import type { Router } from './router';
+import type { Env, ErrorHandler, H, HandlerInterface, MergePath, MergeSchemaPath, MiddlewareHandlerInterface, NotFoundHandler, OnHandlerInterface, RouterRoute, Schema } from './types';
+type GetPath<E extends Env> = (request: Request, options?: {
+    env?: E['Bindings'];
+}) => string;
+export type HonoOptions<E extends Env> = {
+    /**
+     * `strict` option specifies whether to distinguish whether the last path is a directory or not.
+     *
+     * @see {@link https://hono.dev/docs/api/hono#strict-mode}
+     *
+     * @default true
+     */
+    strict?: boolean;
+    /**
+     * `router` option specifies which router to use.
+     *
+     * @see {@link https://hono.dev/docs/api/hono#router-option}
+     *
+     * @example
+     * ```ts
+     * const app = new Hono({ router: new RegExpRouter() })
+     * ```
+     */
+    router?: Router<[H, RouterRoute]>;
+    /**
+     * `getPath` can handle the host header value.
+     *
+     * @see {@link https://hono.dev/docs/api/routing#routing-with-host-header-value}
+     *
+     * @example
+     * ```ts
+     * const app = new Hono({
+     *  getPath: (req) =>
+     *   '/' + req.headers.get('host') + req.url.replace(/^https?:\/\/[^/]+(\/[^?]*)/, '$1'),
+     * })
+     *
+     * app.get('/www1.example.com/hello', () => c.text('hello www1'))
+     *
+     * // A following request will match the route:
+     * // new Request('http://www1.example.com/hello', {
+     * //  headers: { host: 'www1.example.com' },
+     * // })
+     * ```
+     */
+    getPath?: GetPath<E>;
+};
+type MountOptionHandler = (c: Context) => unknown;
+type MountReplaceRequest = (originalRequest: Request) => Request;
+type MountOptions = MountOptionHandler | {
+    optionHandler?: MountOptionHandler;
+    replaceRequest?: MountReplaceRequest | false;
+};
+declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/', CurrentPath extends string = BasePath> {
+             
+    get: HandlerInterface<E, 'get', S, BasePath, CurrentPath>;
+    post: HandlerInterface<E, 'post', S, BasePath, CurrentPath>;
+    put: HandlerInterface<E, 'put', S, BasePath, CurrentPath>;
+    delete: HandlerInterface<E, 'delete', S, BasePath, CurrentPath>;
+    options: HandlerInterface<E, 'options', S, BasePath, CurrentPath>;
+    patch: HandlerInterface<E, 'patch', S, BasePath, CurrentPath>;
+    all: HandlerInterface<E, 'all', S, BasePath, CurrentPath>;
+    on: OnHandlerInterface<E, S, BasePath>;
+    use: MiddlewareHandlerInterface<E, S, BasePath>;
+    router: Router<[H, RouterRoute]>;
+    readonly getPath: GetPath<E>;
+    private _basePath;
+    routes: RouterRoute[];
+    constructor(options?: HonoOptions<E>);
+    private errorHandler;
+    /**
+     * `.route()` allows grouping other Hono instance in routes.
+     *
+     * @see {@link https://hono.dev/docs/api/routing#grouping}
+     *
+     * @param {string} path - base Path
+     * @param {Hono} app - other Hono instance
+     * @returns {Hono} routed Hono instance
+     *
+     * @example
+     * ```ts
+     * const app = new Hono()
+     * const app2 = new Hono()
+     *
+     * app2.get("/user", (c) => c.text("user"))
+     * app.route("/api", app2) // GET /api/user
+     * ```
+     */
+    route<SubPath extends string, SubEnv extends Env, SubSchema extends Schema, SubBasePath extends string, SubCurrentPath extends string>(path: SubPath, app: Hono<SubEnv, SubSchema, SubBasePath, SubCurrentPath>): Hono<E, MergeSchemaPath<SubSchema, MergePath<BasePath, SubPath>> | S, BasePath, CurrentPath>;
+    /**
+     * `.basePath()` allows base paths to be specified.
+     *
+     * @see {@link https://hono.dev/docs/api/routing#base-path}
+     *
+     * @param {string} path - base Path
+     * @returns {Hono} changed Hono instance
+     *
+     * @example
+     * ```ts
+     * const api = new Hono().basePath('/api')
+     * ```
+     */
+    basePath<SubPath extends string>(path: SubPath): Hono<E, S, MergePath<BasePath, SubPath>, MergePath<BasePath, SubPath>>;
+    /**
+     * `.onError()` handles an error and returns a customized Response.
+     *
+     * @see {@link https://hono.dev/docs/api/hono#error-handling}
+     *
+     * @param {ErrorHandler} handler - request Handler for error
+     * @returns {Hono} changed Hono instance
+     *
+     * @example
+     * ```ts
+     * app.onError((err, c) => {
+     *   console.error(`${err}`)
+     *   return c.text('Custom Error Message', 500)
+     * })
+     * ```
+     */
+    onError: (handler: ErrorHandler<E>) => Hono<E, S, BasePath, CurrentPath>;
+    /**
+     * `.notFound()` allows you to customize a Not Found Response.
+     *
+     * @see {@link https://hono.dev/docs/api/hono#not-found}
+     *
+     * @param {NotFoundHandler} handler - request handler for not-found
+     * @returns {Hono} changed Hono instance
+     *
+     * @example
+     * ```ts
+     * app.notFound((c) => {
+     *   return c.text('Custom 404 Message', 404)
+     * })
+     * ```
+     */
+    notFound: (handler: NotFoundHandler<E>) => Hono<E, S, BasePath, CurrentPath>;
+    /**
+     * `.mount()` allows you to mount applications built with other frameworks into your Hono application.
+     *
+     * @see {@link https://hono.dev/docs/api/hono#mount}
+     *
+     * @param {string} path - base Path
+     * @param {Function} applicationHandler - other Request Handler
+     * @param {MountOptions} [options] - options of `.mount()`
+     * @returns {Hono} mounted Hono instance
+     *
+     * @example
+     * ```ts
+     * import { Router as IttyRouter } from 'itty-router'
+     * import { Hono } from 'hono'
+     * // Create itty-router application
+     * const ittyRouter = IttyRouter()
+     * // GET /itty-router/hello
+     * ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
+     *
+     * const app = new Hono()
+     * app.mount('/itty-router', ittyRouter.handle)
+     * ```
+     *
+     * @example
+     * ```ts
+     * const app = new Hono()
+     * // Send the request to another application without modification.
+     * app.mount('/app', anotherApp, {
+     *   replaceRequest: (req) => req,
+     * })
+     * ```
+     */
+    mount(path: string, applicationHandler: (request: Request, ...args: any) => Response | Promise<Response>, options?: MountOptions): Hono<E, S, BasePath, CurrentPath>;
+    /**
+     * `.fetch()` will be entry point of your app.
+     *
+     * @see {@link https://hono.dev/docs/api/hono#fetch}
+     *
+     * @param {Request} request - request Object of request
+     * @param {Env} Env - env Object
+     * @param {ExecutionContext} - context of execution
+     * @returns {Response | Promise<Response>} response of request
+     *
+     */
+    fetch: (request: Request, Env?: E['Bindings'] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
+    /**
+     * `.request()` is a useful method for testing.
+     * You can pass a URL or pathname to send a GET request.
+     * app will return a Response object.
+     * ```ts
+     * test('GET /hello is ok', async () => {
+     *   const res = await app.request('/hello')
+     *   expect(res.status).toBe(200)
+     * })
+     * ```
+     * @see https://hono.dev/docs/api/hono#request
+     */
+    request: (input: Request | string | URL, requestInit?: RequestInit, Env?: E["Bindings"] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
+    /**
+     * `.fire()` automatically adds a global fetch event listener.
+     * This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
+     * @deprecated
+     * Use `fire` from `hono/service-worker` instead.
+     * ```ts
+     * import { Hono } from 'hono'
+     * import { fire } from 'hono/service-worker'
+     *
+     * const app = new Hono()
+     * // ...
+     * fire(app)
+     * ```
+     * @see https://hono.dev/docs/api/hono#fire
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
+     * @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/
+     */
+    fire: () => void;
+}
+export { Hono as HonoBase };

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

@@ -0,0 +1,19 @@
+import { HonoBase } from './hono-base';
+import type { HonoOptions } from './hono-base';
+import type { BlankEnv, BlankSchema, Env, Schema } from './types';
+/**
+ * The Hono class extends the functionality of the HonoBase class.
+ * It sets up routing and allows for custom options to be passed.
+ *
+ * @template E - The environment type.
+ * @template S - The schema type.
+ * @template BasePath - The base path type.
+ */
+export declare class Hono<E extends Env = BlankEnv, S extends Schema = BlankSchema, BasePath extends string = '/'> extends HonoBase<E, S, BasePath> {
+    /**
+     * Creates an instance of the Hono class.
+     *
+     * @param options - Optional configuration options for the Hono instance.
+     */
+    constructor(options?: HonoOptions<E>);
+}

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

@@ -0,0 +1,36 @@
+/**
+ * @module
+ *
+ * Hono - Web Framework built on Web Standards
+ *
+ * @example
+ * ```ts
+ * import { Hono } from 'hono'
+ * const app = new Hono()
+ *
+ * app.get('/', (c) => c.text('Hono!'))
+ *
+ * export default app
+ * ```
+ */
+import { Hono } from './hono';
+/**
+ * Types for environment variables, error handlers, handlers, middleware handlers, and more.
+ */
+export type { Env, ErrorHandler, Handler, MiddlewareHandler, Next, NotFoundResponse, NotFoundHandler, ValidationTargets, Input, Schema, ToSchema, TypedResponse, } from './types';
+/**
+ * Types for context, context variable map, context renderer, and execution context.
+ */
+export type { Context, ContextVariableMap, ContextRenderer, ExecutionContext } from './context';
+/**
+ * Type for HonoRequest.
+ */
+export type { HonoRequest } from './request';
+/**
+ * Types for inferring request and response types and client request options.
+ */
+export type { InferRequestType, InferResponseType, ClientRequestOptions } from './client';
+/**
+ * Hono framework for building web applications.
+ */
+export { Hono };

package/dist/_types/hono/dist/types/request/constants.d.ts

@@ -0,0 +1 @@
+export declare const GET_MATCH_RESULT: unique symbol;

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

@@ -0,0 +1,311 @@
+import { GET_MATCH_RESULT } from './request/constants';
+import type { Result } from './router';
+import type { Input, InputToDataByTarget, ParamKeyToRecord, ParamKeys, RemoveQuestion, RouterRoute, ValidationTargets } from './types';
+import type { BodyData, ParseBodyOptions } from './utils/body';
+import type { CustomHeader, RequestHeader } from './utils/headers';
+import type { Simplify, UnionToIntersection } from './utils/types';
+type Body = {
+    json: any;
+    text: string;
+    arrayBuffer: ArrayBuffer;
+    blob: Blob;
+    formData: FormData;
+};
+type BodyCache = Partial<Body>;
+export declare class HonoRequest<P extends string = '/', I extends Input['out'] = {}> {
+             
+    /**
+     * `.raw` can get the raw Request object.
+     *
+     * @see {@link https://hono.dev/docs/api/request#raw}
+     *
+     * @example
+     * ```ts
+     * // For Cloudflare Workers
+     * app.post('/', async (c) => {
+     *   const metadata = c.req.raw.cf?.hostMetadata?
+     *   ...
+     * })
+     * ```
+     */
+    raw: Request;
+    routeIndex: number;
+    /**
+     * `.path` can get the pathname of the request.
+     *
+     * @see {@link https://hono.dev/docs/api/request#path}
+     *
+     * @example
+     * ```ts
+     * app.get('/about/me', (c) => {
+     *   const pathname = c.req.path // `/about/me`
+     * })
+     * ```
+     */
+    path: string;
+    bodyCache: BodyCache;
+    constructor(request: Request, path?: string, matchResult?: Result<[unknown, RouterRoute]>);
+    /**
+     * `.req.param()` gets the path parameters.
+     *
+     * @see {@link https://hono.dev/docs/api/routing#path-parameter}
+     *
+     * @example
+     * ```ts
+     * const name = c.req.param('name')
+     * // or all parameters at once
+     * const { id, comment_id } = c.req.param()
+     * ```
+     */
+    param<P2 extends ParamKeys<P> = ParamKeys<P>>(key: string extends P ? never : P2 extends `${infer _}?` ? never : P2): string;
+    param<P2 extends RemoveQuestion<ParamKeys<P>> = RemoveQuestion<ParamKeys<P>>>(key: P2): string | undefined;
+    param(key: string): string | undefined;
+    param<P2 extends string = P>(): Simplify<UnionToIntersection<ParamKeyToRecord<ParamKeys<P2>>>>;
+    /**
+     * `.query()` can get querystring parameters.
+     *
+     * @see {@link https://hono.dev/docs/api/request#query}
+     *
+     * @example
+     * ```ts
+     * // Query params
+     * app.get('/search', (c) => {
+     *   const query = c.req.query('q')
+     * })
+     *
+     * // Get all params at once
+     * app.get('/search', (c) => {
+     *   const { q, limit, offset } = c.req.query()
+     * })
+     * ```
+     */
+    query(key: string): string | undefined;
+    query(): Record<string, string>;
+    /**
+     * `.queries()` can get multiple querystring parameter values, e.g. /search?tags=A&tags=B
+     *
+     * @see {@link https://hono.dev/docs/api/request#queries}
+     *
+     * @example
+     * ```ts
+     * app.get('/search', (c) => {
+     *   // tags will be string[]
+     *   const tags = c.req.queries('tags')
+     * })
+     * ```
+     */
+    queries(key: string): string[] | undefined;
+    queries(): Record<string, string[]>;
+    /**
+     * `.header()` can get the request header value.
+     *
+     * @see {@link https://hono.dev/docs/api/request#header}
+     *
+     * @example
+     * ```ts
+     * app.get('/', (c) => {
+     *   const userAgent = c.req.header('User-Agent')
+     * })
+     * ```
+     */
+    header(name: RequestHeader): string | undefined;
+    header(name: string): string | undefined;
+    header(): Record<RequestHeader | (string & CustomHeader), string>;
+    /**
+     * `.parseBody()` can parse Request body of type `multipart/form-data` or `application/x-www-form-urlencoded`
+     *
+     * @see {@link https://hono.dev/docs/api/request#parsebody}
+     *
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.parseBody()
+     * })
+     * ```
+     */
+    parseBody<Options extends Partial<ParseBodyOptions>, T extends BodyData<Options>>(options?: Options): Promise<T>;
+    parseBody<T extends BodyData>(options?: Partial<ParseBodyOptions>): Promise<T>;
+    /**
+     * `.json()` can parse Request body of type `application/json`
+     *
+     * @see {@link https://hono.dev/docs/api/request#json}
+     *
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.json()
+     * })
+     * ```
+     */
+    json<T = any>(): Promise<T>;
+    /**
+     * `.text()` can parse Request body of type `text/plain`
+     *
+     * @see {@link https://hono.dev/docs/api/request#text}
+     *
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.text()
+     * })
+     * ```
+     */
+    text(): Promise<string>;
+    /**
+     * `.arrayBuffer()` parse Request body as an `ArrayBuffer`
+     *
+     * @see {@link https://hono.dev/docs/api/request#arraybuffer}
+     *
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.arrayBuffer()
+     * })
+     * ```
+     */
+    arrayBuffer(): Promise<ArrayBuffer>;
+    /**
+     * Parses the request body as a `Blob`.
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.blob();
+     * });
+     * ```
+     * @see https://hono.dev/docs/api/request#blob
+     */
+    blob(): Promise<Blob>;
+    /**
+     * Parses the request body as `FormData`.
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.formData();
+     * });
+     * ```
+     * @see https://hono.dev/docs/api/request#formdata
+     */
+    formData(): Promise<FormData>;
+    /**
+     * Adds validated data to the request.
+     *
+     * @param target - The target of the validation.
+     * @param data - The validated data to add.
+     */
+    addValidatedData(target: keyof ValidationTargets, data: {}): void;
+    /**
+     * Gets validated data from the request.
+     *
+     * @param target - The target of the validation.
+     * @returns The validated data.
+     *
+     * @see https://hono.dev/docs/api/request#valid
+     */
+    valid<T extends keyof I & keyof ValidationTargets>(target: T): InputToDataByTarget<I, T>;
+    /**
+     * `.url()` can get the request url strings.
+     *
+     * @see {@link https://hono.dev/docs/api/request#url}
+     *
+     * @example
+     * ```ts
+     * app.get('/about/me', (c) => {
+     *   const url = c.req.url // `http://localhost:8787/about/me`
+     *   ...
+     * })
+     * ```
+     */
+    get url(): string;
+    /**
+     * `.method()` can get the method name of the request.
+     *
+     * @see {@link https://hono.dev/docs/api/request#method}
+     *
+     * @example
+     * ```ts
+     * app.get('/about/me', (c) => {
+     *   const method = c.req.method // `GET`
+     * })
+     * ```
+     */
+    get method(): string;
+    get [GET_MATCH_RESULT](): Result<[unknown, RouterRoute]>;
+    /**
+     * `.matchedRoutes()` can return a matched route in the handler
+     *
+     * @deprecated
+     *
+     * Use matchedRoutes helper defined in "hono/route" instead.
+     *
+     * @see {@link https://hono.dev/docs/api/request#matchedroutes}
+     *
+     * @example
+     * ```ts
+     * app.use('*', async function logger(c, next) {
+     *   await next()
+     *   c.req.matchedRoutes.forEach(({ handler, method, path }, i) => {
+     *     const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
+     *     console.log(
+     *       method,
+     *       ' ',
+     *       path,
+     *       ' '.repeat(Math.max(10 - path.length, 0)),
+     *       name,
+     *       i === c.req.routeIndex ? '<- respond from here' : ''
+     *     )
+     *   })
+     * })
+     * ```
+     */
+    get matchedRoutes(): RouterRoute[];
+    /**
+     * `routePath()` can retrieve the path registered within the handler
+     *
+     * @deprecated
+     *
+     * Use routePath helper defined in "hono/route" instead.
+     *
+     * @see {@link https://hono.dev/docs/api/request#routepath}
+     *
+     * @example
+     * ```ts
+     * app.get('/posts/:id', (c) => {
+     *   return c.json({ path: c.req.routePath })
+     * })
+     * ```
+     */
+    get routePath(): string;
+}
+/**
+ * Clones a HonoRequest's underlying raw Request object.
+ *
+ * This utility handles both consumed and unconsumed request bodies:
+ * - If the request body hasn't been consumed, it uses the native `clone()` method
+ * - If the request body has been consumed, it reconstructs a new Request using cached body data
+ *
+ * This is particularly useful when you need to:
+ * - Process the same request body multiple times
+ * - Pass requests to external services after validation
+ *
+ * @param req - The HonoRequest object to clone
+ * @returns A Promise that resolves to a new Request object with the same properties
+ * @throws {HTTPException} If the request body was consumed directly via `req.raw`
+ *   without using HonoRequest methods (e.g., `req.json()`, `req.text()`), making it
+ *   impossible to reconstruct the body from cache
+ *
+ * @example
+ * ```ts
+ * // Clone after consuming the body (e.g., after validation)
+ * app.post('/forward',
+ *   validator('json', (data) => data),
+ *   async (c) => {
+ *     const validated = c.req.valid('json')
+ *     // Body has been consumed, but cloneRawRequest still works
+ *     const clonedReq = await cloneRawRequest(c.req)
+ *     return fetch('http://backend-service.com', clonedReq)
+ *   }
+ * )
+ * ```
+ */
+export declare const cloneRawRequest: (req: HonoRequest) => Promise<Request>;
+export {};

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

@@ -0,0 +1,97 @@
+/**
+ * @module
+ * This module provides types definitions and variables for the routers.
+ */
+/**
+ * Constant representing all HTTP methods in uppercase.
+ */
+export declare const METHOD_NAME_ALL: "ALL";
+/**
+ * Constant representing all HTTP methods in lowercase.
+ */
+export declare const METHOD_NAME_ALL_LOWERCASE: "all";
+/**
+ * Array of supported HTTP methods.
+ */
+export declare const METHODS: readonly ["get", "post", "put", "delete", "options", "patch"];
+/**
+ * Error message indicating that a route cannot be added because the matcher is already built.
+ */
+export declare const MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
+/**
+ * Interface representing a router.
+ *
+ * @template T - The type of the handler.
+ */
+export interface Router<T> {
+    /**
+     * The name of the router.
+     */
+    name: string;
+    /**
+     * Adds a route to the router.
+     *
+     * @param method - The HTTP method (e.g., 'get', 'post').
+     * @param path - The path for the route.
+     * @param handler - The handler for the route.
+     */
+    add(method: string, path: string, handler: T): void;
+    /**
+     * Matches a route based on the given method and path.
+     *
+     * @param method - The HTTP method (e.g., 'get', 'post').
+     * @param path - The path to match.
+     * @returns The result of the match.
+     */
+    match(method: string, path: string): Result<T>;
+}
+/**
+ * Type representing a map of parameter indices.
+ */
+export type ParamIndexMap = Record<string, number>;
+/**
+ * Type representing a stash of parameters.
+ */
+export type ParamStash = string[];
+/**
+ * Type representing a map of parameters.
+ */
+export type Params = Record<string, string>;
+/**
+ * Type representing the result of a route match.
+ *
+ * The result can be in one of two formats:
+ * 1. An array of handlers with their corresponding parameter index maps, followed by a parameter stash.
+ * 2. An array of handlers with their corresponding parameter maps.
+ *
+ * Example:
+ *
+ * [[handler, paramIndexMap][], paramArray]
+ * ```typescript
+ * [
+ *   [
+ *     [middlewareA, {}],                     // '*'
+ *     [funcA,       {'id': 0}],              // '/user/:id/*'
+ *     [funcB,       {'id': 0, 'action': 1}], // '/user/:id/:action'
+ *   ],
+ *   ['123', 'abc']
+ * ]
+ * ```
+ *
+ * [[handler, params][]]
+ * ```typescript
+ * [
+ *   [
+ *     [middlewareA, {}],                             // '*'
+ *     [funcA,       {'id': '123'}],                  // '/user/:id/*'
+ *     [funcB,       {'id': '123', 'action': 'abc'}], // '/user/:id/:action'
+ *   ]
+ * ]
+ * ```
+ */
+export type Result<T> = [[T, ParamIndexMap][], ParamStash] | [[T, Params][]];
+/**
+ * Error class representing an unsupported path error.
+ */
+export declare class UnsupportedPathError extends Error {
+}