fastmcp 4.9.2 → 4.11.0

package/README.md

@@ -594,6 +594,48 @@ server.addTool({
 });
 ```
 
+**Plain JSON Schema Example:**
+
+If you already have a JSON Schema — from an OpenAPI document, a config file, or
+another server — `jsonSchemaAdapter` wraps it so it can be used directly, with
+no schema library in between.
+
+It requires the peer dependency `ajv`, which does the validation, plus
+`ajv-formats` if your schema uses `format` keywords such as `email` or `uri`.
+Both are imported the first time a tool is called, so servers that don't use
+this pay nothing for it.
+
+```bash
+npm install ajv ajv-formats
+```
+
+```typescript
+import { jsonSchemaAdapter } from "fastmcp";
+
+server.addTool({
+  name: "fetch-json-schema",
+  description: "Fetch the content of a url (using plain JSON Schema)",
+  parameters: jsonSchemaAdapter({
+    type: "object",
+    properties: {
+      url: { type: "string", format: "uri" },
+    },
+    required: ["url"],
+  }),
+  execute: async (args) => {
+    const { url } = args as { url: string };
+    return await fetchWebpageContent(url);
+  },
+});
+```
+
+Works for `outputSchema` too. Note that FastMCP advertises every tool schema
+with `additionalProperties: false`, whatever your schema said — the same
+treatment Zod and Valibot schemas get.
+
+Unlike the schema libraries above, a plain JSON Schema carries no TypeScript
+types, so `execute` receives `unknown` arguments. Cast or narrow them yourself.
+
 #### Tools Without Parameters
 
 When creating tools that don't require parameters, you have two options:
@@ -1186,15 +1228,32 @@ server.addTool({
 });
 ```
 
