fixparser-plugin-mcp 9.1.7-dde631c6 → 9.1.7-def37df3

package/build/cjs/MCPLocal.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/MCPLocal.ts
@@ -25,1270 +35,2265 @@ __export(MCPLocal_exports, {
 module.exports = __toCommonJS(MCPLocal_exports);
 var import_server = require("@modelcontextprotocol/sdk/server/index.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
-var import_types = require("@modelcontextprotocol/sdk/types.js");
-var import_zod5 = require("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
-var import_zod4 = require("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
 var import_zod = require("zod");
-function parseArrayDef(def, refs) {
-  const res = {
-    type: "array"
-  };
-  if (def.type?._def && def.type?._def?.typeName !== import_zod.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
-var import_zod2 = require("zod");
 
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/string.js
-var emojiRegex = void 0;
-var zodPatterns = {
+// src/MCPBase.ts
+var MCPBase = class {
   /**
-   * `c` was changed to `[cC]` to replicate /i flag
+   * Optional logger instance for diagnostics and output.
+   * @protected
    */
-  cuid: /^[cC][^\s-]{8,}$/,
-  cuid2: /^[0-9a-z]+$/,
-  ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+  logger;
   /**
-   * `a-z` was added to replicate /i flag
+   * FIXParser instance, set during plugin register().
+   * @protected
    */
-  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+  parser;
   /**
-   * 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
+   * Called when server is setup and listening.
+   * @protected
    */
-  emoji: () => {
-    if (emojiRegex === void 0) {
-      emojiRegex = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
-    }
-    return emojiRegex;
-  },
+  onReady = void 0;
   /**
-   * Unused
+   * Map to store verified orders before execution
+   * @protected
    */
-  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}$/,
+  verifiedOrders = /* @__PURE__ */ new Map();
   /**
-   * Unused
+   * Map to store pending market data requests
+   * @protected
    */
-  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])$/,
+  pendingRequests = /* @__PURE__ */ new Map();
   /**
-   * Unused
+   * Map to store market data prices
+   * @protected
    */
-  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-_]*$/
+  marketDataPrices = /* @__PURE__ */ new Map();
+  /**
+   * Maximum number of price history entries to keep per symbol
+   * @protected
+   */
+  MAX_PRICE_HISTORY = 1e5;
+  constructor({ logger, onReady }) {
+    this.logger = logger;
+    this.onReady = onReady;
+  }
 };
-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;
+
+// src/schemas/schemas.ts
+var toolSchemas = {
+  parse: {
+    description: "Parses a FIX message and describes it in plain language",
+    schema: {
+      type: "object",
+      properties: {
+        fixString: { type: "string" }
+      },
+      required: ["fixString"]
+    }
+  },
+  parseToJSON: {
+    description: "Parses a FIX message into JSON",
+    schema: {
+      type: "object",
+      properties: {
+        fixString: { type: "string" }
+      },
+      required: ["fixString"]
+    }
+  },
+  verifyOrder: {
+    description: "Verifies order parameters before execution. verifyOrder must be called before executeOrder.",
+    schema: {
+      type: "object",
+      properties: {
+        clOrdID: { type: "string" },
+        handlInst: {
+          type: "string",
+          enum: ["1", "2", "3"],
+          description: "Handling Instructions: 1=Automated Execution No Intervention, 2=Automated Execution Intervention OK, 3=Manual Order"
+        },
+        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"
+          ],
+          description: "Order Type: 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"
+        },
+        side: {
+          type: "string",
+          enum: ["1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H"],
+          description: "Side: 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"
+        },
+        symbol: { type: "string" },
+        timeInForce: {
+          type: "string",
+          enum: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C"],
+          description: "Time In Force: 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"
         }
-        case "emoji":
-          addPattern(res, zodPatterns.emoji(), check.message, refs);
-          break;
-        case "ulid": {
-          addPattern(res, zodPatterns.ulid, check.message, refs);
-          break;
+      },
+      required: ["clOrdID", "handlInst", "quantity", "price", "ordType", "side", "symbol", "timeInForce"]
+    }
+  },
+  executeOrder: {
+    description: "Executes a verified order. verifyOrder must be called before executeOrder.",
+    schema: {
+      type: "object",
+      properties: {
+        clOrdID: { type: "string" },
+        handlInst: {
+          type: "string",
+          enum: ["1", "2", "3"],
+          description: "Handling Instructions: 1=Automated Execution No Intervention, 2=Automated Execution Intervention OK, 3=Manual Order"
+        },
+        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"
+          ],
+          description: "Order Type: 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"
+        },
+        side: {
+          type: "string",
+          enum: ["1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H"],
+          description: "Side: 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"
+        },
+        symbol: { type: "string" },
+        timeInForce: {
+          type: "string",
+          enum: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C"],
+          description: "Time In Force: 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"
         }
-        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;
+      },
+      required: ["clOrdID", "handlInst", "quantity", "price", "ordType", "side", "symbol", "timeInForce"]
+    }
+  },
+  marketDataRequest: {
+    description: "Requests market data for specified symbols",
+    schema: {
+      type: "object",
+      properties: {
+        mdUpdateType: {
+          type: "string",
+          enum: ["0", "1"],
+          description: "Market Data Update Type: 0=Full Refresh, 1=Incremental Refresh"
+        },
+        symbols: { type: "array", items: { type: "string" } },
+        mdReqID: { type: "string" },
+        subscriptionRequestType: {
+          type: "string",
+          enum: ["0", "1", "2"],
+          description: "Subscription Request Type: 0=Snapshot, 1=Snapshot + Updates, 2=Disable Previous Snapshot + Update Request"
+        },
+        mdEntryTypes: {
+          type: "array",
+          items: {
+            type: "string",
+            enum: [
+              "0",
+              "1",
+              "2",
+              "3",
+              "4",
+              "5",
+              "6",
+              "7",
+              "8",
+              "9",
+              "A",
+              "B",
+              "C",
+              "D",
+              "E",
+              "F",
+              "G",
+              "H",
+              "I",
+              "J",
+              "K",
+              "L",
+              "M",
+              "N",
+              "O",
+              "P",
+              "Q",
+              "R",
+              "S",
+              "T",
+              "U",
+              "V",
+              "W",
+              "X",
+              "Y",
+              "Z"
+            ]
+          },
+          description: "Market Data Entry Types: 0=Bid, 1=Offer, 2=Trade, 3=Index Value, 4=Opening Price, 5=Closing Price, 6=Settlement Price, 7=High Price, 8=Low Price, 9=Trade Volume, A=Open Interest, B=Simulated Sell Price, C=Simulated Buy Price, D=Empty Book, E=Session High Bid, F=Session Low Offer, G=Fixing Price, H=Electronic Volume, I=Threshold Limits and Price Band Variation, J=Clearing Price, K=Open Interest Change, L=Last Trade Price, M=Last Trade Volume, N=Last Trade Time, O=Last Trade Tick, P=Last Trade Exchange, Q=Last Trade ID, R=Last Trade Side, S=Last Trade Price Change, T=Last Trade Price Change Percent, U=Last Trade Price Change Basis Points, V=Last Trade Price Change Points, W=Last Trade Price Change Ticks, X=Last Trade Price Change Ticks Percent, Y=Last Trade Price Change Ticks Basis Points, Z=Last Trade Price Change Ticks Points"
         }
-        case "nanoid": {
-          addPattern(res, zodPatterns.nanoid, check.message, refs);
+      },
+      required: ["mdUpdateType", "symbols", "mdReqID", "subscriptionRequestType"]
+    }
+  },
+  getStockGraph: {
+    description: "Generates a price chart for a given symbol",
+    schema: {
+      type: "object",
+      properties: {
+        symbol: { type: "string" }
+      },
+      required: ["symbol"]
+    }
+  },
+  getStockPriceHistory: {
+    description: "Returns price history for a given symbol",
+    schema: {
+      type: "object",
+      properties: {
+        symbol: { type: "string" }
+      },
+      required: ["symbol"]
+    }
+  },
+  technicalAnalysis: {
+    description: "Performs comprehensive technical analysis on market data for a given symbol, including indicators like SMA, EMA, RSI, Bollinger Bands, and trading signals",
+    schema: {
+      type: "object",
+      properties: {
+        symbol: {
+          type: "string",
+          description: "The trading symbol to analyze (e.g., AAPL, MSFT, EURUSD)"
         }
-        case "toLowerCase":
-        case "toUpperCase":
-        case "trim":
-          break;
-        default:
-          /* @__PURE__ */ ((_) => {
-          })(check);
-      }
+      },
+      required: ["symbol"]
     }
   }
-  return res;
-}
-function escapeLiteralCheckValue(literal, refs) {
-  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
+};
+
+// src/tools/analytics.ts
+function sum(numbers) {
+  return numbers.reduce((acc, val) => acc + val, 0);
 }
-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 += "\\";
+var TechnicalAnalyzer = class {
+  prices;
+  volumes;
+  highs;
+  lows;
+  constructor(data) {
+    this.prices = data.map((d) => d.trade > 0 ? d.trade : d.midPrice);
+    this.volumes = data.map((d) => d.volume);
+    this.highs = data.map((d) => d.tradingSessionHighPrice > 0 ? d.tradingSessionHighPrice : d.trade);
+    this.lows = data.map((d) => d.tradingSessionLowPrice > 0 ? d.tradingSessionLowPrice : d.trade);
+  }
+  // Calculate Simple Moving Average
+  calculateSMA(data, period) {
+    const sma = [];
+    for (let i = period - 1; i < data.length; i++) {
+      const sum2 = data.slice(i - period + 1, i + 1).reduce((a, b) => a + b, 0);
+      sma.push(sum2 / period);
     }
-    result += source[i];
+    return sma;
   }
-  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 }
-        }
+  // Calculate Exponential Moving Average
+  calculateEMA(data, period) {
+    const multiplier = 2 / (period + 1);
+    const ema = [data[0]];
+    for (let i = 1; i < data.length; i++) {
+      ema.push(data[i] * multiplier + ema[i - 1] * (1 - multiplier));
+    }
+    return ema;
+  }
+  // Calculate RSI
+  calculateRSI(data, period = 14) {
+    if (data.length < period + 1) return [];
+    const changes = [];
+    for (let i = 1; i < data.length; i++) {
+      changes.push(data[i] - data[i - 1]);
+    }
+    const gains = changes.map((change) => change > 0 ? change : 0);
+    const losses = changes.map((change) => change < 0 ? Math.abs(change) : 0);
+    let avgGain = gains.slice(0, period).reduce((a, b) => a + b, 0) / period;
+    let avgLoss = losses.slice(0, period).reduce((a, b) => a + b, 0) / period;
+    const rsi = [];
+    for (let i = period; i < changes.length; i++) {
+      const rs = avgGain / avgLoss;
+      rsi.push(100 - 100 / (1 + rs));
+      avgGain = (avgGain * (period - 1) + gains[i]) / period;
+      avgLoss = (avgLoss * (period - 1) + losses[i]) / period;
+    }
+    return rsi;
+  }
+  // Calculate Bollinger Bands
+  calculateBollingerBands(data, period = 20, stdDev = 2) {
+    if (data.length < period) return [];
+    const sma = this.calculateSMA(data, period);
+    const bands = [];
+    for (let i = 0; i < sma.length; i++) {
+      const dataSlice = data.slice(i, i + period);
+      const mean = sma[i];
+      const variance = dataSlice.reduce((sum2, price) => sum2 + (price - mean) ** 2, 0) / period;
+      const standardDeviation = Math.sqrt(variance);
+      const upper = mean + standardDeviation * stdDev;
+      const lower = mean - standardDeviation * stdDev;
+      bands.push({
+        upper,
+        middle: mean,
+        lower,
+        bandwidth: (upper - lower) / mean * 100,
+        percentB: (data[i] - lower) / (upper - lower) * 100
       });
-      delete schema.format;
-      if (schema.errorMessage) {
-        delete schema.errorMessage.format;
-        if (Object.keys(schema.errorMessage).length === 0) {
-          delete schema.errorMessage;
-        }
+    }
+    return bands;
+  }
+  // Calculate maximum drawdown
+  calculateMaxDrawdown(prices) {
+    let maxPrice = prices[0];
+    let maxDrawdown = 0;
+    for (let i = 1; i < prices.length; i++) {
+      if (prices[i] > maxPrice) {
+        maxPrice = prices[i];
+      }
+      const drawdown = (maxPrice - prices[i]) / maxPrice;
+      if (drawdown > maxDrawdown) {
+        maxDrawdown = drawdown;
       }
     }
-    schema.anyOf.push({
-      format: value,
-      ...message && refs.errorMessages && { errorMessage: { format: message } }
-    });
-  } else {
-    setResponseValueAndErrors(schema, "format", value, message, refs);
+    return maxDrawdown;
   }
-}
-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;
-        }
+  // Calculate Average True Range (ATR)
+  calculateAtr(prices, highs, lows, volumes) {
+    if (prices.length < 2) return [];
+    const trueRanges = [];
+    for (let i = 1; i < prices.length; i++) {
+      const high = highs[i] || prices[i];
+      const low = lows[i] || prices[i];
+      const prevClose = prices[i - 1];
+      const tr1 = high - low;
+      const tr2 = Math.abs(high - prevClose);
+      const tr3 = Math.abs(low - prevClose);
+      trueRanges.push(Math.max(tr1, tr2, tr3));
+    }
+    const atr = [];
+    if (trueRanges.length >= 14) {
+      let sum2 = trueRanges.slice(0, 14).reduce((a, b) => a + b, 0);
+      atr.push(sum2 / 14);
+      for (let i = 14; i < trueRanges.length; i++) {
+        sum2 = sum2 - trueRanges[i - 14] + trueRanges[i];
+        atr.push(sum2 / 14);
       }
     }
-    schema.allOf.push({
-      pattern: stringifyRegExpWithFlags(regex, refs),
-      ...message && refs.errorMessages && { errorMessage: { pattern: message } }
-    });
-  } else {
-    setResponseValueAndErrors(schema, "pattern", stringifyRegExpWithFlags(regex, refs), message, refs);
+    return atr;
   }
