likec4 1.32.0 → 1.32.1

package/dist/shared/{likec4.8nZi1RFs.d.mts → likec4.CVzYPnDX.d.mts}

@@ -15616,8 +15616,9 @@ type ProjectConfig = InferOutput<typeof ProjectConfig>;
 type ArrowType = 'crow' | 'diamond' | 'dot' | 'none' | 'normal' | 'odiamond' | 'odot' | 'onormal' | 'open' | 'vee';
 type Boolean = boolean;
 type BorderStyleValue = 'none' | LineOptions;
+type ColorLiteral = HexColor | RGBAColor;
+declare const ColorLiteral = "ColorLiteral";
 type CustomColorId = 'element' | 'model' | ArrowType | ElementShape | LineOptions | string;
-type CustomColorValue = string;
 type DeploymentElement = DeployedInstance | DeploymentNode;
 declare const DeploymentElement = "DeploymentElement";
 type DeploymentNodeOrElementKind = DeploymentNodeKind | ElementKind;
@@ -16076,6 +16077,12 @@ interface GlobalStyleId extends AstNode {
     name: string;
 }
 declare const GlobalStyleId = "GlobalStyleId";
+interface HexColor extends AstNode {
+    readonly $container: SpecificationColor | SpecificationTag;
+    readonly $type: 'HexColor';
+    hex: number | string;
+}
+declare const HexColor = "HexColor";
 interface IconProperty extends AstNode {
     readonly $container: CustomElementProperties | DeployedInstanceBody | DeploymentNodeBody | DeploymentViewRuleStyle | ElementBody | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
     readonly $type: 'IconProperty';
@@ -16301,6 +16308,15 @@ interface RelationStyleProperty extends AstNode {
     props: Array<RelationshipStyleProperty>;
 }
 declare const RelationStyleProperty = "RelationStyleProperty";
+interface RGBAColor extends AstNode {
+    readonly $container: SpecificationColor | SpecificationTag;
+    readonly $type: 'RGBAColor';
+    alpha?: number | string;
+    blue: number;
+    green: number;
+    red: number;
+}
+declare const RGBAColor = "RGBAColor";
 interface ShapeProperty extends AstNode {
     readonly $container: CustomElementProperties | DeploymentViewRuleStyle | ElementStyleProperty | GlobalStyle | ViewRuleStyle;
     readonly $type: 'ShapeProperty';
@@ -16318,7 +16334,7 @@ declare const ShapeSizeProperty = "ShapeSizeProperty";
 interface SpecificationColor extends AstNode {
     readonly $container: SpecificationRule;
     readonly $type: 'SpecificationColor';
-    color: CustomColorValue;
+    color: ColorLiteral;
     name: CustomColor;
 }
 declare const SpecificationColor = "SpecificationColor";
@@ -16373,7 +16389,7 @@ declare const SpecificationRule = "SpecificationRule";
 interface SpecificationTag extends AstNode {
     readonly $container: SpecificationRule;
     readonly $type: 'SpecificationTag';
-    color?: CustomColorValue;
+    color?: ColorLiteral;
     tag: Tag;
 }
 declare const SpecificationTag = "SpecificationTag";
@@ -16551,6 +16567,7 @@ declare const WildcardExpression = "WildcardExpression";
 type LikeC4AstType = {
     ArrowProperty: ArrowProperty;
     BorderProperty: BorderProperty;
+    ColorLiteral: ColorLiteral;
     ColorProperty: ColorProperty;
     CustomColor: CustomColor;
     CustomElementProperties: CustomElementProperties;
@@ -16612,6 +16629,7 @@ type LikeC4AstType = {
     GlobalStyleGroup: GlobalStyleGroup;
     GlobalStyleId: GlobalStyleId;
     Globals: Globals;
+    HexColor: HexColor;
     IconProperty: IconProperty;
     Imported: Imported;
     ImportsFromPoject: ImportsFromPoject;
@@ -16637,6 +16655,7 @@ type LikeC4AstType = {
     OpacityProperty: OpacityProperty;
     OutgoingRelationExpr: OutgoingRelationExpr;
     PaddingSizeProperty: PaddingSizeProperty;
+    RGBAColor: RGBAColor;
     Referenceable: Referenceable;
     Relation: Relation;
     RelationBody: RelationBody;
@@ -16703,7 +16722,7 @@ type LikeC4AstType = {
 
 type Guard<N extends AstNode> = (n: AstNode) => n is N;
 type Guarded<G> = G extends Guard<infer N> ? N : never;
-declare const isValidatableAstNode: (n: AstNode) => n is DeployedInstance | DeploymentNode | DeploymentViewRulePredicate | DeploymentViewRuleStyle | ViewRuleAutoLayout | DynamicViewGlobalPredicateRef | DynamicViewIncludePredicate | ViewRuleGlobalStyle | ViewRuleStyle | ElementStringProperty | ElementStyleProperty | IconProperty | LinkProperty | MetadataBody | ElementKindExpression | ElementTagExpression | FqnRefExpr | WildcardExpression | FqnExprWhere | FqnExprWith | DirectedRelationExpr | InOutRelationExpr | IncomingRelationExpr | OutgoingRelationExpr | RelationExprWhere | RelationExprWith | Element | ExtendDeployment | ExtendElement | Imported | DeploymentView | DynamicView | ElementView | RelationStringProperty | ArrowProperty | ColorProperty | LineProperty | PaddingSizeProperty | ShapeSizeProperty | TextSizeProperty | MetadataAttribute | NotationProperty | NotesProperty | SpecificationElementStringProperty | SpecificationRelationshipStringProperty | ViewStringProperty | BorderProperty | MultipleProperty | OpacityProperty | ShapeProperty | ViewRuleGlobalPredicateRef | ViewRuleGroup | ViewRulePredicate | SpecificationRelationshipKind | GlobalStyle | SpecificationColor | NavigateToProperty | DynamicViewStep | ElementRef | DeploymentRelation | Tags | SpecificationDeploymentNodeKind | DynamicViewParallelSteps | GlobalDynamicPredicateGroup | Relation | SpecificationElementKind | Globals | GlobalPredicateGroup | GlobalStyleGroup | ImportsFromPoject | SpecificationRule | SpecificationTag;
+declare const isValidatableAstNode: (n: AstNode) => n is HexColor | RGBAColor | DeployedInstance | DeploymentNode | DeploymentViewRulePredicate | DeploymentViewRuleStyle | ViewRuleAutoLayout | DynamicViewGlobalPredicateRef | DynamicViewIncludePredicate | ViewRuleGlobalStyle | ViewRuleStyle | ElementStringProperty | ElementStyleProperty | IconProperty | LinkProperty | MetadataBody | ElementKindExpression | ElementTagExpression | FqnRefExpr | WildcardExpression | FqnExprWhere | FqnExprWith | DirectedRelationExpr | InOutRelationExpr | IncomingRelationExpr | OutgoingRelationExpr | RelationExprWhere | RelationExprWith | Element | ExtendDeployment | ExtendElement | Imported | DeploymentView | DynamicView | ElementView | RelationStringProperty | ArrowProperty | ColorProperty | LineProperty | PaddingSizeProperty | ShapeSizeProperty | TextSizeProperty | MetadataAttribute | NotationProperty | NotesProperty | SpecificationElementStringProperty | SpecificationRelationshipStringProperty | ViewStringProperty | BorderProperty | MultipleProperty | OpacityProperty | ShapeProperty | ViewRuleGlobalPredicateRef | ViewRuleGroup | ViewRulePredicate | SpecificationRelationshipKind | GlobalStyle | SpecificationColor | NavigateToProperty | DynamicViewStep | ElementRef | DeploymentRelation | Tags | SpecificationDeploymentNodeKind | DynamicViewParallelSteps | GlobalDynamicPredicateGroup | Relation | SpecificationElementKind | Globals | GlobalPredicateGroup | GlobalStyleGroup | SpecificationTag | ImportsFromPoject | SpecificationRule;
 type ValidatableAstNode = Guarded<typeof isValidatableAstNode>;
 declare function checksFromDiagnostics(doc: LikeC4LangiumDocument): {
     isValid: (n: ValidatableAstNode) => boolean;
@@ -17173,6 +17192,7 @@ declare class BaseParser {
     convertLinks(source?: LinkProperty['$container']): c4.Link[] | undefined;
     parseLinks(source?: LinkProperty['$container']): c4.Link[] | undefined;
     parseIconProperty(prop: IconProperty | undefined): c4.IconUrl | undefined;
+    parseColorLiteral(astNode: ColorLiteral): c4.ColorLiteral | undefined;
     parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
     parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
 }
@@ -17245,6 +17265,7 @@ declare const DocumentParserFromMixins: {
         convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
         parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
         parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+        parseColorLiteral(astNode: ColorLiteral): ProjectId | undefined;
         parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
         parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
         parseDeploymentView(astNode: DeploymentView): ParsedAstDeploymentView;
@@ -17321,6 +17342,7 @@ declare const DocumentParserFromMixins: {
         convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
         parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
         parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+        parseColorLiteral(astNode: ColorLiteral): ProjectId | undefined;
         parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
         parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
         parseDeploymentView(astNode: DeploymentView): ParsedAstDeploymentView;
@@ -17361,6 +17383,7 @@ declare const DocumentParserFromMixins: {
         convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
         parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
         parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+        parseColorLiteral(astNode: ColorLiteral): ProjectId | undefined;
         parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
         parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     };
@@ -17413,6 +17436,7 @@ declare const DocumentParserFromMixins: {
         convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
         parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
         parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+        parseColorLiteral(astNode: ColorLiteral): ProjectId | undefined;
         parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
         parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     };
@@ -17458,6 +17482,7 @@ declare const DocumentParserFromMixins: {
         convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
         parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
         parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+        parseColorLiteral(astNode: ColorLiteral): ProjectId | undefined;
         parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
         parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
         parseDeployment(): void;
@@ -17511,6 +17536,7 @@ declare const DocumentParserFromMixins: {
         convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
         parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
         parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+        parseColorLiteral(astNode: ColorLiteral): ProjectId | undefined;
         parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
         parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     };
@@ -17557,6 +17583,7 @@ declare const DocumentParserFromMixins: {
         convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
         parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
         parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+        parseColorLiteral(astNode: ColorLiteral): ProjectId | undefined;
         parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
         parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     };
@@ -17585,6 +17612,7 @@ declare const DocumentParserFromMixins: {
         convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
         parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
         parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+        parseColorLiteral(astNode: ColorLiteral): ProjectId | undefined;
         parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
         parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     };
@@ -17626,6 +17654,7 @@ declare const DocumentParserFromMixins: {
         convertLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
         parseLinks(source?: LinkProperty["$container"]): ProjectId[] | undefined;
         parseIconProperty(prop: IconProperty | undefined): ProjectId | undefined;
+        parseColorLiteral(astNode: ColorLiteral): ProjectId | undefined;
         parseElementStyle(elementProps: Array<ElementProperty> | ElementStyleProperty | undefined): ParsedElementStyle;
         parseStyleProps(styleProps: Array<StyleProperty> | undefined): ParsedElementStyle;
     };
@@ -18947,6 +18976,22 @@ declare enum ZodFirstPartyTypeKind {
     ZodReadonly = "ZodReadonly"
 }
 
+declare const RequestMetaSchema: 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: ZodOptional<ZodUnion<[ZodString, ZodNumber]>>;
+}, "passthrough", ZodTypeAny, 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: ZodOptional<ZodUnion<[ZodString, ZodNumber]>>;
+}, ZodTypeAny, "passthrough">, 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: ZodOptional<ZodUnion<[ZodString, ZodNumber]>>;
+}, ZodTypeAny, "passthrough">>;
 declare const RequestSchema: ZodObject<{
     method: ZodString;
     params: ZodOptional<ZodObject<{
@@ -19673,6 +19718,10 @@ declare const ProgressSchema: ZodObject<{
      * Total number of items to process (or total progress required), if known.
      */
     total: ZodOptional<ZodNumber>;
+    /**
+     * An optional message describing the current progress.
+     */
+    message: ZodOptional<ZodString>;
 }, "passthrough", ZodTypeAny, objectOutputType<{
     /**
      * The progress thus far. This should increase every time progress is made, even if the total is unknown.
@@ -19682,6 +19731,10 @@ declare const ProgressSchema: ZodObject<{
      * Total number of items to process (or total progress required), if known.
      */
     total: ZodOptional<ZodNumber>;
+    /**
+     * An optional message describing the current progress.
+     */
+    message: ZodOptional<ZodString>;
 }, ZodTypeAny, "passthrough">, objectInputType<{
     /**
      * The progress thus far. This should increase every time progress is made, even if the total is unknown.
@@ -19691,6 +19744,10 @@ declare const ProgressSchema: ZodObject<{
      * Total number of items to process (or total progress required), if known.
      */
     total: ZodOptional<ZodNumber>;
+    /**
+     * An optional message describing the current progress.
+     */
+    message: ZodOptional<ZodString>;
 }, ZodTypeAny, "passthrough">>;
 /**
  * A known resource that the server is capable of reading.
@@ -23454,6 +23511,131 @@ declare const GetPromptResultSchema: ZodObject<objectUtil.extendShape<{
         }, ZodTypeAny, "passthrough">>]>;
     }, ZodTypeAny, "passthrough">>, "many">;
 }>, ZodTypeAny, "passthrough">>;
+/**
+ * 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.
+ */
+declare const ToolAnnotationsSchema: ZodObject<{
+    /**
+     * A human-readable title for the tool.
+     */
+    title: ZodOptional<ZodString>;
+    /**
+     * If true, the tool does not modify its environment.
+     *
+     * Default: false
+     */
+    readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+}, "passthrough", ZodTypeAny, objectOutputType<{
+    /**
+     * A human-readable title for the tool.
+     */
+    title: ZodOptional<ZodString>;
+    /**
+     * If true, the tool does not modify its environment.
+     *
+     * Default: false
+     */
+    readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+}, ZodTypeAny, "passthrough">, objectInputType<{
+    /**
+     * A human-readable title for the tool.
+     */
+    title: ZodOptional<ZodString>;
+    /**
+     * If true, the tool does not modify its environment.
+     *
+     * Default: false
+     */
+    readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+}, ZodTypeAny, "passthrough">>;
 /**
  * The server's response to a tool call.
  */
@@ -23463,7 +23645,13 @@ declare const CallToolResultSchema: ZodObject<objectUtil.extendShape<{
      */
     _meta: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
 }, {
-    content: ZodArray<ZodUnion<[ZodObject<{
+    /**
+     * A list of content objects that represent the result of the tool call.
+     *
+     * If the Tool does not define an outputSchema, this field MUST be present in the result.
+     * For backwards compatibility, this field is always present, but it may be empty.
+     */
+    content: ZodDefault<ZodArray<ZodUnion<[ZodObject<{
         type: ZodLiteral<"text">;
         /**
          * The text content of the message.
@@ -23802,15 +23990,41 @@ declare const CallToolResultSchema: ZodObject<objectUtil.extendShape<{
              */
             blob: ZodString;
         }>, ZodTypeAny, "passthrough">>]>;
-    }, ZodTypeAny, "passthrough">>]>, "many">;
-    isError: ZodOptional<ZodDefault<ZodBoolean>>;
+    }, ZodTypeAny, "passthrough">>]>, "many">>;
+    /**
+     * An object containing structured tool output.
+     *
+     * If the Tool defines an outputSchema, this field MUST be present in the result, and contain a JSON object that matches the schema.
+     */
+    structuredContent: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+    /**
+     * Whether the tool call ended in an error.
+     *
+     * If not set, this is assumed to be false (the call was successful).
+     *
+     * Any errors that originate from the tool SHOULD be reported inside the result
+     * object, with `isError` set to true, _not_ as an MCP protocol-level error
+     * response. Otherwise, the LLM would not be able to see that an error occurred
+     * and self-correct.
+     *
+     * However, any errors in _finding_ the tool, an error indicating that the
+     * server does not support tool calls, or any other exceptional conditions,
+     * should be reported as an MCP error response.
+     */
+    isError: ZodOptional<ZodBoolean>;
 }>, "passthrough", ZodTypeAny, objectOutputType<objectUtil.extendShape<{
     /**
      * This result property is reserved by the protocol to allow clients and servers to attach additional metadata to their responses.
      */
     _meta: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
 }, {
-    content: ZodArray<ZodUnion<[ZodObject<{
+    /**
+     * A list of content objects that represent the result of the tool call.
+     *
+     * If the Tool does not define an outputSchema, this field MUST be present in the result.
+     * For backwards compatibility, this field is always present, but it may be empty.
+     */
+    content: ZodDefault<ZodArray<ZodUnion<[ZodObject<{
         type: ZodLiteral<"text">;
         /**
          * The text content of the message.
@@ -24149,15 +24363,41 @@ declare const CallToolResultSchema: ZodObject<objectUtil.extendShape<{
              */
             blob: ZodString;
         }>, ZodTypeAny, "passthrough">>]>;
-    }, ZodTypeAny, "passthrough">>]>, "many">;
-    isError: ZodOptional<ZodDefault<ZodBoolean>>;
+    }, ZodTypeAny, "passthrough">>]>, "many">>;
+    /**
+     * An object containing structured tool output.
+     *
+     * If the Tool defines an outputSchema, this field MUST be present in the result, and contain a JSON object that matches the schema.
+     */
+    structuredContent: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+    /**
+     * Whether the tool call ended in an error.
+     *
+     * If not set, this is assumed to be false (the call was successful).
+     *
+     * Any errors that originate from the tool SHOULD be reported inside the result
+     * object, with `isError` set to true, _not_ as an MCP protocol-level error
+     * response. Otherwise, the LLM would not be able to see that an error occurred
+     * and self-correct.
+     *
+     * However, any errors in _finding_ the tool, an error indicating that the
+     * server does not support tool calls, or any other exceptional conditions,
+     * should be reported as an MCP error response.
+     */
+    isError: ZodOptional<ZodBoolean>;
 }>, ZodTypeAny, "passthrough">, objectInputType<objectUtil.extendShape<{
     /**
      * This result property is reserved by the protocol to allow clients and servers to attach additional metadata to their responses.
      */
     _meta: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
 }, {
-    content: ZodArray<ZodUnion<[ZodObject<{
+    /**
+     * A list of content objects that represent the result of the tool call.
+     *
+     * If the Tool does not define an outputSchema, this field MUST be present in the result.
+     * For backwards compatibility, this field is always present, but it may be empty.
+     */
+    content: ZodDefault<ZodArray<ZodUnion<[ZodObject<{
         type: ZodLiteral<"text">;
         /**
          * The text content of the message.
@@ -24496,8 +24736,28 @@ declare const CallToolResultSchema: ZodObject<objectUtil.extendShape<{
              */
             blob: ZodString;
         }>, ZodTypeAny, "passthrough">>]>;
-    }, ZodTypeAny, "passthrough">>]>, "many">;
-    isError: ZodOptional<ZodDefault<ZodBoolean>>;
+    }, ZodTypeAny, "passthrough">>]>, "many">>;
+    /**
+     * An object containing structured tool output.
+     *
+     * If the Tool defines an outputSchema, this field MUST be present in the result, and contain a JSON object that matches the schema.
+     */
+    structuredContent: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+    /**
+     * Whether the tool call ended in an error.
+     *
+     * If not set, this is assumed to be false (the call was successful).
+     *
+     * Any errors that originate from the tool SHOULD be reported inside the result
+     * object, with `isError` set to true, _not_ as an MCP protocol-level error
+     * response. Otherwise, the LLM would not be able to see that an error occurred
+     * and self-correct.
+     *
+     * However, any errors in _finding_ the tool, an error indicating that the
+     * server does not support tool calls, or any other exceptional conditions,
+     * should be reported as an MCP error response.
+     */
+    isError: ZodOptional<ZodBoolean>;
 }>, ZodTypeAny, "passthrough">>;
 /**
  * Notification of a log message passed from server to client. If no logging/setLevel request has been sent from the client, the server MAY decide which messages to send automatically.
@@ -27942,6 +28202,10 @@ declare const ServerNotificationSchema: ZodUnion<[ZodObject<objectUtil.extendSha
          * Total number of items to process (or total progress required), if known.
          */
         total: ZodOptional<ZodNumber>;
+        /**
+         * An optional message describing the current progress.
+         */
+        message: ZodOptional<ZodString>;
     }>, {
         /**
          * The progress token which was given in the initial request, used to associate this notification with the request that is proceeding.
@@ -27961,6 +28225,10 @@ declare const ServerNotificationSchema: ZodUnion<[ZodObject<objectUtil.extendSha
          * Total number of items to process (or total progress required), if known.
          */
         total: ZodOptional<ZodNumber>;
+        /**
+         * An optional message describing the current progress.
+         */
+        message: ZodOptional<ZodString>;
     }>, {
         /**
          * The progress token which was given in the initial request, used to associate this notification with the request that is proceeding.
@@ -27980,6 +28248,10 @@ declare const ServerNotificationSchema: ZodUnion<[ZodObject<objectUtil.extendSha
          * Total number of items to process (or total progress required), if known.
          */
         total: ZodOptional<ZodNumber>;
+        /**
+         * An optional message describing the current progress.
+         */
+        message: ZodOptional<ZodString>;
     }>, {
         /**
          * The progress token which was given in the initial request, used to associate this notification with the request that is proceeding.
@@ -27990,6 +28262,7 @@ declare const ServerNotificationSchema: ZodUnion<[ZodObject<objectUtil.extendSha
     params: {
         progressToken: string | number;
         progress: number;
+        message?: string | undefined;
         _meta?: objectOutputType<{}, ZodTypeAny, "passthrough"> | undefined;
         total?: number | undefined;
     } & {
@@ -28000,6 +28273,7 @@ declare const ServerNotificationSchema: ZodUnion<[ZodObject<objectUtil.extendSha
     params: {
         progressToken: string | number;
         progress: number;
+        message?: string | undefined;
         _meta?: objectInputType<{}, ZodTypeAny, "passthrough"> | undefined;
         total?: number | undefined;
     } & {
@@ -33596,7 +33870,13 @@ declare const ServerResultSchema: ZodUnion<[ZodObject<{
      */
     _meta: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
 }, {
-    content: ZodArray<ZodUnion<[ZodObject<{
+    /**
+     * A list of content objects that represent the result of the tool call.
+     *
+     * If the Tool does not define an outputSchema, this field MUST be present in the result.
+     * For backwards compatibility, this field is always present, but it may be empty.
+     */
+    content: ZodDefault<ZodArray<ZodUnion<[ZodObject<{
         type: ZodLiteral<"text">;
         /**
          * The text content of the message.
@@ -33935,15 +34215,41 @@ declare const ServerResultSchema: ZodUnion<[ZodObject<{
              */
             blob: ZodString;
         }>, ZodTypeAny, "passthrough">>]>;
-    }, ZodTypeAny, "passthrough">>]>, "many">;
-    isError: ZodOptional<ZodDefault<ZodBoolean>>;
+    }, ZodTypeAny, "passthrough">>]>, "many">>;
+    /**
+     * An object containing structured tool output.
+     *
+     * If the Tool defines an outputSchema, this field MUST be present in the result, and contain a JSON object that matches the schema.
+     */
+    structuredContent: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+    /**
+     * Whether the tool call ended in an error.
+     *
+     * If not set, this is assumed to be false (the call was successful).
+     *
+     * Any errors that originate from the tool SHOULD be reported inside the result
+     * object, with `isError` set to true, _not_ as an MCP protocol-level error
+     * response. Otherwise, the LLM would not be able to see that an error occurred
+     * and self-correct.
+     *
+     * However, any errors in _finding_ the tool, an error indicating that the
+     * server does not support tool calls, or any other exceptional conditions,
+     * should be reported as an MCP error response.
+     */
+    isError: ZodOptional<ZodBoolean>;
 }>, "passthrough", ZodTypeAny, objectOutputType<objectUtil.extendShape<{
     /**
      * This result property is reserved by the protocol to allow clients and servers to attach additional metadata to their responses.
      */
     _meta: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
 }, {
-    content: ZodArray<ZodUnion<[ZodObject<{
+    /**
+     * A list of content objects that represent the result of the tool call.
+     *
+     * If the Tool does not define an outputSchema, this field MUST be present in the result.
+     * For backwards compatibility, this field is always present, but it may be empty.
+     */
+    content: ZodDefault<ZodArray<ZodUnion<[ZodObject<{
         type: ZodLiteral<"text">;
         /**
          * The text content of the message.
@@ -34282,15 +34588,41 @@ declare const ServerResultSchema: ZodUnion<[ZodObject<{
              */
             blob: ZodString;
         }>, ZodTypeAny, "passthrough">>]>;
-    }, ZodTypeAny, "passthrough">>]>, "many">;
-    isError: ZodOptional<ZodDefault<ZodBoolean>>;
+    }, ZodTypeAny, "passthrough">>]>, "many">>;
+    /**
+     * An object containing structured tool output.
+     *
+     * If the Tool defines an outputSchema, this field MUST be present in the result, and contain a JSON object that matches the schema.
+     */
+    structuredContent: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+    /**
+     * Whether the tool call ended in an error.
+     *
+     * If not set, this is assumed to be false (the call was successful).
+     *
+     * Any errors that originate from the tool SHOULD be reported inside the result
+     * object, with `isError` set to true, _not_ as an MCP protocol-level error
+     * response. Otherwise, the LLM would not be able to see that an error occurred
+     * and self-correct.
+     *
+     * However, any errors in _finding_ the tool, an error indicating that the
+     * server does not support tool calls, or any other exceptional conditions,
+     * should be reported as an MCP error response.
+     */
+    isError: ZodOptional<ZodBoolean>;
 }>, ZodTypeAny, "passthrough">, objectInputType<objectUtil.extendShape<{
     /**
      * This result property is reserved by the protocol to allow clients and servers to attach additional metadata to their responses.
      */
     _meta: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
 }, {
-    content: ZodArray<ZodUnion<[ZodObject<{
+    /**
+     * A list of content objects that represent the result of the tool call.
+     *
+     * If the Tool does not define an outputSchema, this field MUST be present in the result.
+     * For backwards compatibility, this field is always present, but it may be empty.
+     */
+    content: ZodDefault<ZodArray<ZodUnion<[ZodObject<{
         type: ZodLiteral<"text">;
         /**
          * The text content of the message.
@@ -34629,8 +34961,28 @@ declare const ServerResultSchema: ZodUnion<[ZodObject<{
              */
             blob: ZodString;
         }>, ZodTypeAny, "passthrough">>]>;
-    }, ZodTypeAny, "passthrough">>]>, "many">;
-    isError: ZodOptional<ZodDefault<ZodBoolean>>;
+    }, ZodTypeAny, "passthrough">>]>, "many">>;
+    /**
+     * An object containing structured tool output.
+     *
+     * If the Tool defines an outputSchema, this field MUST be present in the result, and contain a JSON object that matches the schema.
+     */
+    structuredContent: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+    /**
+     * Whether the tool call ended in an error.
+     *
+     * If not set, this is assumed to be false (the call was successful).
+     *
+     * Any errors that originate from the tool SHOULD be reported inside the result
+     * object, with `isError` set to true, _not_ as an MCP protocol-level error
+     * response. Otherwise, the LLM would not be able to see that an error occurred
+     * and self-correct.
+     *
+     * However, any errors in _finding_ the tool, an error indicating that the
+     * server does not support tool calls, or any other exceptional conditions,
+     * should be reported as an MCP error response.
+     */
+    isError: ZodOptional<ZodBoolean>;
 }>, ZodTypeAny, "passthrough">>, ZodObject<objectUtil.extendShape<objectUtil.extendShape<{
     /**
      * This result property is reserved by the protocol to allow clients and servers to attach additional metadata to their responses.
@@ -34658,36 +35010,152 @@ declare const ServerResultSchema: ZodUnion<[ZodObject<{
         inputSchema: ZodObject<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
         }, "passthrough", ZodTypeAny, objectOutputType<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
         }, ZodTypeAny, "passthrough">, objectInputType<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
         }, ZodTypeAny, "passthrough">>;
-    }, "passthrough", ZodTypeAny, objectOutputType<{
-        /**
-         * The name of the tool.
-         */
-        name: ZodString;
-        /**
-         * A human-readable description of the tool.
-         */
-        description: ZodOptional<ZodString>;
         /**
-         * A JSON Schema object defining the expected parameters for the tool.
+         * An optional JSON Schema object defining the structure of the tool's output returned in
+         * the structuredContent field of a CallToolResult.
          */
-        inputSchema: ZodObject<{
+        outputSchema: ZodOptional<ZodObject<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
         }, "passthrough", ZodTypeAny, objectOutputType<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
         }, ZodTypeAny, "passthrough">, objectInputType<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
