@lovable.dev/mcp-js 0.22.1 → 0.22.2-rc.1

package/dist/chunk-IXZIFYO6.js

@@ -1,79 +0,0 @@
-import {
-  JSON_HEADERS,
-  corsPreflightResponse,
-  getOAuthRuntime,
-  headResponse,
-  methodNotAllowed,
-  oauthConfigurationErrorResponse,
-  resolveProtectedResource,
-  withCors
-} from "./chunk-IFDWUM7L.js";
-import {
-  describeError,
-  log
-} from "./chunk-H37EB22A.js";
-
-// src/protocols/oauth-metadata.ts
-function notFound() {
-  return withCors(
-    new Response(JSON.stringify({ error: "not found" }), {
-      status: 404,
-      // `no-store` so a 404 (OAuth unconfigured) isn't heuristically cached and
-      // then served past a later deploy that enables OAuth and starts returning 200.
-      headers: { ...JSON_HEADERS, "Cache-Control": "no-store" }
-    })
-  );
-}
-async function buildProtectedResourceMetadata(mcp, auth, request, options, discovery) {
-  const issuer = await discovery.resolveIssuer();
-  const body = {
-    resource: resolveProtectedResource(auth, request, options),
-    authorization_servers: [issuer],
-    bearer_methods_supported: ["header"],
-    resource_name: auth.resourceName ?? mcp.title,
-    resource_documentation: auth.resourceDocumentation
-  };
-  if (auth.requiredScopes && auth.requiredScopes.length > 0)
-    body.scopes_supported = auth.requiredScopes;
-  return body;
-}
-function createOAuthProtectedResourceMetadataHandler(mcp, options = {}) {
-  const runtime = getOAuthRuntime(mcp, options);
-  if (runtime.kind === "configured" && runtime.auth.protectedResourceMetadataUrl === void 0 && runtime.auth.resource === void 0 && runtime.options.resourcePath === void 0) {
-    throw new Error(
-      `@lovable.dev/mcp-js: auth.resource or a resourcePath is required so the protected-resource metadata doesn't advertise the well-known URL as the resource`
-    );
-  }
-  return async (request) => {
-    if (runtime.kind !== "configured" || runtime.auth.protectedResourceMetadataUrl !== void 0)
-      return notFound();
-    if (request.method === "OPTIONS")
-      return corsPreflightResponse("GET, HEAD, OPTIONS");
-    if (request.method !== "GET" && request.method !== "HEAD")
-      return withCors(methodNotAllowed("GET, HEAD, OPTIONS"));
-    const headers = {
-      ...JSON_HEADERS,
-      "Cache-Control": "public, max-age=300",
-      Vary: "Host"
-    };
-    try {
-      const metadata = await buildProtectedResourceMetadata(
-        mcp,
-        runtime.auth,
-        request,
-        runtime.options,
-        runtime.discovery
-      );
-      const response = withCors(Response.json(metadata, { headers }));
-      return request.method === "HEAD" ? headResponse(response) : response;
-    } catch (err) {
-      log.error("oauth.metadata.config_error", { ...describeError(err), outcome: "500 oauth configuration error" });
-      const response = withCors(oauthConfigurationErrorResponse());
-      return request.method === "HEAD" ? headResponse(response) : response;
-    }
-  };
-}
-
-export {
-  createOAuthProtectedResourceMetadataHandler
-};

package/dist/chunk-MA5H6PSF.js

@@ -1,46 +0,0 @@
-// src/auth/context.ts
-var ToolContext = class {
-  #auth;
-  constructor(auth) {
-    this.#auth = auth;
-  }
-  /** Whether the in-flight tool call carries a verified auth context. */
-  isAuthenticated() {
-    return this.#auth !== void 0;
-  }
-  /** The verified bearer token, or `undefined` when unauthenticated. Pass it to downstream APIs; never return or log it. */
-  getToken() {
-    return this.#auth?.bearer.token;
-  }
-  /** The verified user id (the token `sub`), or `undefined`. */
-  getUserId() {
-    return this.#auth?.principal.sub;
-  }
-  /** The verified user email, or `undefined` when absent. */
-  getUserEmail() {
-    return this.#auth?.principal.email;
-  }
-  /** The verified OAuth `client_id`, or `undefined`. */
-  getClientId() {
-    return this.#auth?.principal.clientId;
-  }
-  /** The verified OAuth scopes, or `undefined` when unauthenticated. */
-  getScopes() {
-    return this.#auth?.principal.scopes;
-  }
-  /** The verified token issuer, or `undefined`. */
-  getIssuer() {
-    return this.#auth?.principal.issuer;
-  }
-  /**
-   * The full verified JWT claims, or `undefined`. Use this for app/business
-   * authorization on issuer-specific claims that have no dedicated accessor.
-   */
-  getClaims() {
-    return this.#auth?.principal.claims;
-  }
-};
-
-export {
-  ToolContext
-};