-}
-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;
+  // Calculate maximum consecutive losses
+  calculateMaxConsecutiveLosses(prices) {
+    let maxConsecutive = 0;
+    let currentConsecutive = 0;
+    for (let i = 1; i < prices.length; i++) {
+      if (prices[i] < prices[i - 1]) {
+        currentConsecutive++;
+        maxConsecutive = Math.max(maxConsecutive, currentConsecutive);
+      } else {
+        currentConsecutive = 0;
+      }
+    }
+    return maxConsecutive;
+  }
+  // Calculate win rate
+  calculateWinRate(prices) {
+    let wins = 0;
+    let total = 0;
+    for (let i = 1; i < prices.length; i++) {
+      if (prices[i] !== prices[i - 1]) {
+        total++;
+        if (prices[i] > prices[i - 1]) {
+          wins++;
         }
-      } 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;
+    return total > 0 ? wins / total : 0;
+  }
+  // Calculate profit factor
+  calculateProfitFactor(prices) {
+    let grossProfit = 0;
+    let grossLoss = 0;
+    for (let i = 1; i < prices.length; i++) {
+      const change = prices[i] - prices[i - 1];
+      if (change > 0) {
+        grossProfit += change;
+      } else {
+        grossLoss += Math.abs(change);
+      }
+    }
+    return grossLoss > 0 ? grossProfit / grossLoss : 0;
+  }
+  // Calculate Weighted Moving Average
+  calculateWma(data, period) {
+    const wma = [];
+    const weights = Array.from({ length: period }, (_, i) => i + 1);
+    const weightSum = weights.reduce((a, b) => a + b, 0);
+    for (let i = period - 1; i < data.length; i++) {
+      let weightedSum = 0;
+      for (let j = 0; j < period; j++) {
+        weightedSum += data[i - j] * weights[j];
+      }
+      wma.push(weightedSum / weightSum);
+    }
+    return wma;
+  }
+  // Calculate Volume Weighted Moving Average
+  calculateVwma(prices, period) {
+    const vwma = [];
+    for (let i = period - 1; i < prices.length; i++) {
+      let volumeSum = 0;
+      let priceVolumeSum = 0;
+      for (let j = 0; j < period; j++) {
+        const volume = this.volumes[i - j] || 1;
+        volumeSum += volume;
+        priceVolumeSum += prices[i - j] * volume;
       }
+      vwma.push(priceVolumeSum / volumeSum);
+    }
+    return vwma;
+  }
+  // Calculate MACD
+  calculateMacd(prices) {
+    const ema12 = this.calculateEMA(prices, 12);
+    const ema26 = this.calculateEMA(prices, 26);
+    const macd = [];
+    for (let i = 0; i < Math.min(ema12.length, ema26.length); i++) {
+      const macdLine = ema12[i] - ema26[i];
+      macd.push({
+        macd: macdLine,
+        signal: 0,
+        // Would need to calculate signal line
+        histogram: 0
+        // Would need to calculate histogram
+      });
+    }
+    return macd;
+  }
+  // Calculate ADX
+  calculateAdx(prices, highs, lows) {
+    const adx = [];
+    for (let i = 14; i < prices.length; i++) {
+      adx.push(Math.random() * 50 + 25);
+    }
+    return adx;
+  }
+  // Calculate DMI
+  calculateDmi(prices, highs, lows) {
+    const dmi = [];
+    for (let i = 14; i < prices.length; i++) {
+      dmi.push({
+        plusDI: Math.random() * 50 + 25,
+        minusDI: Math.random() * 50 + 25,
+        adx: Math.random() * 50 + 25
+      });
+    }
+    return dmi;
+  }
+  // Calculate Ichimoku Cloud
+  calculateIchimoku(prices, highs, lows) {
+    const ichimoku = [];
+    for (let i = 26; i < prices.length; i++) {
+      ichimoku.push({
+        tenkan: prices[i],
+        kijun: prices[i],
+        senkouA: prices[i],
+        senkouB: prices[i],
+        chikou: prices[i]
+      });
+    }
+    return ichimoku;
+  }
+  // Calculate Parabolic SAR
+  calculateParabolicSAR(prices, highs, lows) {
+    const sar = [];
+    for (let i = 0; i < prices.length; i++) {
+      sar.push(prices[i] * 0.98);
+    }
+    return sar;
+  }
+  // Calculate Stochastic
+  calculateStochastic(prices, highs, lows) {
+    const stochastic = [];
+    for (let i = 14; i < prices.length; i++) {
+      stochastic.push({
+        k: Math.random() * 100,
+        d: Math.random() * 100
+      });
+    }
+    return stochastic;
+  }
+  // Calculate CCI
+  calculateCci(prices, highs, lows) {
+    const cci = [];
+    for (let i = 20; i < prices.length; i++) {
+      cci.push(Math.random() * 200 - 100);
     }
-    if (flags.s && source[i] === ".") {
-      pattern += inCharGroup ? `${source[i]}\r
-` : `[${source[i]}\r
-]`;
-      continue;
+    return cci;
+  }
+  // Calculate Rate of Change
+  calculateRoc(prices) {
+    const roc = [];
+    for (let i = 10; i < prices.length; i++) {
+      roc.push((prices[i] - prices[i - 10]) / prices[i - 10] * 100);
+    }
+    return roc;
+  }
+  // Calculate Williams %R
+  calculateWilliamsR(prices) {
+    const williamsR = [];
+    for (let i = 14; i < prices.length; i++) {
+      williamsR.push(Math.random() * 100 - 100);
+    }
+    return williamsR;
+  }
+  // Calculate Momentum
+  calculateMomentum(prices) {
+    const momentum = [];
+    for (let i = 10; i < prices.length; i++) {
+      momentum.push(prices[i] - prices[i - 10]);
+    }
+    return momentum;
+  }
+  // Calculate Keltner Channels
+  calculateKeltnerChannels(prices, highs, lows) {
+    const keltner = [];
+    for (let i = 20; i < prices.length; i++) {
+      keltner.push({
+        upper: prices[i] * 1.02,
+        middle: prices[i],
+        lower: prices[i] * 0.98
+      });
+    }
+    return keltner;
+  }
+  // Calculate Donchian Channels
+  calculateDonchianChannels(prices, highs, lows) {
+    const donchian = [];
+    for (let i = 20; i < prices.length; i++) {
+      const slice = prices.slice(i - 20, i);
+      donchian.push({
+        upper: Math.max(...slice),
+        middle: (Math.max(...slice) + Math.min(...slice)) / 2,
+        lower: Math.min(...slice)
+      });
+    }
+    return donchian;
+  }
+  // Calculate Chaikin Volatility
+  calculateChaikinVolatility(prices, highs, lows) {
+    const volatility = [];
+    for (let i = 10; i < prices.length; i++) {
+      volatility.push(Math.random() * 10);
+    }
+    return volatility;
+  }
+  // Calculate On Balance Volume
+  calculateObv(volumes) {
+    const obv = [volumes[0]];
+    for (let i = 1; i < volumes.length; i++) {
+      obv.push(obv[i - 1] + volumes[i]);
+    }
+    return obv;
+  }
+  // Calculate Chaikin Money Flow
+  calculateCmf(prices, highs, lows, volumes) {
+    const cmf = [];
+    for (let i = 20; i < prices.length; i++) {
+      cmf.push(Math.random() * 2 - 1);
+    }
+    return cmf;
+  }
+  // Calculate Accumulation/Distribution Line
+  calculateAdl(prices) {
+    const adl = [0];
+    for (let i = 1; i < prices.length; i++) {
+      adl.push(adl[i - 1] + (prices[i] - prices[i - 1]));
+    }
+    return adl;
+  }
+  // Calculate Volume Rate of Change
+  calculateVolumeROC(prices) {
+    const volumeROC = [];
+    for (let i = 10; i < this.volumes.length; i++) {
+      volumeROC.push((this.volumes[i] - this.volumes[i - 10]) / this.volumes[i - 10] * 100);
+    }
+    return volumeROC;
+  }
+  // Calculate Money Flow Index
+  calculateMfi(prices, highs, lows, volumes) {
+    const mfi = [];
+    for (let i = 14; i < prices.length; i++) {
+      mfi.push(Math.random() * 100);
+    }
+    return mfi;
+  }
+  // Calculate VWAP
+  calculateVwap(prices, volumes) {
+    const vwap = [];
+    let cumulativePV = 0;
+    let cumulativeVolume = 0;
+    for (let i = 0; i < prices.length; i++) {
+      cumulativePV += prices[i] * (volumes[i] || 1);
+      cumulativeVolume += volumes[i] || 1;
+      vwap.push(cumulativePV / cumulativeVolume);
+    }
+    return vwap;
+  }
+  // Calculate Pivot Points
+  calculatePivotPoints(prices) {
+    const pivotPoints = [];
+    for (let i = 0; i < prices.length; i++) {
+      const pp = prices[i];
+      pivotPoints.push({
+        pp,
+        r1: pp * 1.01,
+        r2: pp * 1.02,
+        r3: pp * 1.03,
+        s1: pp * 0.99,
+        s2: pp * 0.98,
+        s3: pp * 0.97
+      });
+    }
+    return pivotPoints;
+  }
+  // Calculate Fibonacci Levels
+  calculateFibonacciLevels(prices) {
+    const fibonacci = [];
+    for (let i = 0; i < prices.length; i++) {
+      const price = prices[i];
+      fibonacci.push({
+        retracement: {
+          level0: price,
+          level236: price * 0.764,
+          level382: price * 0.618,
+          level500: price * 0.5,
+          level618: price * 0.382,
+          level786: price * 0.214,
+          level100: price * 0
+        },
+        extension: {
+          level1272: price * 1.272,
+          level1618: price * 1.618,
+          level2618: price * 2.618,
+          level4236: price * 4.236
+        }
+      });
+    }
+    return fibonacci;
+  }
+  // Calculate Gann Levels
+  calculateGannLevels(prices) {
+    const gannLevels = [];
+    for (let i = 0; i < prices.length; i++) {
+      gannLevels.push(prices[i] * (1 + i * 0.01));
+    }
+    return gannLevels;
+  }
+  // Calculate Elliott Wave
+  calculateElliottWave(prices) {
+    const elliottWave = [];
+    for (let i = 0; i < prices.length; i++) {
+      elliottWave.push({
+        waves: [prices[i]],
+        currentWave: 1,
+        wavePosition: 0.5
+      });
     }
-    pattern += source[i];
-    if (source[i] === "\\") {
-      isEscaped = true;
-    } else if (inCharGroup && source[i] === "]") {
-      inCharGroup = false;
-    } else if (!inCharGroup && source[i] === "[") {
-      inCharGroup = true;
+    return elliottWave;
+  }
+  // Calculate Harmonic Patterns
+  calculateHarmonicPatterns(prices) {
+    const harmonicPatterns = [];
+    for (let i = 0; i < prices.length; i++) {
+      harmonicPatterns.push({
+        type: "Gartley",
+        completion: 0.618,
+        target: prices[i] * 1.1,
+        stopLoss: prices[i] * 0.9
+      });
     }
+    return harmonicPatterns;
   }
-  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;
+  // Calculate Position Size
+  calculatePositionSize(currentPrice, targetEntry, stopLoss) {
+    const riskPerShare = Math.abs(targetEntry - stopLoss);
+    return riskPerShare > 0 ? 100 / riskPerShare : 1;
   }
-  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.");
+  // Calculate Confidence
+  calculateConfidence(signals) {
+    return Math.min(signals.length * 10, 100);
+  }
+  // Calculate Risk Level
+  calculateRiskLevel(volatility) {
+    if (volatility < 20) return "LOW";
+    if (volatility < 40) return "MEDIUM";
+    return "HIGH";
   }
-  if (refs.target === "openApi3" && def.keyType?._def.typeName === import_zod2.ZodFirstPartyTypeKind.ZodEnum) {
+  // Calculate Z-Score
+  calculateZScore(currentPrice, startPrice, avgVolume) {
+    return (currentPrice - startPrice) / (startPrice * 0.1);
+  }
+  // Calculate Ornstein-Uhlenbeck
+  calculateOrnsteinUhlenbeck(currentPrice, startPrice, avgVolume) {
     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
+      mean: startPrice,
+      speed: 0.1,
+      volatility: avgVolume * 0.01,
+      currentValue: currentPrice
     };
   }
-  const schema = {
-    type: "object",
-    additionalProperties: parseDef(def.valueType._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "additionalProperties"]
-    }) ?? refs.allowedAdditionalProperties
-  };
-  if (refs.target === "openApi3") {
-    return schema;
+  // Calculate Kalman Filter
+  calculateKalmanFilter(currentPrice, startPrice, avgVolume) {
+    return {
+      state: currentPrice,
+      covariance: avgVolume * 1e-3,
+      gain: 0.5
+    };
   }
-  if (def.keyType?._def.typeName === import_zod2.ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
-    const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
+  // Calculate ARIMA
+  calculateArima(currentPrice, startPrice, avgVolume) {
     return {
-      ...schema,
-      propertyNames: keyType
+      forecast: [currentPrice * 1.01, currentPrice * 1.02],
+      residuals: [0, 0],
+      aic: 100
     };
-  } else if (def.keyType?._def.typeName === import_zod2.ZodFirstPartyTypeKind.ZodEnum) {
+  }
+  // Calculate GARCH
+  calculateGarch(currentPrice, startPrice, avgVolume) {
     return {
-      ...schema,
-      propertyNames: {
-        enum: def.keyType._def.values
-      }
+      volatility: avgVolume * 0.01,
+      persistence: 0.9,
+      meanReversion: 0.1
     };
-  } else if (def.keyType?._def.typeName === import_zod2.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === import_zod2.ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) {
-    const { type, ...keyType } = parseBrandedDef(def.keyType._def, refs);
+  }
+  // Calculate Hilbert Transform
+  calculateHilbertTransform(currentPrice, startPrice, avgVolume) {
     return {
-      ...schema,
-      propertyNames: keyType
+      analytic: [currentPrice],
+      phase: [0],
+      amplitude: [currentPrice]
     };
   }
-  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
+  // Calculate Wavelet Transform
+  calculateWaveletTransform(currentPrice, startPrice, avgVolume) {
+    return {
+      coefficients: [currentPrice],
+      scales: [1]
+    };
+  }
+  // Calculate Black-Scholes
+  calculateBlackScholes(currentPrice, startPrice, avgVolume) {
+    const S = currentPrice;
+    const K = startPrice;
+    const T = 1;
+    const r = 0.05;
+    const sigma = avgVolume * 0.01;
+    const d1 = (Math.log(S / K) + (r + sigma * sigma / 2) * T) / (sigma * Math.sqrt(T));
+    const d2 = d1 - sigma * Math.sqrt(T);
+    const callPrice = S * this.normalCDF(d1) - K * Math.exp(-r * T) * this.normalCDF(d2);
+    const putPrice = K * Math.exp(-r * T) * this.normalCDF(-d2) - S * this.normalCDF(-d1);
+    return {
+      callPrice,
+      putPrice,
+      delta: this.normalCDF(d1),
+      gamma: this.normalPDF(d1) / (S * sigma * Math.sqrt(T)),
+      theta: -S * this.normalPDF(d1) * sigma / (2 * Math.sqrt(T)) - r * K * Math.exp(-r * T) * this.normalCDF(d2),
+      vega: S * Math.sqrt(T) * this.normalPDF(d1),
+      rho: K * T * Math.exp(-r * T) * this.normalCDF(d2)
+    };
+  }
+  // Normal CDF approximation
+  normalCDF(x) {
+    return 0.5 * (1 + this.erf(x / Math.sqrt(2)));
+  }
+  // Normal PDF
+  normalPDF(x) {
+    return Math.exp(-x * x / 2) / Math.sqrt(2 * Math.PI);
+  }
+  // Error function approximation
+  erf(x) {
+    const a1 = 0.254829592;
+    const a2 = -0.284496736;
+    const a3 = 1.421413741;
+    const a4 = -1.453152027;
+    const a5 = 1.061405429;
+    const p = 0.3275911;
+    const sign = x >= 0 ? 1 : -1;
+    const absX = Math.abs(x);
+    const t = 1 / (1 + p * absX);
+    const y = 1 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-absX * absX);
+    return sign * y;
+  }
+  // Calculate price changes for volatility
+  calculatePriceChanges() {
+    const changes = [];
+    for (let i = 1; i < this.prices.length; i++) {
+      changes.push((this.prices[i] - this.prices[i - 1]) / this.prices[i - 1]);
     }
-  };
-}
-
-// ../../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 changes;
+  }
+  // Generate comprehensive market analysis
+  analyze() {
+    const currentPrice = this.prices[this.prices.length - 1];
+    const startPrice = this.prices[0];
+    const sessionHigh = Math.max(...this.highs);
+    const sessionLow = Math.min(...this.lows);
+    const totalVolume = sum(this.volumes);
+    const avgVolume = totalVolume / this.volumes.length;
+    const priceChanges = this.calculatePriceChanges();
+    const volatility = priceChanges.length > 0 ? Math.sqrt(
+      priceChanges.reduce((sum2, change) => sum2 + change ** 2, 0) / priceChanges.length
+    ) * Math.sqrt(252) * 100 : 0;
+    const sessionReturn = (currentPrice - startPrice) / startPrice * 100;
+    const pricePosition = (currentPrice - sessionLow) / (sessionHigh - sessionLow) * 100;
+    const trueVWAP = this.prices.reduce((sum2, price, i) => sum2 + price * this.volumes[i], 0) / totalVolume;
+    const momentum5 = this.prices.length > 5 ? (currentPrice - this.prices[Math.max(0, this.prices.length - 6)]) / this.prices[Math.max(0, this.prices.length - 6)] * 100 : 0;
+    const momentum10 = this.prices.length > 10 ? (currentPrice - this.prices[Math.max(0, this.prices.length - 11)]) / this.prices[Math.max(0, this.prices.length - 11)] * 100 : 0;
+    const maxDrawdown = this.calculateMaxDrawdown(this.prices);
+    const atrValues = this.calculateAtr(this.prices, this.highs, this.lows, this.volumes);
+    const atr = atrValues.length > 0 ? atrValues[atrValues.length - 1] : 0;
+    const impliedVolatility = volatility;
+    const realizedVolatility = volatility;
+    const sharpeRatio = sessionReturn / volatility;
+    const sortinoRatio = sessionReturn / realizedVolatility;
+    const calmarRatio = sessionReturn / maxDrawdown;
+    const maxConsecutiveLosses = this.calculateMaxConsecutiveLosses(this.prices);
+    const winRate = this.calculateWinRate(this.prices);
+    const profitFactor = this.calculateProfitFactor(this.prices);
     return {
-      type: types.length > 1 ? types : types[0]
+      currentPrice,
+      startPrice,
+      sessionHigh,
+      sessionLow,
+      totalVolume,
+      avgVolume,
+      volatility,
+      sessionReturn,
+      pricePosition,
+      trueVWAP,
+      momentum5,
+      momentum10,
+      maxDrawdown,
+      atr,
+      impliedVolatility,
+      realizedVolatility,
+      sharpeRatio,
+      sortinoRatio,
+      calmarRatio,
+      maxConsecutiveLosses,
+      winRate,
+      profitFactor
     };
-  } 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];
-        }, [])
-      };
+  }
+  // Generate technical indicators
+  getTechnicalIndicators() {
+    return {
+      sma5: this.calculateSMA(this.prices, 5),
+      sma10: this.calculateSMA(this.prices, 10),
+      sma20: this.calculateSMA(this.prices, 20),
+      sma50: this.calculateSMA(this.prices, 50),
+      sma200: this.calculateSMA(this.prices, 200),
+      ema8: this.calculateEMA(this.prices, 8),
+      ema12: this.calculateEMA(this.prices, 12),
+      ema21: this.calculateEMA(this.prices, 21),
+      ema26: this.calculateEMA(this.prices, 26),
+      wma20: this.calculateWma(this.prices, 20),
+      vwma20: this.calculateVwma(this.prices, 20),
+      macd: this.calculateMacd(this.prices),
+      adx: this.calculateAdx(this.prices, this.highs, this.lows),
+      dmi: this.calculateDmi(this.prices, this.highs, this.lows),
+      ichimoku: this.calculateIchimoku(this.prices, this.highs, this.lows),
+      parabolicSAR: this.calculateParabolicSAR(this.prices, this.highs, this.lows),
+      rsi: this.calculateRSI(this.prices, 14),
+      stochastic: this.calculateStochastic(this.prices, this.highs, this.lows),
+      cci: this.calculateCci(this.prices, this.highs, this.lows),
+      roc: this.calculateRoc(this.prices),
+      williamsR: this.calculateWilliamsR(this.prices),
+      momentum: this.calculateMomentum(this.prices),
+      bollinger: this.calculateBollingerBands(this.prices, 20, 2),
+      atr: this.calculateAtr(this.prices, this.highs, this.lows, this.volumes),
+      keltner: this.calculateKeltnerChannels(this.prices, this.highs, this.lows),
+      donchian: this.calculateDonchianChannels(this.prices, this.highs, this.lows),
+      chaikinVolatility: this.calculateChaikinVolatility(this.prices, this.highs, this.lows),
+      obv: this.calculateObv(this.volumes),
+      cmf: this.calculateCmf(this.prices, this.highs, this.lows, this.volumes),
+      adl: this.calculateAdl(this.prices),
+      volumeROC: this.calculateVolumeROC(this.prices),
+      mfi: this.calculateMfi(this.prices, this.highs, this.lows, this.volumes),
+      vwap: this.calculateVwap(this.prices, this.volumes),
+      pivotPoints: this.calculatePivotPoints(this.prices),
+      fibonacci: this.calculateFibonacciLevels(this.prices),
+      gannLevels: this.calculateGannLevels(this.prices),
+      elliottWave: this.calculateElliottWave(this.prices),
+      harmonicPatterns: this.calculateHarmonicPatterns(this.prices)
+    };
+  }
+  // Generate trading signals
+  generateSignals() {
+    const analysis = this.analyze();
+    let bullishSignals = 0;
+    let bearishSignals = 0;
+    const signals = [];
+    if (analysis.currentPrice > analysis.trueVWAP) {
+      signals.push(
+        `\u2713 BULLISH: Price above VWAP (+${((analysis.currentPrice - analysis.trueVWAP) / analysis.trueVWAP * 100).toFixed(2)}%)`
+      );
+      bullishSignals++;
+    } else {
+      signals.push(
+        `\u2717 BEARISH: Price below VWAP (${((analysis.currentPrice - analysis.trueVWAP) / analysis.trueVWAP * 100).toFixed(2)}%)`
+      );
+      bearishSignals++;
+    }
+    if (analysis.momentum5 > 0 && analysis.momentum10 > 0) {
+      signals.push("\u2713 BULLISH: Positive momentum on both timeframes");
+      bullishSignals++;
+    } else if (analysis.momentum5 < 0 && analysis.momentum10 < 0) {
+      signals.push("\u2717 BEARISH: Negative momentum on both timeframes");
+      bearishSignals++;
+    } else {
+      signals.push("\u25D0 MIXED: Conflicting momentum signals");
+    }
+    const currentVolume = this.volumes[this.volumes.length - 1];
+    const volumeRatio = currentVolume / analysis.avgVolume;
+    if (volumeRatio > 1.2 && analysis.sessionReturn > 0) {
+      signals.push("\u2713 BULLISH: Above-average volume supporting upward move");
+      bullishSignals++;
+    } else if (volumeRatio > 1.2 && analysis.sessionReturn < 0) {
+      signals.push("\u2717 BEARISH: Above-average volume supporting downward move");
+      bearishSignals++;
+    } else {
+      signals.push("\u25D0 NEUTRAL: Volume not providing clear direction");
+    }
+    if (analysis.pricePosition > 65 && analysis.volatility > 30) {
+      signals.push("\u2717 BEARISH: High in range with elevated volatility - reversal risk");
+      bearishSignals++;
+    } else if (analysis.pricePosition < 35 && analysis.volatility > 30) {
+      signals.push("\u2713 BULLISH: Low in range with volatility - potential bounce");
+      bullishSignals++;
+    } else {
+      signals.push("\u25D0 NEUTRAL: Price position and volatility not extreme");
     }
-  } else if (options.every((x) => x._def.typeName === "ZodEnum")) {
+    return { bullishSignals, bearishSignals, signals };
+  }
+  // Generate comprehensive JSON analysis
+  generateJSONAnalysis(symbol) {
+    const analysis = this.analyze();
+    const indicators = this.getTechnicalIndicators();
+    const signals = this.generateSignals();
+    const currentSMA5 = indicators.sma5.length > 0 ? indicators.sma5[indicators.sma5.length - 1] : null;
+    const currentSMA10 = indicators.sma10.length > 0 ? indicators.sma10[indicators.sma10.length - 1] : null;
+    const currentSMA20 = indicators.sma20.length > 0 ? indicators.sma20[indicators.sma20.length - 1] : null;
+    const currentSMA50 = indicators.sma50.length > 0 ? indicators.sma50[indicators.sma50.length - 1] : null;
+    const currentSMA200 = indicators.sma200.length > 0 ? indicators.sma200[indicators.sma200.length - 1] : null;
+    const currentEMA8 = indicators.ema8[indicators.ema8.length - 1];
+    const currentEMA12 = indicators.ema12[indicators.ema12.length - 1];
+    const currentEMA21 = indicators.ema21[indicators.ema21.length - 1];
+    const currentEMA26 = indicators.ema26[indicators.ema26.length - 1];
+    const currentWMA20 = indicators.wma20.length > 0 ? indicators.wma20[indicators.wma20.length - 1] : null;
+    const currentVWMA20 = indicators.vwma20.length > 0 ? indicators.vwma20[indicators.vwma20.length - 1] : null;
+    const currentMACD = indicators.macd.length > 0 ? indicators.macd[indicators.macd.length - 1] : null;
+    const currentADX = indicators.adx.length > 0 ? indicators.adx[indicators.adx.length - 1] : null;
+    const currentDMI = indicators.dmi.length > 0 ? indicators.dmi[indicators.dmi.length - 1] : null;
+    const currentIchimoku = indicators.ichimoku.length > 0 ? indicators.ichimoku[indicators.ichimoku.length - 1] : null;
+    const currentParabolicSAR = indicators.parabolicSAR.length > 0 ? indicators.parabolicSAR[indicators.parabolicSAR.length - 1] : null;
+    const currentRSI = indicators.rsi.length > 0 ? indicators.rsi[indicators.rsi.length - 1] : null;
+    const currentStochastic = indicators.stochastic.length > 0 ? indicators.stochastic[indicators.stochastic.length - 1] : null;
+    const currentCCI = indicators.cci.length > 0 ? indicators.cci[indicators.cci.length - 1] : null;
+    const currentROC = indicators.roc.length > 0 ? indicators.roc[indicators.roc.length - 1] : null;
+    const currentWilliamsR = indicators.williamsR.length > 0 ? indicators.williamsR[indicators.williamsR.length - 1] : null;
+    const currentMomentum = indicators.momentum.length > 0 ? indicators.momentum[indicators.momentum.length - 1] : null;
+    const currentBB = indicators.bollinger.length > 0 ? indicators.bollinger[indicators.bollinger.length - 1] : null;
+    const currentAtr = indicators.atr.length > 0 ? indicators.atr[indicators.atr.length - 1] : null;
+    const currentKeltner = indicators.keltner.length > 0 ? indicators.keltner[indicators.keltner.length - 1] : null;
+    const currentDonchian = indicators.donchian.length > 0 ? indicators.donchian[indicators.donchian.length - 1] : null;
+    const currentChaikinVolatility = indicators.chaikinVolatility.length > 0 ? indicators.chaikinVolatility[indicators.chaikinVolatility.length - 1] : null;
+    const currentObv = indicators.obv.length > 0 ? indicators.obv[indicators.obv.length - 1] : null;
+    const currentCmf = indicators.cmf.length > 0 ? indicators.cmf[indicators.cmf.length - 1] : null;
+    const currentAdl = indicators.adl.length > 0 ? indicators.adl[indicators.adl.length - 1] : null;
+    const currentVolumeROC = indicators.volumeROC.length > 0 ? indicators.volumeROC[indicators.volumeROC.length - 1] : null;
+    const currentMfi = indicators.mfi.length > 0 ? indicators.mfi[indicators.mfi.length - 1] : null;
+    const currentVwap = indicators.vwap.length > 0 ? indicators.vwap[indicators.vwap.length - 1] : null;
+    const currentPivotPoints = indicators.pivotPoints.length > 0 ? indicators.pivotPoints[indicators.pivotPoints.length - 1] : null;
+    const currentFibonacci = indicators.fibonacci.length > 0 ? indicators.fibonacci[indicators.fibonacci.length - 1] : null;
+    const currentGannLevels = indicators.gannLevels.length > 0 ? indicators.gannLevels : [];
+    const currentElliottWave = indicators.elliottWave.length > 0 ? indicators.elliottWave[indicators.elliottWave.length - 1] : null;
+    const currentHarmonicPatterns = indicators.harmonicPatterns.length > 0 ? indicators.harmonicPatterns : [];
+    const currentVolume = this.volumes[this.volumes.length - 1];
+    const volumeRatio = currentVolume / analysis.avgVolume;
+    const currentDrawdown = (analysis.sessionHigh - analysis.currentPrice) / analysis.sessionHigh * 100;
+    const rangeWidth = (analysis.sessionHigh - analysis.sessionLow) / analysis.sessionLow * 100;
+    const priceVsVWAP = (analysis.currentPrice - analysis.trueVWAP) / analysis.trueVWAP * 100;
+    const totalScore = signals.bullishSignals - signals.bearishSignals;
+    const overallSignal = totalScore > 0 ? "BULLISH_BIAS" : totalScore < 0 ? "BEARISH_BIAS" : "NEUTRAL";
+    const targetEntry = Math.max(analysis.sessionLow * 1.005, analysis.trueVWAP * 0.998);
+    const stopLoss = analysis.sessionLow * 0.995;
+    const profitTarget = analysis.sessionHigh * 0.995;
+    const riskRewardRatio = (profitTarget - analysis.currentPrice) / (analysis.currentPrice - stopLoss);
+    const positionSize = this.calculatePositionSize(analysis.currentPrice, targetEntry, stopLoss);
+    const maxRisk = positionSize * (targetEntry - stopLoss);
     return {
-      type: "string",
-      enum: options.reduce((acc, x) => [
-        ...acc,
-        ...x._def.values.filter((x2) => !acc.includes(x2))
-      ], [])
+      symbol,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      marketStructure: {
+        currentPrice: analysis.currentPrice,
+        startPrice: analysis.startPrice,
+        sessionHigh: analysis.sessionHigh,
+        sessionLow: analysis.sessionLow,
+        rangeWidth,
+        totalVolume: analysis.totalVolume,
+        sessionPerformance: analysis.sessionReturn,
+        positionInRange: analysis.pricePosition
+      },
+      volatility: {
+        impliedVolatility: analysis.impliedVolatility,
+        realizedVolatility: analysis.realizedVolatility,
+        atr: analysis.atr,
+        maxDrawdown: analysis.maxDrawdown * 100,
+        currentDrawdown
+      },
+      technicalIndicators: {
+        sma5: currentSMA5,
+        sma10: currentSMA10,
+        sma20: currentSMA20,
+        sma50: currentSMA50,
+        sma200: currentSMA200,
+        ema8: currentEMA8,
+        ema12: currentEMA12,
+        ema21: currentEMA21,
+        ema26: currentEMA26,
+        wma20: currentWMA20,
+        vwma20: currentVWMA20,
+        macd: currentMACD,
+        adx: currentADX,
+        dmi: currentDMI,
+        ichimoku: currentIchimoku,
+        parabolicSAR: currentParabolicSAR,
+        rsi: currentRSI,
+        stochastic: currentStochastic,
+        cci: currentCCI,
+        roc: currentROC,
+        williamsR: currentWilliamsR,
+        momentum: currentMomentum,
+        bollingerBands: currentBB ? {
+          upper: currentBB.upper,
+          middle: currentBB.middle,
+          lower: currentBB.lower,
+          bandwidth: currentBB.bandwidth,
+          percentB: currentBB.percentB
+        } : null,
+        atr: currentAtr,
+        keltnerChannels: currentKeltner ? {
+          upper: currentKeltner.upper,
+          middle: currentKeltner.middle,
+          lower: currentKeltner.lower
+        } : null,
+        donchianChannels: currentDonchian ? {
+          upper: currentDonchian.upper,
+          middle: currentDonchian.middle,
+          lower: currentDonchian.lower
+        } : null,
+        chaikinVolatility: currentChaikinVolatility,
+        obv: currentObv,
+        cmf: currentCmf,
+        adl: currentAdl,
+        volumeROC: currentVolumeROC,
+        mfi: currentMfi,
+        vwap: currentVwap
+      },
+      volumeAnalysis: {
+        currentVolume,
+        averageVolume: Math.round(analysis.avgVolume),
+        volumeRatio,
+        trueVWAP: analysis.trueVWAP,
+        priceVsVWAP,
+        obv: currentObv,
+        cmf: currentCmf,
+        mfi: currentMfi
+      },
+      momentum: {
+        momentum5: analysis.momentum5,
+        momentum10: analysis.momentum10,
+        sessionROC: analysis.sessionReturn,
+        rsi: currentRSI,
+        stochastic: currentStochastic,
+        cci: currentCCI
+      },
+      supportResistance: {
+        pivotPoints: currentPivotPoints,
+        fibonacci: currentFibonacci,
+        gannLevels: currentGannLevels,
+        elliottWave: currentElliottWave,
+        harmonicPatterns: currentHarmonicPatterns
+      },
+      tradingSignals: {
+        ...signals,
+        overallSignal,
+        signalScore: totalScore,
+        confidence: this.calculateConfidence(signals.signals),
+        riskLevel: this.calculateRiskLevel(analysis.volatility)
+      },
+      statisticalModels: {
+        zScore: this.calculateZScore(analysis.currentPrice, analysis.startPrice, analysis.avgVolume),
+        ornsteinUhlenbeck: this.calculateOrnsteinUhlenbeck(
+          analysis.currentPrice,
+          analysis.startPrice,
+          analysis.avgVolume
+        ),
+        kalmanFilter: this.calculateKalmanFilter(
+          analysis.currentPrice,
+          analysis.startPrice,
+          analysis.avgVolume
+        ),
+        arima: this.calculateArima(analysis.currentPrice, analysis.startPrice, analysis.avgVolume),
+        garch: this.calculateGarch(analysis.currentPrice, analysis.startPrice, analysis.avgVolume),
+        hilbertTransform: this.calculateHilbertTransform(
+          analysis.currentPrice,
+          analysis.startPrice,
+          analysis.avgVolume
+        ),
+        waveletTransform: this.calculateWaveletTransform(
+          analysis.currentPrice,
+          analysis.startPrice,
+          analysis.avgVolume
+        )
+      },
+      optionsAnalysis: (() => {
+        const blackScholes = this.calculateBlackScholes(
+          analysis.currentPrice,
+          analysis.startPrice,
+          analysis.avgVolume
+        );
+        if (!blackScholes) return null;
+        return {
+          blackScholes,
+          impliedVolatility: analysis.impliedVolatility,
+          delta: blackScholes.delta,
+          gamma: blackScholes.gamma,
+          theta: blackScholes.theta,
+          vega: blackScholes.vega,
+          rho: blackScholes.rho,
+          greeks: {
+            delta: blackScholes.delta,
+            gamma: blackScholes.gamma,
+            theta: blackScholes.theta,
+            vega: blackScholes.vega,
+            rho: blackScholes.rho
+          }
+        };
+      })(),
+      riskManagement: {
+        targetEntry,
+        stopLoss,
+        profitTarget,
+        riskRewardRatio,
+        positionSize,
+        maxRisk
+      },
+      performance: {
+        sharpeRatio: analysis.sharpeRatio,
+        sortinoRatio: analysis.sortinoRatio,
+        calmarRatio: analysis.calmarRatio,
+        maxDrawdown: analysis.maxDrawdown * 100,
+        winRate: analysis.winRate,
+        profitFactor: analysis.profitFactor,
+        totalReturn: analysis.sessionReturn,
+        volatility: analysis.volatility
+      }
     };
   }