-        }, ZodTypeAny, "passthrough">>;
-    }, ZodTypeAny, "passthrough">, objectInputType<{
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, ZodTypeAny, "passthrough">>>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: ZodOptional<ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, "passthrough", ZodTypeAny, objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, ZodTypeAny, "passthrough">, objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, ZodTypeAny, "passthrough">>>;
+    }, "passthrough", ZodTypeAny, objectOutputType<{
         /**
          * The name of the tool.
          */
@@ -34702,70 +35170,644 @@ declare const ServerResultSchema: ZodUnion<[ZodObject<{
         inputSchema: ZodObject<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
         }, "passthrough", ZodTypeAny, objectOutputType<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
         }, ZodTypeAny, "passthrough">, objectInputType<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
         }, ZodTypeAny, "passthrough">>;
-    }, ZodTypeAny, "passthrough">>, "many">;
-}>, "passthrough", ZodTypeAny, objectOutputType<objectUtil.extendShape<objectUtil.extendShape<{
-    /**
-     * This result property is reserved by the protocol to allow clients and servers to attach additional metadata to their responses.
-     */
-    _meta: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
-}, {
-    /**
-     * An opaque token representing the pagination position after the last returned result.
-     * If present, there may be more results available.
-     */
-    nextCursor: ZodOptional<ZodString>;
-}>, {
-    tools: ZodArray<ZodObject<{
-        /**
-         * The name of the tool.
-         */
-        name: ZodString;
-        /**
-         * A human-readable description of the tool.
-         */
-        description: ZodOptional<ZodString>;
         /**
-         * A JSON Schema object defining the expected parameters for the tool.
+         * An optional JSON Schema object defining the structure of the tool's output returned in
+         * the structuredContent field of a CallToolResult.
          */
-        inputSchema: ZodObject<{
+        outputSchema: ZodOptional<ZodObject<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
         }, "passthrough", ZodTypeAny, objectOutputType<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
         }, ZodTypeAny, "passthrough">, objectInputType<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
-        }, ZodTypeAny, "passthrough">>;
-    }, "passthrough", ZodTypeAny, objectOutputType<{
-        /**
-         * The name of the tool.
-         */
-        name: ZodString;
-        /**
-         * A human-readable description of the tool.
-         */
-        description: ZodOptional<ZodString>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, ZodTypeAny, "passthrough">>>;
         /**
-         * A JSON Schema object defining the expected parameters for the tool.
+         * Optional additional tool information.
          */
-        inputSchema: ZodObject<{
+        annotations: ZodOptional<ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, "passthrough", ZodTypeAny, objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, ZodTypeAny, "passthrough">, objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, ZodTypeAny, "passthrough">>>;
+    }, ZodTypeAny, "passthrough">, objectInputType<{
+        /**
+         * The name of the tool.
+         */
+        name: ZodString;
+        /**
+         * A human-readable description of the tool.
+         */
+        description: ZodOptional<ZodString>;
+        /**
+         * A JSON Schema object defining the expected parameters for the tool.
+         */
+        inputSchema: ZodObject<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
         }, "passthrough", ZodTypeAny, objectOutputType<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
         }, ZodTypeAny, "passthrough">, objectInputType<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
         }, ZodTypeAny, "passthrough">>;