+`reportProgress` accepts an optional human-readable `message` alongside the numeric fields, which clients can display next to the progress indicator:
+
+```js
+await reportProgress({
+  progress: 40,
+  total: 100,
+  message: "Downloading chunk 4 of 10…",
+});
+```
+
+Progress notifications are only emitted when the client opts in by supplying a `progressToken` on the tool call; otherwise `reportProgress` is a no-op. Because `notifications/progress` is part of the MCP specification (the `message` field since revision 2025-03-26), this is the portable way to send incremental updates during a long-running tool call — see [Streaming Output](#streaming-output) below for the difference.
+
 #### Streaming Output
 
-FastMCP supports streaming partial results from tools while they're still executing, enabling responsive UIs and real-time feedback. This is particularly useful for:
+FastMCP can stream partial results from tools while they're still executing, enabling responsive UIs and real-time feedback. This is particularly useful for:
 
 - Long-running operations that generate content incrementally
 - Progressive generation of text, images, or other media
 - Operations where users benefit from seeing immediate partial results
 
-To enable streaming for a tool, add the `streamingHint` annotation and use the `streamContent` method:
+> [!IMPORTANT]
+> `streamContent` is a **FastMCP extension, not part of the MCP specification**. It emits a `notifications/tool/streamContent` notification, which the MCP specification does not define — as of revision `2025-11-25` there is no standard mechanism for streaming tool output ([SEP-2998](https://github.com/modelcontextprotocol/modelcontextprotocol/pull/2998) is the in-progress proposal to add one).
+>
+> Clients discard notifications they have no handler registered for, silently and without error. A client only sees streamed content if it registers a handler for the method (or sets a `fallbackNotificationHandler`), and **no client is known to render it as tool output** — MCP Inspector, for example, logs it in its notifications pane via a fallback handler, but the tool result itself still shows only what `execute` returned. Streaming is therefore mainly useful when you also control the client — see [Consuming streamed content](#consuming-streamed-content) below. If you need incremental updates that work on any client, use [`reportProgress`](#progress) with a `message` instead.
+
+To stream from a tool, use the `streamContent` method:
 
 ```js
 server.addTool({
@@ -1204,7 +1263,7 @@ server.addTool({
     prompt: z.string(),
   }),
   annotations: {
-    streamingHint: true, // Signals this tool uses streaming
+    streamingHint: true, // Advisory only; see below
     readOnlyHint: true,
   },
   execute: async (args, { streamContent }) => {
@@ -1218,19 +1277,45 @@ server.addTool({
       await new Promise((resolve) => setTimeout(resolve, 300)); // Simulate delay
     }
 
-    // When using streamContent, you can:
-    // 1. Return void (if all content was streamed)
-    // 2. Return a final result (which will be appended to streamed content)
+    // Always return a final result. Returning nothing sends an empty tool
+    // result, so clients that ignore the streamed notifications see no output
+    // at all.
+    return "The quick brown fox jumps over the lazy dog.";
+  },
+});
+```
 
-    // Option 1: All content was streamed, so return void
-    return;
+> [!WARNING]
+> Returning `undefined` from `execute` produces a tool result with empty `content`. If you stream everything and return nothing, the tool call resolves to an empty result with no indication that anything was lost — including on clients that do log the notification. Return the complete result as well, and treat streamed content purely as a progressive-rendering enhancement.
 
-    // Option 2: Return final content that will be appended
-    // return "Generation complete!";
-  },
+The `streamingHint` annotation is advisory metadata. It is forwarded verbatim to clients in `tools/list`, but it does not enable or gate `streamContent`, and FastMCP itself never reads it. No client is known to act on it today, though [SEP-2998](https://github.com/modelcontextprotocol/modelcontextprotocol/pull/2998) proposes standardizing the same annotation name.
+
+##### Consuming streamed content
+
+A client sees these notifications only if it registers a handler for the method (or sets a `fallbackNotificationHandler`):
+
+```ts
+import { z } from "zod";
+
+const StreamContentNotificationSchema = z.object({
+  method: z.literal("notifications/tool/streamContent"),
+  params: z.object({
+    content: z.array(z.any()),
+    toolName: z.string(),
+  }),
 });
+
+client.setNotificationHandler(
+  StreamContentNotificationSchema,
+  (notification) => {
+    const { content, toolName } = notification.params;
+    // Render the partial content however you like.
+  },
+);
 ```
 
+Note that notifications carry only `toolName`, not a request or progress token, so concurrent calls to the same tool on one session cannot be told apart.
+
 Streaming works with all content types (text, image, audio) and can be combined with progress reporting:
 
 ```js
@@ -1247,10 +1332,14 @@ server.addTool({
     const total = args.datasetSize;
 
     for (let i = 0; i < total; i++) {
-      // Report numeric progress
-      await reportProgress({ progress: i, total });
+      // Standard progress notification: reaches every spec-compliant client
+      await reportProgress({
+        progress: i,
+        total,
+        message: `Processed ${i} of ${total} items`,
+      });
 
-      // Stream intermediate results
+      // Richer partial content: only reaches clients that opt in
       if (i % 10 === 0) {
         await streamContent({
           type: "text",

package/dist/FastMCP.cjs

@@ -7,7 +7,8 @@
 
 
 
-var _chunkENLYR3QMcjs = require('./chunk-ENLYR3QM.cjs');
+
+var _chunkISO2WPB5cjs = require('./chunk-ISO2WPB5.cjs');
 
 
 
@@ -41,5 +42,6 @@ var _chunkDZYT6QAHcjs = require('./chunk-DZYT6QAH.cjs');
 
 
 
-exports.AuthProvider = _chunkDZYT6QAHcjs.AuthProvider; exports.AzureProvider = _chunkDZYT6QAHcjs.AzureProvider; exports.DiscoveryDocumentCache = _chunkENLYR3QMcjs.DiscoveryDocumentCache; exports.FastMCP = _chunkENLYR3QMcjs.FastMCP; exports.FastMCPSession = _chunkENLYR3QMcjs.FastMCPSession; exports.GitHubProvider = _chunkDZYT6QAHcjs.GitHubProvider; exports.GoogleProvider = _chunkDZYT6QAHcjs.GoogleProvider; exports.OAuthProvider = _chunkDZYT6QAHcjs.OAuthProvider; exports.ServerState = _chunkENLYR3QMcjs.ServerState; exports.UnexpectedStateError = _chunkENLYR3QMcjs.UnexpectedStateError; exports.UserError = _chunkENLYR3QMcjs.UserError; exports.audioContent = _chunkENLYR3QMcjs.audioContent; exports.getAuthSession = _chunkDZYT6QAHcjs.getAuthSession; exports.imageContent = _chunkENLYR3QMcjs.imageContent; exports.requireAll = _chunkDZYT6QAHcjs.requireAll; exports.requireAny = _chunkDZYT6QAHcjs.requireAny; exports.requireAuth = _chunkDZYT6QAHcjs.requireAuth; exports.requireRole = _chunkDZYT6QAHcjs.requireRole; exports.requireScopes = _chunkDZYT6QAHcjs.requireScopes;
+
+exports.AuthProvider = _chunkDZYT6QAHcjs.AuthProvider; exports.AzureProvider = _chunkDZYT6QAHcjs.AzureProvider; exports.DiscoveryDocumentCache = _chunkISO2WPB5cjs.DiscoveryDocumentCache; exports.FastMCP = _chunkISO2WPB5cjs.FastMCP; exports.FastMCPSession = _chunkISO2WPB5cjs.FastMCPSession; exports.GitHubProvider = _chunkDZYT6QAHcjs.GitHubProvider; exports.GoogleProvider = _chunkDZYT6QAHcjs.GoogleProvider; exports.OAuthProvider = _chunkDZYT6QAHcjs.OAuthProvider; exports.ServerState = _chunkISO2WPB5cjs.ServerState; exports.UnexpectedStateError = _chunkISO2WPB5cjs.UnexpectedStateError; exports.UserError = _chunkISO2WPB5cjs.UserError; exports.audioContent = _chunkISO2WPB5cjs.audioContent; exports.getAuthSession = _chunkDZYT6QAHcjs.getAuthSession; exports.imageContent = _chunkISO2WPB5cjs.imageContent; exports.jsonSchemaAdapter = _chunkISO2WPB5cjs.jsonSchemaAdapter; exports.requireAll = _chunkDZYT6QAHcjs.requireAll; exports.requireAny = _chunkDZYT6QAHcjs.requireAny; exports.requireAuth = _chunkDZYT6QAHcjs.requireAuth; exports.requireRole = _chunkDZYT6QAHcjs.requireRole; exports.requireScopes = _chunkDZYT6QAHcjs.requireScopes;
 //# sourceMappingURL=FastMCP.cjs.map

package/dist/FastMCP.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/fastmcp/fastmcp/dist/FastMCP.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,gjCAAC","file":"/home/runner/work/fastmcp/fastmcp/dist/FastMCP.cjs"}
+{"version":3,"sources":["/home/runner/work/fastmcp/fastmcp/dist/FastMCP.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,inCAAC","file":"/home/runner/work/fastmcp/fastmcp/dist/FastMCP.cjs"}

package/dist/FastMCP.d.cts

@@ -47,6 +47,71 @@ declare class DiscoveryDocumentCache {
     has(url: string): boolean;
 }
 
+/**
+ * A plain JSON Schema object descriptor.
+ */
+type JsonSchemaObject = {
+    [key: string]: unknown;
+    $schema?: string;
+    additionalProperties?: boolean;
+    properties?: Record<string, unknown>;
+    required?: string[];
+    type: string;
+};
+/**
+ * A Standard Schema that also carries the JSON Schema it was built from.
+ *
+ * `~standard.jsonSchema` is the Standard JSON Schema extension. Anything that
+ * knows about it — including the `xsschema` conversion FastMCP uses to build
+ * `tools/list` — reads the schema straight off the object instead of trying to
+ * derive one from a validation library it does not recognise.
+ */
+interface JsonSchemaStandardSchema extends StandardSchemaV1 {
+    readonly "~standard": {
+        readonly jsonSchema: {
+            readonly input: () => JsonSchemaObject;
+            readonly output: () => JsonSchemaObject;
+        };
+    } & StandardSchemaV1.Props;
+}
+/**
+ * Wraps a plain JSON Schema object so it can be used as a tool's `parameters`
+ * or `outputSchema`, without pulling in Zod, Valibot, or another validation
+ * library.
+ *
+ * Validation uses AJV, which is an optional peer dependency — install `ajv`
+ * (and `ajv-formats` if you use `format` keywords) to use this. It is imported
+ * on first validation, so servers that never call this pay nothing for it.
+ *
+ * Note that FastMCP applies the same strictness to every tool schema: objects
+ * are advertised with `additionalProperties: false`, whatever the input schema
+ * said.
+ *
+ * @example
+ * ```ts
+ * import { FastMCP, jsonSchemaAdapter } from "fastmcp";
+ *
+ * const server = new FastMCP({ name: "Example", version: "1.0.0" });
+ *
+ * server.addTool({
+ *   name: "greet",
+ *   description: "Greet a user",
+ *   parameters: jsonSchemaAdapter({
+ *     type: "object",
+ *     properties: {
+ *       name: { type: "string" },
+ *     },
+ *     required: ["name"],
+ *   }),
+ *   execute: async ({ name }) => `Hello, ${name}!`,
+ * });
+ * ```
+ *
+ * @param schema - A plain JSON Schema object
+ * @returns A Standard Schema that validates against `schema`
+ */
+declare function jsonSchemaAdapter(schema: JsonSchemaObject): JsonSchemaStandardSchema;
+
 interface Logger {
     debug(...args: unknown[]): void;
     error(...args: unknown[]): void;
@@ -120,6 +185,22 @@ type Context<T extends FastMCPSessionAuth> = {
      * counters, or maintain user-specific data across multiple requests.
      */
     sessionId?: string;
+    /**
+     * Streams incremental content while the tool is still executing, by emitting
+     * a `notifications/tool/streamContent` notification.
+     *
+     * NOTE: this is a FastMCP extension, not part of the MCP specification. As of
+     * revision 2025-11-25 the spec has no streaming tool output primitive (see
+     * SEP-2998 for the in-progress proposal). A client only receives these
+     * notifications if it registers a handler for the method or sets a
+     * `fallbackNotificationHandler`; otherwise the SDK drops them silently. No
+     * client is known to render them as tool output.
+     *
+     * Always return a final result from `execute` rather than relying on streamed
+     * content alone, otherwise clients that ignore the notification see an empty
+     * tool result. For incremental status that works everywhere, prefer
+     * {@link Context.reportProgress} with a `message`.
+     */
     streamContent: (content: Content | Content[]) => Promise<void>;
 };
 type Extra = unknown;
@@ -134,6 +215,13 @@ type Literal = boolean | null | number | string | undefined;
  */
 type LoadContext<T extends FastMCPSessionAuth> = Omit<Context<T>, "reportProgress" | "streamContent">;
 type Progress = {
+    /**
+     * An optional human-readable message describing the current progress.
+     *
+     * Part of `notifications/progress` since MCP revision 2025-03-26, so unlike
+     * `streamContent` this reaches any spec-compliant client.
+     */
+    message?: string;
     /**
      * The progress thus far. This should increase every time progress is made, even if the total is unknown.
      */
@@ -616,8 +704,11 @@ type Tool<T extends FastMCPSessionAuth, Params extends ToolParameters = ToolPara
     };
     annotations?: {
         /**
-         * When true, the tool leverages incremental content streaming
-         * Return void for tools that handle all their output via streaming
+         * Advisory metadata signalling that the tool streams incremental content
+         * via {@link Context.streamContent}. Forwarded verbatim in `tools/list`.
+         *
+         * This has no effect on FastMCP's behavior: it neither enables nor is
+         * required by `streamContent`. No known client interprets it today.
          */
         streamingHint?: boolean;
     } & ToolAnnotations;
@@ -920,4 +1011,4 @@ declare class FastMCP<T extends FastMCPSessionAuth = FastMCPSessionAuth> extends
     stop(): Promise<void>;
 }
 
-export { type AudioContent, AuthProvider, type Content, type ContentResult, type Context, DiscoveryDocumentCache, FastMCP, type FastMCPEvents, type FastMCPRequest, type FastMCPResponse, FastMCPSession, type FastMCPSessionAuth, type FastMCPSessionEvents, type HTTPMethod, type ImageContent, type InputPrompt, type InputPromptArgument, type LoadContext, type Logger, type LoggingLevel, OAuthSession, type Progress, type Prompt, type PromptArgument, type Resource, type ResourceContent, type ResourceResult, type ResourceTemplate, type ResourceTemplateArgument, type RouteHandler, type RouteOptions, type SSEServer, type SerializableValue, type ServerOptions, ServerState, type TextContent, type Tool, type ToolParameters, UnexpectedStateError, UserError, audioContent, imageContent };
+export { type AudioContent, AuthProvider, type Content, type ContentResult, type Context, DiscoveryDocumentCache, FastMCP, type FastMCPEvents, type FastMCPRequest, type FastMCPResponse, FastMCPSession, type FastMCPSessionAuth, type FastMCPSessionEvents, type HTTPMethod, type ImageContent, type InputPrompt, type InputPromptArgument, type JsonSchemaObject, type JsonSchemaStandardSchema, type LoadContext, type Logger, type LoggingLevel, OAuthSession, type Progress, type Prompt, type PromptArgument, type Resource, type ResourceContent, type ResourceResult, type ResourceTemplate, type ResourceTemplateArgument, type RouteHandler, type RouteOptions, type SSEServer, type SerializableValue, type ServerOptions, ServerState, type TextContent, type Tool, type ToolParameters, UnexpectedStateError, UserError, audioContent, imageContent, jsonSchemaAdapter };

package/dist/FastMCP.d.ts

@@ -47,6 +47,71 @@ declare class DiscoveryDocumentCache {
     has(url: string): boolean;
 }
 
+/**
+ * A plain JSON Schema object descriptor.
+ */
+type JsonSchemaObject = {
+    [key: string]: unknown;
+    $schema?: string;
+    additionalProperties?: boolean;
+    properties?: Record<string, unknown>;
+    required?: string[];
+    type: string;
+};
+/**
+ * A Standard Schema that also carries the JSON Schema it was built from.
+ *
+ * `~standard.jsonSchema` is the Standard JSON Schema extension. Anything that
+ * knows about it — including the `xsschema` conversion FastMCP uses to build
+ * `tools/list` — reads the schema straight off the object instead of trying to
+ * derive one from a validation library it does not recognise.
+ */
+interface JsonSchemaStandardSchema extends StandardSchemaV1 {
+    readonly "~standard": {
+        readonly jsonSchema: {
+            readonly input: () => JsonSchemaObject;
+            readonly output: () => JsonSchemaObject;
+        };
+    } & StandardSchemaV1.Props;
+}
+/**
+ * Wraps a plain JSON Schema object so it can be used as a tool's `parameters`
+ * or `outputSchema`, without pulling in Zod, Valibot, or another validation
+ * library.
+ *
+ * Validation uses AJV, which is an optional peer dependency — install `ajv`
+ * (and `ajv-formats` if you use `format` keywords) to use this. It is imported
+ * on first validation, so servers that never call this pay nothing for it.
+ *
+ * Note that FastMCP applies the same strictness to every tool schema: objects
+ * are advertised with `additionalProperties: false`, whatever the input schema
+ * said.
+ *
+ * @example
+ * ```ts
+ * import { FastMCP, jsonSchemaAdapter } from "fastmcp";
+ *
+ * const server = new FastMCP({ name: "Example", version: "1.0.0" });
+ *
+ * server.addTool({
+ *   name: "greet",
+ *   description: "Greet a user",
+ *   parameters: jsonSchemaAdapter({
+ *     type: "object",
+ *     properties: {
+ *       name: { type: "string" },
+ *     },
+ *     required: ["name"],
+ *   }),
+ *   execute: async ({ name }) => `Hello, ${name}!`,
+ * });
+ * ```
+ *
+ * @param schema - A plain JSON Schema object
+ * @returns A Standard Schema that validates against `schema`
+ */
+declare function jsonSchemaAdapter(schema: JsonSchemaObject): JsonSchemaStandardSchema;
+
 interface Logger {
     debug(...args: unknown[]): void;
     error(...args: unknown[]): void;
@@ -120,6 +185,22 @@ type Context<T extends FastMCPSessionAuth> = {
      * counters, or maintain user-specific data across multiple requests.
      */
     sessionId?: string;
+    /**
+     * Streams incremental content while the tool is still executing, by emitting
+     * a `notifications/tool/streamContent` notification.
+     *
+     * NOTE: this is a FastMCP extension, not part of the MCP specification. As of
+     * revision 2025-11-25 the spec has no streaming tool output primitive (see
+     * SEP-2998 for the in-progress proposal). A client only receives these
+     * notifications if it registers a handler for the method or sets a
+     * `fallbackNotificationHandler`; otherwise the SDK drops them silently. No
+     * client is known to render them as tool output.
+     *
+     * Always return a final result from `execute` rather than relying on streamed
+     * content alone, otherwise clients that ignore the notification see an empty
+     * tool result. For incremental status that works everywhere, prefer
+     * {@link Context.reportProgress} with a `message`.
+     */
     streamContent: (content: Content | Content[]) => Promise<void>;
 };
 type Extra = unknown;
@@ -134,6 +215,13 @@ type Literal = boolean | null | number | string | undefined;
  */
 type LoadContext<T extends FastMCPSessionAuth> = Omit<Context<T>, "reportProgress" | "streamContent">;
 type Progress = {
+    /**
+     * An optional human-readable message describing the current progress.
+     *
+     * Part of `notifications/progress` since MCP revision 2025-03-26, so unlike
+     * `streamContent` this reaches any spec-compliant client.
+     */
+    message?: string;
     /**
      * The progress thus far. This should increase every time progress is made, even if the total is unknown.
      */
@@ -616,8 +704,11 @@ type Tool<T extends FastMCPSessionAuth, Params extends ToolParameters = ToolPara
     };
     annotations?: {
         /**
-         * When true, the tool leverages incremental content streaming
-         * Return void for tools that handle all their output via streaming
+         * Advisory metadata signalling that the tool streams incremental content
+         * via {@link Context.streamContent}. Forwarded verbatim in `tools/list`.
+         *
+         * This has no effect on FastMCP's behavior: it neither enables nor is
+         * required by `streamContent`. No known client interprets it today.
          */
         streamingHint?: boolean;
     } & ToolAnnotations;
@@ -920,4 +1011,4 @@ declare class FastMCP<T extends FastMCPSessionAuth = FastMCPSessionAuth> extends
     stop(): Promise<void>;
 }
 
-export { type AudioContent, AuthProvider, type Content, type ContentResult, type Context, DiscoveryDocumentCache, FastMCP, type FastMCPEvents, type FastMCPRequest, type FastMCPResponse, FastMCPSession, type FastMCPSessionAuth, type FastMCPSessionEvents, type HTTPMethod, type ImageContent, type InputPrompt, type InputPromptArgument, type LoadContext, type Logger, type LoggingLevel, OAuthSession, type Progress, type Prompt, type PromptArgument, type Resource, type ResourceContent, type ResourceResult, type ResourceTemplate, type ResourceTemplateArgument, type RouteHandler, type RouteOptions, type SSEServer, type SerializableValue, type ServerOptions, ServerState, type TextContent, type Tool, type ToolParameters, UnexpectedStateError, UserError, audioContent, imageContent };
+export { type AudioContent, AuthProvider, type Content, type ContentResult, type Context, DiscoveryDocumentCache, FastMCP, type FastMCPEvents, type FastMCPRequest, type FastMCPResponse, FastMCPSession, type FastMCPSessionAuth, type FastMCPSessionEvents, type HTTPMethod, type ImageContent, type InputPrompt, type InputPromptArgument, type JsonSchemaObject, type JsonSchemaStandardSchema, type LoadContext, type Logger, type LoggingLevel, OAuthSession, type Progress, type Prompt, type PromptArgument, type Resource, type ResourceContent, type ResourceResult, type ResourceTemplate, type ResourceTemplateArgument, type RouteHandler, type RouteOptions, type SSEServer, type SerializableValue, type ServerOptions, ServerState, type TextContent, type Tool, type ToolParameters, UnexpectedStateError, UserError, audioContent, imageContent, jsonSchemaAdapter };

package/dist/FastMCP.js

@@ -6,8 +6,9 @@ import {
   UnexpectedStateError,
   UserError,
   audioContent,
-  imageContent
-} from "./chunk-JIPRWP6F.js";
+  imageContent,
+  jsonSchemaAdapter
+} from "./chunk-JOZJUFKE.js";
 import {
   AuthProvider,
   AzureProvider,
@@ -36,6 +37,7 @@ export {
   audioContent,
   getAuthSession,
   imageContent,
+  jsonSchemaAdapter,
   requireAll,
   requireAny,
   requireAuth,