@modelcontextprotocol/sdk 1.10.2 → 1.11.0

package/dist/esm/types.d.ts

@@ -1,5 +1,5 @@
 import { z, ZodTypeAny } from "zod";
-export declare const LATEST_PROTOCOL_VERSION = "2024-11-05";
+export declare const LATEST_PROTOCOL_VERSION = "2025-03-26";
 export declare const SUPPORTED_PROTOCOL_VERSIONS: string[];
 export declare const JSONRPC_VERSION = "2.0";
 /**
@@ -10,6 +10,22 @@ export declare const ProgressTokenSchema: z.ZodUnion<[z.ZodString, z.ZodNumber]>
  * An opaque token used to represent a cursor for pagination.
  */
 export declare const CursorSchema: z.ZodString;
+declare const RequestMetaSchema: z.ZodObject<{
+    /**
+     * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+     */
+    progressToken: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    /**
+     * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+     */
+    progressToken: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    /**
+     * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+     */
+    progressToken: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+}, z.ZodTypeAny, "passthrough">>;
 export declare const RequestSchema: z.ZodObject<{
     method: z.ZodString;
     params: z.ZodOptional<z.ZodObject<{
@@ -10397,6 +10413,131 @@ export declare const PromptListChangedNotificationSchema: z.ZodObject<z.objectUt
         _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
 }>;
+/**
+ * Additional properties describing a Tool to clients.
+ *
+ * NOTE: all properties in ToolAnnotations are **hints**.
+ * They are not guaranteed to provide a faithful description of
+ * tool behavior (including descriptive properties like `title`).
+ *
+ * Clients should never make tool use decisions based on ToolAnnotations
+ * received from untrusted servers.
+ */
+export declare const ToolAnnotationsSchema: z.ZodObject<{
+    /**
+     * A human-readable title for the tool.
+     */
+    title: z.ZodOptional<z.ZodString>;
+    /**
+     * If true, the tool does not modify its environment.
+     *
+     * Default: false
+     */
+    readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * If true, the tool may perform destructive updates to its environment.
+     * If false, the tool performs only additive updates.
+     *
+     * (This property is meaningful only when `readOnlyHint == false`)
+     *
+     * Default: true
+     */
+    destructiveHint: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * If true, calling the tool repeatedly with the same arguments
+     * will have no additional effect on the its environment.
+     *
+     * (This property is meaningful only when `readOnlyHint == false`)
+     *
+     * Default: false
+     */
+    idempotentHint: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * If true, this tool may interact with an "open world" of external
+     * entities. If false, the tool's domain of interaction is closed.
+     * For example, the world of a web search tool is open, whereas that
+     * of a memory tool is not.
+     *
+     * Default: true
+     */
+    openWorldHint: z.ZodOptional<z.ZodBoolean>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    /**
+     * A human-readable title for the tool.
+     */
+    title: z.ZodOptional<z.ZodString>;
+    /**
+     * If true, the tool does not modify its environment.
+     *
+     * Default: false
+     */
+    readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * If true, the tool may perform destructive updates to its environment.
+     * If false, the tool performs only additive updates.
+     *
+     * (This property is meaningful only when `readOnlyHint == false`)
+     *
+     * Default: true
+     */
+    destructiveHint: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * If true, calling the tool repeatedly with the same arguments
+     * will have no additional effect on the its environment.
+     *
+     * (This property is meaningful only when `readOnlyHint == false`)
+     *
+     * Default: false
+     */
+    idempotentHint: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * If true, this tool may interact with an "open world" of external
+     * entities. If false, the tool's domain of interaction is closed.
+     * For example, the world of a web search tool is open, whereas that
+     * of a memory tool is not.
+     *
+     * Default: true
+     */
+    openWorldHint: z.ZodOptional<z.ZodBoolean>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    /**
+     * A human-readable title for the tool.
+     */
+    title: z.ZodOptional<z.ZodString>;
+    /**
+     * If true, the tool does not modify its environment.
+     *
+     * Default: false
+     */
+    readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * If true, the tool may perform destructive updates to its environment.
+     * If false, the tool performs only additive updates.
+     *
+     * (This property is meaningful only when `readOnlyHint == false`)
+     *
+     * Default: true
+     */
+    destructiveHint: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * If true, calling the tool repeatedly with the same arguments
+     * will have no additional effect on the its environment.
+     *
+     * (This property is meaningful only when `readOnlyHint == false`)
+     *
+     * Default: false
+     */
+    idempotentHint: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * If true, this tool may interact with an "open world" of external
+     * entities. If false, the tool's domain of interaction is closed.
+     * For example, the world of a web search tool is open, whereas that
+     * of a memory tool is not.
+     *
+     * Default: true
+     */
+    openWorldHint: z.ZodOptional<z.ZodBoolean>;
+}, z.ZodTypeAny, "passthrough">>;
 /**
  * Definition for a tool the client can call.
  */
@@ -10422,6 +10563,124 @@ export declare const ToolSchema: z.ZodObject<{
         type: z.ZodLiteral<"object">;
         properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
     }, z.ZodTypeAny, "passthrough">>;
+    /**
+     * Optional additional tool information.
+     */
+    annotations: z.ZodOptional<z.ZodObject<{
+        /**
+         * A human-readable title for the tool.
+         */
+        title: z.ZodOptional<z.ZodString>;
+        /**
+         * If true, the tool does not modify its environment.
+         *
+         * Default: false
+         */
+        readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, the tool may perform destructive updates to its environment.
+         * If false, the tool performs only additive updates.
+         *
+         * (This property is meaningful only when `readOnlyHint == false`)
+         *
+         * Default: true
+         */
+        destructiveHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, calling the tool repeatedly with the same arguments
+         * will have no additional effect on the its environment.
+         *
+         * (This property is meaningful only when `readOnlyHint == false`)
+         *
+         * Default: false
+         */
+        idempotentHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, this tool may interact with an "open world" of external
+         * entities. If false, the tool's domain of interaction is closed.
+         * For example, the world of a web search tool is open, whereas that
+         * of a memory tool is not.
+         *
+         * Default: true
+         */
+        openWorldHint: z.ZodOptional<z.ZodBoolean>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        /**
+         * A human-readable title for the tool.
+         */
+        title: z.ZodOptional<z.ZodString>;
+        /**
+         * If true, the tool does not modify its environment.
+         *
+         * Default: false
+         */
+        readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, the tool may perform destructive updates to its environment.
+         * If false, the tool performs only additive updates.
+         *
+         * (This property is meaningful only when `readOnlyHint == false`)
+         *
+         * Default: true
+         */
+        destructiveHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, calling the tool repeatedly with the same arguments
+         * will have no additional effect on the its environment.
+         *
+         * (This property is meaningful only when `readOnlyHint == false`)
+         *
+         * Default: false
+         */
+        idempotentHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, this tool may interact with an "open world" of external
+         * entities. If false, the tool's domain of interaction is closed.
+         * For example, the world of a web search tool is open, whereas that
+         * of a memory tool is not.
+         *
+         * Default: true
+         */
+        openWorldHint: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        /**
+         * A human-readable title for the tool.
+         */
+        title: z.ZodOptional<z.ZodString>;
+        /**
+         * If true, the tool does not modify its environment.
+         *
+         * Default: false
+         */
+        readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, the tool may perform destructive updates to its environment.
+         * If false, the tool performs only additive updates.
+         *
+         * (This property is meaningful only when `readOnlyHint == false`)
+         *
+         * Default: true
+         */
+        destructiveHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, calling the tool repeatedly with the same arguments
+         * will have no additional effect on the its environment.
+         *
+         * (This property is meaningful only when `readOnlyHint == false`)
+         *
+         * Default: false
+         */
+        idempotentHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, this tool may interact with an "open world" of external
+         * entities. If false, the tool's domain of interaction is closed.
+         * For example, the world of a web search tool is open, whereas that
+         * of a memory tool is not.
+         *
+         * Default: true
+         */
+        openWorldHint: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">>>;
 }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
     /**
      * The name of the tool.
@@ -10444,6 +10703,124 @@ export declare const ToolSchema: z.ZodObject<{
         type: z.ZodLiteral<"object">;
         properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
     }, z.ZodTypeAny, "passthrough">>;
+    /**
+     * Optional additional tool information.
+     */
+    annotations: z.ZodOptional<z.ZodObject<{
+        /**
+         * A human-readable title for the tool.
+         */
+        title: z.ZodOptional<z.ZodString>;
+        /**
+         * If true, the tool does not modify its environment.
+         *
+         * Default: false
+         */
+        readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, the tool may perform destructive updates to its environment.
+         * If false, the tool performs only additive updates.
+         *
+         * (This property is meaningful only when `readOnlyHint == false`)
+         *
+         * Default: true
+         */
+        destructiveHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, calling the tool repeatedly with the same arguments
+         * will have no additional effect on the its environment.
+         *
+         * (This property is meaningful only when `readOnlyHint == false`)
+         *
+         * Default: false
+         */
+        idempotentHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, this tool may interact with an "open world" of external
+         * entities. If false, the tool's domain of interaction is closed.
+         * For example, the world of a web search tool is open, whereas that
+         * of a memory tool is not.
+         *
+         * Default: true
+         */
+        openWorldHint: z.ZodOptional<z.ZodBoolean>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        /**
+         * A human-readable title for the tool.
+         */
+        title: z.ZodOptional<z.ZodString>;
+        /**
+         * If true, the tool does not modify its environment.
+         *
+         * Default: false
+         */
+        readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, the tool may perform destructive updates to its environment.
+         * If false, the tool performs only additive updates.
+         *
+         * (This property is meaningful only when `readOnlyHint == false`)
+         *
+         * Default: true
+         */
+        destructiveHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, calling the tool repeatedly with the same arguments
+         * will have no additional effect on the its environment.
+         *
+         * (This property is meaningful only when `readOnlyHint == false`)
+         *
+         * Default: false
+         */
+        idempotentHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, this tool may interact with an "open world" of external
+         * entities. If false, the tool's domain of interaction is closed.
+         * For example, the world of a web search tool is open, whereas that
+         * of a memory tool is not.
+         *
+         * Default: true
+         */
+        openWorldHint: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        /**
+         * A human-readable title for the tool.
+         */
+        title: z.ZodOptional<z.ZodString>;
+        /**
+         * If true, the tool does not modify its environment.
+         *
+         * Default: false
+         */
+        readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, the tool may perform destructive updates to its environment.
+         * If false, the tool performs only additive updates.
+         *
+         * (This property is meaningful only when `readOnlyHint == false`)
+         *
+         * Default: true
+         */
+        destructiveHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, calling the tool repeatedly with the same arguments
+         * will have no additional effect on the its environment.
+         *
+         * (This property is meaningful only when `readOnlyHint == false`)
+         *
+         * Default: false
+         */
+        idempotentHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, this tool may interact with an "open world" of external
+         * entities. If false, the tool's domain of interaction is closed.
+         * For example, the world of a web search tool is open, whereas that
+         * of a memory tool is not.
+         *
+         * Default: true
+         */
+        openWorldHint: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">>>;
 }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
     /**
      * The name of the tool.
@@ -10466,6 +10843,124 @@ export declare const ToolSchema: z.ZodObject<{
         type: z.ZodLiteral<"object">;
         properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
     }, z.ZodTypeAny, "passthrough">>;
+    /**
+     * Optional additional tool information.
+     */
+    annotations: z.ZodOptional<z.ZodObject<{
+        /**
+         * A human-readable title for the tool.
+         */
+        title: z.ZodOptional<z.ZodString>;
+        /**
+         * If true, the tool does not modify its environment.
+         *
+         * Default: false
+         */
+        readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, the tool may perform destructive updates to its environment.
+         * If false, the tool performs only additive updates.
+         *
+         * (This property is meaningful only when `readOnlyHint == false`)
+         *
+         * Default: true
+         */
+        destructiveHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, calling the tool repeatedly with the same arguments
+         * will have no additional effect on the its environment.
+         *
+         * (This property is meaningful only when `readOnlyHint == false`)
+         *
+         * Default: false
+         */
+        idempotentHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, this tool may interact with an "open world" of external
+         * entities. If false, the tool's domain of interaction is closed.
+         * For example, the world of a web search tool is open, whereas that
+         * of a memory tool is not.
+         *
+         * Default: true
+         */
+        openWorldHint: z.ZodOptional<z.ZodBoolean>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        /**
+         * A human-readable title for the tool.
+         */
+        title: z.ZodOptional<z.ZodString>;
+        /**
+         * If true, the tool does not modify its environment.
+         *
+         * Default: false
+         */
+        readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, the tool may perform destructive updates to its environment.
+         * If false, the tool performs only additive updates.
+         *
+         * (This property is meaningful only when `readOnlyHint == false`)
+         *
+         * Default: true
+         */
+        destructiveHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, calling the tool repeatedly with the same arguments
+         * will have no additional effect on the its environment.
+         *
+         * (This property is meaningful only when `readOnlyHint == false`)
+         *
+         * Default: false
+         */
+        idempotentHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, this tool may interact with an "open world" of external
+         * entities. If false, the tool's domain of interaction is closed.
+         * For example, the world of a web search tool is open, whereas that
+         * of a memory tool is not.
+         *
+         * Default: true
+         */
+        openWorldHint: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        /**
+         * A human-readable title for the tool.
+         */
+        title: z.ZodOptional<z.ZodString>;
+        /**
+         * If true, the tool does not modify its environment.
+         *
+         * Default: false
+         */
+        readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, the tool may perform destructive updates to its environment.
+         * If false, the tool performs only additive updates.
+         *
+         * (This property is meaningful only when `readOnlyHint == false`)
+         *
+         * Default: true
+         */
+        destructiveHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, calling the tool repeatedly with the same arguments
+         * will have no additional effect on the its environment.
+         *
+         * (This property is meaningful only when `readOnlyHint == false`)
+         *
+         * Default: false
+         */
+        idempotentHint: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * If true, this tool may interact with an "open world" of external
+         * entities. If false, the tool's domain of interaction is closed.
+         * For example, the world of a web search tool is open, whereas that
+         * of a memory tool is not.
+         *
+         * Default: true
+         */
+        openWorldHint: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">>>;
 }, z.ZodTypeAny, "passthrough">>;
 /**
  * Sent from the client to request a list of tools the server has.
@@ -10687,32 +11182,128 @@ export declare const ListToolsResultSchema: z.ZodObject<z.objectUtil.extendShape
             type: z.ZodLiteral<"object">;
             properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
         }, z.ZodTypeAny, "passthrough">>;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         /**
-         * The name of the tool.
-         */
-        name: z.ZodString;
-        /**
-         * A human-readable description of the tool.
-         */
-        description: z.ZodOptional<z.ZodString>;
-        /**
-         * A JSON Schema object defining the expected parameters for the tool.
+         * Optional additional tool information.
          */
-        inputSchema: z.ZodObject<{
-            type: z.ZodLiteral<"object">;
-            properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+        annotations: z.ZodOptional<z.ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
         }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-            type: z.ZodLiteral<"object">;
-            properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
-        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-            type: z.ZodLiteral<"object">;
-            properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
-        }, z.ZodTypeAny, "passthrough">>;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        /**
-         * The name of the tool.
-         */
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        /**
+         * The name of the tool.
+         */
         name: z.ZodString;
         /**
          * A human-readable description of the tool.
@@ -10731,6 +11322,264 @@ export declare const ListToolsResultSchema: z.ZodObject<z.objectUtil.extendShape
             type: z.ZodLiteral<"object">;
             properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
         }, z.ZodTypeAny, "passthrough">>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: z.ZodOptional<z.ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        /**
+         * The name of the tool.
+         */
+        name: z.ZodString;
+        /**
+         * A human-readable description of the tool.
+         */
+        description: z.ZodOptional<z.ZodString>;
+        /**
+         * A JSON Schema object defining the expected parameters for the tool.
+         */
+        inputSchema: z.ZodObject<{
+            type: z.ZodLiteral<"object">;
+            properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            type: z.ZodLiteral<"object">;
+            properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            type: z.ZodLiteral<"object">;
+            properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+        }, z.ZodTypeAny, "passthrough">>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: z.ZodOptional<z.ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">>>;
     }, z.ZodTypeAny, "passthrough">>, "many">;
 }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
     /**
@@ -10766,6 +11615,124 @@ export declare const ListToolsResultSchema: z.ZodObject<z.objectUtil.extendShape
             type: z.ZodLiteral<"object">;
             properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
         }, z.ZodTypeAny, "passthrough">>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: z.ZodOptional<z.ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">>>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         /**
          * The name of the tool.
@@ -10788,6 +11755,124 @@ export declare const ListToolsResultSchema: z.ZodObject<z.objectUtil.extendShape
             type: z.ZodLiteral<"object">;
             properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
         }, z.ZodTypeAny, "passthrough">>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: z.ZodOptional<z.ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">>>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         /**
          * The name of the tool.
@@ -10810,6 +11895,124 @@ export declare const ListToolsResultSchema: z.ZodObject<z.objectUtil.extendShape
             type: z.ZodLiteral<"object">;
             properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
         }, z.ZodTypeAny, "passthrough">>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: z.ZodOptional<z.ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">>>;
     }, z.ZodTypeAny, "passthrough">>, "many">;
 }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
     /**
@@ -10845,6 +12048,124 @@ export declare const ListToolsResultSchema: z.ZodObject<z.objectUtil.extendShape
             type: z.ZodLiteral<"object">;
             properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
         }, z.ZodTypeAny, "passthrough">>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: z.ZodOptional<z.ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">>>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         /**
          * The name of the tool.
@@ -10867,6 +12188,124 @@ export declare const ListToolsResultSchema: z.ZodObject<z.objectUtil.extendShape
             type: z.ZodLiteral<"object">;
             properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
         }, z.ZodTypeAny, "passthrough">>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: z.ZodOptional<z.ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">>>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         /**
          * The name of the tool.
@@ -10889,6 +12328,124 @@ export declare const ListToolsResultSchema: z.ZodObject<z.objectUtil.extendShape
             type: z.ZodLiteral<"object">;
             properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
         }, z.ZodTypeAny, "passthrough">>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: z.ZodOptional<z.ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">>>;
     }, z.ZodTypeAny, "passthrough">>, "many">;
 }>, z.ZodTypeAny, "passthrough">>;
 /**
@@ -28126,6 +29683,124 @@ export declare const ServerResultSchema: z.ZodUnion<[z.ZodObject<{
             type: z.ZodLiteral<"object">;
             properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
         }, z.ZodTypeAny, "passthrough">>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: z.ZodOptional<z.ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">>>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         /**
          * The name of the tool.
@@ -28148,6 +29823,124 @@ export declare const ServerResultSchema: z.ZodUnion<[z.ZodObject<{
             type: z.ZodLiteral<"object">;
             properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
         }, z.ZodTypeAny, "passthrough">>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: z.ZodOptional<z.ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">>>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         /**
          * The name of the tool.
@@ -28170,6 +29963,124 @@ export declare const ServerResultSchema: z.ZodUnion<[z.ZodObject<{
             type: z.ZodLiteral<"object">;
             properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
         }, z.ZodTypeAny, "passthrough">>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: z.ZodOptional<z.ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">>>;
     }, z.ZodTypeAny, "passthrough">>, "many">;
 }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
     /**
@@ -28205,6 +30116,124 @@ export declare const ServerResultSchema: z.ZodUnion<[z.ZodObject<{
             type: z.ZodLiteral<"object">;
             properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
         }, z.ZodTypeAny, "passthrough">>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: z.ZodOptional<z.ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">>>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         /**
          * The name of the tool.
@@ -28227,6 +30256,124 @@ export declare const ServerResultSchema: z.ZodUnion<[z.ZodObject<{
             type: z.ZodLiteral<"object">;
             properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
         }, z.ZodTypeAny, "passthrough">>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: z.ZodOptional<z.ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">>>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         /**
          * The name of the tool.
@@ -28249,6 +30396,124 @@ export declare const ServerResultSchema: z.ZodUnion<[z.ZodObject<{
             type: z.ZodLiteral<"object">;
             properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
         }, z.ZodTypeAny, "passthrough">>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: z.ZodOptional<z.ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">>>;
     }, z.ZodTypeAny, "passthrough">>, "many">;
 }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
     /**
@@ -28284,6 +30549,124 @@ export declare const ServerResultSchema: z.ZodUnion<[z.ZodObject<{
             type: z.ZodLiteral<"object">;
             properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
         }, z.ZodTypeAny, "passthrough">>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: z.ZodOptional<z.ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">>>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         /**
          * The name of the tool.
@@ -28306,6 +30689,124 @@ export declare const ServerResultSchema: z.ZodUnion<[z.ZodObject<{
             type: z.ZodLiteral<"object">;
             properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
         }, z.ZodTypeAny, "passthrough">>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: z.ZodOptional<z.ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">>>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         /**
          * The name of the tool.
@@ -28328,6 +30829,124 @@ export declare const ServerResultSchema: z.ZodUnion<[z.ZodObject<{
             type: z.ZodLiteral<"object">;
             properties: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
         }, z.ZodTypeAny, "passthrough">>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: z.ZodOptional<z.ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: z.ZodOptional<z.ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, the tool may perform destructive updates to its environment.
+             * If false, the tool performs only additive updates.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: true
+             */
+            destructiveHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, calling the tool repeatedly with the same arguments
+             * will have no additional effect on the its environment.
+             *
+             * (This property is meaningful only when `readOnlyHint == false`)
+             *
+             * Default: false
+             */
+            idempotentHint: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * If true, this tool may interact with an "open world" of external
+             * entities. If false, the tool's domain of interaction is closed.
+             * For example, the world of a web search tool is open, whereas that
+             * of a memory tool is not.
+             *
+             * Default: true
+             */
+            openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">>>;
     }, z.ZodTypeAny, "passthrough">>, "many">;
 }>, z.ZodTypeAny, "passthrough">>]>;
 export declare class McpError extends Error {
@@ -28343,6 +30962,7 @@ type Infer<Schema extends ZodTypeAny> = Flatten<z.infer<Schema>>;
 export type ProgressToken = Infer<typeof ProgressTokenSchema>;
 export type Cursor = Infer<typeof CursorSchema>;
 export type Request = Infer<typeof RequestSchema>;
+export type RequestMeta = Infer<typeof RequestMetaSchema>;
 export type Notification = Infer<typeof NotificationSchema>;
 export type Result = Infer<typeof ResultSchema>;
 export type RequestId = Infer<typeof RequestIdSchema>;
@@ -28391,6 +31011,7 @@ export type EmbeddedResource = Infer<typeof EmbeddedResourceSchema>;
 export type PromptMessage = Infer<typeof PromptMessageSchema>;
 export type GetPromptResult = Infer<typeof GetPromptResultSchema>;
 export type PromptListChangedNotification = Infer<typeof PromptListChangedNotificationSchema>;
+export type ToolAnnotations = Infer<typeof ToolAnnotationsSchema>;
 export type Tool = Infer<typeof ToolSchema>;
 export type ListToolsRequest = Infer<typeof ListToolsRequestSchema>;
 export type ListToolsResult = Infer<typeof ListToolsResultSchema>;