+        /**
+         * An optional JSON Schema object defining the structure of the tool's output returned in
+         * the structuredContent field of a CallToolResult.
+         */
+        outputSchema: ZodOptional<ZodObject<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, "passthrough", ZodTypeAny, objectOutputType<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, ZodTypeAny, "passthrough">, objectInputType<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, ZodTypeAny, "passthrough">>>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: ZodOptional<ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, "passthrough", ZodTypeAny, objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, ZodTypeAny, "passthrough">, objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, ZodTypeAny, "passthrough">>>;
+    }, ZodTypeAny, "passthrough">>, "many">;
+}>, "passthrough", ZodTypeAny, objectOutputType<objectUtil.extendShape<objectUtil.extendShape<{
+    /**
+     * This result property is reserved by the protocol to allow clients and servers to attach additional metadata to their responses.
+     */
+    _meta: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+}, {
+    /**
+     * An opaque token representing the pagination position after the last returned result.
+     * If present, there may be more results available.
+     */
+    nextCursor: ZodOptional<ZodString>;
+}>, {
+    tools: ZodArray<ZodObject<{
+        /**
+         * The name of the tool.
+         */
+        name: ZodString;
+        /**
+         * A human-readable description of the tool.
+         */
+        description: ZodOptional<ZodString>;
+        /**
+         * A JSON Schema object defining the expected parameters for the tool.
+         */
+        inputSchema: ZodObject<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, "passthrough", ZodTypeAny, objectOutputType<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, ZodTypeAny, "passthrough">, objectInputType<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, ZodTypeAny, "passthrough">>;
+        /**
+         * An optional JSON Schema object defining the structure of the tool's output returned in
+         * the structuredContent field of a CallToolResult.
+         */
+        outputSchema: ZodOptional<ZodObject<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, "passthrough", ZodTypeAny, objectOutputType<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, ZodTypeAny, "passthrough">, objectInputType<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, ZodTypeAny, "passthrough">>>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: ZodOptional<ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, "passthrough", ZodTypeAny, objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, ZodTypeAny, "passthrough">, objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, ZodTypeAny, "passthrough">>>;
+    }, "passthrough", ZodTypeAny, objectOutputType<{
+        /**
+         * The name of the tool.
+         */
+        name: ZodString;
+        /**
+         * A human-readable description of the tool.
+         */
+        description: ZodOptional<ZodString>;
+        /**
+         * A JSON Schema object defining the expected parameters for the tool.
+         */
+        inputSchema: ZodObject<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, "passthrough", ZodTypeAny, objectOutputType<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, ZodTypeAny, "passthrough">, objectInputType<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, ZodTypeAny, "passthrough">>;
+        /**
+         * An optional JSON Schema object defining the structure of the tool's output returned in
+         * the structuredContent field of a CallToolResult.
+         */
+        outputSchema: ZodOptional<ZodObject<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, "passthrough", ZodTypeAny, objectOutputType<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, ZodTypeAny, "passthrough">, objectInputType<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, ZodTypeAny, "passthrough">>>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: ZodOptional<ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, "passthrough", ZodTypeAny, objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, ZodTypeAny, "passthrough">, objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, ZodTypeAny, "passthrough">>>;
     }, ZodTypeAny, "passthrough">, objectInputType<{
         /**
          * The name of the tool.
@@ -34781,13 +35823,151 @@ declare const ServerResultSchema: ZodUnion<[ZodObject<{
         inputSchema: ZodObject<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, "passthrough", ZodTypeAny, objectOutputType<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, ZodTypeAny, "passthrough">, objectInputType<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, ZodTypeAny, "passthrough">>;
+        /**
+         * An optional JSON Schema object defining the structure of the tool's output returned in
+         * the structuredContent field of a CallToolResult.
+         */
+        outputSchema: ZodOptional<ZodObject<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, "passthrough", ZodTypeAny, objectOutputType<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, ZodTypeAny, "passthrough">, objectInputType<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, ZodTypeAny, "passthrough">>>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: ZodOptional<ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
         }, "passthrough", ZodTypeAny, objectOutputType<{
-            type: ZodLiteral<"object">;
-            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
         }, ZodTypeAny, "passthrough">, objectInputType<{
-            type: ZodLiteral<"object">;
-            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
-        }, ZodTypeAny, "passthrough">>;
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, ZodTypeAny, "passthrough">>>;
     }, ZodTypeAny, "passthrough">>, "many">;
 }>, ZodTypeAny, "passthrough">, objectInputType<objectUtil.extendShape<objectUtil.extendShape<{
     /**
@@ -34816,13 +35996,151 @@ declare const ServerResultSchema: ZodUnion<[ZodObject<{
         inputSchema: ZodObject<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
         }, "passthrough", ZodTypeAny, objectOutputType<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
         }, ZodTypeAny, "passthrough">, objectInputType<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
         }, ZodTypeAny, "passthrough">>;
+        /**
+         * An optional JSON Schema object defining the structure of the tool's output returned in
+         * the structuredContent field of a CallToolResult.
+         */
+        outputSchema: ZodOptional<ZodObject<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, "passthrough", ZodTypeAny, objectOutputType<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, ZodTypeAny, "passthrough">, objectInputType<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, ZodTypeAny, "passthrough">>>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: ZodOptional<ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, "passthrough", ZodTypeAny, objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, ZodTypeAny, "passthrough">, objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, ZodTypeAny, "passthrough">>>;
     }, "passthrough", ZodTypeAny, objectOutputType<{
         /**
          * The name of the tool.
@@ -34838,13 +36156,151 @@ declare const ServerResultSchema: ZodUnion<[ZodObject<{
         inputSchema: ZodObject<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
         }, "passthrough", ZodTypeAny, objectOutputType<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
         }, ZodTypeAny, "passthrough">, objectInputType<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
         }, ZodTypeAny, "passthrough">>;
+        /**
+         * An optional JSON Schema object defining the structure of the tool's output returned in
+         * the structuredContent field of a CallToolResult.
+         */
+        outputSchema: ZodOptional<ZodObject<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, "passthrough", ZodTypeAny, objectOutputType<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, ZodTypeAny, "passthrough">, objectInputType<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, ZodTypeAny, "passthrough">>>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: ZodOptional<ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, "passthrough", ZodTypeAny, objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, ZodTypeAny, "passthrough">, objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, ZodTypeAny, "passthrough">>>;
     }, ZodTypeAny, "passthrough">, objectInputType<{
         /**
          * The name of the tool.
@@ -34860,13 +36316,151 @@ declare const ServerResultSchema: ZodUnion<[ZodObject<{
         inputSchema: ZodObject<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
         }, "passthrough", ZodTypeAny, objectOutputType<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
         }, ZodTypeAny, "passthrough">, objectInputType<{
             type: ZodLiteral<"object">;
             properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
         }, ZodTypeAny, "passthrough">>;
+        /**
+         * An optional JSON Schema object defining the structure of the tool's output returned in
+         * the structuredContent field of a CallToolResult.
+         */
+        outputSchema: ZodOptional<ZodObject<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, "passthrough", ZodTypeAny, objectOutputType<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, ZodTypeAny, "passthrough">, objectInputType<{
+            type: ZodLiteral<"object">;
+            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, ZodTypeAny, "passthrough">>>;
+        /**
+         * Optional additional tool information.
+         */
+        annotations: ZodOptional<ZodObject<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, "passthrough", ZodTypeAny, objectOutputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, ZodTypeAny, "passthrough">, objectInputType<{
+            /**
+             * A human-readable title for the tool.
+             */
+            title: ZodOptional<ZodString>;
+            /**
+             * If true, the tool does not modify its environment.
+             *
+             * Default: false
+             */
+            readOnlyHint: ZodOptional<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: ZodOptional<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: ZodOptional<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: ZodOptional<ZodBoolean>;
+        }, ZodTypeAny, "passthrough">>>;
     }, ZodTypeAny, "passthrough">>, "many">;
 }>, ZodTypeAny, "passthrough">>]>;
 type Primitive = string | number | boolean | bigint | null | undefined;