package/dist/chunk-TJN33K5U.js

@@ -1,141 +0,0 @@
-import {
-  extractTextContent
-} from "./chunk-6QFZYYUV.js";
-import {
-  ToolContext
-} from "./chunk-MA5H6PSF.js";
-import {
-  JSON_HEADERS,
-  assertRestResourceBinding,
-  corsPreflightResponse,
-  createNoopRecorder,
-  createRequestAuthorizer,
-  methodNotAllowed,
-  nowMs,
-  withCors
-} from "./chunk-IFDWUM7L.js";
-
-// src/protocols/rest/invoke-tool.ts
-import { getParseErrorMessage, objectFromShape, safeParseAsync } from "@modelcontextprotocol/sdk/server/zod-compat.js";
-var MAX_REFLECTED_TOOL_NAME = 256;
-function safeReflectName(name) {
-  const text = String(name);
-  return text.length > MAX_REFLECTED_TOOL_NAME ? `${text.slice(0, MAX_REFLECTED_TOOL_NAME)}\u2026` : text;
-}
-function isEmptyArgs(value) {
-  if (value == null)
-    return true;
-  if (typeof value !== "object" || Array.isArray(value))
-    return false;
-  return Object.keys(value).length === 0;
-}
-function createInvokeToolHandler(mcp, options = {}) {
-  assertRestResourceBinding(mcp, options);
-  const authorizer = createRequestAuthorizer(mcp, options);
-  const handle = async (request, toolName, recorder) => {
-    const authResult = await authorizer.authorize(request, recorder);
-    if (!authResult.ok)
-      return authResult.response;
-    const endUserId = authResult.auth?.principal.sub;
-    if (request.method !== "POST")
-      return methodNotAllowed("POST, OPTIONS");
-    const tool = mcp.tools.find((t) => t.name === toolName);
-    if (!tool) {
-      return new Response(JSON.stringify({ error: `unknown tool: ${safeReflectName(toolName)}` }), {
-        status: 404,
-        headers: JSON_HEADERS
-      });
-    }
-    let rawArgs = {};
-    const text = await request.text();
-    if (text) {
-      try {
-        rawArgs = JSON.parse(text);
-      } catch {
-        return new Response(JSON.stringify({ error: "invalid JSON body" }), {
-          status: 400,
-          headers: JSON_HEADERS
-        });
-      }
-    }
-    let args = rawArgs;
-    if (tool.inputSchema) {
-      try {
-        const schema = objectFromShape(tool.inputSchema);
-        const parsed = await safeParseAsync(schema, rawArgs);
-        if (!parsed.success) {
-          return new Response(
-            JSON.stringify({
-              error: "validation failed",
-              details: getParseErrorMessage(parsed.error)
-            }),
-            { status: 400, headers: JSON_HEADERS }
-          );
-        }
-        args = parsed.data;
-      } catch {
-        return new Response(JSON.stringify({ error: "schema error", tool: toolName }), {
-          status: 500,
-          headers: JSON_HEADERS
-        });
-      }
-    } else if (!isEmptyArgs(rawArgs)) {
-      return new Response(JSON.stringify({ error: "tool has no inputSchema; expected empty body" }), {
-        status: 400,
-        headers: JSON_HEADERS
-      });
-    }
-    let result;
-    const start = nowMs();
-    try {
-      result = await tool.handler(args, new ToolContext(authResult.auth));
-    } catch {
-      await recorder.emit({
-        tool: tool.name,
-        method: "tools/call",
-        outcome: "handler_error",
-        durationMs: nowMs() - start,
-        endUserId
-      });
-      return new Response(JSON.stringify({ error: "handler threw", tool: toolName }), {
-        status: 500,
-        headers: JSON_HEADERS
-      });
-    }
-    if (result == null) {
-      await recorder.emit({
-        tool: tool.name,
-        method: "tools/call",
-        outcome: "handler_error",
-        durationMs: nowMs() - start,
-        endUserId
-      });
-      return new Response(JSON.stringify({ error: `tool "${toolName}" returned no result` }), {
-        status: 500,
-        headers: JSON_HEADERS
-      });
-    }
-    await recorder.emit({
-      tool: tool.name,
-      method: "tools/call",
-      outcome: result.isError ? "tool_error" : "ok",
-      durationMs: nowMs() - start,
-      errorText: result.isError ? extractTextContent(result.content) : void 0,
-      endUserId
-    });
-    return Response.json({
-      content: result.content ?? [],
-      structuredContent: result.structuredContent,
-      isError: result.isError
-    });
-  };
-  return async (request, toolName, recorder = createNoopRecorder()) => {
-    if (request.method === "OPTIONS")
-      return corsPreflightResponse("POST, OPTIONS");
-    return withCors(await handle(request, toolName, recorder));
-  };
-}
-
-export {
-  createInvokeToolHandler
-};

