likec4 1.32.0 → 1.32.2

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

@@ -1,6 +1,6 @@
-import * as c4 from '@likec4/core';
-import { Fqn, EdgeId, AnyAux, ComputedView, Specification, DiagramView, MultiMap as MultiMap$1, ProjectId, NonEmptyArray, NonEmptyReadonlyArray, ViewId, RelationId, DeploymentFqn, ViewChange } from '@likec4/core';
 import { Tagged, ValueOf, ConditionalPick, Writable, Simplify, MergeExclusive } from 'type-fest';
+import * as c4 from '@likec4/core';
+import { Fqn, EdgeId, AnyAux, aux, ComputedView, Specification, DiagramView, MultiMap as MultiMap$1, ProjectId, NonEmptyArray, NonEmptyReadonlyArray, ViewId, RelationId, DeploymentFqn, ViewChange } from '@likec4/core';
 import { LikeC4Model } from '@likec4/core/model';
 import picomatch from '/home/runner/work/likec4/likec4/node_modules/.pnpm/@types+picomatch@4.0.0/node_modules/@types/picomatch/posix.d.ts';
 import { ProjectId as ProjectId$1, Fqn as Fqn$1 } from '@likec4/core/types';
@@ -12066,26 +12066,60 @@ interface GraphvizPort {
     layoutJson(dot: DotSource): Promise<string>;
     svg(dot: DotSource): Promise<string>;
 }