@@ -34875,6 +36469,7 @@ type Flatten<T> = T extends Primitive ? T : T extends Array<infer U> ? Array<Fla
 } : T;
 type Infer<Schema extends ZodTypeAny> = Flatten<TypeOf<Schema>>;
 type Request = Infer<typeof RequestSchema>;
+type RequestMeta = Infer<typeof RequestMetaSchema>;
 type Notification = Infer<typeof NotificationSchema>;
 type Result = Infer<typeof ResultSchema>;
 type RequestId = Infer<typeof RequestIdSchema>;
@@ -34888,6 +36483,7 @@ type ListResourcesResult = Infer<typeof ListResourcesResultSchema>;
 type ReadResourceResult = Infer<typeof ReadResourceResultSchema>;
 type ResourceUpdatedNotification = Infer<typeof ResourceUpdatedNotificationSchema>;
 type GetPromptResult = Infer<typeof GetPromptResultSchema>;
+type ToolAnnotations = Infer<typeof ToolAnnotationsSchema>;
 type CallToolResult = Infer<typeof CallToolResultSchema>;
 type LoggingMessageNotification = Infer<typeof LoggingMessageNotificationSchema>;
 type CreateMessageRequest = Infer<typeof CreateMessageRequestSchema>;
@@ -35066,6 +36662,15 @@ type RequestHandlerExtra<SendRequestT extends Request, SendNotificationT extends
      * The session ID from the transport, if available.
      */
     sessionId?: string;