package/dist/chunk-UQK5UO6C.js

@@ -1,26 +0,0 @@
-// src/core/forwarded.ts
-function applyForwardedOrigin(request, options) {
-  const proto = options.trustForwardedProto ? firstForwardedValue(request, "x-forwarded-proto") : void 0;
-  const host = options.trustForwardedHost ? firstForwardedValue(request, "x-forwarded-host") : void 0;
-  if (proto === void 0 && host === void 0)
-    return request;
-  const url = new URL(request.url);
-  let changed = false;
-  if (proto !== void 0 && `${proto}:` !== url.protocol) {
-    url.protocol = `${proto}:`;
-    changed = true;
-  }
-  if (host !== void 0 && host !== url.host) {
-    url.host = host;
-    changed = true;
-  }
-  return changed ? new Request(url.href, request) : request;
-}
-function firstForwardedValue(request, header) {
-  const value = request.headers.get(header)?.split(",")[0]?.trim();
-  return value ? value : void 0;
-}
-
-export {
-  applyForwardedOrigin
-};

package/dist/chunk-XQWJN6DC.js

@@ -1,14 +0,0 @@
-// src/stacks/supabase/paths.ts
-var FUNCTIONS_MOUNT_PREFIX = "/functions/v1/";
-function assertFunctionName(value, label = "functionName") {
-  if (!/^[a-zA-Z0-9_-]+$/.test(value)) {
-    throw new Error(
-      `@lovable.dev/mcp-js: ${label} must be a single path segment matching [A-Za-z0-9_-], got ${JSON.stringify(value)}`
-    );
-  }
-}
-
-export {
-  FUNCTIONS_MOUNT_PREFIX,
-  assertFunctionName
-};

package/dist/chunk-Y3ZFPEQH.js

@@ -1,8 +0,0 @@
-// src/core/fs-errors.ts
-function isFileMissing(err) {
-  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
-}
-
-export {
-  isFileMissing
-};

package/dist/chunk-ZQXSWTPU.js

@@ -1,6 +0,0 @@
-// package.json
-var version = "0.22.1";
-
-export {
-  version
-};

package/dist/types-qqrmJ736.d.ts

