fixparser-plugin-mcp 9.1.7-3e178996 → 9.1.7-3f807208

package/build/esm/MCPLocal.mjs

@@ -1,1281 +1,9 @@
 // src/MCPLocal.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
+import { Field, Fields, Messages } from "fixparser";
 import { z } from "zod";
-
-// ../../node_modules/zod-to-json-schema/dist/esm/Options.js
-var ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
-var defaultOptions = {
-  name: void 0,
-  $refStrategy: "root",
-  basePath: ["#"],
-  effectStrategy: "input",
-  pipeStrategy: "all",
-  dateStrategy: "format:date-time",
-  mapStrategy: "entries",
-  removeAdditionalStrategy: "passthrough",
-  allowedAdditionalProperties: true,
-  rejectedAdditionalProperties: false,
-  definitionPath: "definitions",
-  target: "jsonSchema7",
-  strictUnions: false,
-  definitions: {},
-  errorMessages: false,
-  markdownDescription: false,
-  patternStrategy: "escape",
-  applyRegexFlags: false,
-  emailStrategy: "format:email",
-  base64Strategy: "contentEncoding:base64",
-  nameStrategy: "ref"
-};
-var getDefaultOptions = (options) => typeof options === "string" ? {
-  ...defaultOptions,
-  name: options
-} : {
-  ...defaultOptions,
-  ...options
-};
-
-// ../../node_modules/zod-to-json-schema/dist/esm/Refs.js
-var getRefs = (options) => {
-  const _options = getDefaultOptions(options);
-  const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
-  return {
-    ..._options,
-    currentPath,
-    propertyPath: void 0,
-    seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [
-      def._def,
-      {
-        def: def._def,
-        path: [..._options.basePath, _options.definitionPath, name],
-        // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
-        jsonSchema: void 0
-      }
-    ]))
-  };
-};
-
-// ../../node_modules/zod-to-json-schema/dist/esm/errorMessages.js
-function addErrorMessage(res, key, errorMessage, refs) {
-  if (!refs?.errorMessages)
-    return;
-  if (errorMessage) {
-    res.errorMessage = {
-      ...res.errorMessage,
-      [key]: errorMessage
-    };
-  }
-}
-function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
-  res[key] = value;
-  addErrorMessage(res, key, errorMessage, refs);
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/selectParser.js
-import { ZodFirstPartyTypeKind as ZodFirstPartyTypeKind3 } from "zod";
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/any.js
-function parseAnyDef() {
-  return {};
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/array.js
-import { ZodFirstPartyTypeKind } from "zod";
-function parseArrayDef(def, refs) {
-  const res = {
-    type: "array"
-  };
-  if (def.type?._def && def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) {
-    res.items = parseDef(def.type._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "items"]
-    });
-  }
-  if (def.minLength) {
-    setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs);
-  }
-  if (def.maxLength) {
-    setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
-  }
-  if (def.exactLength) {
-    setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
-    setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
-  }
-  return res;
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js
-function parseBigintDef(def, refs) {
-  const res = {
-    type: "integer",
-    format: "int64"
-  };
-  if (!def.checks)
-    return res;
-  for (const check of def.checks) {
-    switch (check.kind) {
-      case "min":
-        if (refs.target === "jsonSchema7") {
-          if (check.inclusive) {
-            setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
-          } else {
-            setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
-          }
-        } else {
-          if (!check.inclusive) {
-            res.exclusiveMinimum = true;
-          }
-          setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
-        }
-        break;
-      case "max":
-        if (refs.target === "jsonSchema7") {
-          if (check.inclusive) {
-            setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
-          } else {
-            setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
-          }
-        } else {
-          if (!check.inclusive) {
-            res.exclusiveMaximum = true;
-          }
-          setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
-        }
-        break;
-      case "multipleOf":
-        setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
-        break;
-    }
-  }
-  return res;
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js
-function parseBooleanDef() {
-  return {
-    type: "boolean"
-  };
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/branded.js
-function parseBrandedDef(_def, refs) {
-  return parseDef(_def.type._def, refs);
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/catch.js
-var parseCatchDef = (def, refs) => {
-  return parseDef(def.innerType._def, refs);
-};
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/date.js
-function parseDateDef(def, refs, overrideDateStrategy) {
-  const strategy = overrideDateStrategy ?? refs.dateStrategy;
-  if (Array.isArray(strategy)) {
-    return {
-      anyOf: strategy.map((item, i) => parseDateDef(def, refs, item))
-    };
-  }
-  switch (strategy) {
-    case "string":
-    case "format:date-time":
-      return {
-        type: "string",
-        format: "date-time"
-      };
-    case "format:date":
-      return {
-        type: "string",
-        format: "date"
-      };
-    case "integer":
-      return integerDateParser(def, refs);
-  }
-}
-var integerDateParser = (def, refs) => {
-  const res = {
-    type: "integer",
-    format: "unix-time"
-  };
-  if (refs.target === "openApi3") {
-    return res;
-  }
-  for (const check of def.checks) {
-    switch (check.kind) {
-      case "min":
-        setResponseValueAndErrors(
-          res,
-          "minimum",
-          check.value,
-          // This is in milliseconds
-          check.message,
-          refs
-        );
-        break;
-      case "max":
-        setResponseValueAndErrors(
-          res,
-          "maximum",
-          check.value,
-          // This is in milliseconds
-          check.message,
-          refs
-        );
-        break;
-    }
-  }
-  return res;
-};
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/default.js
-function parseDefaultDef(_def, refs) {
-  return {
-    ...parseDef(_def.innerType._def, refs),
-    default: _def.defaultValue()
-  };
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/effects.js
-function parseEffectsDef(_def, refs) {
-  return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : {};
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/enum.js
-function parseEnumDef(def) {
-  return {
-    type: "string",
-    enum: Array.from(def.values)
-  };
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js
-var isJsonSchema7AllOfType = (type) => {
-  if ("type" in type && type.type === "string")
-    return false;
-  return "allOf" in type;
-};
-function parseIntersectionDef(def, refs) {
-  const allOf = [
-    parseDef(def.left._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "allOf", "0"]
-    }),
-    parseDef(def.right._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "allOf", "1"]
-    })
-  ].filter((x) => !!x);
-  let unevaluatedProperties = refs.target === "jsonSchema2019-09" ? { unevaluatedProperties: false } : void 0;
-  const mergedAllOf = [];
-  allOf.forEach((schema) => {
-    if (isJsonSchema7AllOfType(schema)) {
-      mergedAllOf.push(...schema.allOf);
-      if (schema.unevaluatedProperties === void 0) {
-        unevaluatedProperties = void 0;
-      }
-    } else {
-      let nestedSchema = schema;
-      if ("additionalProperties" in schema && schema.additionalProperties === false) {
-        const { additionalProperties, ...rest } = schema;
-        nestedSchema = rest;
-      } else {
-        unevaluatedProperties = void 0;
-      }
-      mergedAllOf.push(nestedSchema);
-    }
-  });
-  return mergedAllOf.length ? {
-    allOf: mergedAllOf,
-    ...unevaluatedProperties
-  } : void 0;
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/literal.js
-function parseLiteralDef(def, refs) {
-  const parsedType = typeof def.value;
-  if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") {
-    return {
-      type: Array.isArray(def.value) ? "array" : "object"
-    };
-  }
-  if (refs.target === "openApi3") {
-    return {
-      type: parsedType === "bigint" ? "integer" : parsedType,
-      enum: [def.value]
-    };
-  }
-  return {
-    type: parsedType === "bigint" ? "integer" : parsedType,
-    const: def.value
-  };
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/record.js
-import { ZodFirstPartyTypeKind as ZodFirstPartyTypeKind2 } from "zod";
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/string.js
-var emojiRegex = void 0;
-var zodPatterns = {
-  /**
-   * `c` was changed to `[cC]` to replicate /i flag
-   */
-  cuid: /^[cC][^\s-]{8,}$/,
-  cuid2: /^[0-9a-z]+$/,
-  ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
-  /**
-   * `a-z` was added to replicate /i flag
-   */
-  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
-  /**
-   * Constructed a valid Unicode RegExp
-   *
-   * Lazily instantiate since this type of regex isn't supported
-   * in all envs (e.g. React Native).
-   *
-   * See:
-   * https://github.com/colinhacks/zod/issues/2433
-   * Fix in Zod:
-   * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
-   */
-  emoji: () => {
-    if (emojiRegex === void 0) {
-      emojiRegex = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
-    }
-    return emojiRegex;
-  },
-  /**
-   * Unused
-   */
-  uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
-  /**
-   * Unused
-   */
-  ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
-  ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
-  /**
-   * Unused
-   */
-  ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
-  ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
-  base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
-  base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
-  nanoid: /^[a-zA-Z0-9_-]{21}$/,
-  jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
-};
-function parseStringDef(def, refs) {
-  const res = {
-    type: "string"
-  };
-  if (def.checks) {
-    for (const check of def.checks) {
-      switch (check.kind) {
-        case "min":
-          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
-          break;
-        case "max":
-          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
-          break;
-        case "email":
-          switch (refs.emailStrategy) {
-            case "format:email":
-              addFormat(res, "email", check.message, refs);
-              break;
-            case "format:idn-email":
-              addFormat(res, "idn-email", check.message, refs);
-              break;
-            case "pattern:zod":
-              addPattern(res, zodPatterns.email, check.message, refs);
-              break;
-          }
-          break;
-        case "url":
-          addFormat(res, "uri", check.message, refs);
-          break;
-        case "uuid":
-          addFormat(res, "uuid", check.message, refs);
-          break;
-        case "regex":
-          addPattern(res, check.regex, check.message, refs);
-          break;
-        case "cuid":
-          addPattern(res, zodPatterns.cuid, check.message, refs);
-          break;
-        case "cuid2":
-          addPattern(res, zodPatterns.cuid2, check.message, refs);
-          break;
-        case "startsWith":
-          addPattern(res, RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`), check.message, refs);
-          break;
-        case "endsWith":
-          addPattern(res, RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`), check.message, refs);
-          break;
-        case "datetime":
-          addFormat(res, "date-time", check.message, refs);
-          break;
-        case "date":
-          addFormat(res, "date", check.message, refs);
-          break;
-        case "time":
-          addFormat(res, "time", check.message, refs);
-          break;
-        case "duration":
-          addFormat(res, "duration", check.message, refs);
-          break;
-        case "length":
-          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
-          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
-          break;
-        case "includes": {
-          addPattern(res, RegExp(escapeLiteralCheckValue(check.value, refs)), check.message, refs);
-          break;
-        }
-        case "ip": {
-          if (check.version !== "v6") {
-            addFormat(res, "ipv4", check.message, refs);
-          }
-          if (check.version !== "v4") {
-            addFormat(res, "ipv6", check.message, refs);
-          }
-          break;
-        }
-        case "base64url":
-          addPattern(res, zodPatterns.base64url, check.message, refs);
-          break;
-        case "jwt":
-          addPattern(res, zodPatterns.jwt, check.message, refs);
-          break;
-        case "cidr": {
-          if (check.version !== "v6") {
-            addPattern(res, zodPatterns.ipv4Cidr, check.message, refs);
-          }
-          if (check.version !== "v4") {
-            addPattern(res, zodPatterns.ipv6Cidr, check.message, refs);
-          }
-          break;
-        }
-        case "emoji":
-          addPattern(res, zodPatterns.emoji(), check.message, refs);
-          break;
-        case "ulid": {
-          addPattern(res, zodPatterns.ulid, check.message, refs);
-          break;
-        }
-        case "base64": {
-          switch (refs.base64Strategy) {
-            case "format:binary": {
-              addFormat(res, "binary", check.message, refs);
-              break;
-            }
-            case "contentEncoding:base64": {
-              setResponseValueAndErrors(res, "contentEncoding", "base64", check.message, refs);
-              break;
-            }
-            case "pattern:zod": {
-              addPattern(res, zodPatterns.base64, check.message, refs);
-              break;
-            }
-          }
-          break;
-        }
-        case "nanoid": {
-          addPattern(res, zodPatterns.nanoid, check.message, refs);
-        }
-        case "toLowerCase":
-        case "toUpperCase":
-        case "trim":
-          break;
-        default:
-          /* @__PURE__ */ ((_) => {
-          })(check);
-      }
-    }
-  }
-  return res;
-}
-function escapeLiteralCheckValue(literal, refs) {
-  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
-}
-var ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
-function escapeNonAlphaNumeric(source) {
-  let result = "";
-  for (let i = 0; i < source.length; i++) {
-    if (!ALPHA_NUMERIC.has(source[i])) {
-      result += "\\";
-    }
-    result += source[i];
-  }
-  return result;
-}
-function addFormat(schema, value, message, refs) {
-  if (schema.format || schema.anyOf?.some((x) => x.format)) {
-    if (!schema.anyOf) {
-      schema.anyOf = [];
-    }
-    if (schema.format) {
-      schema.anyOf.push({
-        format: schema.format,
-        ...schema.errorMessage && refs.errorMessages && {
-          errorMessage: { format: schema.errorMessage.format }
-        }
-      });
-      delete schema.format;
-      if (schema.errorMessage) {
-        delete schema.errorMessage.format;
-        if (Object.keys(schema.errorMessage).length === 0) {
-          delete schema.errorMessage;
-        }
-      }
-    }
-    schema.anyOf.push({
-      format: value,
-      ...message && refs.errorMessages && { errorMessage: { format: message } }
-    });
-  } else {
-    setResponseValueAndErrors(schema, "format", value, message, refs);
-  }
-}
-function addPattern(schema, regex, message, refs) {
-  if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {
-    if (!schema.allOf) {
-      schema.allOf = [];
-    }
-    if (schema.pattern) {
-      schema.allOf.push({
-        pattern: schema.pattern,
-        ...schema.errorMessage && refs.errorMessages && {
-          errorMessage: { pattern: schema.errorMessage.pattern }
-        }
-      });
-      delete schema.pattern;
-      if (schema.errorMessage) {
-        delete schema.errorMessage.pattern;
-        if (Object.keys(schema.errorMessage).length === 0) {
-          delete schema.errorMessage;
-        }
-      }
-    }
-    schema.allOf.push({
-      pattern: stringifyRegExpWithFlags(regex, refs),
-      ...message && refs.errorMessages && { errorMessage: { pattern: message } }
-    });
-  } else {
-    setResponseValueAndErrors(schema, "pattern", stringifyRegExpWithFlags(regex, refs), message, refs);
-  }
-}
-function stringifyRegExpWithFlags(regex, refs) {
-  if (!refs.applyRegexFlags || !regex.flags) {
-    return regex.source;
-  }
-  const flags = {
-    i: regex.flags.includes("i"),
-    m: regex.flags.includes("m"),
-    s: regex.flags.includes("s")
-    // `.` matches newlines
-  };
-  const source = flags.i ? regex.source.toLowerCase() : regex.source;
-  let pattern = "";
-  let isEscaped = false;
-  let inCharGroup = false;
-  let inCharRange = false;
-  for (let i = 0; i < source.length; i++) {
-    if (isEscaped) {
-      pattern += source[i];
-      isEscaped = false;
-      continue;
-    }
-    if (flags.i) {
-      if (inCharGroup) {
-        if (source[i].match(/[a-z]/)) {
-          if (inCharRange) {
-            pattern += source[i];
-            pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
-            inCharRange = false;
-          } else if (source[i + 1] === "-" && source[i + 2]?.match(/[a-z]/)) {
-            pattern += source[i];
-            inCharRange = true;
-          } else {
-            pattern += `${source[i]}${source[i].toUpperCase()}`;
-          }
-          continue;
-        }
-      } else if (source[i].match(/[a-z]/)) {
-        pattern += `[${source[i]}${source[i].toUpperCase()}]`;
-        continue;
-      }
-    }
-    if (flags.m) {
-      if (source[i] === "^") {
-        pattern += `(^|(?<=[\r
-]))`;
-        continue;
-      } else if (source[i] === "$") {
-        pattern += `($|(?=[\r
-]))`;
-        continue;
-      }
-    }
-    if (flags.s && source[i] === ".") {
-      pattern += inCharGroup ? `${source[i]}\r
-` : `[${source[i]}\r
-]`;
-      continue;
-    }
-    pattern += source[i];
-    if (source[i] === "\\") {
-      isEscaped = true;
-    } else if (inCharGroup && source[i] === "]") {
-      inCharGroup = false;
-    } else if (!inCharGroup && source[i] === "[") {
-      inCharGroup = true;
-    }
-  }
-  try {
-    new RegExp(pattern);
-  } catch {
-    console.warn(`Could not convert regex pattern at ${refs.currentPath.join("/")} to a flag-independent form! Falling back to the flag-ignorant source`);
-    return regex.source;
-  }
-  return pattern;
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/record.js
-function parseRecordDef(def, refs) {
-  if (refs.target === "openAi") {
-    console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
-  }
-  if (refs.target === "openApi3" && def.keyType?._def.typeName === ZodFirstPartyTypeKind2.ZodEnum) {
-    return {
-      type: "object",
-      required: def.keyType._def.values,
-      properties: def.keyType._def.values.reduce((acc, key) => ({
-        ...acc,
-        [key]: parseDef(def.valueType._def, {
-          ...refs,
-          currentPath: [...refs.currentPath, "properties", key]
-        }) ?? {}
-      }), {}),
-      additionalProperties: refs.rejectedAdditionalProperties
-    };
-  }
-  const schema = {
-    type: "object",
-    additionalProperties: parseDef(def.valueType._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "additionalProperties"]
-    }) ?? refs.allowedAdditionalProperties
-  };
-  if (refs.target === "openApi3") {
-    return schema;
-  }
-  if (def.keyType?._def.typeName === ZodFirstPartyTypeKind2.ZodString && def.keyType._def.checks?.length) {
-    const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
-    return {
-      ...schema,
-      propertyNames: keyType
-    };
-  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind2.ZodEnum) {
-    return {
-      ...schema,
-      propertyNames: {
-        enum: def.keyType._def.values
-      }
-    };
-  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind2.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind2.ZodString && def.keyType._def.type._def.checks?.length) {
-    const { type, ...keyType } = parseBrandedDef(def.keyType._def, refs);
-    return {
-      ...schema,
-      propertyNames: keyType
-    };
-  }
-  return schema;
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/map.js
-function parseMapDef(def, refs) {
-  if (refs.mapStrategy === "record") {
-    return parseRecordDef(def, refs);
-  }
-  const keys = parseDef(def.keyType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "items", "items", "0"]
-  }) || {};
-  const values = parseDef(def.valueType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "items", "items", "1"]
-  }) || {};
-  return {
-    type: "array",
-    maxItems: 125,
-    items: {
-      type: "array",
-      items: [keys, values],
-      minItems: 2,
-      maxItems: 2
-    }
-  };
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js
-function parseNativeEnumDef(def) {
-  const object = def.values;
-  const actualKeys = Object.keys(def.values).filter((key) => {
-    return typeof object[object[key]] !== "number";
-  });
-  const actualValues = actualKeys.map((key) => object[key]);
-  const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values)));
-  return {
-    type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
-    enum: actualValues
-  };
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/never.js
-function parseNeverDef() {
-  return {
-    not: {}
-  };
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/null.js
-function parseNullDef(refs) {
-  return refs.target === "openApi3" ? {
-    enum: ["null"],
-    nullable: true
-  } : {
-    type: "null"
-  };
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/union.js
-var primitiveMappings = {
-  ZodString: "string",
-  ZodNumber: "number",
-  ZodBigInt: "integer",
-  ZodBoolean: "boolean",
-  ZodNull: "null"
-};
-function parseUnionDef(def, refs) {
-  if (refs.target === "openApi3")
-    return asAnyOf(def, refs);
-  const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
-  if (options.every((x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length))) {
-    const types = options.reduce((types2, x) => {
-      const type = primitiveMappings[x._def.typeName];
-      return type && !types2.includes(type) ? [...types2, type] : types2;
-    }, []);
-    return {
-      type: types.length > 1 ? types : types[0]
-    };
-  } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
-    const types = options.reduce((acc, x) => {
-      const type = typeof x._def.value;
-      switch (type) {
-        case "string":
-        case "number":
-        case "boolean":
-          return [...acc, type];
-        case "bigint":
-          return [...acc, "integer"];
-        case "object":
-          if (x._def.value === null)
-            return [...acc, "null"];
-        case "symbol":
-        case "undefined":
-        case "function":
-        default:
-          return acc;
-      }
-    }, []);
-    if (types.length === options.length) {
-      const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
-      return {
-        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
-        enum: options.reduce((acc, x) => {
-          return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
-        }, [])
-      };
-    }
-  } else if (options.every((x) => x._def.typeName === "ZodEnum")) {
-    return {
-      type: "string",
-      enum: options.reduce((acc, x) => [
-        ...acc,
-        ...x._def.values.filter((x2) => !acc.includes(x2))
-      ], [])
-    };
-  }
-  return asAnyOf(def, refs);
-}
-var asAnyOf = (def, refs) => {
-  const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x, i) => parseDef(x._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "anyOf", `${i}`]
-  })).filter((x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0));
-  return anyOf.length ? { anyOf } : void 0;
-};
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js
-function parseNullableDef(def, refs) {
-  if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(def.innerType._def.typeName) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
-    if (refs.target === "openApi3") {
-      return {
-        type: primitiveMappings[def.innerType._def.typeName],
-        nullable: true
-      };
-    }
-    return {
-      type: [
-        primitiveMappings[def.innerType._def.typeName],
-        "null"
-      ]
-    };
-  }
-  if (refs.target === "openApi3") {
-    const base2 = parseDef(def.innerType._def, {
-      ...refs,
-      currentPath: [...refs.currentPath]
-    });
-    if (base2 && "$ref" in base2)
-      return { allOf: [base2], nullable: true };
-    return base2 && { ...base2, nullable: true };
-  }
-  const base = parseDef(def.innerType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "anyOf", "0"]
-  });
-  return base && { anyOf: [base, { type: "null" }] };
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/number.js
-function parseNumberDef(def, refs) {
-  const res = {
-    type: "number"
-  };
-  if (!def.checks)
-    return res;
-  for (const check of def.checks) {
-    switch (check.kind) {
-      case "int":
-        res.type = "integer";
-        addErrorMessage(res, "type", check.message, refs);
-        break;
-      case "min":
-        if (refs.target === "jsonSchema7") {
-          if (check.inclusive) {
-            setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
-          } else {
-            setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
-          }
-        } else {
-          if (!check.inclusive) {
-            res.exclusiveMinimum = true;
-          }
-          setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
-        }
-        break;
-      case "max":
-        if (refs.target === "jsonSchema7") {
-          if (check.inclusive) {
-            setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
-          } else {
-            setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
-          }
-        } else {
-          if (!check.inclusive) {
-            res.exclusiveMaximum = true;
-          }
-          setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
-        }
-        break;
-      case "multipleOf":
-        setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
-        break;
-    }
-  }
-  return res;
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/object.js
-import { ZodOptional } from "zod";
-function parseObjectDef(def, refs) {
-  const forceOptionalIntoNullable = refs.target === "openAi";
-  const result = {
-    type: "object",
-    properties: {}
-  };
-  const required = [];
-  const shape = def.shape();
-  for (const propName in shape) {
-    let propDef = shape[propName];
-    if (propDef === void 0 || propDef._def === void 0) {
-      continue;
-    }
-    let propOptional = safeIsOptional(propDef);
-    if (propOptional && forceOptionalIntoNullable) {
-      if (propDef instanceof ZodOptional) {
-        propDef = propDef._def.innerType;
-      }
-      if (!propDef.isNullable()) {
-        propDef = propDef.nullable();
-      }
-      propOptional = false;
-    }
-    const parsedDef = parseDef(propDef._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "properties", propName],
-      propertyPath: [...refs.currentPath, "properties", propName]
-    });
-    if (parsedDef === void 0) {
-      continue;
-    }
-    result.properties[propName] = parsedDef;
-    if (!propOptional) {
-      required.push(propName);
-    }
-  }
-  if (required.length) {
-    result.required = required;
-  }
-  const additionalProperties = decideAdditionalProperties(def, refs);
-  if (additionalProperties !== void 0) {
-    result.additionalProperties = additionalProperties;
-  }
-  return result;
-}
-function decideAdditionalProperties(def, refs) {
-  if (def.catchall._def.typeName !== "ZodNever") {
-    return parseDef(def.catchall._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "additionalProperties"]
-    });
-  }
-  switch (def.unknownKeys) {
-    case "passthrough":
-      return refs.allowedAdditionalProperties;
-    case "strict":
-      return refs.rejectedAdditionalProperties;
-    case "strip":
-      return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
-  }
-}
-function safeIsOptional(schema) {
-  try {
-    return schema.isOptional();
-  } catch {
-    return true;
-  }
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/optional.js
-var parseOptionalDef = (def, refs) => {
-  if (refs.currentPath.toString() === refs.propertyPath?.toString()) {
-    return parseDef(def.innerType._def, refs);
-  }
-  const innerSchema = parseDef(def.innerType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "anyOf", "1"]
-  });
-  return innerSchema ? {
-    anyOf: [
-      {
-        not: {}
-      },
-      innerSchema
-    ]
-  } : {};
-};
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js
-var parsePipelineDef = (def, refs) => {
-  if (refs.pipeStrategy === "input") {
-    return parseDef(def.in._def, refs);
-  } else if (refs.pipeStrategy === "output") {
-    return parseDef(def.out._def, refs);
-  }
-  const a = parseDef(def.in._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "allOf", "0"]
-  });
-  const b = parseDef(def.out._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
-  });
-  return {
-    allOf: [a, b].filter((x) => x !== void 0)
-  };
-};
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/promise.js
-function parsePromiseDef(def, refs) {
-  return parseDef(def.type._def, refs);
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/set.js
-function parseSetDef(def, refs) {
-  const items = parseDef(def.valueType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "items"]
-  });
-  const schema = {
-    type: "array",
-    uniqueItems: true,
-    items
-  };
-  if (def.minSize) {
-    setResponseValueAndErrors(schema, "minItems", def.minSize.value, def.minSize.message, refs);
-  }
-  if (def.maxSize) {
-    setResponseValueAndErrors(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs);
-  }
-  return schema;
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js
-function parseTupleDef(def, refs) {
-  if (def.rest) {
-    return {
-      type: "array",
-      minItems: def.items.length,
-      items: def.items.map((x, i) => parseDef(x._def, {
-        ...refs,
-        currentPath: [...refs.currentPath, "items", `${i}`]
-      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], []),
-      additionalItems: parseDef(def.rest._def, {
-        ...refs,
-        currentPath: [...refs.currentPath, "additionalItems"]
-      })
-    };
-  } else {
-    return {
-      type: "array",
-      minItems: def.items.length,
-      maxItems: def.items.length,
-      items: def.items.map((x, i) => parseDef(x._def, {
-        ...refs,
-        currentPath: [...refs.currentPath, "items", `${i}`]
-      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], [])
-    };
-  }
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js
-function parseUndefinedDef() {
-  return {
-    not: {}
-  };
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js
-function parseUnknownDef() {
-  return {};
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js
-var parseReadonlyDef = (def, refs) => {
-  return parseDef(def.innerType._def, refs);
-};
-
-// ../../node_modules/zod-to-json-schema/dist/esm/selectParser.js
-var selectParser = (def, typeName, refs) => {
-  switch (typeName) {
-    case ZodFirstPartyTypeKind3.ZodString:
-      return parseStringDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodNumber:
-      return parseNumberDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodObject:
-      return parseObjectDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodBigInt:
-      return parseBigintDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodBoolean:
-      return parseBooleanDef();
-    case ZodFirstPartyTypeKind3.ZodDate:
-      return parseDateDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodUndefined:
-      return parseUndefinedDef();
-    case ZodFirstPartyTypeKind3.ZodNull:
-      return parseNullDef(refs);
-    case ZodFirstPartyTypeKind3.ZodArray:
-      return parseArrayDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodUnion:
-    case ZodFirstPartyTypeKind3.ZodDiscriminatedUnion:
-      return parseUnionDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodIntersection:
-      return parseIntersectionDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodTuple:
-      return parseTupleDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodRecord:
-      return parseRecordDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodLiteral:
-      return parseLiteralDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodEnum:
-      return parseEnumDef(def);
-    case ZodFirstPartyTypeKind3.ZodNativeEnum:
-      return parseNativeEnumDef(def);
-    case ZodFirstPartyTypeKind3.ZodNullable:
-      return parseNullableDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodOptional:
-      return parseOptionalDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodMap:
-      return parseMapDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodSet:
-      return parseSetDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodLazy:
-      return () => def.getter()._def;
-    case ZodFirstPartyTypeKind3.ZodPromise:
-      return parsePromiseDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodNaN:
-    case ZodFirstPartyTypeKind3.ZodNever:
-      return parseNeverDef();
-    case ZodFirstPartyTypeKind3.ZodEffects:
-      return parseEffectsDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodAny:
-      return parseAnyDef();
-    case ZodFirstPartyTypeKind3.ZodUnknown:
-      return parseUnknownDef();
-    case ZodFirstPartyTypeKind3.ZodDefault:
-      return parseDefaultDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodBranded:
-      return parseBrandedDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodReadonly:
-      return parseReadonlyDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodCatch:
-      return parseCatchDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodPipeline:
-      return parsePipelineDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodFunction:
-    case ZodFirstPartyTypeKind3.ZodVoid:
-    case ZodFirstPartyTypeKind3.ZodSymbol:
-      return void 0;
-    default:
-      return /* @__PURE__ */ ((_) => void 0)(typeName);
-  }
-};
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parseDef.js
-function parseDef(def, refs, forceResolution = false) {
-  const seenItem = refs.seen.get(def);
-  if (refs.override) {
-    const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
-    if (overrideResult !== ignoreOverride) {
-      return overrideResult;
-    }
-  }
-  if (seenItem && !forceResolution) {
-    const seenSchema = get$ref(seenItem, refs);
-    if (seenSchema !== void 0) {
-      return seenSchema;
-    }
-  }
-  const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
-  refs.seen.set(def, newItem);
-  const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);
-  const jsonSchema = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
-  if (jsonSchema) {
-    addMeta(def, refs, jsonSchema);
-  }
-  if (refs.postProcess) {
-    const postProcessResult = refs.postProcess(jsonSchema, def, refs);
-    newItem.jsonSchema = jsonSchema;
-    return postProcessResult;
-  }
-  newItem.jsonSchema = jsonSchema;
-  return jsonSchema;
-}
-var get$ref = (item, refs) => {
-  switch (refs.$refStrategy) {
-    case "root":
-      return { $ref: item.path.join("/") };
-    case "relative":
-      return { $ref: getRelativePath(refs.currentPath, item.path) };
-    case "none":
-    case "seen": {
-      if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
-        console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`);
-        return {};
-      }
-      return refs.$refStrategy === "seen" ? {} : void 0;
-    }
-  }
-};
-var getRelativePath = (pathA, pathB) => {
-  let i = 0;
-  for (; i < pathA.length && i < pathB.length; i++) {
-    if (pathA[i] !== pathB[i])
-      break;
-  }
-  return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
-};
-var addMeta = (def, refs, jsonSchema) => {
-  if (def.description) {
-    jsonSchema.description = def.description;
-    if (refs.markdownDescription) {
-      jsonSchema.markdownDescription = def.description;
-    }
-  }
-  return jsonSchema;
-};
-
-// ../../node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js
-var zodToJsonSchema = (schema, options) => {
-  const refs = getRefs(options);
-  const definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name2, schema2]) => ({
-    ...acc,
-    [name2]: parseDef(schema2._def, {
-      ...refs,
-      currentPath: [...refs.basePath, refs.definitionPath, name2]
-    }, true) ?? {}
-  }), {}) : void 0;
-  const name = typeof options === "string" ? options : options?.nameStrategy === "title" ? void 0 : options?.name;
-  const main = parseDef(schema._def, name === void 0 ? refs : {
-    ...refs,
-    currentPath: [...refs.basePath, refs.definitionPath, name]
-  }, false) ?? {};
-  const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
-  if (title !== void 0) {
-    main.title = title;
-  }
-  const combined = name === void 0 ? definitions ? {
-    ...main,
-    [refs.definitionPath]: definitions
-  } : main : {
-    $ref: [
-      ...refs.$refStrategy === "relative" ? [] : refs.basePath,
-      refs.definitionPath,
-      name
-    ].join("/"),
-    [refs.definitionPath]: {
-      ...definitions,
-      [name]: main
-    }
-  };
-  if (refs.target === "jsonSchema7") {
-    combined.$schema = "http://json-schema.org/draft-07/schema#";
-  } else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") {
-    combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
-  }
-  if (refs.target === "openAi" && ("anyOf" in combined || "oneOf" in combined || "allOf" in combined || "type" in combined && Array.isArray(combined.type))) {
-    console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
-  }
-  return combined;
-};
-
-// src/MCPLocal.ts
-import {
-  Field,
-  Fields,
-  HandlInst,
-  MDEntryType,
-  Messages,
-  OrdType,
-  SubscriptionRequestType,
-  TimeInForce
-} from "fixparser";
 var MCPLocal = class {
-  logger;
   parser;
   server = new Server(
     {
@@ -1283,39 +11,260 @@ var MCPLocal = class {
       version: "1.0.0"
     },
     {
-      capabilities: { tools: {} }
+      capabilities: {
+        tools: {
+          parse: {
+            description: "Parses a FIX message and describes it in plain language",
+            parameters: {
+              type: "object",
+              properties: {
+                fixString: { type: "string" }
+              },
+              required: ["fixString"]
+            }
+          },
+          parseToJSON: {
+            description: "Parses a FIX message into JSON",
+            parameters: {
+              type: "object",
+              properties: {
+                fixString: { type: "string" }
+              },
+              required: ["fixString"]
+            }
+          },
+          verifyOrder: {
+            description: "Verifies order parameters before execution",
+            parameters: {
+              type: "object",
+              properties: {
+                clOrdID: { type: "string" },
+                handlInst: { type: "string", enum: ["1", "2", "3"] },
+                quantity: { type: "string" },
+                price: { type: "string" },
+                ordType: {
+                  type: "string",
+                  enum: [
+                    "1",
+                    "2",
+                    "3",
+                    "4",
+                    "5",
+                    "6",
+                    "7",
+                    "8",
+                    "9",
+                    "A",
+                    "B",
+                    "C",
+                    "D",
+                    "E",
+                    "F",
+                    "G",
+                    "H",
+                    "I",
+                    "J",
+                    "K",
+                    "L",
+                    "M",
+                    "P",
+                    "Q",
+                    "R",
+                    "S"
+                  ]
+                },
+                side: {
+                  type: "string",
+                  enum: [
+                    "1",
+                    "2",
+                    "3",
+                    "4",
+                    "5",
+                    "6",
+                    "7",
+                    "8",
+                    "9",
+                    "A",
+                    "B",
+                    "C",
+                    "D",
+                    "E",
+                    "F",
+                    "G",
+                    "H"
+                  ]
+                },
+                symbol: { type: "string" },
+                timeInForce: {
+                  type: "string",
+                  enum: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C"]
+                }
+              },
+              required: [
+                "clOrdID",
+                "handlInst",
+                "quantity",
+                "price",
+                "ordType",
+                "side",
+                "symbol",
+                "timeInForce"
+              ]
+            }
+          },
+          executeOrder: {
+            description: "Executes a verified order",
+            parameters: {
+              type: "object",
+              properties: {
+                clOrdID: { type: "string" },
+                handlInst: { type: "string", enum: ["1", "2", "3"] },
+                quantity: { type: "string" },
+                price: { type: "string" },
+                ordType: { type: "string" },
+                side: { type: "string" },
+                symbol: { type: "string" },
+                timeInForce: { type: "string" }
+              },
+              required: [
+                "clOrdID",
+                "handlInst",
+                "quantity",
+                "price",
+                "ordType",
+                "side",
+                "symbol",
+                "timeInForce"
+              ]
+            }
+          },
+          marketDataRequest: {
+            description: "Requests market data for specified symbols",
+            parameters: {
+              type: "object",
+              properties: {
+                mdUpdateType: { type: "string", enum: ["0", "1"] },
+                symbols: { type: "array", items: { type: "string" } },
+                mdReqID: { type: "string" },
+                subscriptionRequestType: { type: "string", enum: ["0", "1", "2"] },
+                mdEntryTypes: { type: "array", items: { type: "string" } }
+              },
+              required: ["mdUpdateType", "symbols", "mdReqID", "subscriptionRequestType", "mdEntryTypes"]
+            }
+          },
+          getStockGraph: {
+            description: "Generates a price chart for a given symbol",
+            parameters: {
+              type: "object",
+              properties: {
+                symbol: { type: "string" }
+              },
+              required: ["symbol"]
+            }
+          },
+          getStockPriceHistory: {
+            description: "Returns price history for a given symbol",
+            parameters: {
+              type: "object",
+              properties: {
+                symbol: { type: "string" }
+              },
+              required: ["symbol"]
+            }
+          }
+        },
+        resources: {
+          greeting: {
+            description: "A simple greeting resource",
+            uri: "greeting-resource"
+          },
+          stockGraph: {
+            description: "Generates a price chart for a given symbol",
+            uri: "stockGraph/{symbol}"
+          },
+          stockPriceHistory: {
+            description: "Returns price history for a given symbol",
+            uri: "stockPriceHistory/{symbol}"
+          }
+        }
+      }
     }
   );
   transport = new StdioServerTransport();
   onReady = void 0;
   pendingRequests = /* @__PURE__ */ new Map();
+  verifiedOrders = /* @__PURE__ */ new Map();
+  // Store market data prices with timestamps
+  marketDataPrices = /* @__PURE__ */ new Map();
+  MAX_PRICE_HISTORY = 1e5;
+  // Maximum number of price points to store per symbol
   constructor({ logger, onReady }) {
-    if (logger) this.logger = logger;
     if (onReady) this.onReady = onReady;
   }
   async register(parser) {
     this.parser = parser;
     this.parser.addOnMessageCallback((message) => {
-      this.logger?.log({
+      this.parser?.logger.log({
         level: "info",
-        message: `FIXParser (MCP): (${parser.protocol?.toUpperCase()}): << received ${message.description}`
+        message: `MCP Server received message: ${message.messageType}: ${message.description}`
       });
       const msgType = message.messageType;
-      if (msgType === Messages.MarketDataSnapshotFullRefresh || msgType === Messages.ExecutionReport) {
-        const idField = msgType === Messages.MarketDataSnapshotFullRefresh ? message.getField(Fields.MDReqID) : message.getField(Fields.ClOrdID);
-        if (idField) {
-          const id = idField.value;
-          if (typeof id === "string" || typeof id === "number") {
-            const callback = this.pendingRequests.get(String(id));
-            if (callback) {
-              callback(message);
-              this.pendingRequests.delete(String(id));
+      if (msgType === Messages.MarketDataSnapshotFullRefresh || msgType === Messages.ExecutionReport || msgType === Messages.Reject || msgType === Messages.MarketDataIncrementalRefresh) {
+        this.parser?.logger.log({
+          level: "info",
+          message: `MCP Server handling message type: ${msgType}`
+        });
+        let id;
+        if (msgType === Messages.MarketDataIncrementalRefresh || msgType === Messages.MarketDataSnapshotFullRefresh) {
+          const symbol = message.getField(Fields.Symbol);
+          const price = message.getField(Fields.MDEntryPx);
+          const timestamp = message.getField(Fields.MDEntryTime)?.value || Date.now();
+          if (symbol?.value && price?.value) {
+            const symbolStr = String(symbol.value);
+            const priceNum = Number(price.value);
+            const priceHistory = this.marketDataPrices.get(symbolStr) || [];
+            priceHistory.push({
+              timestamp: Number(timestamp),
+              price: priceNum
+            });
+            if (priceHistory.length > this.MAX_PRICE_HISTORY) {
+              priceHistory.shift();
             }
+            this.marketDataPrices.set(symbolStr, priceHistory);
+            this.parser?.logger.log({
+              level: "info",
+              message: `MCP Server added ${symbol}: ${priceNum}`
+            });
+            this.server.notification({
+              method: "priceUpdate",
+              params: {
+                symbol: symbolStr,
+                price: priceNum,
+                timestamp: Number(timestamp)
+              }
+            });
+          }
+        }
+        if (msgType === Messages.MarketDataSnapshotFullRefresh) {
+          const mdReqID = message.getField(Fields.MDReqID);
+          if (mdReqID) id = String(mdReqID.value);
+        } else if (msgType === Messages.ExecutionReport) {
+          const clOrdID = message.getField(Fields.ClOrdID);
+          if (clOrdID) id = String(clOrdID.value);
+        } else if (msgType === Messages.Reject) {
+          const refSeqNum = message.getField(Fields.RefSeqNum);
+          if (refSeqNum) id = String(refSeqNum.value);
+        }
+        if (id) {
+          const callback = this.pendingRequests.get(id);
+          if (callback) {
+            callback(message);
+            this.pendingRequests.delete(id);
           }
         }
       }
     });
-    this.logger = parser.logger;
     this.addWorkflows();
     await this.server.connect(this.transport);
     if (this.onReady) {
@@ -1324,443 +273,716 @@ var MCPLocal = class {
   }
   addWorkflows() {
     if (!this.parser) {
-      this.logger?.log({
-        level: "error",
-        message: "FIXParser (MCP): -- FIXParser instance not initialized. Ignoring setup of workflows..."
-      });
       return;
     }
     if (!this.server) {
-      this.logger?.log({
-        level: "error",
-        message: "FIXParser (MCP): -- MCP Server not initialized. Ignoring setup of workflows..."
-      });
       return;
     }
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "parse",
-            description: "Parses a FIX message and describes it in plain language",
-            inputSchema: zodToJsonSchema(
-              z.object({
-                fixString: z.string().describe("FIX message string to parse")
-              }),
-              { name: "ParseInput" }
-            )
-          },
-          {
-            name: "parseToJSON",
-            description: "Parses a FIX message into JSON",
-            inputSchema: zodToJsonSchema(
-              z.object({
-                fixString: z.string().describe("FIX message string to parse")
-              }),
-              { name: "ParseToJSONInput" }
-            )
-          },
-          {
-            name: "newOrderSingle",
-            description: "Creates and sends a New Order Single",
-            inputSchema: zodToJsonSchema(
-              z.object({
-                clOrdID: z.string().describe("Client Order ID"),
-                handlInst: z.enum(["1", "2", "3"]).default(HandlInst.AutomatedExecutionNoIntervention).optional().describe("Handling instruction"),
-                quantity: z.number().describe("Order quantity"),
-                price: z.number().describe("Order price"),
-                ordType: z.enum([
-                  "1",
-                  "2",
-                  "3",
-                  "4",
-                  "5",
-                  "6",
-                  "7",
-                  "8",
-                  "9",
-                  "A",
-                  "B",
-                  "C",
-                  "D",
-                  "E",
-                  "F",
-                  "G",
-                  "H",
-                  "I",
-                  "J",
-                  "K",
-                  "L",
-                  "M",
-                  "P",
-                  "Q",
-                  "R",
-                  "S"
-                ]).default("1").optional().describe("Order type"),
-                side: z.enum([
-                  "1",
-                  "2",
-                  "3",
-                  "4",
-                  "5",
-                  "6",
-                  "7",
-                  "8",
-                  "9",
-                  "A",
-                  "B",
-                  "C",
-                  "D",
-                  "E",
-                  "F",
-                  "G",
-                  "H"
-                ]).describe("Order side (1=Buy, 2=Sell)"),
-                symbol: z.string().describe("Trading symbol"),
-                timeInForce: z.enum(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C"]).default(TimeInForce.Day).optional().describe("Time in force")
-              }),
-              { name: "NewOrderSingleInput" }
-            )
-          },
-          {
-            name: "marketDataRequest",
-            description: "Sends a request for Market Data with the given symbol",
-            inputSchema: zodToJsonSchema(
-              z.object({
-                mdUpdateType: z.enum(["0", "1"]).default("0").optional().describe("Market data update type"),
-                symbol: z.string().describe("Trading symbol"),
-                mdReqID: z.string().describe("Market data request ID"),
-                subscriptionRequestType: z.enum(["0", "1", "2"]).default(SubscriptionRequestType.SnapshotAndUpdates).optional().describe("Subscription request type"),
-                mdEntryType: z.enum([
-                  "0",
-                  "1",
-                  "2",
-                  "3",
-                  "4",
-                  "5",
-                  "6",
-                  "7",
-                  "8",
-                  "9",
-                  "A",
-                  "B",
-                  "C",
-                  "D",
-                  "E",
-                  "F",
-                  "G",
-                  "H",
-                  "J",
-                  "K",
-                  "L",
-                  "M",
-                  "N",
-                  "O",
-                  "P",
-                  "Q",
-                  "S",
-                  "R",
-                  "T",
-                  "U",
-                  "V",
-                  "W",
-                  "X",
-                  "Y",
-                  "Z",
-                  "a",
-                  "b",
-                  "c",
-                  "d",
-                  "e",
-                  "g",
-                  "h",
-                  "i",
-                  "t"
-                ]).default(MDEntryType.Bid).optional().describe("Market data entry type")
-              }),
-              { name: "MarketDataRequestInput" }
-            )
-          }
-        ]
-      };
-    });
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-      switch (name) {
-        case "parse": {
-          const { fixString } = z.object({
-            fixString: z.string().describe("FIX message string to parse")
-          }).parse(args || {});
-          try {
-            const parsedMessage = this.parser?.parse(fixString);
-            if (!parsedMessage || parsedMessage.length === 0) {
+    this.server.setRequestHandler(
+      z.object({ method: z.literal("resources/list") }),
+      async (request, extra) => {
+        return {
+          resources: [
+            {
+              name: "greeting",
+              description: "A simple greeting resource",
+              uri: "greeting-resource"
+            }
+          ]
+        };
+      }
+    );
+    this.server.setRequestHandler(
+      z.object({ method: z.literal("resources/templates/list") }),
+      async (request, extra) => {
+        return {
+          resourceTemplates: [
+            {
+              name: "stockGraph",
+              description: "Generates a price chart for a given symbol",
+              uriTemplate: "stockGraph/{symbol}",
+              parameters: {
+                type: "object",
+                properties: {
+                  symbol: { type: "string" }
+                },
+                required: ["symbol"]
+              }
+            },
+            {
+              name: "stockPriceHistory",
+              description: "Returns price history for a given symbol",
+              uriTemplate: "stockPriceHistory/{symbol}",
+              parameters: {
+                type: "object",
+                properties: {
+                  symbol: { type: "string" }
+                },
+                required: ["symbol"]
+              }
+            }
+          ]
+        };
+      }
+    );
+    this.server.setRequestHandler(
+      z.object({ method: z.literal("tools/list") }),
+      async (request, extra) => {
+        return {
+          tools: [
+            {
+              name: "parse",
+              description: "Parses a FIX message and describes it in plain language",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  fixString: { type: "string" }
+                },
+                required: ["fixString"]
+              }
+            },
+            {
+              name: "parseToJSON",
+              description: "Parses a FIX message into JSON",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  fixString: { type: "string" }
+                },
+                required: ["fixString"]
+              }
+            },
+            {
+              name: "verifyOrder",
+              description: "Verifies order parameters before execution",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  clOrdID: { type: "string" },
+                  handlInst: { type: "string", enum: ["1", "2", "3"] },
+                  quantity: { type: "string" },
+                  price: { type: "string" },
+                  ordType: {
+                    type: "string",
+                    enum: [
+                      "1",
+                      "2",
+                      "3",
+                      "4",
+                      "5",
+                      "6",
+                      "7",
+                      "8",
+                      "9",
+                      "A",
+                      "B",
+                      "C",
+                      "D",
+                      "E",
+                      "F",
+                      "G",
+                      "H",
+                      "I",
+                      "J",
+                      "K",
+                      "L",
+                      "M",
+                      "P",
+                      "Q",
+                      "R",
+                      "S"
+                    ]
+                  },
+                  side: {
+                    type: "string",
+                    enum: [
+                      "1",
+                      "2",
+                      "3",
+                      "4",
+                      "5",
+                      "6",
+                      "7",
+                      "8",
+                      "9",
+                      "A",
+                      "B",
+                      "C",
+                      "D",
+                      "E",
+                      "F",
+                      "G",
+                      "H"
+                    ]
+                  },
+                  symbol: { type: "string" },
+                  timeInForce: {
+                    type: "string",
+                    enum: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C"]
+                  }
+                },
+                required: [
+                  "clOrdID",
+                  "handlInst",
+                  "quantity",
+                  "price",
+                  "ordType",
+                  "side",
+                  "symbol",
+                  "timeInForce"
+                ]
+              }
+            },
+            {
+              name: "executeOrder",
+              description: "Executes a verified order",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  clOrdID: { type: "string" },
+                  handlInst: { type: "string", enum: ["1", "2", "3"] },
+                  quantity: { type: "string" },
+                  price: { type: "string" },
+                  ordType: { type: "string" },
+                  side: { type: "string" },
+                  symbol: { type: "string" },
+                  timeInForce: { type: "string" }
+                },
+                required: [
+                  "clOrdID",
+                  "handlInst",
+                  "quantity",
+                  "price",
+                  "ordType",
+                  "side",
+                  "symbol",
+                  "timeInForce"
+                ]
+              }
+            },
+            {
+              name: "marketDataRequest",
+              description: "Requests market data for specified symbols",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  mdUpdateType: { type: "string", enum: ["0", "1"] },
+                  symbols: { type: "array", items: { type: "string" } },
+                  mdReqID: { type: "string" },
+                  subscriptionRequestType: { type: "string", enum: ["0", "1", "2"] },
+                  mdEntryTypes: { type: "array", items: { type: "string" } }
+                },
+                required: [
+                  "mdUpdateType",
+                  "symbols",
+                  "mdReqID",
+                  "subscriptionRequestType",
+                  "mdEntryTypes"
+                ]
+              }
+            }
+          ]
+        };
+      }
+    );
+    this.server.setRequestHandler(
+      z.object({
+        method: z.literal("tools/call"),
+        params: z.object({
+          name: z.string(),
+          arguments: z.any(),
+          _meta: z.object({
+            progressToken: z.number()
+          }).optional()
+        })
+      }),
+      async (request, extra) => {
+        const { name, arguments: args } = request.params;
+        switch (name) {
+          case "parse":
+            try {
+              const parsedMessage = this.parser?.parse(args.fixString);
+              if (!parsedMessage || parsedMessage.length === 0) {
+                return {
+                  contents: [
+                    {
+                      type: "text",
+                      text: "Error: Failed to parse FIX string",
+                      uri: "parse"
+                    }
+                  ],
+                  isError: true
+                };
+              }
               return {
-                isError: true,
-                content: [{ type: "text", text: "Error: Failed to parse FIX string" }]
+                contents: [
+                  {
+                    type: "text",
+                    text: `${parsedMessage[0].description}
+${parsedMessage[0].messageTypeDescription}`,
+                    uri: "parse"
+                  }
+                ]
+              };
+            } catch (error) {
+              return {
+                contents: [
+                  {
+                    type: "text",
+                    text: `Error: ${error instanceof Error ? error.message : "Failed to parse FIX string"}`,
+                    uri: "parse"
+                  }
+                ],
+                isError: true
               };
             }
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Parsed FIX message: ${fixString} (placeholder implementation)`
-                }
-              ]
-            };
-          } catch (error) {
-            return {
-              isError: true,
-              content: [
-                {
-                  type: "text",
-                  text: "Error: Failed to parse FIX string"
-                }
-              ]
-            };
-          }
-        }
-        case "parseToJSON": {
-          const { fixString } = z.object({
-            fixString: z.string().describe("FIX message string to parse")
-          }).parse(args || {});
-          try {
-            const parsedMessage = this.parser?.parse(fixString);
-            if (!parsedMessage || parsedMessage.length === 0) {
+          case "parseToJSON":
+            try {
+              const parsedMessage = this.parser?.parse(args.fixString);
+              if (!parsedMessage || parsedMessage.length === 0) {
+                return {
+                  contents: [
+                    {
+                      type: "text",
+                      text: "Error: Failed to parse FIX string",
+                      uri: "parseToJSON"
+                    }
+                  ],
+                  isError: true
+                };
+              }
+              return {
+                contents: [
+                  {
+                    type: "text",
+                    text: `${parsedMessage[0].toFIXJSON()}`,
+                    uri: "parseToJSON"
+                  }
+                ]
+              };
+            } catch (error) {
               return {
-                isError: true,
-                content: [{ type: "text", text: "Error: Failed to parse FIX string" }]
+                contents: [
+                  {
+                    type: "text",
+                    text: `Error: ${error instanceof Error ? error.message : "Failed to parse FIX string"}`,
+                    uri: "parseToJSON"
+                  }
+                ],
+                isError: true
               };
             }
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify({ fixString, parsed: "placeholder" })
-                }
-              ]
-            };
-          } catch (error) {
-            return {
-              isError: true,
-              content: [
-                {
-                  type: "text",
-                  text: "Error: Failed to parse FIX string"
-                }
-              ]
-            };
-          }
-        }
-        case "newOrderSingle": {
-          const { clOrdID, handlInst, quantity, price, ordType, side, symbol, timeInForce } = z.object({
-            clOrdID: z.string().describe("Client Order ID"),
-            handlInst: z.enum(["1", "2", "3"]).default(HandlInst.AutomatedExecutionNoIntervention).optional().describe("Handling instruction"),
-            quantity: z.number().describe("Order quantity"),
-            price: z.number().describe("Order price"),
-            ordType: z.enum([
-              "1",
-              "2",
-              "3",
-              "4",
-              "5",
-              "6",
-              "7",
-              "8",
-              "9",
-              "A",
-              "B",
-              "C",
-              "D",
-              "E",
-              "F",
-              "G",
-              "H",
-              "I",
-              "J",
-              "K",
-              "L",
-              "M",
-              "P",
-              "Q",
-              "R",
-              "S"
-            ]).default(OrdType.Market).optional().describe("Order type"),
-            side: z.enum([
-              "1",
-              "2",
-              "3",
-              "4",
-              "5",
-              "6",
-              "7",
-              "8",
-              "9",
-              "A",
-              "B",
-              "C",
-              "D",
-              "E",
-              "F",
-              "G",
-              "H"
-            ]).describe("Order side (1=Buy, 2=Sell)"),
-            symbol: z.string().describe("Trading symbol"),
-            timeInForce: z.enum(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C"]).default(TimeInForce.Day).optional().describe("Time in force")
-          }).parse(args || {});
-          const response = new Promise((resolve) => {
-            this.pendingRequests.set(clOrdID, resolve);
-          });
-          const order = this.parser?.createMessage(
-            new Field(Fields.MsgType, Messages.NewOrderSingle),
-            new Field(Fields.MsgSeqNum, this.parser?.getNextTargetMsgSeqNum()),
-            new Field(Fields.SenderCompID, this.parser?.sender),
-            new Field(Fields.TargetCompID, this.parser?.target),
-            new Field(Fields.SendingTime, this.parser?.getTimestamp()),
-            new Field(Fields.ClOrdID, clOrdID),
-            new Field(Fields.Side, side),
-            new Field(Fields.Symbol, symbol),
-            new Field(Fields.OrderQty, quantity),
-            new Field(Fields.Price, price),
-            new Field(Fields.OrdType, ordType),
-            new Field(Fields.HandlInst, handlInst),
-            new Field(Fields.TimeInForce, timeInForce),
-            new Field(Fields.TransactTime, this.parser?.getTimestamp())
-          );
-          if (!this.parser?.connected) {
-            this.logger?.log({
-              level: "error",
-              message: "FIXParser (MCP): -- Not connected. Ignoring message."
-            });
-            return {
-              isError: true,
-              content: [
-                {
-                  type: "text",
-                  text: "Error: Not connected. Ignoring message."
-                }
-              ]
-            };
-          }
-          this.parser?.send(order);
-          this.logger?.log({
-            level: "info",
-            message: `FIXParser (MCP): (${this.parser?.protocol?.toUpperCase()}): >> sent ${order?.description}`
-          });
-          const fixData = await response;
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Execution Report for order ${clOrdID}: ${JSON.stringify(fixData.toFIXJSON())}`
+          case "verifyOrder":
+            try {
+              this.verifiedOrders.set(args.clOrdID, {
+                clOrdID: args.clOrdID,
+                handlInst: args.handlInst,
+                quantity: Number.parseFloat(args.quantity),
+                price: Number.parseFloat(args.price),
+                ordType: args.ordType,
+                side: args.side,
+                symbol: args.symbol,
+                timeInForce: args.timeInForce
+              });
+              const ordTypeNames = {
+                "1": "Market",
+                "2": "Limit",
+                "3": "Stop",
+                "4": "StopLimit",
+                "5": "MarketOnClose",
+                "6": "WithOrWithout",
+                "7": "LimitOrBetter",
+                "8": "LimitWithOrWithout",
+                "9": "OnBasis",
+                A: "OnClose",
+                B: "LimitOnClose",
+                C: "ForexMarket",
+                D: "PreviouslyQuoted",
+                E: "PreviouslyIndicated",
+                F: "ForexLimit",
+                G: "ForexSwap",
+                H: "ForexPreviouslyQuoted",
+                I: "Funari",
+                J: "MarketIfTouched",
+                K: "MarketWithLeftOverAsLimit",
+                L: "PreviousFundValuationPoint",
+                M: "NextFundValuationPoint",
+                P: "Pegged",
+                Q: "CounterOrderSelection",
+                R: "StopOnBidOrOffer",
+                S: "StopLimitOnBidOrOffer"
+              };
+              const sideNames = {
+                "1": "Buy",
+                "2": "Sell",
+                "3": "BuyMinus",
+                "4": "SellPlus",
+                "5": "SellShort",
+                "6": "SellShortExempt",
+                "7": "Undisclosed",
+                "8": "Cross",
+                "9": "CrossShort",
+                A: "CrossShortExempt",
+                B: "AsDefined",
+                C: "Opposite",
+                D: "Subscribe",
+                E: "Redeem",
+                F: "Lend",
+                G: "Borrow",
+                H: "SellUndisclosed"
+              };
+              const timeInForceNames = {
+                "0": "Day",
+                "1": "GoodTillCancel",
+                "2": "AtTheOpening",
+                "3": "ImmediateOrCancel",
+                "4": "FillOrKill",
+                "5": "GoodTillCrossing",
+                "6": "GoodTillDate",
+                "7": "AtTheClose",
+                "8": "GoodThroughCrossing",
+                "9": "AtCrossing",
+                A: "GoodForTime",
+                B: "GoodForAuction",
+                C: "GoodForMonth"
+              };
+              const handlInstNames = {
+                "1": "AutomatedExecutionNoIntervention",
+                "2": "AutomatedExecutionInterventionOK",
+                "3": "ManualOrder"
+              };
+              return {
+                contents: [
+                  {
+                    type: "text",
+                    text: `VERIFICATION: All parameters valid. Ready to proceed with order execution.
+                                            
+Parameters verified:
+- ClOrdID: ${args.clOrdID}
+- HandlInst: ${args.handlInst} (${handlInstNames[args.handlInst]})
+- Quantity: ${args.quantity}
+- Price: ${args.price}
+- OrdType: ${args.ordType} (${ordTypeNames[args.ordType]})
+- Side: ${args.side} (${sideNames[args.side]})
+- Symbol: ${args.symbol}
+- TimeInForce: ${args.timeInForce} (${timeInForceNames[args.timeInForce]})
+
+To execute this order, call the executeOrder tool with these exact same parameters.`,
+                    uri: "verifyOrder"
+                  }
+                ]
+              };
+            } catch (error) {
+              return {
+                contents: [
+                  {
+                    type: "text",
+                    text: `Error: ${error instanceof Error ? error.message : "Failed to verify order parameters"}`,
+                    uri: "verifyOrder"
+                  }
+                ],
+                isError: true
+              };
+            }
+          case "executeOrder":
+            try {
+              const verifiedOrder = this.verifiedOrders.get(args.clOrdID);
+              if (!verifiedOrder) {
+                return {
+                  contents: [
+                    {
+                      type: "text",
+                      text: `Error: Order ${args.clOrdID} has not been verified. Please call verifyOrder first.`,
+                      uri: "executeOrder"
+                    }
+                  ],
+                  isError: true
+                };
               }
-            ]
-          };
-        }
-        case "marketDataRequest": {
-          const { mdUpdateType, symbol, mdReqID, subscriptionRequestType, mdEntryType } = z.object({
-            mdUpdateType: z.enum(["0", "1"]).default("0").optional().describe("Market data update type"),
-            symbol: z.string().describe("Trading symbol"),
-            mdReqID: z.string().describe("Market data request ID"),
-            subscriptionRequestType: z.enum(["0", "1", "2"]).default(SubscriptionRequestType.SnapshotAndUpdates).optional().describe("Subscription request type"),
-            mdEntryType: z.enum([
-              "0",
-              "1",
-              "2",
-              "3",
-              "4",
-              "5",
-              "6",
-              "7",
-              "8",
-              "9",
-              "A",
-              "B",
-              "C",
-              "D",
-              "E",
-              "F",
-              "G",
-              "H",
-              "J",
-              "K",
-              "L",
-              "M",
-              "N",
-              "O",
-              "P",
-              "Q",
-              "S",
-              "R",
-              "T",
-              "U",
-              "V",
-              "W",
-              "X",
-              "Y",
-              "Z",
-              "a",
-              "b",
-              "c",
-              "d",
-              "e",
-              "g",
-              "h",
-              "i",
-              "t"
-            ]).default(MDEntryType.Bid).optional().describe("Market data entry type")
-          }).parse(args || {});
-          const response = new Promise((resolve) => {
-            this.pendingRequests.set(mdReqID, resolve);
-          });
-          const marketDataRequest = this.parser?.createMessage(
-            new Field(Fields.MsgType, Messages.MarketDataRequest),
-            new Field(Fields.SenderCompID, this.parser?.sender),
-            new Field(Fields.MsgSeqNum, this.parser?.getNextTargetMsgSeqNum()),
-            new Field(Fields.TargetCompID, this.parser?.target),
-            new Field(Fields.SendingTime, this.parser?.getTimestamp()),
-            new Field(Fields.MarketDepth, 0),
-            new Field(Fields.MDUpdateType, mdUpdateType),
-            new Field(Fields.NoRelatedSym, 1),
-            new Field(Fields.Symbol, symbol),
-            new Field(Fields.MDReqID, mdReqID),
-            new Field(Fields.SubscriptionRequestType, subscriptionRequestType),
-            new Field(Fields.NoMDEntryTypes, 1),
-            new Field(Fields.MDEntryType, mdEntryType)
-          );
-          if (!this.parser?.connected) {
-            this.logger?.log({
-              level: "error",
-              message: "FIXParser (MCP): -- Not connected. Ignoring message."
-            });
+              if (verifiedOrder.handlInst !== args.handlInst || verifiedOrder.quantity !== Number.parseFloat(args.quantity) || verifiedOrder.price !== Number.parseFloat(args.price) || verifiedOrder.ordType !== args.ordType || verifiedOrder.side !== args.side || verifiedOrder.symbol !== args.symbol || verifiedOrder.timeInForce !== args.timeInForce) {
+                return {
+                  contents: [
+                    {
+                      type: "text",
+                      text: "Error: Order parameters do not match the verified order. Please use the exact same parameters that were verified.",
+                      uri: "executeOrder"
+                    }
+                  ],
+                  isError: true
+                };
+              }
+              const response = new Promise((resolve) => {
+                this.pendingRequests.set(args.clOrdID, resolve);
+              });
+              const order = this.parser?.createMessage(
+                new Field(Fields.MsgType, Messages.NewOrderSingle),
+                new Field(Fields.MsgSeqNum, this.parser?.getNextTargetMsgSeqNum()),
+                new Field(Fields.SenderCompID, this.parser?.sender),
+                new Field(Fields.TargetCompID, this.parser?.target),
+                new Field(Fields.SendingTime, this.parser?.getTimestamp()),
+                new Field(Fields.ClOrdID, args.clOrdID),
+                new Field(Fields.Side, args.side),
+                new Field(Fields.Symbol, args.symbol),
+                new Field(Fields.OrderQty, Number.parseFloat(args.quantity)),
+                new Field(Fields.Price, Number.parseFloat(args.price)),
+                new Field(Fields.OrdType, args.ordType),
+                new Field(Fields.HandlInst, args.handlInst),
+                new Field(Fields.TimeInForce, args.timeInForce),
+                new Field(Fields.TransactTime, this.parser?.getTimestamp())
+              );
+              if (!this.parser?.connected) {
+                return {
+                  contents: [
+                    {
+                      type: "text",
+                      text: "Error: Not connected. Ignoring message.",
+                      uri: "executeOrder"
+                    }
+                  ],
+                  isError: true
+                };
+              }
+              this.parser?.send(order);
+              const fixData = await response;
+              this.verifiedOrders.delete(args.clOrdID);
+              return {
+                contents: [
+                  {
+                    type: "text",
+                    text: fixData.messageType === Messages.Reject ? `Reject message for order ${args.clOrdID}: ${JSON.stringify(fixData.toFIXJSON())}` : `Execution Report for order ${args.clOrdID}: ${JSON.stringify(fixData.toFIXJSON())}`,
+                    uri: "executeOrder"
+                  }
+                ]
+              };
+            } catch (error) {
+              return {
+                contents: [
+                  {
+                    type: "text",
+                    text: `Error: ${error instanceof Error ? error.message : "Failed to execute order"}`,
+                    uri: "executeOrder"
+                  }
+                ],
+                isError: true
+              };
+            }
+          case "marketDataRequest":
+            try {
+              const response = new Promise((resolve) => {
+                this.pendingRequests.set(args.mdReqID, resolve);
+              });
+              const messageFields = [
+                new Field(Fields.MsgType, Messages.MarketDataRequest),
+                new Field(Fields.SenderCompID, this.parser?.sender),
+                new Field(Fields.MsgSeqNum, this.parser?.getNextTargetMsgSeqNum()),
+                new Field(Fields.TargetCompID, this.parser?.target),
+                new Field(Fields.SendingTime, this.parser?.getTimestamp()),
+                new Field(Fields.MDReqID, args.mdReqID),
+                new Field(Fields.SubscriptionRequestType, args.subscriptionRequestType),
+                new Field(Fields.MarketDepth, 0),
+                new Field(Fields.MDUpdateType, args.mdUpdateType)
+              ];
+              messageFields.push(new Field(Fields.NoRelatedSym, args.symbols.length));
+              args.symbols.forEach((symbol) => {
+                messageFields.push(new Field(Fields.Symbol, symbol));
+              });
+              messageFields.push(new Field(Fields.NoMDEntryTypes, args.mdEntryTypes.length));
+              args.mdEntryTypes.forEach((entryType) => {
+                messageFields.push(new Field(Fields.MDEntryType, entryType));
+              });
+              const mdr = this.parser?.createMessage(...messageFields);
+              if (!this.parser?.connected) {
+                return {
+                  contents: [
+                    {
+                      type: "text",
+                      text: "Error: Not connected. Ignoring message.",
+                      uri: "marketDataRequest"
+                    }
+                  ],
+                  isError: true
+                };
+              }
+              this.parser?.send(mdr);
+              const fixData = await response;
+              return {
+                contents: [
+                  {
+                    type: "text",
+                    text: `Market data for ${args.symbols.join(", ")}: ${JSON.stringify(fixData.toFIXJSON())}`,
+                    uri: "marketDataRequest"
+                  }
+                ]
+              };
+            } catch (error) {
+              return {
+                contents: [
+                  {
+                    type: "text",
+                    text: `Error: ${error instanceof Error ? error.message : "Failed to request market data"}`,
+                    uri: "marketDataRequest"
+                  }
+                ],
+                isError: true
+              };
+            }
+          case "getStockGraph":
+            try {
+              const symbol = args.symbol;
+              const priceHistory = this.marketDataPrices.get(symbol) || [];
+              if (priceHistory.length === 0) {
+                return {
+                  contents: [
+                    {
+                      type: "text",
+                      text: `No price data available for ${symbol}`,
+                      uri: "getStockGraph"
+                    }
+                  ]
+                };
+              }
+              const width = 600;
+              const height = 300;
+              const padding = 40;
+              const xScale = (width - 2 * padding) / (priceHistory.length - 1);
+              const yMin = Math.min(...priceHistory.map((d) => d.price));
+              const yMax = Math.max(...priceHistory.map((d) => d.price));
+              const yScale = (height - 2 * padding) / (yMax - yMin);
+              const points = priceHistory.map((d, i) => {
+                const x = padding + i * xScale;
+                const y = height - padding - (d.price - yMin) * yScale;
+                return `${x},${y}`;
+              }).join(" L ");
+              const svg = `<?xml version="1.0" encoding="UTF-8"?>
+<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">
+    <!-- Background -->
+    <rect width="100%" height="100%" fill="#f8f9fa"/>
+    
+    <!-- Grid lines -->
+    <g stroke="#e9ecef" stroke-width="1">
+        ${Array.from({ length: 5 }, (_, i) => {
+                const y = padding + (height - 2 * padding) * i / 4;
+                return `<line x1="${padding}" y1="${y}" x2="${width - padding}" y2="${y}"/>`;
+              }).join("\n")}
+    </g>
+    
+    <!-- Price line -->
+    <path d="M ${points}" 
+          fill="none" 
+          stroke="#007bff" 
+          stroke-width="2"/>
+    
+    <!-- Data points -->
+    ${priceHistory.map((d, i) => {
+                const x = padding + i * xScale;
+                const y = height - padding - (d.price - yMin) * yScale;
+                return `<circle cx="${x}" cy="${y}" r="3" fill="#007bff"/>`;
+              }).join("\n")}
+    
+    <!-- Labels -->
+    <g font-family="Arial" font-size="12" fill="#495057">
+        ${Array.from({ length: 5 }, (_, i) => {
+                const x = padding + (width - 2 * padding) * i / 4;
+                const index = Math.floor((priceHistory.length - 1) * i / 4);
+                const timestamp = new Date(priceHistory[index].timestamp).toLocaleTimeString();
+                return `<text x="${x + padding}" y="${height - padding + 20}" text-anchor="middle">${timestamp}</text>`;
+              }).join("\n")}
+        ${Array.from({ length: 5 }, (_, i) => {
+                const y = padding + (height - 2 * padding) * i / 4;
+                const price = yMax - (yMax - yMin) * i / 4;
+                return `<text x="${padding - 5}" y="${y + 4}" text-anchor="end">$${price.toFixed(2)}</text>`;
+              }).join("\n")}
+    </g>
+    
+    <!-- Title -->
+    <text x="${width / 2}" y="${padding / 2}" 
+          font-family="Arial" font-size="16" font-weight="bold" 
+          text-anchor="middle" fill="#212529">
+        ${symbol} - Price Chart (${priceHistory.length} points)
+    </text>
+</svg>`;
+              return {
+                contents: [
+                  {
+                    type: "text",
+                    text: svg,
+                    uri: "getStockGraph"
+                  }
+                ]
+              };
+            } catch (error) {
+              return {
+                contents: [
+                  {
+                    type: "text",
+                    text: `Error: ${error instanceof Error ? error.message : "Failed to generate stock graph"}`,
+                    uri: "getStockGraph"
+                  }
+                ],
+                isError: true
+              };
+            }
+          case "getStockPriceHistory":
+            try {
+              const symbol = args.symbol;
+              const priceHistory = this.marketDataPrices.get(symbol) || [];
+              if (priceHistory.length === 0) {
+                return {
+                  contents: [
+                    {
+                      type: "text",
+                      text: `No price data available for ${symbol}`,
+                      uri: "getStockPriceHistory"
+                    }
+                  ]
+                };
+              }
+              return {
+                contents: [
+                  {
+                    type: "text",
+                    text: JSON.stringify(
+                      {
+                        symbol,
+                        count: priceHistory.length,
+                        prices: priceHistory.map((point) => ({
+                          timestamp: new Date(point.timestamp).toISOString(),
+                          price: point.price
+                        }))
+                      },
+                      null,
+                      2
+                    ),
+                    uri: "getStockPriceHistory"
+                  }
+                ]
+              };
+            } catch (error) {
+              return {
+                contents: [
+                  {
+                    type: "text",
+                    text: `Error: ${error instanceof Error ? error.message : "Failed to get stock price history"}`,
+                    uri: "getStockPriceHistory"
+                  }
+                ],
+                isError: true
+              };
+            }
+          default:
             return {
-              isError: true,
-              content: [
+              contents: [
                 {
                   type: "text",
-                  text: "Error: Not connected. Ignoring message."
+                  text: `Tool not found: ${name}`,
+                  uri: name
                 }
-              ]
+              ],
+              isError: true
             };
-          }
-          this.parser?.send(marketDataRequest);
-          this.logger?.log({
-            level: "info",
-            message: `FIXParser (MCP): (${this.parser?.protocol?.toUpperCase()}): >> sent ${marketDataRequest?.description}`
-          });
-          const fixData = await response;
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Market data for ${symbol}: ${JSON.stringify(fixData.toFIXJSON())}`
-              }
-            ]
-          };
         }
-        default:
-          throw new Error(`Unknown tool: ${name}`);
       }
-    });
+    );
     process.on("SIGINT", async () => {
       await this.server.close();
       process.exit(0);