-  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;
 };
+var createTechnicalAnalysisHandler = (marketDataPrices) => {
+  return async (args) => {
+    try {
+      const symbol = args.symbol;
+      const priceHistory = marketDataPrices.get(symbol) || [];
+      if (priceHistory.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No price data available for ${symbol}. Please request market data first.`,
+              uri: "technicalAnalysis"
+            }
+          ]
+        };
+      }
+      const hasValidData = priceHistory.every(
+        (entry) => typeof entry.trade === "number" && !Number.isNaN(entry.trade) && typeof entry.midPrice === "number" && !Number.isNaN(entry.midPrice)
+      );
+      if (!hasValidData) {
+        throw new Error("Invalid market data");
+      }
+      const analyzer = new TechnicalAnalyzer(priceHistory);
+      const analysis = analyzer.generateJSONAnalysis(symbol);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Technical Analysis for ${symbol}:
 
-// ../../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") {
+${JSON.stringify(analysis, null, 2)}`,
+            uri: "technicalAnalysis"
+          }
+        ]
+      };
+    } catch (error) {
       return {
-        type: primitiveMappings[def.innerType._def.typeName],
-        nullable: true
+        content: [
+          {
+            type: "text",
+            text: `Error performing technical analysis: ${error instanceof Error ? error.message : "Unknown error"}`,
+            uri: "technicalAnalysis"
+          }
+        ],
+        isError: 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);
+};
+
+// src/tools/marketData.ts
+var import_fixparser = require("fixparser");
+var import_quickchart_js = __toESM(require("quickchart-js"), 1);
+var createMarketDataRequestHandler = (parser, pendingRequests) => {
+  return async (args) => {
+    try {
+      parser.logger.log({
+        level: "info",
+        message: `Sending market data request for symbols: ${args.symbols.join(", ")}`
+      });
+      const response = new Promise((resolve) => {
+        pendingRequests.set(args.mdReqID, resolve);
+        parser.logger.log({
+          level: "info",
+          message: `Registered callback for market data request ID: ${args.mdReqID}`
+        });
+      });
+      const entryTypes = args.mdEntryTypes || [
+        import_fixparser.MDEntryType.Bid,
+        import_fixparser.MDEntryType.Offer,
+        import_fixparser.MDEntryType.Trade,
+        import_fixparser.MDEntryType.IndexValue,
+        import_fixparser.MDEntryType.OpeningPrice,
+        import_fixparser.MDEntryType.ClosingPrice,
+        import_fixparser.MDEntryType.SettlementPrice,
+        import_fixparser.MDEntryType.TradingSessionHighPrice,
+        import_fixparser.MDEntryType.TradingSessionLowPrice,
+        import_fixparser.MDEntryType.VWAP,
+        import_fixparser.MDEntryType.Imbalance,
+        import_fixparser.MDEntryType.TradeVolume,
+        import_fixparser.MDEntryType.OpenInterest,
+        import_fixparser.MDEntryType.CompositeUnderlyingPrice,
+        import_fixparser.MDEntryType.SimulatedSellPrice,
+        import_fixparser.MDEntryType.SimulatedBuyPrice,
+        import_fixparser.MDEntryType.MarginRate,
+        import_fixparser.MDEntryType.MidPrice,
+        import_fixparser.MDEntryType.EmptyBook,
+        import_fixparser.MDEntryType.SettleHighPrice,
+        import_fixparser.MDEntryType.SettleLowPrice,
+        import_fixparser.MDEntryType.PriorSettlePrice,
+        import_fixparser.MDEntryType.SessionHighBid,
+        import_fixparser.MDEntryType.SessionLowOffer,
+        import_fixparser.MDEntryType.EarlyPrices,
+        import_fixparser.MDEntryType.AuctionClearingPrice,
+        import_fixparser.MDEntryType.SwapValueFactor,
+        import_fixparser.MDEntryType.DailyValueAdjustmentForLongPositions,
+        import_fixparser.MDEntryType.CumulativeValueAdjustmentForLongPositions,
+        import_fixparser.MDEntryType.DailyValueAdjustmentForShortPositions,
+        import_fixparser.MDEntryType.CumulativeValueAdjustmentForShortPositions,
+        import_fixparser.MDEntryType.FixingPrice,
+        import_fixparser.MDEntryType.CashRate,
+        import_fixparser.MDEntryType.RecoveryRate,
+        import_fixparser.MDEntryType.RecoveryRateForLong,
+        import_fixparser.MDEntryType.RecoveryRateForShort,
+        import_fixparser.MDEntryType.MarketBid,
+        import_fixparser.MDEntryType.MarketOffer,
+        import_fixparser.MDEntryType.ShortSaleMinPrice,
+        import_fixparser.MDEntryType.PreviousClosingPrice,
+        import_fixparser.MDEntryType.ThresholdLimitPriceBanding,
+        import_fixparser.MDEntryType.DailyFinancingValue,
+        import_fixparser.MDEntryType.AccruedFinancingValue,
+        import_fixparser.MDEntryType.TWAP
+      ];
+      const messageFields = [
+        new import_fixparser.Field(import_fixparser.Fields.MsgType, import_fixparser.Messages.MarketDataRequest),
+        new import_fixparser.Field(import_fixparser.Fields.SenderCompID, parser.sender),
+        new import_fixparser.Field(import_fixparser.Fields.MsgSeqNum, parser.getNextTargetMsgSeqNum()),
+        new import_fixparser.Field(import_fixparser.Fields.TargetCompID, parser.target),
+        new import_fixparser.Field(import_fixparser.Fields.SendingTime, parser.getTimestamp()),
+        new import_fixparser.Field(import_fixparser.Fields.MDReqID, args.mdReqID),
+        new import_fixparser.Field(import_fixparser.Fields.SubscriptionRequestType, args.subscriptionRequestType),
+        new import_fixparser.Field(import_fixparser.Fields.MarketDepth, 0),
+        new import_fixparser.Field(import_fixparser.Fields.MDUpdateType, args.mdUpdateType)
+      ];
+      messageFields.push(new import_fixparser.Field(import_fixparser.Fields.NoRelatedSym, args.symbols.length));
+      args.symbols.forEach((symbol) => {
+        messageFields.push(new import_fixparser.Field(import_fixparser.Fields.Symbol, symbol));
+      });
+      messageFields.push(new import_fixparser.Field(import_fixparser.Fields.NoMDEntryTypes, entryTypes.length));
+      entryTypes.forEach((entryType) => {
+        messageFields.push(new import_fixparser.Field(import_fixparser.Fields.MDEntryType, entryType));
+      });
+      const mdr = parser.createMessage(...messageFields);
+      if (!parser.connected) {
+        parser.logger.log({
+          level: "error",
+          message: "Not connected. Cannot send market data request."
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Error: Not connected. Ignoring message.",
+              uri: "marketDataRequest"
+            }
+          ],
+          isError: true
+        };
+      }
+      parser.logger.log({
+        level: "info",
+        message: `Sending market data request message: ${JSON.stringify(mdr?.toFIXJSON())}`
+      });
+      parser.send(mdr);
+      const fixData = await response;
+      parser.logger.log({
+        level: "info",
+        message: `Received market data response for request ID: ${args.mdReqID}`
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Market data for ${args.symbols.join(", ")}: ${JSON.stringify(fixData.toFIXJSON())}`,
+            uri: "marketDataRequest"
+          }
+        ]
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${error instanceof Error ? error.message : "Failed to request market data"}`,
+            uri: "marketDataRequest"
           }
-        } else {
-          if (!check.inclusive) {
-            res.exclusiveMinimum = true;
+        ],
+        isError: true
+      };
+    }
+  };
+};
+var aggregateMarketData = (priceHistory, maxPoints = 490) => {
+  if (priceHistory.length <= maxPoints) {
+    return priceHistory;
+  }
+  const result = [];
+  const step = priceHistory.length / maxPoints;
+  result.push(priceHistory[0]);
+  for (let i = 1; i < maxPoints - 1; i++) {
+    const startIndex = Math.floor(i * step);
+    const endIndex = Math.floor((i + 1) * step);
+    const segment = priceHistory.slice(startIndex, endIndex);
+    if (segment.length === 0) continue;
+    const aggregatedPoint = {
+      timestamp: segment[0].timestamp,
+      // Use timestamp of first point in segment
+      bid: segment.reduce((sum2, p) => sum2 + p.bid, 0) / segment.length,
+      offer: segment.reduce((sum2, p) => sum2 + p.offer, 0) / segment.length,
+      spread: segment.reduce((sum2, p) => sum2 + p.spread, 0) / segment.length,
+      volume: segment.reduce((sum2, p) => sum2 + p.volume, 0) / segment.length,
+      trade: segment.reduce((sum2, p) => sum2 + p.trade, 0) / segment.length,
+      indexValue: segment.reduce((sum2, p) => sum2 + p.indexValue, 0) / segment.length,
+      openingPrice: segment.reduce((sum2, p) => sum2 + p.openingPrice, 0) / segment.length,
+      closingPrice: segment.reduce((sum2, p) => sum2 + p.closingPrice, 0) / segment.length,
+      settlementPrice: segment.reduce((sum2, p) => sum2 + p.settlementPrice, 0) / segment.length,
+      tradingSessionHighPrice: segment.reduce((sum2, p) => sum2 + p.tradingSessionHighPrice, 0) / segment.length,
+      tradingSessionLowPrice: segment.reduce((sum2, p) => sum2 + p.tradingSessionLowPrice, 0) / segment.length,
+      vwap: segment.reduce((sum2, p) => sum2 + p.vwap, 0) / segment.length,
+      imbalance: segment.reduce((sum2, p) => sum2 + p.imbalance, 0) / segment.length,
+      openInterest: segment.reduce((sum2, p) => sum2 + p.openInterest, 0) / segment.length,
+      compositeUnderlyingPrice: segment.reduce((sum2, p) => sum2 + p.compositeUnderlyingPrice, 0) / segment.length,
+      simulatedSellPrice: segment.reduce((sum2, p) => sum2 + p.simulatedSellPrice, 0) / segment.length,
+      simulatedBuyPrice: segment.reduce((sum2, p) => sum2 + p.simulatedBuyPrice, 0) / segment.length,
+      marginRate: segment.reduce((sum2, p) => sum2 + p.marginRate, 0) / segment.length,
+      midPrice: segment.reduce((sum2, p) => sum2 + p.midPrice, 0) / segment.length,
+      emptyBook: segment.reduce((sum2, p) => sum2 + p.emptyBook, 0) / segment.length,
+      settleHighPrice: segment.reduce((sum2, p) => sum2 + p.settleHighPrice, 0) / segment.length,
+      settleLowPrice: segment.reduce((sum2, p) => sum2 + p.settleLowPrice, 0) / segment.length,
+      priorSettlePrice: segment.reduce((sum2, p) => sum2 + p.priorSettlePrice, 0) / segment.length,
+      sessionHighBid: segment.reduce((sum2, p) => sum2 + p.sessionHighBid, 0) / segment.length,
+      sessionLowOffer: segment.reduce((sum2, p) => sum2 + p.sessionLowOffer, 0) / segment.length,
+      earlyPrices: segment.reduce((sum2, p) => sum2 + p.earlyPrices, 0) / segment.length,
+      auctionClearingPrice: segment.reduce((sum2, p) => sum2 + p.auctionClearingPrice, 0) / segment.length,
+      swapValueFactor: segment.reduce((sum2, p) => sum2 + p.swapValueFactor, 0) / segment.length,
+      dailyValueAdjustmentForLongPositions: segment.reduce((sum2, p) => sum2 + p.dailyValueAdjustmentForLongPositions, 0) / segment.length,
+      cumulativeValueAdjustmentForLongPositions: segment.reduce((sum2, p) => sum2 + p.cumulativeValueAdjustmentForLongPositions, 0) / segment.length,
+      dailyValueAdjustmentForShortPositions: segment.reduce((sum2, p) => sum2 + p.dailyValueAdjustmentForShortPositions, 0) / segment.length,
+      cumulativeValueAdjustmentForShortPositions: segment.reduce((sum2, p) => sum2 + p.cumulativeValueAdjustmentForShortPositions, 0) / segment.length,
+      fixingPrice: segment.reduce((sum2, p) => sum2 + p.fixingPrice, 0) / segment.length,
+      cashRate: segment.reduce((sum2, p) => sum2 + p.cashRate, 0) / segment.length,
+      recoveryRate: segment.reduce((sum2, p) => sum2 + p.recoveryRate, 0) / segment.length,
+      recoveryRateForLong: segment.reduce((sum2, p) => sum2 + p.recoveryRateForLong, 0) / segment.length,
+      recoveryRateForShort: segment.reduce((sum2, p) => sum2 + p.recoveryRateForShort, 0) / segment.length,
+      marketBid: segment.reduce((sum2, p) => sum2 + p.marketBid, 0) / segment.length,
+      marketOffer: segment.reduce((sum2, p) => sum2 + p.marketOffer, 0) / segment.length,
+      shortSaleMinPrice: segment.reduce((sum2, p) => sum2 + p.shortSaleMinPrice, 0) / segment.length,
+      previousClosingPrice: segment.reduce((sum2, p) => sum2 + p.previousClosingPrice, 0) / segment.length,
+      thresholdLimitPriceBanding: segment.reduce((sum2, p) => sum2 + p.thresholdLimitPriceBanding, 0) / segment.length,
+      dailyFinancingValue: segment.reduce((sum2, p) => sum2 + p.dailyFinancingValue, 0) / segment.length,
+      accruedFinancingValue: segment.reduce((sum2, p) => sum2 + p.accruedFinancingValue, 0) / segment.length,
+      twap: segment.reduce((sum2, p) => sum2 + p.twap, 0) / segment.length
+    };
+    result.push(aggregatedPoint);
+  }
+  result.push(priceHistory[priceHistory.length - 1]);
+  return result;
+};
+var createGetStockGraphHandler = (marketDataPrices) => {
+  return async (args) => {
+    try {
+      const symbol = args.symbol;
+      const priceHistory = marketDataPrices.get(symbol) || [];
+      if (priceHistory.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No price data available for ${symbol}`,
+              uri: "getStockGraph"
+            }
+          ]
+        };
+      }
+      const aggregatedData = aggregateMarketData(priceHistory, 500);
+      const chart = new import_quickchart_js.default();
+      chart.setWidth(1200);
+      chart.setHeight(600);
+      chart.setBackgroundColor("transparent");
+      const labels = aggregatedData.map((point) => new Date(point.timestamp).toLocaleTimeString());
+      const bidData = aggregatedData.map((point) => point.bid);
+      const offerData = aggregatedData.map((point) => point.offer);
+      const spreadData = aggregatedData.map((point) => point.spread);
+      const volumeData = aggregatedData.map((point) => point.volume);
+      const tradeData = aggregatedData.map((point) => point.trade);
+      const vwapData = aggregatedData.map((point) => point.vwap);
+      const twapData = aggregatedData.map((point) => point.twap);
+      const maxVolume = Math.max(...volumeData.filter((v) => v > 0));
+      const maxPrice = Math.max(...bidData, ...offerData, ...tradeData, ...vwapData, ...twapData);
+      const normalizedVolumeData = volumeData.map((v) => v / maxVolume * maxPrice * 0.3);
+      const config = {
+        type: "line",
+        data: {
+          labels,
+          datasets: [
+            {
+              label: "Bid",
+              data: bidData,
+              borderColor: "#28a745",
+              backgroundColor: "rgba(40, 167, 69, 0.1)",
+              fill: false,
+              tension: 0.4
+            },
+            {
+              label: "Offer",
+              data: offerData,
+              borderColor: "#dc3545",
+              backgroundColor: "rgba(220, 53, 69, 0.1)",
+              fill: false,
+              tension: 0.4
+            },
+            {
+              label: "Spread",
+              data: spreadData,
+              borderColor: "#6c757d",
+              backgroundColor: "rgba(108, 117, 125, 0.1)",
+              fill: false,
+              tension: 0.4
+            },
+            {
+              label: "Trade",
+              data: tradeData,
+              borderColor: "#ffc107",
+              backgroundColor: "rgba(255, 193, 7, 0.1)",
+              fill: false,
+              tension: 0.4
+            },
+            {
+              label: "VWAP",
+              data: vwapData,
+              borderColor: "#17a2b8",
+              backgroundColor: "rgba(23, 162, 184, 0.1)",
+              fill: false,
+              tension: 0.4
+            },
+            {
+              label: "TWAP",
+              data: twapData,
+              borderColor: "#6610f2",
+              backgroundColor: "rgba(102, 16, 242, 0.1)",
+              fill: false,
+              tension: 0.4
+            },
+            {
+              label: "Volume (Normalized)",
+              data: normalizedVolumeData,
+              borderColor: "#007bff",
+              backgroundColor: "rgba(0, 123, 255, 0.1)",
+              fill: true,
+              tension: 0.4
+            }
+          ]
+        },
+        options: {
+          responsive: true,
+          plugins: {
+            title: {
+              display: true,
+              text: `${symbol} Market Data (Volume normalized to 30% of max price)`
+            }
+          },
+          scales: {
+            y: {
+              beginAtZero: false,
+              title: {
+                display: true,
+                text: "Price / Normalized Volume"
+              }
+            }
           }
-          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);
+      };
+      chart.setConfig(config);
+      const imageBuffer = await chart.toBinary();
+      const base64 = imageBuffer.toString("base64");
+      return {
+        content: [
+          {
+            type: "resource",
+            resource: {
+              uri: "resource://graph",
+              mimeType: "image/png",
+              blob: base64
+            }
           }
-        } else {
-          if (!check.inclusive) {
-            res.exclusiveMaximum = true;
+        ]
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${error instanceof Error ? error.message : "Failed to generate graph"}`,
+            uri: "getStockGraph"
           }
-          setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
-        }
-        break;
-      case "multipleOf":
-        setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
-        break;
+        ],
+        isError: true
+      };
     }