-type Params<A extends AnyAux = AnyAux> = {
+type LayoutTaskParams<A extends aux.Any = aux.Any> = {
     view: ComputedView<A>;
     specification: Specification<A>;
 };
-type LayoutResult = {
+type LayoutResult<A extends aux.Any = aux.Any> = {
     dot: DotSource;
-    diagram: DiagramView;
+    diagram: DiagramView<A>;
 };
 declare class GraphvizLayouter {
     private graphviz;
-    constructor(graphviz: GraphvizPort);
-    get port(): GraphvizPort;
+    constructor(graphviz?: GraphvizPort);
+    get graphvizPort(): GraphvizPort;
     changePort(graphviz: GraphvizPort): void;
     dotToJson(dot: DotSource): Promise<GraphvizJson>;
-    layout<A extends AnyAux>(params: Params<A>): Promise<LayoutResult>;
-    svg<A extends AnyAux>(params: Params<A>): Promise<{
+    layout<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<LayoutResult<A>>;
+    svg<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<{
         svg: string;
         dot: DotSource;
     }>;
-    dot<A extends AnyAux>(params: Params<A>): Promise<DotSource>;
+    dot<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<DotSource>;
+}
+
+declare class QueueGraphvizLayoter extends GraphvizLayouter {
+    private queue;
+    private isProcessingBatch;
+    constructor(options?: {
+        graphviz?: GraphvizPort;
+        /**
+        Concurrency limit.
+    
+        Minimum: `1`.
+    
+        @default 2
+        */
+        concurrency?: number;
+        /**
+        Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
+        @default 20_000
+        */
+        timeout?: number;
+        /**
+        Whether or not a timeout is considered an exception.
+        @default true
+        */
+        throwOnTimeout?: boolean;
+    });
+    private runInQueue;
+    changePort(graphvizPort: GraphvizPort): void;
+    layout<A extends AnyAux>(params: LayoutTaskParams<A>): Promise<LayoutResult<A>>;
+    batchLayout<A extends AnyAux>(params: {
+        batch: LayoutTaskParams<A>[];
+        onSuccess?: (task: LayoutTaskParams<A>, result: LayoutResult<A>) => void;
+        onError?: (task: LayoutTaskParams<A>, error: unknown) => void;
+    }): Promise<LayoutResult<A>[]>;
 }
 
 interface WorkDoneProgressReporter {
@@ -14214,7 +14248,7 @@ type SchemaWithFallbackAsync<TSchema extends BaseSchema<unknown, unknown, BaseIs
 type SchemaWithPipe<TPipe extends readonly [
     BaseSchema<unknown, unknown, BaseIssue<unknown>>,
     ...PipeItem<any, unknown, BaseIssue<unknown>>[]
-]> = Omit<FirstTupleItem<TPipe>, '~standard' | '~run' | '~types'> & {
+]> = Omit<FirstTupleItem<TPipe>, 'pipe' | '~standard' | '~run' | '~types'> & {
     /**
      * The pipe items.
      */
@@ -14254,7 +14288,7 @@ type SchemaWithPipe<TPipe extends readonly [
 type SchemaWithPipeAsync<TPipe extends readonly [
     (BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>),
     ...(PipeItem<any, unknown, BaseIssue<unknown>> | PipeItemAsync<any, unknown, BaseIssue<unknown>>)[]
-]> = Omit<FirstTupleItem<TPipe>, 'async' | '~standard' | '~run' | '~types'> & {
+]> = Omit<FirstTupleItem<TPipe>, 'async' | 'pipe' | '~standard' | '~run' | '~types'> & {
     /**
      * The pipe items.
      */
@@ -14723,15 +14757,15 @@ type Prettify<TObject> = {
 /**
  * Marks specific keys as optional.
  */
-type MarkOptional<TObject, TKeys extends keyof TObject> = Partial<TObject> & Required<Omit<TObject, TKeys>>;
+type MarkOptional<TObject, TKeys extends keyof TObject> = {
+    [TKey in keyof TObject]?: unknown;
+} & Omit<TObject, TKeys> & Partial<Pick<TObject, TKeys>>;
 /**
  * Extracts first tuple item.
- *
  */
 type FirstTupleItem<TTuple extends readonly [unknown, ...unknown[]]> = TTuple[0];
 /**
  * Extracts last tuple item.
- *
  */
 type LastTupleItem<TTuple extends readonly [unknown, ...unknown[]]> = TTuple[TTuple extends readonly [unknown, ...infer TRest] ? TRest['length'] : never];
 
@@ -15489,6 +15523,14 @@ declare function string(): StringSchema<undefined>;
  * @returns A string schema.
  */
 declare function string<const TMessage extends ErrorMessage<StringIssue> | undefined>(message: TMessage): StringSchema<TMessage>;
+/**
+ * Content input type.
+ */
+type ContentInput = string | MaybeReadonly<unknown[]>;
+/**
+ * Content requirement type.
+ */
+type ContentRequirement<TInput extends ContentInput> = TInput extends readonly unknown[] ? TInput[number] : TInput;
 /**
  * Length input type.
  */
@@ -15520,6 +15562,70 @@ interface DescriptionAction<TInput, TDescription extends string> extends BaseMet
  */
 declare function description<TInput, TDescription extends string>(description_: TDescription): DescriptionAction<TInput, TDescription>;
 
+/**
+ * Excludes issue interface.
+ */
+interface ExcludesIssue<TInput extends ContentInput, TRequirement extends ContentRequirement<TInput>> extends BaseIssue<TInput> {
+    /**
+     * The issue kind.
+     */
+    readonly kind: 'validation';
+    /**
+     * The issue type.
+     */
+    readonly type: 'excludes';
+    /**
+     * The expected property.
+     */
+    readonly expected: string;
+    /**
+     * The content to be excluded.
+     */
+    readonly requirement: TRequirement;
+}
+/**
+ * Excludes action interface.
+ */
+interface ExcludesAction<TInput extends ContentInput, TRequirement extends ContentRequirement<TInput>, TMessage extends ErrorMessage<ExcludesIssue<TInput, TRequirement>> | undefined> extends BaseValidation<TInput, TInput, ExcludesIssue<TInput, TRequirement>> {
+    /**
+     * The action type.
+     */
+    readonly type: 'excludes';
+    /**
+     * The action reference.
+     */
+    readonly reference: typeof excludes;
+    /**
+     * The expected property.
+     */
+    readonly expects: string;
+    /**
+     * The content to be excluded.
+     */
+    readonly requirement: TRequirement;
+    /**
+     * The error message.
+     */
+    readonly message: TMessage;
+}
+/**
+ * Creates an excludes validation action.
+ *
+ * @param requirement The content to be excluded.
+ *
+ * @returns An excludes action.
+ */
+declare function excludes<TInput extends ContentInput, const TRequirement extends ContentRequirement<TInput>>(requirement: TRequirement): ExcludesAction<TInput, TRequirement, undefined>;
+/**
+ * Creates an excludes validation action.
+ *
+ * @param requirement The content to be excluded.
+ * @param message The error message.
+ *
+ * @returns An excludes action.
+ */
+declare function excludes<TInput extends ContentInput, const TRequirement extends ContentRequirement<TInput>, const TMessage extends ErrorMessage<ExcludesIssue<TInput, TRequirement>> | undefined>(requirement: TRequirement, message: TMessage): ExcludesAction<TInput, TRequirement, TMessage>;
+
 /**
  * Non empty issue interface.
  */
@@ -15602,8 +15708,8 @@ interface ReadonlyAction<TInput> extends BaseTransformation<TInput, ReadonlyOutp
 declare function readonly<TInput>(): ReadonlyAction<TInput>;
 
 declare const ProjectConfig: ObjectSchema<{
-    readonly name: SchemaWithPipe<readonly [SchemaWithPipe<readonly [StringSchema<undefined>, NonEmptyAction<string, undefined>]>, DescriptionAction<string, "Project name, must be unique in the workspace">]>;
-    readonly contactPerson: OptionalSchema<SchemaWithPipe<readonly [SchemaWithPipe<readonly [StringSchema<undefined>, NonEmptyAction<string, undefined>]>, DescriptionAction<string, "A person who has been involved in creating or maintaining this project">]>, undefined>;
+    readonly name: SchemaWithPipe<readonly [StringSchema<undefined>, NonEmptyAction<string, "Project name cannot be empty">, ExcludesAction<string, "default", "Project name cannot be \"default\"">, ExcludesAction<string, ".", "Project name cannot contain \".\", try to use A-z, 0-9, _ and -">, ExcludesAction<string, "@", "Project name cannot contain \"@\", try to use A-z, 0-9, _ and -">, ExcludesAction<string, "#", "Project name cannot contain \"#\", try to use A-z, 0-9, _ and -">, DescriptionAction<string, "Project name, must be unique in the workspace">]>;
+    readonly contactPerson: OptionalSchema<SchemaWithPipe<readonly [StringSchema<undefined>, NonEmptyAction<string, "Contact person cannot be empty if specified">, DescriptionAction<string, "A person who has been involved in creating or maintaining this project">]>, undefined>;
     readonly exclude: OptionalSchema<SchemaWithPipe<readonly [ArraySchema<StringSchema<undefined>, undefined>, DescriptionAction<string[], "List of file patterns to exclude from the project, default is [\"**/node_modules/**/*\"]">]>, undefined>;
 }, undefined>;
 type ProjectConfig = InferOutput<typeof ProjectConfig>;
@@ -15616,8 +15722,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;
@@ -15777,6 +15884,7 @@ interface DeploymentRelation extends AstNode {
     readonly $container: DeployedInstanceBody | DeploymentNodeBody | ExtendDeploymentBody | ModelDeployments;
     readonly $type: 'DeploymentRelation';
     body?: DeploymentRelationBody;
+    description?: string;
     dotKind?: RelationKindDotRef;
     kind?: Reference<RelationshipKind>;
     source?: FqnRef;
@@ -16076,6 +16184,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';
@@ -16238,6 +16352,7 @@ interface Relation extends AstNode {
     readonly $container: ElementBody | ExtendElementBody | Model;
     readonly $type: 'Relation';
     body?: RelationBody;
+    description?: string;
     dotKind?: RelationKindDotRef;
     kind?: Reference<RelationshipKind>;
     source?: FqnRef;
@@ -16301,6 +16416,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 +16442,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 +16497,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 +16675,7 @@ declare const WildcardExpression = "WildcardExpression";
 type LikeC4AstType = {
     ArrowProperty: ArrowProperty;
     BorderProperty: BorderProperty;
+    ColorLiteral: ColorLiteral;
     ColorProperty: ColorProperty;
     CustomColor: CustomColor;
     CustomElementProperties: CustomElementProperties;
@@ -16612,6 +16737,7 @@ type LikeC4AstType = {
     GlobalStyleGroup: GlobalStyleGroup;
     GlobalStyleId: GlobalStyleId;
     Globals: Globals;
+    HexColor: HexColor;
     IconProperty: IconProperty;
     Imported: Imported;
     ImportsFromPoject: ImportsFromPoject;
@@ -16637,6 +16763,7 @@ type LikeC4AstType = {
     OpacityProperty: OpacityProperty;
     OutgoingRelationExpr: OutgoingRelationExpr;
     PaddingSizeProperty: PaddingSizeProperty;
+    RGBAColor: RGBAColor;
     Referenceable: Referenceable;
     Relation: Relation;
     RelationBody: RelationBody;
@@ -16703,7 +16830,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;
@@ -16974,7 +17101,6 @@ declare class ProjectsManager {
      * Checks if the provided file system entry is a valid project config file.
      *
      * @param entry The file system entry to check
-     * @returns {boolean} Returns true if the entry is a valid config file, false otherwise.
      */
     loadConfigFile(entry: FileSystemNode): Promise<Project | undefined>;
     registerProject(configFile: URI): Promise<Project>;
@@ -17173,6 +17299,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 +17372,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 +17449,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 +17490,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 +17543,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 +17589,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 +17643,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 +17690,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 +17719,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 +17761,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;
     };
@@ -17798,13 +17934,16 @@ type Primitive$1 = string | number | symbol | bigint | boolean | null | undefine
 declare namespace util {
     type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
     export type isAny<T> = 0 extends 1 & T ? true : false;
-    export const assertEqual: <A, B>(val: AssertEqual<A, B>) => AssertEqual<A, B>;
+    export const assertEqual: <A, B>(_: AssertEqual<A, B>) => void;
     export function assertIs<T>(_arg: T): void;
     export function assertNever(_x: never): never;
     export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
     export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
     export type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
     export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
+    export type InexactPartial<T> = {
+        [k in keyof T]?: T[k] | undefined;
+    };
     export const arrayToEnum: <T extends string, U extends [T, ...T[]]>(items: U) => { [k in U[number]]: k; };
     export const getValidEnumValues: (obj: any) => any[];
     export const objectValues: (obj: any) => any[];
@@ -17855,24 +17994,24 @@ declare namespace objectUtil {
 }
 declare const ZodParsedType: {
     string: "string";
-    number: "number";
-    bigint: "bigint";
-    boolean: "boolean";
-    symbol: "symbol";
-    undefined: "undefined";
-    object: "object";
-    function: "function";
-    map: "map";
     nan: "nan";
+    number: "number";
     integer: "integer";
     float: "float";
+    boolean: "boolean";
     date: "date";
+    bigint: "bigint";
+    symbol: "symbol";
+    function: "function";
+    undefined: "undefined";
     null: "null";
     array: "array";
+    object: "object";
     unknown: "unknown";
     promise: "promise";
     void: "void";
     never: "never";
+    map: "map";
     set: "set";
 };
 type ZodParsedType = keyof typeof ZodParsedType;
@@ -17905,7 +18044,7 @@ declare const ZodIssueCode: {
 type ZodIssueCode = keyof typeof ZodIssueCode;
 type ZodIssueBase = {
     path: (string | number)[];
-    message?: string;
+    message?: string | undefined;
 };
 interface ZodInvalidTypeIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.invalid_type;
@@ -17947,7 +18086,7 @@ interface ZodInvalidDateIssue extends ZodIssueBase {
 }
 type StringValidation = "email" | "url" | "emoji" | "uuid" | "nanoid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "date" | "time" | "duration" | "ip" | "cidr" | "base64" | "jwt" | "base64url" | {
     includes: string;
-    position?: number;
+    position?: number | undefined;
 } | {
     startsWith: string;
 } | {
@@ -17989,7 +18128,7 @@ interface ZodCustomIssue extends ZodIssueBase {
 }
 type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
 type ZodIssue = ZodIssueOptionalMessage & {
-    fatal?: boolean;
+    fatal?: boolean | undefined;
     message: string;
 };
 type recursiveZodFormattedError<T> = T extends [any, ...any[]] ? {
@@ -18022,7 +18161,7 @@ declare class ZodError<T = any> extends Error {
 type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
 type IssueData = stripPath<ZodIssueOptionalMessage> & {
     path?: (string | number)[];
-    fatal?: boolean;
+    fatal?: boolean | undefined;
 };
 type ErrorMapCtx = {
     defaultError: string;
@@ -18042,11 +18181,11 @@ type ParsePath = ParsePathComponent[];
 interface ParseContext {
     readonly common: {
         readonly issues: ZodIssue[];
-        readonly contextualErrorMap?: ZodErrorMap;
+        readonly contextualErrorMap?: ZodErrorMap | undefined;
         readonly async: boolean;
     };
     readonly path: ParsePath;
-    readonly schemaErrorMap?: ZodErrorMap;
+    readonly schemaErrorMap?: ZodErrorMap | undefined;
     readonly parent: ParseContext | null;
     readonly data: any;
     readonly parsedType: ZodParsedType;
@@ -18100,7 +18239,7 @@ declare namespace enumUtil {
 
 declare namespace errorUtil {
     type ErrMessage = string | {
-        message?: string;
+        message?: string | undefined;
     };
     const errToObj: (message?: ErrMessage) => {
         message?: string | undefined;
@@ -18233,15 +18372,15 @@ type output<T extends ZodType<any, any, any>> = T["_output"];
 
 type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
 interface ZodTypeDef {
-    errorMap?: ZodErrorMap;
-    description?: string;
+    errorMap?: ZodErrorMap | undefined;
+    description?: string | undefined;
 }
 type RawCreateParams = {
-    errorMap?: ZodErrorMap;
-    invalid_type_error?: string;
-    required_error?: string;
-    message?: string;
-    description?: string;
+    errorMap?: ZodErrorMap | undefined;
+    invalid_type_error?: string | undefined;
+    required_error?: string | undefined;
+    message?: string | undefined;
+    description?: string | undefined;
 } | undefined;
 type SafeParseSuccess<Output> = {
     success: true;
@@ -18270,13 +18409,13 @@ declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef
     };
     _parseSync(input: ParseInput): SyncParseReturnType<Output>;
     _parseAsync(input: ParseInput): AsyncParseReturnType<Output>;
-    parse(data: unknown, params?: Partial<ParseParams>): Output;
-    safeParse(data: unknown, params?: Partial<ParseParams>): SafeParseReturnType<Input, Output>;
+    parse(data: unknown, params?: util.InexactPartial<ParseParams>): Output;
+    safeParse(data: unknown, params?: util.InexactPartial<ParseParams>): SafeParseReturnType<Input, Output>;
     "~validate"(data: unknown): StandardSchemaV1.Result<Output> | Promise<StandardSchemaV1.Result<Output>>;
-    parseAsync(data: unknown, params?: Partial<ParseParams>): Promise<Output>;
-    safeParseAsync(data: unknown, params?: Partial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
+    parseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<Output>;
+    safeParseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
     /** Alias of safeParseAsync */
-    spa: (data: unknown, params?: Partial<ParseParams>) => Promise<SafeParseReturnType<Input, Output>>;
+    spa: (data: unknown, params?: util.InexactPartial<ParseParams>) => Promise<SafeParseReturnType<Input, Output>>;
     refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, Input>;
     refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;
     refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, Input>;
@@ -18312,99 +18451,99 @@ type IpVersion = "v4" | "v6";
 type ZodStringCheck = {
     kind: "min";
     value: number;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "max";
     value: number;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "length";
     value: number;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "email";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "url";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "emoji";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "uuid";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "nanoid";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "cuid";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "includes";
     value: string;
-    position?: number;
-    message?: string;
+    position?: number | undefined;
+    message?: string | undefined;
 } | {
     kind: "cuid2";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "ulid";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "startsWith";
     value: string;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "endsWith";
     value: string;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "regex";
     regex: RegExp;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "trim";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "toLowerCase";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "toUpperCase";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "jwt";
     alg?: string;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "datetime";
     offset: boolean;
     local: boolean;
     precision: number | null;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "date";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "time";
     precision: number | null;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "duration";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "ip";
-    version?: IpVersion;
-    message?: string;
+    version?: IpVersion | undefined;
+    message?: string | undefined;
 } | {
     kind: "cidr";
-    version?: IpVersion;
-    message?: string;
+    version?: IpVersion | undefined;
+    message?: string | undefined;
 } | {
     kind: "base64";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "base64url";
-    message?: string;
+    message?: string | undefined;
 };
 interface ZodStringDef extends ZodTypeDef {
     checks: ZodStringCheck[];
@@ -18427,15 +18566,15 @@ declare class ZodString extends ZodType<string, ZodStringDef, string> {
     base64url(message?: errorUtil.ErrMessage): ZodString;
     jwt(options?: {
         alg?: string;
-        message?: string;
+        message?: string | undefined;
     }): ZodString;
     ip(options?: string | {
         version?: IpVersion;
-        message?: string;
+        message?: string | undefined;
     }): ZodString;
     cidr(options?: string | {
         version?: IpVersion;
-        message?: string;
+        message?: string | undefined;
     }): ZodString;
     datetime(options?: string | {
         message?: string | undefined;
@@ -18492,22 +18631,22 @@ type ZodNumberCheck = {
     kind: "min";
     value: number;
     inclusive: boolean;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "max";
     value: number;
     inclusive: boolean;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "int";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "multipleOf";
     value: number;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "finite";
-    message?: string;
+    message?: string | undefined;
 };
 interface ZodNumberDef extends ZodTypeDef {
     checks: ZodNumberCheck[];
@@ -18564,15 +18703,15 @@ interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     typeName: ZodFirstPartyTypeKind.ZodArray;
     exactLength: {
         value: number;
-        message?: string;
+        message?: string | undefined;
     } | null;
     minLength: {
         value: number;
-        message?: string;
+        message?: string | undefined;
     } | null;
     maxLength: {
         value: number;
-        message?: string;
+        message?: string | undefined;
     } | null;
 }
 type ArrayCardinality = "many" | "atleastone";
@@ -18584,7 +18723,7 @@ declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinalit
     max(maxLength: number, message?: errorUtil.ErrMessage): this;
     length(len: number, message?: errorUtil.ErrMessage): this;
     nonempty(message?: errorUtil.ErrMessage): ZodArray<T, "atleastone">;
-    static create: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodArray<T_1, "many">;
+    static create: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;
 }
 type UnknownKeysParam = "passthrough" | "strict" | "strip";
 interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
@@ -18669,24 +18808,20 @@ declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysPa
         [k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : T[k];
     }>, UnknownKeys, Catchall>;
     keyof(): ZodEnum<enumUtil.UnionToTupleString<keyof T>>;
-    static create: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any> extends infer T_2 ? { [k in keyof T_2]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>[k]; } : never, baseObjectInputType<T_1> extends infer T_3 ? { [k_1 in keyof T_3]: baseObjectInputType<T_1>[k_1]; } : never>;
-    static strictCreate: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strict", ZodTypeAny, objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any> extends infer T_2 ? { [k in keyof T_2]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>[k]; } : never, baseObjectInputType<T_1> extends infer T_3 ? { [k_1 in keyof T_3]: baseObjectInputType<T_1>[k_1]; } : never>;
-    static lazycreate: <T_1 extends ZodRawShape>(shape: () => T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any> extends infer T_2 ? { [k in keyof T_2]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>[k]; } : never, baseObjectInputType<T_1> extends infer T_3 ? { [k_1 in keyof T_3]: baseObjectInputType<T_1>[k_1]; } : never>;
+    static create: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strip", ZodTypeAny, objectOutputType<Shape, ZodTypeAny, "strip">, objectInputType<Shape, ZodTypeAny, "strip">>;
+    static strictCreate: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strict">;
+    static lazycreate: <Shape extends ZodRawShape>(shape: () => Shape, params?: RawCreateParams) => ZodObject<Shape, "strip">;
 }
 type AnyZodObject = ZodObject<any, any, any>;
 type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;
-interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[
-    ZodTypeAny,
-    ZodTypeAny,
-    ...ZodTypeAny[]
-]>> extends ZodTypeDef {
+interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>> extends ZodTypeDef {
     options: T;
     typeName: ZodFirstPartyTypeKind.ZodUnion;
 }
 declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[number]["_output"], ZodUnionDef<T>, T[number]["_input"]> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get options(): T;
-    static create: <T_1 extends readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T_1, params?: RawCreateParams) => ZodUnion<T_1>;
+    static create: <Options extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;
 }
 type ZodDiscriminatedUnionOption<Discriminator extends string> = ZodObject<{
     [key in Discriminator]: ZodTypeAny;
@@ -18722,7 +18857,7 @@ interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTyp
 }
 declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extends ZodType<T["_output"] & U["_output"], ZodIntersectionDef<T, U>, T["_input"] & U["_input"]> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <T_1 extends ZodTypeAny, U_1 extends ZodTypeAny>(left: T_1, right: U_1, params?: RawCreateParams) => ZodIntersection<T_1, U_1>;
+    static create: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection<TSchema, USchema>;
 }
 type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
 type AssertArray<T> = T extends any[] ? T : never;
@@ -18739,11 +18874,11 @@ interface ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends
     rest: Rest;
     typeName: ZodFirstPartyTypeKind.ZodTuple;
 }
-declare class ZodTuple<T extends [ZodTypeAny, ...ZodTypeAny[]] | [] = [ZodTypeAny, ...ZodTypeAny[]], Rest extends ZodTypeAny | null = null> extends ZodType<OutputTypeOfTupleWithRest<T, Rest>, ZodTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {
+declare class ZodTuple<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodType<OutputTypeOfTupleWithRest<T, Rest>, ZodTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get items(): T;
-    rest<Rest extends ZodTypeAny>(rest: Rest): ZodTuple<T, Rest>;
-    static create: <T_1 extends [] | [ZodTypeAny, ...ZodTypeAny[]]>(schemas: T_1, params?: RawCreateParams) => ZodTuple<T_1, null>;
+    rest<RestSchema extends ZodTypeAny>(rest: RestSchema): ZodTuple<T, RestSchema>;
+    static create: <Items extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, null>;
 }
 interface ZodLiteralDef<T = any> extends ZodTypeDef {
     value: T;
@@ -18752,7 +18887,7 @@ interface ZodLiteralDef<T = any> extends ZodTypeDef {
 declare class ZodLiteral<T> extends ZodType<T, ZodLiteralDef<T>, T> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get value(): T;
-    static create: <T_1 extends Primitive$1>(value: T_1, params?: RawCreateParams) => ZodLiteral<T_1>;
+    static create: <Value extends Primitive$1>(value: Value, params?: RawCreateParams) => ZodLiteral<Value>;
 }
 type EnumValues<T extends string = string> = readonly [T, ...T[]];
 type Values<T extends EnumValues> = {
@@ -18770,7 +18905,7 @@ type typecast<A, T> = A extends T ? A : never;
 declare function createZodEnum<U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: RawCreateParams): ZodEnum<Writeable<T>>;
 declare function createZodEnum<U extends string, T extends [U, ...U[]]>(values: T, params?: RawCreateParams): ZodEnum<T>;
 declare class ZodEnum<T extends [string, ...string[]]> extends ZodType<T[number], ZodEnumDef<T>, T[number]> {
-    #private;
+    _cache: Set<T[number]> | undefined;
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get options(): T;
     get enum(): Values<T>;
@@ -18787,7 +18922,7 @@ interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 declare class ZodPromise<T extends ZodTypeAny> extends ZodType<Promise<T["_output"]>, ZodPromiseDef<T>, Promise<T["_input"]>> {
     unwrap(): T;
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodPromise<T_1>;
+    static create: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;
 }
 type RefinementEffect<T> = {
     type: "refinement";
@@ -18822,7 +18957,7 @@ interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 declare class ZodOptional<T extends ZodTypeAny> extends ZodType<T["_output"] | undefined, ZodOptionalDef<T>, T["_input"] | undefined> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     unwrap(): T;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodOptional<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional<Inner>;
 }
 interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     innerType: T;
@@ -18831,7 +18966,7 @@ interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 declare class ZodNullable<T extends ZodTypeAny> extends ZodType<T["_output"] | null, ZodNullableDef<T>, T["_input"] | null> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     unwrap(): T;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodNullable<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable<Inner>;
 }
 interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     innerType: T;
@@ -18841,15 +18976,9 @@ interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 declare class ZodDefault<T extends ZodTypeAny> extends ZodType<util.noUndefined<T["_output"]>, ZodDefaultDef<T>, T["_input"] | undefined> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     removeDefault(): T;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params: {
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        message?: string | undefined;
-        description?: string | undefined;
-    } & {
-        default: T_1["_input"] | (() => util.noUndefined<T_1["_input"]>);
-    }) => ZodDefault<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
+        default: Inner["_input"] | (() => util.noUndefined<Inner["_input"]>);
+    }) => ZodDefault<Inner>;
 }
 interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     innerType: T;
@@ -18862,15 +18991,9 @@ interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 declare class ZodCatch<T extends ZodTypeAny> extends ZodType<T["_output"], ZodCatchDef<T>, unknown> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     removeCatch(): T;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params: {
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        message?: string | undefined;
-        description?: string | undefined;
-    } & {
-        catch: T_1["_output"] | (() => T_1["_output"]);
-    }) => ZodCatch<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
+        catch: Inner["_output"] | (() => Inner["_output"]);
+    }) => ZodCatch<Inner>;
 }
 interface ZodBrandedDef<T extends ZodTypeAny> extends ZodTypeDef {
     type: T;
@@ -18893,7 +19016,7 @@ interface ZodPipelineDef<A extends ZodTypeAny, B extends ZodTypeAny> extends Zod
 }
 declare class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodType<B["_output"], ZodPipelineDef<A, B>, A["_input"]> {
     _parse(input: ParseInput): ParseReturnType<any>;
-    static create<A extends ZodTypeAny, B extends ZodTypeAny>(a: A, b: B): ZodPipeline<A, B>;
+    static create<ASchema extends ZodTypeAny, BSchema extends ZodTypeAny>(a: ASchema, b: BSchema): ZodPipeline<ASchema, BSchema>;
 }
 type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
     readonly [Symbol.toStringTag]: string;
@@ -18905,7 +19028,7 @@ interface ZodReadonlyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 }
 declare class ZodReadonly<T extends ZodTypeAny> extends ZodType<MakeReadonly<T["_output"]>, ZodReadonlyDef<T>, MakeReadonly<T["_input"]>> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodReadonly<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodReadonly<Inner>;
     unwrap(): T;
 }
 declare enum ZodFirstPartyTypeKind {
@@ -18947,6 +19070,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 +19812,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 +19825,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 +19838,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 +23605,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 +23739,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 +24084,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 +24457,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 +24830,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 +28296,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 +28319,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 +28342,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 +28356,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 +28367,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 +33964,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 +34309,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 +34682,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 +35055,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,13 +35104,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">>;
+        /**
+         * 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.
+         */
+        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.
@@ -34680,70 +35757,484 @@ 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.
+         */
+        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">;
+}>, ZodTypeAny, "passthrough">, objectInputType<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">>;
-    }, ZodTypeAny, "passthrough">, objectInputType<{
         /**
-         * The name of the tool.
+         * An optional JSON Schema object defining the structure of the tool's output returned in
+         * the structuredContent field of a CallToolResult.
          */
-        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<{
+        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">>, "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>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, ZodTypeAny, "passthrough">>>;
         /**
-         * A JSON Schema object defining the expected parameters for the tool.
+         * Optional additional tool information.
          */
-        inputSchema: ZodObject<{
-            type: ZodLiteral<"object">;
-            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+        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">>>;
     }, "passthrough", ZodTypeAny, objectOutputType<{
         /**
          * The name of the tool.
@@ -34759,71 +36250,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">>;
-    }, ZodTypeAny, "passthrough">, objectInputType<{
-        /**
-         * The name of the tool.
-         */
-        name: ZodString;
         /**
-         * A human-readable description of the tool.
+         * An optional JSON Schema object defining the structure of the tool's output returned in
+         * the structuredContent field of a CallToolResult.
          */
-        description: ZodOptional<ZodString>;
-        /**
-         * A JSON Schema object defining the expected parameters for the tool.
-         */
-        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">>, "many">;
-}>, ZodTypeAny, "passthrough">, objectInputType<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>;
+            required: ZodOptional<ZodArray<ZodString, "many">>;
+        }, ZodTypeAny, "passthrough">>>;
         /**
-         * A JSON Schema object defining the expected parameters for the tool.
+         * Optional additional tool information.
          */
-        inputSchema: ZodObject<{
-            type: ZodLiteral<"object">;
-            properties: ZodOptional<ZodObject<{}, "passthrough", ZodTypeAny, objectOutputType<{}, ZodTypeAny, "passthrough">, objectInputType<{}, ZodTypeAny, "passthrough">>>;
+        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">>;
-    }, "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">>>;
+    }, ZodTypeAny, "passthrough">, objectInputType<{
         /**
          * The name of the tool.
          */
@@ -34838,35 +36410,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">>;
-    }, 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.
+         * 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">>;
+            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 +36563,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 +36577,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 +36756,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 +37100,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 +37110,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 +37217,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;
@@ -35579,6 +37314,8 @@ type RegisteredPrompt = {
 };
 
 interface LikeC4MCPServer {
+    readonly isStarted: boolean;
+    readonly port: number;
     start(port: number): Promise<void>;
     stop(): Promise<void>;
 }
@@ -35726,7 +37463,7 @@ interface LikeC4AddedServices {
     likec4: {
         LanguageServices: LikeC4LanguageServices;
         Views: LikeC4Views;
-        Layouter: GraphvizLayouter;
+        Layouter: QueueGraphvizLayoter;
         DeploymentsIndex: DeploymentsIndex;
         FqnIndex: FqnIndex;
         ModelParser: LikeC4ModelParser;
@@ -35752,4 +37489,4 @@ interface LikeC4AddedServices {
 }
 type LikeC4Services = LangiumServices & LikeC4AddedServices;
 
-export { GraphvizLayouter as G, type LikeC4LanguageServices as L, Range$1 as R, WorkspaceFolder as W, type LikeC4Services as a, type LikeC4Views as b };
+export { type LikeC4LanguageServices as L, Range$1 as R, WorkspaceFolder as W, type LikeC4Services as a, type LikeC4Views as b };