@@ -1,321 +0,0 @@
-import { ZodRawShape as ZodRawShape$1, ZodType, TypeOf } from 'zod';
-
-type JwtClaims = Record<string, unknown> & {
-    iss?: string;
-    sub?: string;
-    aud?: string | string[];
-    exp?: number;
-    iat?: number;
-    nbf?: number;
-    scope?: string;
-    client_id?: string;
-    email?: string;
-    /** RFC 8707 resource indicator(s) the token was granted for (Lovable OAuth convention). */
-    resource?: string | string[];
-};
-/**
- * The safe-to-surface half of the auth context, reachable by tools only through
- * `ToolContext` accessors (`getUserId()`, `getClaims()`, …). Carries no
- * credential — the bearer is isolated in `OAuthBearer`.
- */
-interface OAuthPrincipal {
-    claims: JwtClaims;
-    issuer: string;
-    resource: string;
-    acceptedAudiences: readonly string[];
-    scopes: string[];
-    sub?: string;
-    email?: string;
-    clientId?: string;
-}
-/**
- * The raw bearer, isolated from the safe fields. Pass it only into outbound
- * `fetch`/client construction; never return or log it — a leaked token stays
- * valid at the AS until it expires. `token` is a non-enumerable property, so
- * `JSON.stringify`, object spread, and `console.log` omit it by construction.
- */
-interface OAuthBearer {
-    readonly token: string;
-}
-interface McpAuthContext {
-    type: "oauth";
-    principal: OAuthPrincipal;
-    bearer: OAuthBearer;
-}
-interface McpAuthConfig {
-    readonly type: "oauth";
-    readonly issuer: string;
-    readonly resource?: string;
-    readonly resourceName?: string;
-    readonly resourceDocumentation?: string;
-    /**
-     * Absolute URL of an externally hosted RFC 9728 protected-resource metadata
-     * document. When set, the SDK advertises this URL in the 401
-     * `WWW-Authenticate: resource_metadata` challenge and does not generate or
-     * serve its own metadata (the `/.well-known/oauth-protected-resource` handler
-     * 404s). Use it when the resource server already publishes its own PRM.
-     *
-     * Mutually exclusive with the Vite plugin's `metadataPath`: that option has
-     * the SDK serve the document itself at a custom path, so configuring both is
-     * rejected at handler construction.
-     */
-    readonly protectedResourceMetadataUrl?: string;
-    readonly requireOAuthClientClaim?: boolean;
-    readonly acceptedAudiences?: readonly string[];
-    /**
-     * Accept a token whose RFC 8707 `resource` claim matches an accepted
-     * audience (trailing slashes ignored) when its `aud` is an empty array or
-     * absent — the shape Lovable's OAuth server mints; applies to any configured
-     * issuer. A populated `aud` is always authoritative and is never overridden.
-     * Defaults to true. Set false to require a matching `aud` (strict RFC 9068).
-     */
-    readonly acceptResourceClaim?: boolean;
-    readonly requiredScopes?: readonly string[];
-    readonly jwksUri?: string;
-    readonly algorithms?: readonly string[];
-    readonly clockToleranceSeconds?: number;
-    /**
-     * Allowed values for the access token's JOSE `typ` header. Defaults to
-     * `["at+jwt", "JWT"]` so both the RFC 9068 access-token shape and the plain
-     * user-JWT shape (notably Supabase GoTrue's OAuth tokens) are accepted out of
-     * the box. Pin to `["at+jwt"]` to enforce strict RFC 9068. The header `typ`
-     * must be present and string-typed; this option only controls which values pass.
-     */
-    readonly accessTokenTyp?: readonly string[];
-}
-
-/**
- * The auth surface passed to every tool handler as its second argument. It wraps
- * the verified per-request auth context in a private field, so the context — and
- * the bearer token inside it — can't be read, enumerated, spread, or
- * `JSON.stringify`'d off the instance; the accessors below are the only way out.
- * `getToken()` is the single intentional escape hatch for the raw bearer.
- */
-declare class ToolContext {
-    #private;
-    constructor(auth: McpAuthContext | undefined);
-    /** Whether the in-flight tool call carries a verified auth context. */
-    isAuthenticated(): boolean;
-    /** The verified bearer token, or `undefined` when unauthenticated. Pass it to downstream APIs; never return or log it. */
-    getToken(): string | undefined;
-    /** The verified user id (the token `sub`), or `undefined`. */
-    getUserId(): string | undefined;
-    /** The verified user email, or `undefined` when absent. */
-    getUserEmail(): string | undefined;
-    /** The verified OAuth `client_id`, or `undefined`. */
-    getClientId(): string | undefined;
-    /** The verified OAuth scopes, or `undefined` when unauthenticated. */
-    getScopes(): string[] | undefined;
-    /** The verified token issuer, or `undefined`. */
-    getIssuer(): string | undefined;
-    /**
-     * The full verified JWT claims, or `undefined`. Use this for app/business
-     * authorization on issuer-specific claims that have no dedicated accessor.
-     */
-    getClaims(): JwtClaims | undefined;
-}
-
-/**
- * Usage-metrics options. Pass a boolean to the Vite plugins for the common
- * on/off case, or this object to override the ingest endpoint (e.g. to
- * self-host the collector outside Lovable).
- */
-interface MetricsOptions {
-    /** Master switch. Default `true`; metrics still self-disable at runtime when
-     *  the API key env var is absent. */
-    enabled?: boolean;
-    /** OTLP/HTTP (JSON) logs URL to POST each invocation to — the default Lovable
-     *  route or any OTLP collector. Must be an absolute http(s) URL.
-     *  @default "https://api.lovable.dev/v1/app-mcp-usage" */
-    endpoint?: string;
-    /** Extra request headers — e.g. the auth token for a private OTLP collector.
-     *  Sent verbatim with every request (and baked into the build output, so source
-     *  your own build-time env for secrets). Ignored for the default Lovable
-     *  endpoint, which authenticates with `LOVABLE_API_KEY` instead. `content-type`
-     *  cannot be overridden (OTLP/HTTP JSON requires `application/json`). */
-    headers?: Record<string, string>;
-}
-/** Either the bare on/off toggle or the full options object. */
-type MetricsConfig = boolean | MetricsOptions;
-
-/**
- * Any zod schema. Aliased to zod's `ZodType` (no generics) — non-deprecated
- * in both v3 and v4. Use this when you need to type an individual schema;
- * for the `{ text: z.string() }` shape passed to `defineTool`'s
- * `inputSchema`, use `ZodRawShape`.
- */
-type ZodSchema = ZodType;
-/**
- * A raw zod shape (`{ text: z.string(), n: z.number() }`) — the format
- * `defineTool`'s `inputSchema`/`outputSchema` expects.
- */
-type ZodRawShape = ZodRawShape$1;
-/**
- * Infer the parsed-output type of a zod raw shape — given
- * `{ text: ZodString, n: ZodNumber }`, produces `{ text: string, n: number }`.
- */
-type ShapeOutput<Shape extends ZodRawShape> = {
-    [K in keyof Shape]: Shape[K] extends ZodType ? TypeOf<Shape[K]> : unknown;
-};
-/**
- * Per-content-block metadata. Distinct from `ToolAnnotations`, which
- * decorates the tool as a whole — these decorate a single piece of
- * content (an image, a text block, etc.) within the tool's result.
- */
-interface ContentAnnotations {
-    /** Which side of the conversation the content is addressed at. */
-    audience?: ("user" | "assistant")[];
-    /** Higher = more important. Used by clients that summarise content. */
-    priority?: number;
-    /** ISO 8601 timestamp. */
-    lastModified?: string;
-}
-interface ContentBlockBase {
-    annotations?: ContentAnnotations;
-    _meta?: Record<string, unknown>;
-}
-interface TextContent extends ContentBlockBase {
-    type: "text";
-    text: string;
-}
-interface ImageContent extends ContentBlockBase {
-    type: "image";
-    data: string;
-    mimeType: string;
-}
-interface AudioContent extends ContentBlockBase {
-    type: "audio";
-    data: string;
-    mimeType: string;
-}
-interface EmbeddedTextResource extends ContentBlockBase {
-    type: "resource";
-    resource: {
-        uri: string;
-        mimeType?: string;
-        text: string;
-        _meta?: Record<string, unknown>;
-    };
-}
-interface EmbeddedBlobResource extends ContentBlockBase {
-    type: "resource";
-    resource: {
-        uri: string;
-        mimeType?: string;
-        blob: string;
-        _meta?: Record<string, unknown>;
-    };
-}
-type EmbeddedResource = EmbeddedTextResource | EmbeddedBlobResource;
-/**
- * Optional icon entry on `ResourceLink`. Clients that display a resource
- * with a glyph (file browsers, side panels, etc.) pick the best match by
- * MIME type, `sizes`, and the active `theme`. All fields besides `src`
- * are optional — `src` is typically a `file://`, `data:`, or `https:` URI.
- */
-interface ResourceLinkIcon {
-    src: string;
-    mimeType?: string;
-    /** Space-separated dimension string, HTML `<link sizes>` convention (e.g. `"16x16 32x32"`). */
-    sizes?: string;
-    theme?: "light" | "dark";
-}
-interface ResourceLink extends ContentBlockBase {
-    type: "resource_link";
-    uri: string;
-    name: string;
-    title?: string;
-    description?: string;
-    mimeType?: string;
-    icons?: ResourceLinkIcon[];
-}
-/**
- * A single content block in a tool result. Matches the MCP wire format
- * for `tools/call` responses (`type: "text" | "image" | "audio" |
- * "resource" | "resource_link"`).
- */
-type ContentBlock = TextContent | ImageContent | AudioContent | EmbeddedResource | ResourceLink;
-/**
- * The shape of `ToolHandlerResult.content` — an array of content blocks
- * the tool returns to the caller.
- */
-type ToolContent = ContentBlock[];
-/**
- * Per-tool client hints (not enforcement). `annotations.title` is
- * intentionally omitted — use `ToolDefinition.title`, which the MCP
- * 2025-06-18+ spec promoted to top-level.
- */
-interface ToolAnnotations {
-    /** Tool does not modify state. */
-    readOnlyHint?: boolean;
-    /** Tool may make irreversible changes. Only meaningful when readOnlyHint is false. */
-    destructiveHint?: boolean;
-    /** Calling N times has the same effect as calling once. */
-    idempotentHint?: boolean;
-    /** Tool interacts with external/unbounded systems (DB, network, third-party APIs). */
-    openWorldHint?: boolean;
-}
-interface ToolHandlerResult {
-    content?: ToolContent;
-    structuredContent?: Record<string, unknown>;
-    isError?: boolean;
-}
-
-interface ToolDefinition<TInput extends ZodRawShape | undefined = ZodRawShape | undefined, TOutput extends ZodRawShape | undefined = ZodRawShape | undefined> {
-    readonly name: string;
-    /** Human-readable display name shown to the user in MCP clients. Required. */
-    readonly title: string;
-    /** Prose read by the LLM to decide whether to call this tool. Required. */
-    readonly description: string;
-    readonly inputSchema?: TInput;
-    readonly outputSchema?: TOutput;
-    readonly annotations?: ToolAnnotations;
-    readonly handler: TInput extends ZodRawShape ? (args: ShapeOutput<TInput>, ctx: ToolContext) => ToolHandlerResult | Promise<ToolHandlerResult> : (args: Record<string, never> | undefined, ctx: ToolContext) => ToolHandlerResult | Promise<ToolHandlerResult>;
-}
-/**
- * Type-erased element of `McpDefinition.tools`. Per-tool generic typing
- * happens at the `defineTool` call site; see README §6 for the rationale.
- */
-interface AnyToolDefinition {
-    readonly name: string;
-    readonly title: string;
-    readonly description: string;
-    readonly inputSchema?: ZodRawShape;
-    readonly outputSchema?: ZodRawShape;
-    readonly annotations?: ToolAnnotations;
-    readonly handler: (args: any, ctx: ToolContext) => ToolHandlerResult | Promise<ToolHandlerResult>;
-}
-/**
- * Fields a caller supplies when constructing an MCP definition. Pass this
- * shape to `defineMcp(...)` — its return type is the branded `McpDefinition`,
- * which is the type every internal factory (`createInvokeToolHandler`,
- * `createMcpProtocolHandler`, …) consumes. The brand forces consumers
- * through `defineMcp`'s `assertUniqueNames` + freeze.
- */
-interface McpDefinitionInput {
-    readonly name: string;
-    /** Human-readable display name shown to MCP clients. Required. */
-    readonly title: string;
-    readonly version: string;
-    readonly auth?: McpAuthConfig;
-    /**
-     * Server-level prose the LLM reads as context for all tools on this server.
-     * Required for the same reason `ToolDefinition.description` is — optional
-     * fields encourage drift in production agent behavior. Pass an explicit
-     * empty string to opt out.
-     */
-    readonly instructions: string;
-    readonly tools: readonly AnyToolDefinition[];
-    /**
-     * Usage-metrics emission (runtime telemetry), on by default. `false` opts out;
-     * `{ endpoint, headers }` sends to your own OTLP collector. Self-disables at
-     * runtime without `LOVABLE_API_KEY` on the default Lovable endpoint.
-     */
-    readonly metrics?: MetricsConfig;
-}
-declare const McpDefinitionBrand: unique symbol;
-type McpDefinition = McpDefinitionInput & {
-    readonly [McpDefinitionBrand]: never;
-};
-
-export { type AudioContent as A, type ContentAnnotations as C, type EmbeddedBlobResource as E, type ImageContent as I, type JwtClaims as J, type McpAuthConfig as M, type ResourceLink as R, type TextContent as T, type ZodRawShape as Z, type ContentBlock as a, type EmbeddedResource as b, type EmbeddedTextResource as c, type McpDefinition as d, type McpDefinitionInput as e, type MetricsConfig as f, type MetricsOptions as g, type ResourceLinkIcon as h, type ToolAnnotations as i, type ToolContent as j, ToolContext as k, type ToolDefinition as l, type ToolHandlerResult as m, type ZodSchema as n };