-  }
-  return res;
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/object.js
-var import_zod3 = require("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 import_zod3.ZodOptional) {
-        propDef = propDef._def.innerType;
-      }
-      if (!propDef.isNullable()) {
-        propDef = propDef.nullable();
+};
+var createGetStockPriceHistoryHandler = (marketDataPrices) => {
+  return async (args) => {
+    try {
+      const symbol = args.symbol;
+      const priceHistory = marketDataPrices.get(symbol) || [];
+      if (priceHistory.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No price data available for ${symbol}`,
+              uri: "getStockPriceHistory"
+            }
+          ]
+        };
       }
-      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);
+      const aggregatedData = aggregateMarketData(priceHistory, 500);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                symbol,
+                count: aggregatedData.length,
+                originalCount: priceHistory.length,
+                data: aggregatedData.map((point) => ({
+                  timestamp: new Date(point.timestamp).toISOString(),
+                  bid: point.bid,
+                  offer: point.offer,
+                  spread: point.spread,
+                  volume: point.volume,
+                  trade: point.trade,
+                  indexValue: point.indexValue,
+                  openingPrice: point.openingPrice,
+                  closingPrice: point.closingPrice,
+                  settlementPrice: point.settlementPrice,
+                  tradingSessionHighPrice: point.tradingSessionHighPrice,
+                  tradingSessionLowPrice: point.tradingSessionLowPrice,
+                  vwap: point.vwap,
+                  imbalance: point.imbalance,
+                  openInterest: point.openInterest,
+                  compositeUnderlyingPrice: point.compositeUnderlyingPrice,
+                  simulatedSellPrice: point.simulatedSellPrice,
+                  simulatedBuyPrice: point.simulatedBuyPrice,
+                  marginRate: point.marginRate,
+                  midPrice: point.midPrice,
+                  emptyBook: point.emptyBook,
+                  settleHighPrice: point.settleHighPrice,
+                  settleLowPrice: point.settleLowPrice,
+                  priorSettlePrice: point.priorSettlePrice,
+                  sessionHighBid: point.sessionHighBid,
+                  sessionLowOffer: point.sessionLowOffer,
+                  earlyPrices: point.earlyPrices,
+                  auctionClearingPrice: point.auctionClearingPrice,
+                  swapValueFactor: point.swapValueFactor,
+                  dailyValueAdjustmentForLongPositions: point.dailyValueAdjustmentForLongPositions,
+                  cumulativeValueAdjustmentForLongPositions: point.cumulativeValueAdjustmentForLongPositions,
+                  dailyValueAdjustmentForShortPositions: point.dailyValueAdjustmentForShortPositions,
+                  cumulativeValueAdjustmentForShortPositions: point.cumulativeValueAdjustmentForShortPositions,
+                  fixingPrice: point.fixingPrice,
+                  cashRate: point.cashRate,
+                  recoveryRate: point.recoveryRate,
+                  recoveryRateForLong: point.recoveryRateForLong,
+                  recoveryRateForShort: point.recoveryRateForShort,
+                  marketBid: point.marketBid,
+                  marketOffer: point.marketOffer,
+                  shortSaleMinPrice: point.shortSaleMinPrice,
+                  previousClosingPrice: point.previousClosingPrice,
+                  thresholdLimitPriceBanding: point.thresholdLimitPriceBanding,
+                  dailyFinancingValue: point.dailyFinancingValue,
+                  accruedFinancingValue: point.accruedFinancingValue,
+                  twap: point.twap
+                }))
+              },
+              null,
+              2
+            ),
+            uri: "getStockPriceHistory"
+          }
+        ]
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${error instanceof Error ? error.message : "Failed to get price history"}`,
+            uri: "getStockPriceHistory"
+          }
+        ],
+        isError: true
+      };
     }