+    /**
+     * Metadata from the original request.
+     */
+    _meta?: RequestMeta;
+    /**
+     * The JSON-RPC ID of the request being handled.
+     * This can be useful for tracking or logging purposes.
+     */
+    requestId: RequestId;
     /**
      * Sends a notification that relates to the current request being handled.
      *
@@ -35401,6 +37006,7 @@ declare class McpServer {
      * Registers a resource `name` with a template pattern and metadata, which will use the given callback to respond to read requests.
      */
     resource(name: string, template: ResourceTemplate, metadata: ResourceMetadata, readCallback: ReadResourceTemplateCallback): RegisteredResourceTemplate;
+    private _createRegisteredTool;
     /**
      * Registers a zero-argument tool `name`, which will run the given function when the client calls it.
      */
@@ -35410,13 +37016,39 @@ declare class McpServer {
      */
     tool(name: string, description: string, cb: ToolCallback): RegisteredTool;
     /**
-     * Registers a tool `name` accepting the given arguments, which must be an object containing named properties associated with Zod schemas. When the client calls it, the function will be run with the parsed and validated arguments.
+     * Registers a tool taking either a parameter schema for validation or annotations for additional metadata.
+     * This unified overload handles both `tool(name, paramsSchema, cb)` and `tool(name, annotations, cb)` cases.
+     *
+     * Note: We use a union type for the second parameter because TypeScript cannot reliably disambiguate
+     * between ToolAnnotations and ZodRawShape during overload resolution, as both are plain object types.
+     */
+    tool<Args extends ZodRawShape>(name: string, paramsSchemaOrAnnotations: Args | ToolAnnotations, cb: ToolCallback<Args>): RegisteredTool;
+    /**
+     * Registers a tool `name` (with a description) taking either parameter schema or annotations.
+     * This unified overload handles both `tool(name, description, paramsSchema, cb)` and
+     * `tool(name, description, annotations, cb)` cases.
+     *
+     * Note: We use a union type for the third parameter because TypeScript cannot reliably disambiguate
+     * between ToolAnnotations and ZodRawShape during overload resolution, as both are plain object types.
+     */
+    tool<Args extends ZodRawShape>(name: string, description: string, paramsSchemaOrAnnotations: Args | ToolAnnotations, cb: ToolCallback<Args>): RegisteredTool;
+    /**
+     * Registers a tool with both parameter schema and annotations.
      */
-    tool<Args extends ZodRawShape>(name: string, paramsSchema: Args, cb: ToolCallback<Args>): RegisteredTool;
+    tool<Args extends ZodRawShape>(name: string, paramsSchema: Args, annotations: ToolAnnotations, cb: ToolCallback<Args>): RegisteredTool;
     /**
-     * Registers a tool `name` (with a description) accepting the given arguments, which must be an object containing named properties associated with Zod schemas. When the client calls it, the function will be run with the parsed and validated arguments.
+     * Registers a tool with description, parameter schema, and annotations.
      */
-    tool<Args extends ZodRawShape>(name: string, description: string, paramsSchema: Args, cb: ToolCallback<Args>): RegisteredTool;
+    tool<Args extends ZodRawShape>(name: string, description: string, paramsSchema: Args, annotations: ToolAnnotations, cb: ToolCallback<Args>): RegisteredTool;
+    /**
+     * Registers a tool with a config object and callback.
+     */
+    registerTool<InputArgs extends ZodRawShape, OutputArgs extends ZodRawShape>(name: string, config: {
+        description?: string;
+        inputSchema?: InputArgs;
+        outputSchema?: OutputArgs;
+        annotations?: ToolAnnotations;
+    }, cb: ToolCallback<InputArgs>): RegisteredTool;
     /**
      * Registers a zero-argument prompt `name`, which will run the given function when the client calls it.
      */
@@ -35491,20 +37123,29 @@ declare class ResourceTemplate {
  * Callback for a tool handler registered with Server.tool().
  *
  * Parameters will include tool arguments, if applicable, as well as other request handler context.
+ *
+ * The callback should return:
+ * - `structuredContent` if the tool has an outputSchema defined
+ * - `content` if the tool does not have an outputSchema
+ * - Both fields are optional but typically one should be provided
  */
 type ToolCallback<Args extends undefined | ZodRawShape = undefined> = Args extends ZodRawShape ? (args: objectOutputType<Args, ZodTypeAny>, extra: RequestHandlerExtra<ServerRequest, ServerNotification>) => CallToolResult | Promise<CallToolResult> : (extra: RequestHandlerExtra<ServerRequest, ServerNotification>) => CallToolResult | Promise<CallToolResult>;
 type RegisteredTool = {
     description?: string;
     inputSchema?: AnyZodObject;
+    outputSchema?: AnyZodObject;
+    annotations?: ToolAnnotations;
     callback: ToolCallback<undefined | ZodRawShape>;
     enabled: boolean;
     enable(): void;
     disable(): void;
-    update<Args extends ZodRawShape>(updates: {
+    update<InputArgs extends ZodRawShape, OutputArgs extends ZodRawShape>(updates: {
         name?: string | null;
         description?: string;
-        paramsSchema?: Args;
-        callback?: ToolCallback<Args>;
+        paramsSchema?: InputArgs;
+        outputSchema?: OutputArgs;
+        annotations?: ToolAnnotations;
+        callback?: ToolCallback<InputArgs>;
         enabled?: boolean;
     }): void;
     remove(): void;