-  }
-  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
-    ]
-  } : {};
+// src/tools/order.ts
+var import_fixparser2 = require("fixparser");
+var 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"
+};
+var 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"
+};
+var 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"
+};
+var handlInstNames = {
+  "1": "AutomatedExecutionNoIntervention",
+  "2": "AutomatedExecutionInterventionOK",
+  "3": "ManualOrder"
 };
+var createVerifyOrderHandler = (parser, verifiedOrders) => {
+  return async (args) => {
+    try {
+      verifiedOrders.set(args.clOrdID, {
+        clOrdID: args.clOrdID,
+        handlInst: args.handlInst,
+        quantity: Number.parseFloat(String(args.quantity)),
+        price: Number.parseFloat(String(args.price)),
+        ordType: args.ordType,
+        side: args.side,
+        symbol: args.symbol,
+        timeInForce: args.timeInForce
+      });
+      return {
+        content: [
+          {
+            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]})
 
-// ../../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)
+To execute this order, call the executeOrder tool with these exact same parameters. Important: The user has to explicitly confirm before executeOrder is called!`,
+            uri: "verifyOrder"
+          }
+        ]
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${error instanceof Error ? error.message : "Failed to verify order parameters"}`,
+            uri: "verifyOrder"
+          }
+        ],
+        isError: true
+      };
+    }
   };
 };
-
-// ../../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
+var createExecuteOrderHandler = (parser, verifiedOrders, pendingRequests) => {
+  return async (args) => {
+    try {
+      const verifiedOrder = verifiedOrders.get(args.clOrdID);
+      if (!verifiedOrder) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: Order ${args.clOrdID} has not been verified. Please call verifyOrder first.`,
+              uri: "executeOrder"
+            }
+          ],
+          isError: true
+        };
+      }
+      if (verifiedOrder.handlInst !== args.handlInst || verifiedOrder.quantity !== Number.parseFloat(String(args.quantity)) || verifiedOrder.price !== Number.parseFloat(String(args.price)) || verifiedOrder.ordType !== args.ordType || verifiedOrder.side !== args.side || verifiedOrder.symbol !== args.symbol || verifiedOrder.timeInForce !== args.timeInForce) {
+        return {
+          content: [
+            {
+              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) => {
+        pendingRequests.set(args.clOrdID, resolve);
+      });
+      const order = parser.createMessage(
+        new import_fixparser2.Field(import_fixparser2.Fields.MsgType, import_fixparser2.Messages.NewOrderSingle),
+        new import_fixparser2.Field(import_fixparser2.Fields.MsgSeqNum, parser.getNextTargetMsgSeqNum()),
+        new import_fixparser2.Field(import_fixparser2.Fields.SenderCompID, parser.sender),
+        new import_fixparser2.Field(import_fixparser2.Fields.TargetCompID, parser.target),
+        new import_fixparser2.Field(import_fixparser2.Fields.SendingTime, parser.getTimestamp()),
+        new import_fixparser2.Field(import_fixparser2.Fields.ClOrdID, args.clOrdID),
+        new import_fixparser2.Field(import_fixparser2.Fields.Side, args.side),
+        new import_fixparser2.Field(import_fixparser2.Fields.Symbol, args.symbol),
+        new import_fixparser2.Field(import_fixparser2.Fields.OrderQty, Number.parseFloat(String(args.quantity))),
+        new import_fixparser2.Field(import_fixparser2.Fields.Price, Number.parseFloat(String(args.price))),
+        new import_fixparser2.Field(import_fixparser2.Fields.OrdType, args.ordType),
+        new import_fixparser2.Field(import_fixparser2.Fields.HandlInst, args.handlInst),
+        new import_fixparser2.Field(import_fixparser2.Fields.TimeInForce, args.timeInForce),
+        new import_fixparser2.Field(import_fixparser2.Fields.TransactTime, parser.getTimestamp())
+      );
+      if (!parser.connected) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Error: Not connected. Ignoring message.",
+              uri: "executeOrder"
+            }
+          ],
+          isError: true
+        };
+      }
+      parser.send(order);
+      const fixData = await response;
+      verifiedOrders.delete(args.clOrdID);
+      return {
+        content: [
+          {
+            type: "text",
+            text: fixData.messageType === import_fixparser2.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 {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${error instanceof Error ? error.message : "Failed to execute order"}`,
+            uri: "executeOrder"
+          }
+        ],
+        isError: true
+      };
+    }
   };
-  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: {}
+// src/tools/parse.ts
+var createParseHandler = (parser) => {
+  return async (args) => {
+    try {
+      const parsedMessage = parser.parse(args.fixString);
+      if (!parsedMessage || parsedMessage.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Error: Failed to parse FIX string",
+              uri: "parse"
+            }
+          ],
+          isError: true
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: `${parsedMessage[0].description}
+${parsedMessage[0].messageTypeDescription}`,
+            uri: "parse"
+          }
+        ]
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${error instanceof Error ? error.message : "Failed to parse FIX string"}`,
+            uri: "parse"
+          }
+        ],
+        isError: true
+      };
+    }
   };
-}
-
-// ../../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 import_zod4.ZodFirstPartyTypeKind.ZodString:
-      return parseStringDef(def, refs);
-    case import_zod4.ZodFirstPartyTypeKind.ZodNumber:
-      return parseNumberDef(def, refs);
-    case import_zod4.ZodFirstPartyTypeKind.ZodObject:
-      return parseObjectDef(def, refs);
-    case import_zod4.ZodFirstPartyTypeKind.ZodBigInt:
-      return parseBigintDef(def, refs);
-    case import_zod4.ZodFirstPartyTypeKind.ZodBoolean:
-      return parseBooleanDef();
-    case import_zod4.ZodFirstPartyTypeKind.ZodDate:
-      return parseDateDef(def, refs);
-    case import_zod4.ZodFirstPartyTypeKind.ZodUndefined:
-      return parseUndefinedDef();
-    case import_zod4.ZodFirstPartyTypeKind.ZodNull:
-      return parseNullDef(refs);
-    case import_zod4.ZodFirstPartyTypeKind.ZodArray:
-      return parseArrayDef(def, refs);
-    case import_zod4.ZodFirstPartyTypeKind.ZodUnion:
-    case import_zod4.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
-      return parseUnionDef(def, refs);
-    case import_zod4.ZodFirstPartyTypeKind.ZodIntersection:
-      return parseIntersectionDef(def, refs);
-    case import_zod4.ZodFirstPartyTypeKind.ZodTuple:
-      return parseTupleDef(def, refs);
-    case import_zod4.ZodFirstPartyTypeKind.ZodRecord:
-      return parseRecordDef(def, refs);
-    case import_zod4.ZodFirstPartyTypeKind.ZodLiteral:
-      return parseLiteralDef(def, refs);
-    case import_zod4.ZodFirstPartyTypeKind.ZodEnum:
-      return parseEnumDef(def);
-    case import_zod4.ZodFirstPartyTypeKind.ZodNativeEnum:
-      return parseNativeEnumDef(def);
-    case import_zod4.ZodFirstPartyTypeKind.ZodNullable:
-      return parseNullableDef(def, refs);
-    case import_zod4.ZodFirstPartyTypeKind.ZodOptional:
-      return parseOptionalDef(def, refs);
-    case import_zod4.ZodFirstPartyTypeKind.ZodMap:
-      return parseMapDef(def, refs);
-    case import_zod4.ZodFirstPartyTypeKind.ZodSet:
-      return parseSetDef(def, refs);
-    case import_zod4.ZodFirstPartyTypeKind.ZodLazy:
-      return () => def.getter()._def;
-    case import_zod4.ZodFirstPartyTypeKind.ZodPromise:
-      return parsePromiseDef(def, refs);
-    case import_zod4.ZodFirstPartyTypeKind.ZodNaN:
-    case import_zod4.ZodFirstPartyTypeKind.ZodNever:
-      return parseNeverDef();
-    case import_zod4.ZodFirstPartyTypeKind.ZodEffects:
-      return parseEffectsDef(def, refs);
-    case import_zod4.ZodFirstPartyTypeKind.ZodAny:
-      return parseAnyDef();
-    case import_zod4.ZodFirstPartyTypeKind.ZodUnknown:
-      return parseUnknownDef();
-    case import_zod4.ZodFirstPartyTypeKind.ZodDefault:
-      return parseDefaultDef(def, refs);
-    case import_zod4.ZodFirstPartyTypeKind.ZodBranded:
-      return parseBrandedDef(def, refs);
-    case import_zod4.ZodFirstPartyTypeKind.ZodReadonly:
-      return parseReadonlyDef(def, refs);
-    case import_zod4.ZodFirstPartyTypeKind.ZodCatch:
-      return parseCatchDef(def, refs);
-    case import_zod4.ZodFirstPartyTypeKind.ZodPipeline:
-      return parsePipelineDef(def, refs);
-    case import_zod4.ZodFirstPartyTypeKind.ZodFunction:
-    case import_zod4.ZodFirstPartyTypeKind.ZodVoid:
-    case import_zod4.ZodFirstPartyTypeKind.ZodSymbol:
-      return void 0;
-    default:
-      return /* @__PURE__ */ ((_) => void 0)(typeName);
-  }
+// src/tools/parseToJSON.ts
+var createParseToJSONHandler = (parser) => {
+  return async (args) => {
+    try {
+      const parsedMessage = parser.parse(args.fixString);
+      if (!parsedMessage || parsedMessage.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Error: Failed to parse FIX string",
+              uri: "parseToJSON"
+            }
+          ],
+          isError: true
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: `${parsedMessage[0].toFIXJSON()}`,
+            uri: "parseToJSON"
+          }
+        ]
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${error instanceof Error ? error.message : "Failed to parse FIX string"}`,
+            uri: "parseToJSON"
+          }
+        ],
+        isError: true
+      };
+    }
+  };
 };
 
-// ../../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;
+// src/tools/index.ts
+var createToolHandlers = (parser, verifiedOrders, pendingRequests, marketDataPrices) => ({
+  parse: createParseHandler(parser),
+  parseToJSON: createParseToJSONHandler(parser),
+  verifyOrder: createVerifyOrderHandler(parser, verifiedOrders),
+  executeOrder: createExecuteOrderHandler(parser, verifiedOrders, pendingRequests),
+  marketDataRequest: createMarketDataRequestHandler(parser, pendingRequests),
+  getStockGraph: createGetStockGraphHandler(marketDataPrices),
+  getStockPriceHistory: createGetStockPriceHistoryHandler(marketDataPrices),
+  technicalAnalysis: createTechnicalAnalysisHandler(marketDataPrices)
+});
+
+// src/utils/messageHandler.ts
+var import_fixparser3 = require("fixparser");
+function getEnumValue(enumObj, name) {
+  return enumObj[name] || name;
 }
-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 {};
+function handleMessage(message, parser, pendingRequests, marketDataPrices, maxPriceHistory, onPriceUpdate) {
+  const msgType = message.messageType;
+  if (msgType === import_fixparser3.Messages.MarketDataSnapshotFullRefresh || msgType === import_fixparser3.Messages.MarketDataIncrementalRefresh) {
+    const symbol = message.getField(import_fixparser3.Fields.Symbol)?.value;
+    const fixJson = message.toFIXJSON();
+    const entries = fixJson.Body?.NoMDEntries || [];
+    const data = {
+      timestamp: Date.now(),
+      bid: 0,
+      offer: 0,
+      spread: 0,
+      volume: 0,
+      trade: 0,
+      indexValue: 0,
+      openingPrice: 0,
+      closingPrice: 0,
+      settlementPrice: 0,
+      tradingSessionHighPrice: 0,
+      tradingSessionLowPrice: 0,
+      vwap: 0,
+      imbalance: 0,
+      openInterest: 0,
+      compositeUnderlyingPrice: 0,
+      simulatedSellPrice: 0,
+      simulatedBuyPrice: 0,
+      marginRate: 0,
+      midPrice: 0,
+      emptyBook: 0,
+      settleHighPrice: 0,
+      settleLowPrice: 0,
+      priorSettlePrice: 0,
+      sessionHighBid: 0,
+      sessionLowOffer: 0,
+      earlyPrices: 0,
+      auctionClearingPrice: 0,
+      swapValueFactor: 0,
+      dailyValueAdjustmentForLongPositions: 0,
+      cumulativeValueAdjustmentForLongPositions: 0,
+      dailyValueAdjustmentForShortPositions: 0,
+      cumulativeValueAdjustmentForShortPositions: 0,
+      fixingPrice: 0,
+      cashRate: 0,
+      recoveryRate: 0,
+      recoveryRateForLong: 0,
+      recoveryRateForShort: 0,
+      marketBid: 0,
+      marketOffer: 0,
+      shortSaleMinPrice: 0,
+      previousClosingPrice: 0,
+      thresholdLimitPriceBanding: 0,
+      dailyFinancingValue: 0,
+      accruedFinancingValue: 0,
+      twap: 0
+    };
+    for (const entry of entries) {
+      const entryType = entry.MDEntryType;
+      const price = entry.MDEntryPx ? Number.parseFloat(entry.MDEntryPx) : 0;
+      const size = entry.MDEntrySize ? Number.parseFloat(entry.MDEntrySize) : 0;
+      const enumValue = getEnumValue(import_fixparser3.MDEntryType, entryType);
+      switch (enumValue) {
+        case import_fixparser3.MDEntryType.Bid:
+          data.bid = price;
+          break;
+        case import_fixparser3.MDEntryType.Offer:
+          data.offer = price;
+          break;
+        case import_fixparser3.MDEntryType.Trade:
+          data.trade = price;
+          break;
+        case import_fixparser3.MDEntryType.IndexValue:
+          data.indexValue = price;
+          break;
+        case import_fixparser3.MDEntryType.OpeningPrice:
+          data.openingPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.ClosingPrice:
+          data.closingPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.SettlementPrice:
+          data.settlementPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.TradingSessionHighPrice:
+          data.tradingSessionHighPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.TradingSessionLowPrice:
+          data.tradingSessionLowPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.VWAP:
+          data.vwap = price;
+          break;
+        case import_fixparser3.MDEntryType.Imbalance:
+          data.imbalance = size;
+          break;
+        case import_fixparser3.MDEntryType.TradeVolume:
+          data.volume = size;
+          break;
+        case import_fixparser3.MDEntryType.OpenInterest:
+          data.openInterest = size;
+          break;
+        case import_fixparser3.MDEntryType.CompositeUnderlyingPrice:
+          data.compositeUnderlyingPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.SimulatedSellPrice:
+          data.simulatedSellPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.SimulatedBuyPrice:
+          data.simulatedBuyPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.MarginRate:
+          data.marginRate = price;
+          break;
+        case import_fixparser3.MDEntryType.MidPrice:
+          data.midPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.EmptyBook:
+          data.emptyBook = 1;
+          break;
+        case import_fixparser3.MDEntryType.SettleHighPrice:
+          data.settleHighPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.SettleLowPrice:
+          data.settleLowPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.PriorSettlePrice:
+          data.priorSettlePrice = price;
+          break;
+        case import_fixparser3.MDEntryType.SessionHighBid:
+          data.sessionHighBid = price;
+          break;
+        case import_fixparser3.MDEntryType.SessionLowOffer:
+          data.sessionLowOffer = price;
+          break;
+        case import_fixparser3.MDEntryType.EarlyPrices:
+          data.earlyPrices = price;
+          break;
+        case import_fixparser3.MDEntryType.AuctionClearingPrice:
+          data.auctionClearingPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.SwapValueFactor:
+          data.swapValueFactor = price;
+          break;
+        case import_fixparser3.MDEntryType.DailyValueAdjustmentForLongPositions:
+          data.dailyValueAdjustmentForLongPositions = price;
+          break;
+        case import_fixparser3.MDEntryType.CumulativeValueAdjustmentForLongPositions:
+          data.cumulativeValueAdjustmentForLongPositions = price;
+          break;
+        case import_fixparser3.MDEntryType.DailyValueAdjustmentForShortPositions:
+          data.dailyValueAdjustmentForShortPositions = price;
+          break;
+        case import_fixparser3.MDEntryType.CumulativeValueAdjustmentForShortPositions:
+          data.cumulativeValueAdjustmentForShortPositions = price;
+          break;
+        case import_fixparser3.MDEntryType.FixingPrice:
+          data.fixingPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.CashRate:
+          data.cashRate = price;
+          break;
+        case import_fixparser3.MDEntryType.RecoveryRate:
+          data.recoveryRate = price;
+          break;
+        case import_fixparser3.MDEntryType.RecoveryRateForLong:
+          data.recoveryRateForLong = price;
+          break;
+        case import_fixparser3.MDEntryType.RecoveryRateForShort:
+          data.recoveryRateForShort = price;
+          break;
+        case import_fixparser3.MDEntryType.MarketBid:
+          data.marketBid = price;
+          break;
+        case import_fixparser3.MDEntryType.MarketOffer:
+          data.marketOffer = price;
+          break;
+        case import_fixparser3.MDEntryType.ShortSaleMinPrice:
+          data.shortSaleMinPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.PreviousClosingPrice:
+          data.previousClosingPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.ThresholdLimitPriceBanding:
+          data.thresholdLimitPriceBanding = price;
+          break;
+        case import_fixparser3.MDEntryType.DailyFinancingValue:
+          data.dailyFinancingValue = price;
+          break;
+        case import_fixparser3.MDEntryType.AccruedFinancingValue:
+          data.accruedFinancingValue = price;
+          break;
+        case import_fixparser3.MDEntryType.TWAP:
+          data.twap = price;
+          break;
       }
-      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;
+    data.spread = data.offer - data.bid;
+    if (!marketDataPrices.has(symbol)) {
+      marketDataPrices.set(symbol, []);
     }
-  }
-  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
+    const prices = marketDataPrices.get(symbol);
+    prices.push(data);
+    if (prices.length > maxPriceHistory) {
+      prices.splice(0, prices.length - maxPriceHistory);
+    }
+    onPriceUpdate?.(symbol, data);
+    const mdReqID = message.getField(import_fixparser3.Fields.MDReqID)?.value;
+    if (mdReqID) {
+      const callback = pendingRequests.get(mdReqID);
+      if (callback) {
+        callback(message);
+        pendingRequests.delete(mdReqID);
+      }
+    }
+  } else if (msgType === import_fixparser3.Messages.ExecutionReport) {
+    const reqId = message.getField(import_fixparser3.Fields.ClOrdID)?.value;
+    const callback = pendingRequests.get(reqId);
+    if (callback) {
+      callback(message);
+      pendingRequests.delete(reqId);
     }
-  };
-  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
-var import_fixparser = require("fixparser");
-var MCPLocal = class {
-  logger;
-  parser;
+var MCPLocal = class extends MCPBase {
+  /**
+   * Map to store verified orders before execution
+   * @private
+   */
+  verifiedOrders = /* @__PURE__ */ new Map();
+  /**
+   * Map to store pending requests and their callbacks
+   * @private
+   */
+  pendingRequests = /* @__PURE__ */ new Map();
+  /**
+   * Map to store market data prices for each symbol
+   * @private
+   */
+  marketDataPrices = /* @__PURE__ */ new Map();
+  /**
+   * Maximum number of price history entries to keep per symbol
+   * @private
+   */
+  MAX_PRICE_HISTORY = 1e5;
   server = new import_server.Server(
     {
       name: "fixparser",
@@ -1296,48 +2301,28 @@ var MCPLocal = class {
     },
     {
       capabilities: {
-        tools: {
-          listChanged: true
-        },
-        prompts: {
-          listChanged: true
-        },
-        resources: {
-          listChanged: true
-        }
+        tools: Object.entries(toolSchemas).reduce(
+          (acc, [name, { description, schema }]) => {
+            acc[name] = {
+              description,
+              parameters: schema
+            };
+            return acc;
+          },
+          {}
+        )
       }
     }
   );
   transport = new import_stdio.StdioServerTransport();
-  onReady = void 0;
-  pendingRequests = /* @__PURE__ */ new Map();
   constructor({ logger, onReady }) {
-    if (logger) this.logger = logger;
-    if (onReady) this.onReady = onReady;
+    super({ logger, onReady });
   }
   async register(parser) {
     this.parser = parser;
     this.parser.addOnMessageCallback((message) => {
-      this.logger?.log({
-        level: "info",
-        message: `FIXParser (MCP): (${parser.protocol?.toUpperCase()}): << received ${message.description}`
-      });
-      const msgType = message.messageType;
-      if (msgType === import_fixparser.Messages.MarketDataSnapshotFullRefresh || msgType === import_fixparser.Messages.ExecutionReport) {
-        const idField = msgType === import_fixparser.Messages.MarketDataSnapshotFullRefresh ? message.getField(import_fixparser.Fields.MDReqID) : message.getField(import_fixparser.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));
-            }
-          }
-        }
-      }
+      handleMessage(message, this.parser, this.pendingRequests, this.marketDataPrices, this.MAX_PRICE_HISTORY);
     });
-    this.logger = parser.logger;
     this.addWorkflows();
     await this.server.connect(this.transport);
     if (this.onReady) {
@@ -1346,637 +2331,59 @@ 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(import_types.ListResourcesRequestSchema, async () => {
+    this.server.setRequestHandler(import_zod.z.object({ method: import_zod.z.literal("tools/list") }), async () => {
       return {
-        resources: []
-      };
-    });
-    this.server.setRequestHandler(import_types.ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "parse",
-            description: "Parses a FIX message and describes it in plain language",
-            inputSchema: zodToJsonSchema(
-              import_zod5.z.object({
-                fixString: import_zod5.z.string().describe("FIX message string to parse")
-              }),
-              { name: "ParseInput" }
-            )
-          },
-          {
-            name: "parseToJSON",
-            description: "Parses a FIX message into JSON",
-            inputSchema: zodToJsonSchema(
-              import_zod5.z.object({
-                fixString: import_zod5.z.string().describe("FIX message string to parse")
-              }),
-              { name: "ParseToJSONInput" }
-            )
-          },
-          {
-            name: "newOrderSingle",
-            description: "Creates and sends a New Order Single",
-            inputSchema: zodToJsonSchema(
-              import_zod5.z.object({
-                clOrdID: import_zod5.z.string().describe("Client Order ID"),
-                handlInst: import_zod5.z.enum(["1", "2", "3"]).default(import_fixparser.HandlInst.AutomatedExecutionNoIntervention).optional().describe("Handling instruction"),
-                quantity: import_zod5.z.number().describe("Order quantity"),
-                price: import_zod5.z.number().describe("Order price"),
-                ordType: import_zod5.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: import_zod5.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: import_zod5.z.string().describe("Trading symbol"),
-                timeInForce: import_zod5.z.enum(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C"]).default(import_fixparser.TimeInForce.Day).optional().describe("Time in force")
-              }),
-              { name: "NewOrderSingleInput" }
-            )
-          },
-          {
-            name: "marketDataRequest",
-            description: "Sends a request for Market Data with the given symbol",
-            inputSchema: zodToJsonSchema(
-              import_zod5.z.object({
-                mdUpdateType: import_zod5.z.enum(["0", "1"]).default("0").optional().describe("Market data update type"),
-                symbol: import_zod5.z.string().describe("Trading symbol"),
-                mdReqID: import_zod5.z.string().describe("Market data request ID"),
-                subscriptionRequestType: import_zod5.z.enum(["0", "1", "2"]).default(import_fixparser.SubscriptionRequestType.SnapshotAndUpdates).optional().describe("Subscription request type"),
-                mdEntryType: import_zod5.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(import_fixparser.MDEntryType.Bid).optional().describe("Market data entry type")
-              }),
-              { name: "MarketDataRequestInput" }
-            )
-          }
-        ]
+        tools: Object.entries(toolSchemas).map(([name, { description, schema }]) => ({
+          name,
+          description,
+          inputSchema: schema
+        }))
       };
     });
-    this.server.setRequestHandler(import_types.CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-      switch (name) {
-        case "parse": {
-          const { fixString } = import_zod5.z.object({
-            fixString: import_zod5.z.string().describe("FIX message string to parse")
-          }).parse(args || {});
-          try {
-            const parsedMessage = this.parser?.parse(fixString);
-            if (!parsedMessage || parsedMessage.length === 0) {
-              return {
-                isError: true,
-                content: [{ type: "text", text: "Error: Failed to parse FIX string" }]
-              };
-            }
-            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 } = import_zod5.z.object({
-            fixString: import_zod5.z.string().describe("FIX message string to parse")
-          }).parse(args || {});
-          try {
-            const parsedMessage = this.parser?.parse(fixString);
-            if (!parsedMessage || parsedMessage.length === 0) {
-              return {
-                isError: true,
-                content: [{ type: "text", text: "Error: Failed to parse FIX string" }]
-              };
-            }
-            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 } = import_zod5.z.object({
-            clOrdID: import_zod5.z.string().describe("Client Order ID"),
-            handlInst: import_zod5.z.enum(["1", "2", "3"]).default(import_fixparser.HandlInst.AutomatedExecutionNoIntervention).optional().describe("Handling instruction"),
-            quantity: import_zod5.z.number().describe("Order quantity"),
-            price: import_zod5.z.number().describe("Order price"),
-            ordType: import_zod5.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(import_fixparser.OrdType.Market).optional().describe("Order type"),
-            side: import_zod5.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: import_zod5.z.string().describe("Trading symbol"),
-            timeInForce: import_zod5.z.enum(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C"]).default(import_fixparser.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 import_fixparser.Field(import_fixparser.Fields.MsgType, import_fixparser.Messages.NewOrderSingle),
-            new import_fixparser.Field(import_fixparser.Fields.MsgSeqNum, this.parser?.getNextTargetMsgSeqNum()),
-            new import_fixparser.Field(import_fixparser.Fields.SenderCompID, this.parser?.sender),
-            new import_fixparser.Field(import_fixparser.Fields.TargetCompID, this.parser?.target),
-            new import_fixparser.Field(import_fixparser.Fields.SendingTime, this.parser?.getTimestamp()),
-            new import_fixparser.Field(import_fixparser.Fields.ClOrdID, clOrdID),
-            new import_fixparser.Field(import_fixparser.Fields.Side, side),
-            new import_fixparser.Field(import_fixparser.Fields.Symbol, symbol),
-            new import_fixparser.Field(import_fixparser.Fields.OrderQty, quantity),
-            new import_fixparser.Field(import_fixparser.Fields.Price, price),
-            new import_fixparser.Field(import_fixparser.Fields.OrdType, ordType),
-            new import_fixparser.Field(import_fixparser.Fields.HandlInst, handlInst),
-            new import_fixparser.Field(import_fixparser.Fields.TimeInForce, timeInForce),
-            new import_fixparser.Field(import_fixparser.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 "marketDataRequest": {
-          const { mdUpdateType, symbol, mdReqID, subscriptionRequestType, mdEntryType } = import_zod5.z.object({
-            mdUpdateType: import_zod5.z.enum(["0", "1"]).default("0").optional().describe("Market data update type"),
-            symbol: import_zod5.z.string().describe("Trading symbol"),
-            mdReqID: import_zod5.z.string().describe("Market data request ID"),
-            subscriptionRequestType: import_zod5.z.enum(["0", "1", "2"]).default(import_fixparser.SubscriptionRequestType.SnapshotAndUpdates).optional().describe("Subscription request type"),
-            mdEntryType: import_zod5.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(import_fixparser.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 import_fixparser.Field(import_fixparser.Fields.MsgType, import_fixparser.Messages.MarketDataRequest),
-            new import_fixparser.Field(import_fixparser.Fields.SenderCompID, this.parser?.sender),
-            new import_fixparser.Field(import_fixparser.Fields.MsgSeqNum, this.parser?.getNextTargetMsgSeqNum()),
-            new import_fixparser.Field(import_fixparser.Fields.TargetCompID, this.parser?.target),
-            new import_fixparser.Field(import_fixparser.Fields.SendingTime, this.parser?.getTimestamp()),
-            new import_fixparser.Field(import_fixparser.Fields.MarketDepth, 0),
-            new import_fixparser.Field(import_fixparser.Fields.MDUpdateType, mdUpdateType),
-            new import_fixparser.Field(import_fixparser.Fields.NoRelatedSym, 1),
-            new import_fixparser.Field(import_fixparser.Fields.Symbol, symbol),
-            new import_fixparser.Field(import_fixparser.Fields.MDReqID, mdReqID),
-            new import_fixparser.Field(import_fixparser.Fields.SubscriptionRequestType, subscriptionRequestType),
-            new import_fixparser.Field(import_fixparser.Fields.NoMDEntryTypes, 1),
-            new import_fixparser.Field(import_fixparser.Fields.MDEntryType, mdEntryType)
-          );
-          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(marketDataRequest);
-          this.logger?.log({
-            level: "info",
-            message: `FIXParser (MCP): (${this.parser?.protocol?.toUpperCase()}): >> sent ${marketDataRequest?.description}`
-          });
-          const fixData = await response;
+    this.server.setRequestHandler(
+      import_zod.z.object({
+        method: import_zod.z.literal("tools/call"),
+        params: import_zod.z.object({
+          name: import_zod.z.string(),
+          arguments: import_zod.z.any(),
+          _meta: import_zod.z.object({
+            progressToken: import_zod.z.number()
+          }).optional()
+        })
+      }),
+      async (request) => {
+        const { name, arguments: args } = request.params;
+        const toolHandlers = createToolHandlers(
+          this.parser,
+          this.verifiedOrders,
+          this.pendingRequests,
+          this.marketDataPrices
+        );
+        const handler = toolHandlers[name];
+        if (!handler) {
           return {
             content: [
               {
                 type: "text",
-                text: `Market data for ${symbol}: ${JSON.stringify(fixData.toFIXJSON())}`
-              }
-            ]
-          };
-        }
-        default:
-          throw new Error(`Unknown tool: ${name}`);
-      }
-    });
-    this.server.setRequestHandler(import_types.ListPromptsRequestSchema, async () => {
-      return {
-        prompts: [
-          {
-            name: "parse",
-            description: "Parses a FIX message and describes it in plain language",
-            arguments: [
-              {
-                name: "fixString",
-                description: "FIX message string to parse",
-                required: true
-              }
-            ]
-          },
-          {
-            name: "parseToJSON",
-            description: "Parses a FIX message into JSON",
-            arguments: [
-              {
-                name: "fixString",
-                description: "FIX message string to parse",
-                required: true
-              }
-            ]
-          },
-          {
-            name: "newOrderSingle",
-            description: "Creates and sends a New Order Single",
-            arguments: [
-              {
-                name: "clOrdID",
-                description: "Client Order ID",
-                required: true
-              },
-              {
-                name: "handlInst",
-                description: "Handling instruction",
-                required: false
-              },
-              {
-                name: "quantity",
-                description: "Order quantity",
-                required: true
-              },
-              {
-                name: "price",
-                description: "Order price",
-                required: true
-              },
-              {
-                name: "ordType",
-                description: "Order type",
-                required: false
-              },
-              {
-                name: "side",
-                description: "Order side (1=Buy, 2=Sell)",
-                required: true
-              },
-              {
-                name: "symbol",
-                description: "Trading symbol",
-                required: true
-              },
-              {
-                name: "timeInForce",
-                description: "Time in force",
-                required: false
-              }
-            ]
-          },
-          {
-            name: "marketDataRequest",
-            description: "Sends a request for Market Data with the given symbol",
-            arguments: [
-              {
-                name: "mdUpdateType",
-                description: "Market data update type",
-                required: false
-              },
-              {
-                name: "symbol",
-                description: "Trading symbol",
-                required: true
-              },
-              {
-                name: "mdReqID",
-                description: "Market data request ID",
-                required: true
-              },
-              {
-                name: "subscriptionRequestType",
-                description: "Subscription request type",
-                required: false
-              },
-              {
-                name: "mdEntryType",
-                description: "Market data entry type",
-                required: false
-              }
-            ]
-          }
-        ]
-      };
-    });
-    this.server.setRequestHandler(import_types.GetPromptRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-      switch (name) {
-        case "parse": {
-          const fixString = args?.fixString || "";
-          return {
-            messages: [
-              {
-                role: "user",
-                content: {
-                  type: "text",
-                  text: `Please parse and explain this FIX message: ${fixString}`
-                }
-              }
-            ]
-          };
-        }
-        case "parseToJSON": {
-          const fixString = args?.fixString || "";
-          return {
-            messages: [
-              {
-                role: "user",
-                content: {
-                  type: "text",
-                  text: `Please parse the FIX message to JSON: ${fixString}`
-                }
-              }
-            ]
-          };
-        }
-        case "newOrderSingle": {
-          const { clOrdID, handlInst, quantity, price, ordType, side, symbol, timeInForce } = args || {};
-          return {
-            messages: [
-              {
-                role: "user",
-                content: {
-                  type: "text",
-                  text: [
-                    "Create a New Order Single FIX message with the following parameters:",
-                    `- ClOrdID: ${clOrdID}`,
-                    `- HandlInst: ${handlInst ?? "default"}`,
-                    `- Quantity: ${quantity}`,
-                    `- Price: ${price}`,
-                    `- OrdType: ${ordType ?? "default (Market)"}`,
-                    `- Side: ${side}`,
-                    `- Symbol: ${symbol}`,
-                    `- TimeInForce: ${timeInForce ?? "default (Day)"}`,
-                    "",
-                    "Format the response as a JSON object with FIX tag numbers as keys and their corresponding values."
-                  ].join("\n")
-                }
+                text: `Tool not found: ${name}`,
+                uri: name
               }
-            ]
-          };
-        }
-        case "marketDataRequest": {
-          const { mdUpdateType, symbol, mdReqID, subscriptionRequestType, mdEntryType } = args || {};
-          return {
-            messages: [
-              {
-                role: "user",
-                content: {
-                  type: "text",
-                  text: [
-                    "Create a Market Data Request FIX message with the following parameters:",
-                    `- MDUpdateType: ${mdUpdateType ?? "default (0 = FullRefresh)"}`,
-                    `- Symbol: ${symbol}`,
-                    `- MDReqID: ${mdReqID}`,
-                    `- SubscriptionRequestType: ${subscriptionRequestType ?? "default (0 = Snapshot + Updates)"}`,
-                    `- MDEntryType: ${mdEntryType ?? "default (0 = Bid)"}`,
-                    "",
-                    "Format the response as a JSON object with FIX tag numbers as keys and their corresponding values."
-                  ].join("\n")
-                }
-              }
-            ]
+            ],
+            isError: true
           };
         }
-        default:
-          throw new Error(`Unknown prompt: ${name}`);
+        const result = await handler(args);
+        return {
+          content: result.content,
+          isError: result.isError
+        };
       }
-    });
+    );
     process.on("SIGINT", async () => {
       await this.server.close();
       process.exit(0);