@agentwares/agentguard 0.1.6 → 0.1.9

package/dist/fixtures/crm-server.js

@@ -1,1277 +1,11 @@
 #!/usr/bin/env node
-
-// ../../packages/mcp-kit/dist/chunk-7LRFDQNC.js
-import { completable } from "@modelcontextprotocol/sdk/server/completable.js";
-import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import {
-  CreateMessageResultSchema,
-  ElicitResultSchema,
-  SubscribeRequestSchema,
-  UnsubscribeRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
-import { z } from "zod";
-
-// ../../packages/x402/dist/index.js
-var USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
-var USDC_DECIMALS = 6;
-var USDC_EIP712_DOMAIN = { name: "USD Coin", version: "2" };
-function toAtomicUnits(amountUsd, decimals = USDC_DECIMALS) {
-  const trimmed = amountUsd.trim();
-  if (!/^\d+(\.\d+)?$/.test(trimmed)) throw new Error(`not a decimal amount: ${amountUsd}`);
-  const [whole = "0", fraction = ""] = trimmed.split(".");
-  if (fraction.length > decimals) {
-    throw new Error(`${amountUsd} has more than ${decimals} decimal places`);
-  }
-  return `${whole}${fraction.padEnd(decimals, "0")}`.replace(/^0+(?=\d)/, "");
-}
-var DEFAULT_X402_NETWORK = "eip155:8453";
-var X402_HEADER = "X-Payment-Requirements";
-var X402_REQUIRED_HEADER = "PAYMENT-REQUIRED";
-function toAmount(priceUsd) {
-  if (!Number.isFinite(priceUsd) || priceUsd < 0)
-    throw new Error("priceUsd must be a non-negative number");
-  return priceUsd.toFixed(6).replace(/0+$/, "").replace(/\.$/, ".0");
-}
-function buildPaymentRequired(opts) {
-  const amountUsd = toAmount(opts.priceUsd);
-  const creditsPayTo = opts.creditsPayTo ?? opts.selfServe?.keysUrl;
-  const accepts = [];
-  if (opts.payTo) {
-    accepts.push({
-      rail: "x402",
-      scheme: "exact",
-      amountUsd,
-      amount: toAtomicUnits(amountUsd, opts.assetDecimals),
-      resource: opts.resource,
-      description: opts.description,
-      mimeType: "application/json",
-      network: opts.network ?? DEFAULT_X402_NETWORK,
-      asset: opts.asset ?? USDC_BASE,
-      extra: opts.assetDomain ?? USDC_EIP712_DOMAIN,
-      payTo: opts.payTo,
-      maxTimeoutSeconds: 300,
-      ...opts.bazaar ? { bazaar: opts.bazaar } : {}
-    });
-  }
-  if (creditsPayTo) {
-    accepts.push({
-      rail: "prepaid_credits",
-      amountUsd,
-      resource: opts.resource,
-      description: opts.description,
-      currency: "usd",
-      payTo: creditsPayTo,
-      maxTimeoutSeconds: 300,
-      // funding a balance ends at a hosted Stripe Checkout page, which an agent cannot fill in
-      humanRequired: true
-    });
-  }
-  const live = opts.live === true;
-  const selfServe = opts.selfServe;
-  const x402Rail = accepts.find((a) => a.rail === "x402" && a.payTo);
-  const usdcFix = x402Rail ? `Pay in USDC with no account and no human: take the \`accepts\` entry with \`rail: "x402"\`, sign an EIP-3009 transferWithAuthorization for ${x402Rail.amountUsd} USDC to ${x402Rail.payTo} on ${x402Rail.network}, and retry with it base64 in the X-PAYMENT header. The facilitator submits the transfer, so you need USDC and no gas. ` : "";
-  const sampleFix = opts.sampleMode ? "Free first: retry with sample=true \u2014 no key, no payment. " : "";
-  const cardFix = selfServe ? `Or pay by card: POST ${selfServe.keysUrl} (no auth, no signup) returns a key and a Stripe Checkout URL. Funding that key needs a person at a browser; if you are running unattended, surface the URL to your operator rather than retrying, or use the USDC rail above. Once funded, send Authorization: Bearer <key>, plus Idempotency-Key so a repeated call is charged once.` : "";
-  const liveFix = usdcFix || cardFix ? `${sampleFix}${usdcFix}${cardFix}`.trim() : "Retry with a PAYMENT header satisfying one of `accepts`, or send an API key with credit balance.";
-  const body = {
-    code: "PAYMENT_REQUIRED",
-    cause: live ? `This call costs $${amountUsd}. No valid payment or credit was presented.` : `This call costs $${amountUsd}. Pay-per-call (x402 / Stripe MPP) is coming soon; use an API key with prepaid credits.`,
-    fix: live ? liveFix : `Create an API key${opts.signupUrl ? ` at ${opts.signupUrl}` : ""} and retry with Authorization: Bearer <key>. Try the free sample mode first.`,
-    retryable: true,
-    priceUsd: opts.priceUsd,
-    accepts,
-    comingSoon: !live,
-    alternatives: [
-      ...creditsPayTo ? ["api_key_credits"] : [],
-      ...opts.sampleMode ? ["sample_mode"] : []
-    ],
-    ...selfServe ? { selfServe } : {},
-    ...opts.bazaar ? { extensions: { bazaar: opts.bazaar } } : {}
-  };
-  const encoded = JSON.stringify({
-    x402Version: 2,
-    accepts,
-    resource: opts.resource,
-    ...opts.bazaar ? { extensions: { bazaar: opts.bazaar } } : {}
-  });
-  const headers = {
-    "Content-Type": "application/json",
-    "WWW-Authenticate": `Payment realm="agentwares", methods="x402 prepaid_credits", price="${amountUsd} USD"`,
-    [X402_HEADER]: encoded,
-    [X402_REQUIRED_HEADER]: btoa(encoded),
-    "Cache-Control": "no-store"
-  };
-  return { status: 402, headers, body };
-}
-var StubVerifier = class {
-  async verify(request, requirement) {
-    const hasHeader = request.headers.has("PAYMENT") || request.headers.has("X-PAYMENT");
-    return {
-      ok: false,
-      rail: requirement.rail,
-      reason: hasHeader ? "payments are not live yet (phase 2: wallet). Use an API key with credits." : "no payment header present"
-    };
-  }
-};
-
-// ../../packages/mcp-kit/dist/chunk-7LRFDQNC.js
-import { z as z2 } from "zod";
-import { z as z3 } from "zod";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import {
-  CallToolRequestSchema,
-  ErrorCode,
-  ListToolsRequestSchema,
-  McpError
-} from "@modelcontextprotocol/sdk/types.js";
-import { z as z4 } from "zod";
-import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
-var ERROR_CODES = [
-  "INVALID_INPUT",
-  "NOT_FOUND",
-  "UNAUTHORIZED",
-  "PAYMENT_REQUIRED",
-  "RATE_LIMITED",
-  "UPSTREAM_ERROR",
-  "INTERNAL"
-];
-var DEFAULT_RETRYABLE = {
-  INVALID_INPUT: false,
-  NOT_FOUND: false,
-  UNAUTHORIZED: false,
-  PAYMENT_REQUIRED: true,
-  RATE_LIMITED: true,
-  UPSTREAM_ERROR: true,
-  INTERNAL: false
-};
-var DEFAULT_HTTP_STATUS = {
-  INVALID_INPUT: 400,
-  NOT_FOUND: 404,
-  UNAUTHORIZED: 401,
-  PAYMENT_REQUIRED: 402,
-  RATE_LIMITED: 429,
-  UPSTREAM_ERROR: 502,
-  INTERNAL: 500
-};
-var INTERNAL_FIX = "retry; if it persists, report the request id";
-function isStandardCode(code) {
-  return ERROR_CODES.includes(code);
-}
-var McpToolError = class extends Error {
-  code;
-  cause;
-  fix;
-  retryable;
-  details;
-  httpStatus;
-  extra;
-  constructor(init) {
-    super(`${init.code}: ${init.cause}`);
-    this.name = "McpToolError";
-    this.code = init.code;
-    this.cause = init.cause;
-    this.fix = init.fix;
-    this.retryable = init.retryable ?? (isStandardCode(init.code) ? DEFAULT_RETRYABLE[init.code] : false);
-    this.details = init.details;
-    this.httpStatus = init.httpStatus ?? (isStandardCode(init.code) ? DEFAULT_HTTP_STATUS[init.code] : 500);
-    this.extra = init.extra;
-  }
-  /** The body agents see: `{ code, cause, fix, retryable, details?, ...extra }`. */
-  toJSON() {
-    const body = {
-      ...this.extra,
-      code: this.code,
-      cause: this.cause,
-      fix: this.fix,
-      retryable: this.retryable
-    };
-    if (this.details !== void 0) body.details = this.details;
-    return body;
-  }
-};
-function toolError(codeOrInit, cause, fix, extra) {
-  if (typeof codeOrInit === "object") return new McpToolError(codeOrInit);
-  return new McpToolError({ code: codeOrInit, cause: cause ?? "", fix: fix ?? "", ...extra });
-}
-function describeUnknown(err) {
-  if (err instanceof Error) return err.message || err.name;
-  if (typeof err === "string") return err;
-  try {
-    return JSON.stringify(err);
-  } catch {
-    return String(err);
-  }
-}
-function normalizeError(err) {
-  if (err instanceof McpToolError) return err;
-  return new McpToolError({
-    code: "INTERNAL",
-    cause: describeUnknown(err),
-    fix: INTERNAL_FIX,
-    retryable: false
-  });
-}
-function errorResult(err, opts = {}) {
-  const error = normalizeError(err);
-  const body = error.toJSON();
-  const meta = { httpStatus: error.httpStatus };
-  if (opts.requestId !== void 0) meta.requestId = opts.requestId;
-  Object.assign(meta, opts.meta);
-  return {
-    isError: true,
-    content: [{ type: "text", text: JSON.stringify(body) }],
-    structuredContent: body,
-    _meta: meta
-  };
-}
-var TOOL_NAME_PATTERN = /^[a-z][a-z0-9]*(_[a-z0-9]+)+$/;
-var MIN_NAMESPACE_LENGTH = 3;
-var MIN_DESCRIPTION_LENGTH = 20;
-function isValidToolName(name) {
-  if (!TOOL_NAME_PATTERN.test(name)) return false;
-  const namespace = name.split("_")[0] ?? "";
-  return namespace.length >= MIN_NAMESPACE_LENGTH;
-}
-function assertToolName(name) {
-  if (!isValidToolName(name)) {
-    throw new Error(
-      `tool name must be namespaced: <namespace>_<verb>_<object>, got ${JSON.stringify(name)}`
-    );
-  }
-}
-function isPlainObject(value) {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-}
-function isCallToolResult(value) {
-  if (!isPlainObject(value) || !Array.isArray(value.content)) return false;
-  return value.content.every(
-    (block) => isPlainObject(block) && typeof block.type === "string"
-  );
-}
-function toCallToolResult(value) {
-  if (isCallToolResult(value)) return value;
-  const text = typeof value === "string" ? value : JSON.stringify(value ?? null, null, 2);
-  const result = { content: [{ type: "text", text }] };
-  if (isPlainObject(value)) result.structuredContent = value;
-  return result;
-}
-function issuePath(issue) {
-  return issue.path.map(String).join(".") || "(root)";
-}
-function invalidInputError(issues) {
-  const fields = [...new Set(issues.map(issuePath))];
-  const summary = issues.map((issue) => `${issuePath(issue)}: ${issue.message}`).join("; ");
-  return toolError({
-    code: "INVALID_INPUT",
-    cause: `invalid input for ${fields.join(", ")} \u2014 ${summary}`,
-    fix: `fix ${fields.join(", ")} to match the tool's inputSchema (see details.issues), then retry`,
-    retryable: false,
-    details: {
-      fields,
-      issues: issues.map((issue) => ({
-        path: issue.path.map(String),
-        code: issue.code,
-        message: issue.message
-      }))
-    }
-  });
-}
-function defineTool(opts) {
-  assertToolName(opts.name);
-  if (typeof opts.description !== "string" || opts.description.trim().length < MIN_DESCRIPTION_LENGTH) {
-    throw new Error(
-      `tool ${opts.name}: description must be at least ${MIN_DESCRIPTION_LENGTH} characters \u2014 say what it does, when to use it and what it returns`
-    );
-  }
-  const { name, title, description, input, output, annotations } = opts;
-  const handler = opts.handler.bind(opts);
-  const tool = {
-    name,
-    title,
-    description,
-    input,
-    output,
-    annotations,
-    handler,
-    async invoke(rawInput, ctx) {
-      const fail = (err) => {
-        const result = errorResult(err, { requestId: ctx.requestId });
-        if (output) delete result.structuredContent;
-        return result;
-      };
-      const parsed = input.safeParse(rawInput ?? {});
-      if (!parsed.success) return fail(invalidInputError(parsed.error.issues));
-      try {
-        const value = await handler(parsed.data, ctx);
-        if (output && !isCallToolResult(value)) {
-          const checked = output.safeParse(value);
-          if (!checked.success) {
-            throw toolError({
-              code: "INTERNAL",
-              cause: `tool ${name} returned a value that does not match its output schema \u2014 ${checked.error.issues.map((issue) => `${issuePath(issue)}: ${issue.message}`).join("; ")}`,
-              fix: "this is a bug in the tool, not in your call; report it with the request id",
-              retryable: false,
-              details: { issues: checked.error.issues }
-            });
-          }
-          return toCallToolResult(checked.data);
-        }
-        return toCallToolResult(value);
-      } catch (err) {
-        return fail(err);
-      }
-    }
-  };
-  return tool;
-}
-var PNG_BASE64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";
-var WAV_BASE64 = "UklGRiQAAABXQVZFZm10IBAAAAABAAEARKwAAIhYAQACABAAZGF0YQAAAAA=";
-var STATIC_TEXT_URI = "test://static-text";
-var STATIC_TEXT = "This is a static text resource for testing.";
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-function embeddedResource() {
-  return {
-    type: "resource",
-    resource: { uri: STATIC_TEXT_URI, mimeType: "text/plain", text: STATIC_TEXT }
-  };
-}
-function requireExtra(ctx) {
-  if (!ctx.extra) {
-    throw toolError("INTERNAL", "no client connection in this context", "call this tool over MCP");
-  }
-  return ctx.extra;
-}
-async function elicit(ctx, message, requestedSchema) {
-  const result = await requireExtra(ctx).sendRequest(
-    { method: "elicitation/create", params: { message, requestedSchema } },
-    ElicitResultSchema
-  );
-  return `Elicitation completed: action=${result.action}, content=${JSON.stringify(result.content ?? {})}`;
-}
-var conformanceTools = [
-  defineTool({
-    name: "test_simple_text",
-    description: "Conformance fixture: returns a fixed simple text response.",
-    input: z.object({}),
-    handler: () => "This is a simple text response for testing."
-  }),
-  defineTool({
-    name: "test_error_handling",
-    description: "Conformance fixture: always returns an error result (isError: true).",
-    input: z.object({}),
-    handler: () => {
-      throw toolError({
-        code: "UPSTREAM_ERROR",
-        cause: "This tool intentionally returns an error for testing",
-        fix: "nothing to fix; this fixture always fails",
-        retryable: false
-      });
-    }
-  }),
-  defineTool({
-    name: "test_image_content",
-    description: "Conformance fixture: returns a 1x1 PNG image content block.",
-    input: z.object({}),
-    handler: () => ({ content: [{ type: "image", data: PNG_BASE64, mimeType: "image/png" }] })
-  }),
-  defineTool({
-    name: "test_audio_content",
-    description: "Conformance fixture: returns an empty WAV audio content block.",
-    input: z.object({}),
-    handler: () => ({ content: [{ type: "audio", data: WAV_BASE64, mimeType: "audio/wav" }] })
-  }),
-  defineTool({
-    name: "test_embedded_resource",
-    description: "Conformance fixture: returns an embedded text resource content block.",
-    input: z.object({}),
-    handler: () => ({ content: [embeddedResource()] })
-  }),
-  defineTool({
-    name: "test_multiple_content_types",
-    description: "Conformance fixture: returns text, image and resource content blocks together.",
-    input: z.object({}),
-    handler: () => ({
-      content: [
-        { type: "text", text: "Mixed content response" },
-        { type: "image", data: PNG_BASE64, mimeType: "image/png" },
-        embeddedResource()
-      ]
-    })
-  }),
-  defineTool({
-    name: "test_tool_with_logging",
-    description: "Conformance fixture: emits three info log notifications while running.",
-    input: z.object({}),
-    handler: async (_input, ctx) => {
-      await ctx.log?.("info", "Tool execution started");
-      await sleep(50);
-      await ctx.log?.("info", "Tool processing data");
-      await sleep(50);
-      await ctx.log?.("info", "Tool execution completed");
-      return "Tool execution completed with logging";
-    }
-  }),
-  defineTool({
-    name: "test_tool_with_progress",
-    description: "Conformance fixture: reports progress 0/100, 50/100, 100/100 while running.",
-    input: z.object({}),
-    handler: async (_input, ctx) => {
-      await ctx.progress?.(0, 100, "starting");
-      await sleep(50);
-      await ctx.progress?.(50, 100, "halfway");
-      await sleep(50);
-      await ctx.progress?.(100, 100, "done");
-      return "Tool execution completed with progress";
-    }
-  }),
-  defineTool({
-    name: "test_sampling",
-    description: "Conformance fixture: asks the client to sample a completion and returns it.",
-    input: z.object({ prompt: z.string().describe("Prompt to send to the client's model") }),
-    handler: async ({ prompt }, ctx) => {
-      const result = await requireExtra(ctx).sendRequest(
-        {
-          method: "sampling/createMessage",
-          params: {
-            messages: [{ role: "user", content: { type: "text", text: prompt } }],
-            maxTokens: 100
-          }
-        },
-        CreateMessageResultSchema
-      );
-      const content = Array.isArray(result.content) ? result.content[0] : result.content;
-      const text = content && content.type === "text" ? content.text : JSON.stringify(content);
-      return `Sampling completed (${result.model}): ${text}`;
-    }
-  }),
-  defineTool({
-    name: "test_elicitation",
-    description: "Conformance fixture: asks the client for user input and reports the outcome.",
-    input: z.object({ message: z.string().describe("Message shown to the user") }),
-    handler: ({ message }, ctx) => elicit(ctx, message, {
-      type: "object",
-      properties: {
-        name: { type: "string", title: "Name", description: "Your name" },
-        email: { type: "string", title: "Email", format: "email" }
-      },
-      required: ["name"]
-    })
-  }),
-  defineTool({
-    name: "test_elicitation_sep1034_defaults",
-    description: "Conformance fixture: elicitation schema with defaults for every primitive type.",
-    input: z.object({}),
-    handler: (_input, ctx) => elicit(ctx, "Please confirm your details", {
-      type: "object",
-      properties: {
-        name: { type: "string", title: "Name", default: "John Doe" },
-        age: { type: "integer", title: "Age", default: 30 },
-        score: { type: "number", title: "Score", default: 95.5 },
-        status: {
-          type: "string",
-          title: "Status",
-          enum: ["active", "inactive", "pending"],
-          default: "active"
-        },
-        verified: { type: "boolean", title: "Verified", default: true }
-      }
-    })
-  }),
-  defineTool({
-    name: "test_elicitation_sep1330_enums",
-    description: "Conformance fixture: elicitation schema with titled, untitled and multi-select enums.",
-    input: z.object({}),
-    handler: (_input, ctx) => elicit(ctx, "Pick some options", {
-      type: "object",
-      properties: {
-        untitledSingle: {
-          type: "string",
-          title: "Untitled single",
-          enum: ["red", "green", "blue"]
-        },
-        titledSingle: {
-          type: "string",
-          title: "Titled single",
-          oneOf: [
-            { const: "red", title: "Red" },
-            { const: "green", title: "Green" },
-            { const: "blue", title: "Blue" }
-          ]
-        },
-        legacyEnum: {
-          type: "string",
-          title: "Legacy titled",
-          enum: ["red", "green", "blue"],
-          enumNames: ["Red", "Green", "Blue"]
-        },
-        untitledMulti: {
-          type: "array",
-          title: "Untitled multi",
-          items: { type: "string", enum: ["red", "green", "blue"] }
-        },
-        titledMulti: {
-          type: "array",
-          title: "Titled multi",
-          items: {
-            anyOf: [
-              { const: "red", title: "Red" },
-              { const: "green", title: "Green" },
-              { const: "blue", title: "Blue" }
-            ]
-          }
-        }
-      }
-    })
-  }),
-  defineTool({
-    name: "json_schema_2020_12_tool",
-    description: "Conformance fixture: input schema with a $defs reference to an address object.",
-    input: z.object({
-      name: z.string(),
-      address: z.object({ street: z.string(), city: z.string() }).meta({ id: "address" })
-    }),
-    handler: (input) => input
-  })
-];
-function paymentRequiredError(body, reason) {
-  const { code, cause, fix, retryable, ...rest } = body;
-  return toolError({
-    code,
-    cause,
-    fix,
-    retryable,
-    httpStatus: 402,
-    details: reason !== void 0 ? { reason } : void 0,
-    extra: rest
-  });
-}
-function formatUsd(priceUsd) {
-  return priceUsd.toFixed(6).replace(/0+$/, "").replace(/\.$/, ".00").replace(/\.(\d)$/, ".$10");
-}
-function withPayment(tool, opts) {
-  if (!Number.isFinite(opts.priceUsd) || opts.priceUsd < 0) {
-    throw new Error(`withPayment(${tool.name}): priceUsd must be a non-negative number`);
-  }
-  const sampleField = opts.sampleField ?? "sample";
-  if (sampleField in tool.input.shape) {
-    throw new Error(
-      `withPayment(${tool.name}): input already has a field named ${JSON.stringify(sampleField)}; pass sampleField to rename it`
-    );
-  }
-  const verifier = opts.verifier ?? new StubVerifier();
-  const liveRail = opts.verifier !== void 0;
-  const input = tool.input.extend({
-    [sampleField]: z2.boolean().default(false).describe(
-      "Set true to return an example response at no charge (sample mode). Default false."
-    )
-  });
-  const description = `${tool.description.trim()} Paid: $${formatUsd(opts.priceUsd)} per call; without credit you get a PAYMENT_REQUIRED result. Set ${sampleField}=true for a free example response.`;
-  return defineTool({
-    name: tool.name,
-    title: tool.title,
-    description,
-    input,
-    output: tool.output,
-    annotations: tool.annotations,
-    async handler(raw, ctx) {
-      const record = { ...raw };
-      const sample = record[sampleField] === true;
-      delete record[sampleField];
-      if (sample) return tool.handler(record, { ...ctx, sample: true });
-      let reason;
-      if (opts.authorize) {
-        const auth = await opts.authorize(ctx);
-        if (auth.ok) return tool.handler(record, { ...ctx, userId: auth.userId });
-        reason = auth.reason;
-      }
-      const resource = ctx.resourceUrl ?? tool.name;
-      const required = buildPaymentRequired({
-        resource,
-        priceUsd: opts.priceUsd,
-        live: opts.live,
-        description: opts.description,
-        payTo: opts.payTo,
-        creditsPayTo: opts.creditsPayTo,
-        signupUrl: opts.signupUrl,
-        selfServe: opts.selfServe,
-        // withPayment always adds a free `sample` flag to the tool's input schema
-        sampleMode: true,
-        ...opts.bazaar ? { bazaar: opts.bazaar } : {}
-      });
-      const advertised = required.body.accepts.find((a) => a.rail === "prepaid_credits") ?? required.body.accepts[0];
-      const requirement = advertised ?? {
-        rail: "prepaid_credits",
-        amountUsd: String(required.body.priceUsd),
-        resource,
-        ...opts.description ? { description: opts.description } : {}
-      };
-      const verified = await verifier.verify(
-        new Request(`https://mcp.local/${tool.name}`, { headers: ctx.headers }),
-        requirement
-      );
-      if (verified.ok) {
-        let result;
-        try {
-          result = await tool.handler(record, ctx);
-        } catch (error) {
-          await opts.onPaidFailure?.(ctx, verified, error);
-          throw error;
-        }
-        const settled = await verifier.settle?.(verified);
-        if (settled && !settled.ok) {
-          opts.onSettlementFailure?.(ctx, verified, settled.reason);
-        }
-        return result;
-      }
-      reason = liveRail ? verified.reason ?? reason : reason ?? verified.reason;
-      throw paymentRequiredError(required.body, reason);
-    }
-  });
-}
-var exampleEcho = defineTool({
-  name: "example_echo",
-  title: "Echo",
-  description: "Echo a message back unchanged. Use it to check the connection and to see the result shape mcp-kit tools return (JSON text plus structuredContent).",
-  input: z3.object({ message: z3.string().describe("Text to echo back") }),
-  output: z3.object({ message: z3.string() }),
-  annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
-  handler: ({ message }) => ({ message })
-});
-var exampleAdd = defineTool({
-  name: "example_add",
-  title: "Add",
-  description: "Add two numbers and return their sum as { sum }. Demonstrates typed input and output schemas; send non-numbers to see an INVALID_INPUT error result.",
-  input: z3.object({
-    a: z3.number().describe("First addend"),
-    b: z3.number().describe("Second addend")
-  }),
-  output: z3.object({ sum: z3.number() }),
-  annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
-  handler: ({ a, b }) => ({ sum: a + b })
-});
-var examplePaidLookup = withPayment(
-  defineTool({
-    name: "example_paid_lookup",
-    title: "Paid lookup",
-    description: "Look up a record by query and return { query, result, sample } (fake data). Demonstrates a paid tool: without an entitlement the call returns a PAYMENT_REQUIRED result with x402 and MPP payment options.",
-    input: z3.object({ query: z3.string().min(1).describe("What to look up") }),
-    output: z3.object({ query: z3.string(), result: z3.string(), sample: z3.boolean() }),
-    annotations: { readOnlyHint: true, idempotentHint: true },
-    handler: ({ query }, ctx) => ({
-      query,
-      result: ctx.sample ? `SAMPLE: example record for "${query}"` : `record for "${query}"`,
-      sample: ctx.sample === true
-    })
-  }),
-  { priceUsd: 0.05, description: "One record lookup" }
-);
-function isZodObject(schema) {
-  return schema instanceof z4.ZodObject;
-}
-function contextFromExtra(extra) {
-  const headers = new Headers();
-  const raw = extra.requestInfo?.headers;
-  if (raw) {
-    for (const [key, value] of Object.entries(raw)) {
-      if (Array.isArray(value)) for (const item of value) headers.append(key, item);
-      else if (typeof value === "string") headers.append(key, value);
-    }
-  }
-  const progressToken = extra._meta?.progressToken;
-  return {
-    headers,
-    requestId: String(extra.requestId),
-    signal: extra.signal,
-    sessionId: extra.sessionId,
-    meta: extra._meta,
-    extra,
-    log: async (level, data) => {
-      await extra.sendNotification({ method: "notifications/message", params: { level, data } });
-    },
-    progress: async (progress, total, message) => {
-      if (progressToken === void 0) return;
-      await extra.sendNotification({
-        method: "notifications/progress",
-        params: { progressToken, progress, total, message }
-      });
-    }
-  };
-}
-function createMcpServer(opts) {
-  const byName = /* @__PURE__ */ new Map();
-  for (const tool of opts.tools) {
-    if (byName.has(tool.name)) throw new Error(`duplicate tool name: ${tool.name}`);
-    byName.set(tool.name, tool);
-  }
-  const server = new McpServer(
-    { name: opts.name, version: opts.version, title: opts.title, websiteUrl: opts.websiteUrl },
-    { instructions: opts.instructions, capabilities: { logging: {}, ...opts.capabilities } }
-  );
-  const registered = /* @__PURE__ */ new Map();
-  for (const tool of byName.values()) {
-    const config = {
-      title: tool.title,
-      description: tool.description,
-      inputSchema: tool.input,
-      annotations: tool.annotations
-    };
-    if (isZodObject(tool.output)) config.outputSchema = tool.output;
-    registered.set(
-      tool.name,
-      server.registerTool(tool.name, config, () => {
-        throw new Error("unreachable: mcp-kit dispatches tools/call itself");
-      })
-    );
-  }
-  if (byName.size > 0) {
-    server.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      const enabled = [...byName.values()].filter(
-        (tool) => registered.get(tool.name)?.enabled !== false
-      );
-      return {
-        tools: listToolManifest(enabled).map((entry) => ({
-          ...entry,
-          inputSchema: entry.inputSchema,
-          outputSchema: entry.outputSchema
-        }))
-      };
-    });
-    server.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
-      const name = request.params.name;
-      const tool = byName.get(name);
-      const entry = registered.get(name);
-      if (!tool || !entry) throw new McpError(ErrorCode.InvalidParams, `Tool ${name} not found`);
-      if (!entry.enabled) throw new McpError(ErrorCode.InvalidParams, `Tool ${name} disabled`);
-      return tool.invoke(request.params.arguments ?? {}, contextFromExtra(extra));
-    });
-  }
-  return server;
-}
-function toJsonSchema(schema, io = "input") {
-  const json = z4.toJSONSchema(schema, { io, target: "draft-2020-12" });
-  if (isZodObject(schema) && schema._zod.def.catchall === void 0 && json.additionalProperties === void 0) {
-    json.additionalProperties = false;
-  }
-  return json;
-}
-function listToolManifest(tools) {
-  return tools.map((tool) => {
-    const entry = {
-      name: tool.name,
-      description: tool.description,
-      inputSchema: toJsonSchema(tool.input, "input")
-    };
-    if (tool.title !== void 0) entry.title = tool.title;
-    if (isZodObject(tool.output)) entry.outputSchema = toJsonSchema(tool.output, "output");
-    if (tool.annotations !== void 0) entry.annotations = tool.annotations;
-    return entry;
-  });
-}
-var DEFAULT_CORS = {
-  origin: "*",
-  methods: "GET, POST, DELETE, OPTIONS",
-  headers: "Content-Type, Accept, Authorization, Mcp-Session-Id, Mcp-Protocol-Version, Last-Event-ID, PAYMENT, X-PAYMENT",
-  exposeHeaders: "Mcp-Session-Id, Mcp-Protocol-Version, WWW-Authenticate, X-Payment-Requirements, PAYMENT-REQUIRED",
-  maxAge: 86400
-};
-var DEFAULT_SESSION_TTL_MS = 30 * 6e4;
-function corsHeaders(cors) {
-  if (!cors) return {};
-  const c = { ...DEFAULT_CORS, ...typeof cors === "object" ? cors : {} };
-  return {
-    "Access-Control-Allow-Origin": c.origin,
-    "Access-Control-Allow-Methods": c.methods,
-    "Access-Control-Allow-Headers": c.headers,
-    "Access-Control-Expose-Headers": c.exposeHeaders,
-    "Access-Control-Max-Age": String(c.maxAge)
-  };
-}
-function jsonResponse(body, status, headers = {}) {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: { "Content-Type": "application/json", "Cache-Control": "no-store", ...headers }
-  });
-}
-function methodNotAllowed(method, allow, cors) {
-  return jsonResponse(
-    {
-      code: "METHOD_NOT_ALLOWED",
-      cause: `${method} is not supported here without a session`,
-      fix: "send JSON-RPC over POST with `Accept: application/json, text/event-stream` (start with `initialize`)",
-      retryable: false
-    },
-    405,
-    { Allow: allow, ...cors }
-  );
-}
-function splitOptions(opts, transport) {
-  if (typeof opts === "function") return { factory: opts, transport };
-  const {
-    cors,
-    jsonResponse: jsonResponse2,
-    sessions,
-    allowedHosts,
-    allowedOrigins,
-    enableDnsRebindingProtection,
-    ...server
-  } = opts;
-  return {
-    factory: () => createMcpServer(server),
-    transport: {
-      cors,
-      jsonResponse: jsonResponse2,
-      sessions,
-      allowedHosts,
-      allowedOrigins,
-      enableDnsRebindingProtection,
-      ...transport
-    }
-  };
-}
-function withCors(response, cors) {
-  const keys = Object.keys(cors);
-  if (keys.length === 0) return response;
-  const headers = new Headers(response.headers);
-  for (const key of keys) headers.set(key, cors[key] ?? "");
-  return new Response(response.body, {
-    status: response.status,
-    statusText: response.statusText,
-    headers
-  });
-}
-function errorResponse(err, cors) {
-  const error = normalizeError(err);
-  return jsonResponse(error.toJSON(), error.httpStatus, cors);
-}
-function createStatelessHandler({ factory, cors, transportBase }) {
-  return async (request) => {
-    if (request.method !== "POST") return methodNotAllowed(request.method, "POST, OPTIONS", cors);
-    const server = factory();
-    const transport = new WebStandardStreamableHTTPServerTransport({
-      ...transportBase,
-      sessionIdGenerator: void 0
-    });
-    let closed = false;
-    const cleanup = async () => {
-      if (closed) return;
-      closed = true;
-      try {
-        await server.close();
-      } catch {
-      }
-    };
-    try {
-      await server.connect(transport);
-      const response = withCors(await transport.handleRequest(request), cors);
-      if (!response.body) {
-        await cleanup();
-        return response;
-      }
-      request.signal?.addEventListener("abort", () => void cleanup(), { once: true });
-      const body = response.body.pipeThrough(
-        new TransformStream({ flush: () => cleanup() })
-      );
-      return new Response(body, {
-        status: response.status,
-        statusText: response.statusText,
-        headers: response.headers
-      });
-    } catch (err) {
-      await cleanup();
-      return errorResponse(err, cors);
-    }
-  };
-}
-function createStatefulHandler({ factory, cors, transportBase }, options) {
-  const ttlMs = options.ttlMs ?? DEFAULT_SESSION_TTL_MS;
-  const sessions = /* @__PURE__ */ new Map();
-  const drop = (id) => {
-    const session = sessions.get(id);
-    if (!session) return;
-    sessions.delete(id);
-    session.server.close().catch(() => void 0);
-  };
-  const sweep = () => {
-    const now = Date.now();
-    for (const [id, session] of sessions) if (now - session.lastSeen > ttlMs) drop(id);
-  };
-  return async (request) => {
-    const sessionId = request.headers.get("mcp-session-id");
-    if (sessionId) {
-      const session = sessions.get(sessionId);
-      if (!session) {
-        return jsonResponse(
-          {
-            code: "NOT_FOUND",
-            cause: "unknown or expired Mcp-Session-Id",
-            fix: "send `initialize` again without an Mcp-Session-Id header and use the id from the response",
-            retryable: true
-          },
-          404,
-          cors
-        );
-      }
-      session.lastSeen = Date.now();
-      try {
-        return withCors(await session.transport.handleRequest(request), cors);
-      } catch (err) {
-        return errorResponse(err, cors);
-      }
-    }
-    if (request.method !== "POST") return methodNotAllowed(request.method, "POST, OPTIONS", cors);
-    sweep();
-    const server = factory();
-    const transport = new WebStandardStreamableHTTPServerTransport({
-      ...transportBase,
-      sessionIdGenerator: () => crypto.randomUUID(),
-      onsessioninitialized: (id) => {
-        sessions.set(id, { server, transport, lastSeen: Date.now() });
-      },
-      onsessionclosed: (id) => {
-        sessions.delete(id);
-      }
-    });
-    try {
-      await server.connect(transport);
-      const previousOnClose = transport.onclose;
-      transport.onclose = () => {
-        previousOnClose?.();
-        if (transport.sessionId) sessions.delete(transport.sessionId);
-      };
-      const response = withCors(await transport.handleRequest(request), cors);
-      if (!transport.sessionId) server.close().catch(() => void 0);
-      return response;
-    } catch (err) {
-      server.close().catch(() => void 0);
-      return errorResponse(err, cors);
-    }
-  };
-}
-function createHttpHandler(opts, transportOptions = {}) {
-  const { factory, transport: t } = splitOptions(opts, transportOptions);
-  const cors = corsHeaders(t.cors);
-  const sessions = t.sessions ? typeof t.sessions === "object" ? t.sessions : {} : void 0;
-  const context = {
-    factory,
-    cors,
-    transportBase: {
-      enableJsonResponse: t.jsonResponse ?? sessions === void 0,
-      allowedHosts: t.allowedHosts,
-      allowedOrigins: t.allowedOrigins,
-      enableDnsRebindingProtection: t.enableDnsRebindingProtection
-    }
-  };
-  const handler = sessions ? createStatefulHandler(context, sessions) : createStatelessHandler(context);
-  const allow = sessions ? "GET, POST, DELETE, OPTIONS" : "POST, OPTIONS";
-  return async (request) => {
-    if (request.method === "OPTIONS") {
-      return new Response(null, { status: 204, headers: { Allow: allow, ...cors } });
-    }
-    return handler(request);
-  };
-}
-function localhostHosts(port) {
-  const hosts = ["localhost", "127.0.0.1", "[::1]"];
-  return [...hosts, ...hosts.map((h) => `${h}:${port}`)];
-}
-function handleHealth(info) {
-  const tools = typeof info.tools === "number" ? info.tools : info.tools.length;
-  return jsonResponse({ ok: true, name: info.name, version: info.version, tools }, 200);
-}
-async function serveNodeHttp(opts) {
-  const http = await import("http");
-  const host = opts.host ?? "127.0.0.1";
-  const path = opts.path ?? "/mcp";
-  const server = http.createServer((req, res) => {
-    void (async () => {
-      const url = new URL(req.url ?? "/", `http://${req.headers.host ?? host}`);
-      let response;
-      if (url.pathname === path) {
-        const controller = new AbortController();
-        res.on("close", () => {
-          if (!res.writableFinished) controller.abort();
-        });
-        const headers = new Headers();
-        for (const [key, value] of Object.entries(req.headers)) {
-          if (Array.isArray(value)) for (const item of value) headers.append(key, item);
-          else if (typeof value === "string") headers.set(key, value);
-        }
-        const method = req.method ?? "GET";
-        let body;
-        if (method !== "GET" && method !== "HEAD") {
-          const chunks = [];
-          for await (const chunk of req) chunks.push(chunk);
-          body = new Uint8Array(Buffer.concat(chunks));
-        }
-        response = await opts.handler(
-          new Request(url, { method, headers, body, signal: controller.signal })
-        );
-      } else if (url.pathname === "/health" && opts.health) {
-        response = opts.health();
-      } else {
-        response = new Response(
-          JSON.stringify({
-            code: "NOT_FOUND",
-            cause: `no route for ${url.pathname}`,
-            fix: `POST JSON-RPC to ${path}`,
-            retryable: false
-          }),
-          { status: 404, headers: { "Content-Type": "application/json" } }
-        );
-      }
-      const outHeaders = {};
-      response.headers.forEach((value, key) => {
-        outHeaders[key] = value;
-      });
-      res.writeHead(response.status, outHeaders);
-      if (!response.body) {
-        res.end();
-        return;
-      }
-      const reader = response.body.getReader();
-      try {
-        for (; ; ) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          res.write(value);
-        }
-      } catch {
-      }
-      res.end();
-    })().catch((err) => {
-      if (!res.headersSent) res.writeHead(500, { "Content-Type": "application/json" });
-      res.end(
-        JSON.stringify({
-          code: "INTERNAL",
-          cause: err instanceof Error ? err.message : String(err),
-          fix: "retry; if it persists, report the request id",
-          retryable: false
-        })
-      );
-    });
-  });
-  await new Promise((resolve, reject) => {
-    server.once("error", reject);
-    server.listen(opts.port ?? 8765, host, () => resolve());
-  });
-  const address = server.address();
-  const port = typeof address === "object" && address ? address.port : opts.port ?? 8765;
-  return {
-    port,
-    url: `http://${host}:${port}${path}`,
-    close: () => new Promise((resolve, reject) => {
-      server.closeAllConnections();
-      server.close((err) => err ? reject(err) : resolve());
-    })
-  };
-}
-
-// ../../packages/mcp-kit/dist/index.js
-import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
-async function serveStdio(serverOrOpts) {
-  const server = serverOrOpts instanceof McpServer2 ? serverOrOpts : createMcpServer(serverOrOpts);
-  const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  await new Promise((resolve) => {
-    const previous = transport.onclose;
-    transport.onclose = () => {
-      previous?.();
-      resolve();
-    };
-  });
-}
-
-// src/fixtures/crm-server.ts
-import { z as z5 } from "zod";
-function seedState() {
-  const contacts = /* @__PURE__ */ new Map();
-  for (const [id, name, email] of [
-    ["c_1", "Ada Lovelace", "ada@example.com"],
-    ["c_2", "Grace Hopper", "grace@example.com"],
-    ["c_3", "Linus Torvalds", "linus@example.com"]
-  ]) {
-    contacts.set(id, { id, name, email, updated_at: "2026-01-01T00:00:00.000Z" });
-  }
-  return { contacts, mutations: [], emails: [], charges: [] };
-}
-var counter = 0;
-var nextId = (prefix) => `${prefix}_${(++counter).toString(36).padStart(4, "0")}`;
-function crmTools(state) {
-  const contactSchema = z5.object({
-    id: z5.string(),
-    name: z5.string(),
-    email: z5.string(),
-    updated_at: z5.string()
-  });
-  return [
-    defineTool({
-      name: "crm_list_contacts",
-      description: "List every contact in the CRM. Read-only; returns id, name, email and updated_at.",
-      input: z5.object({ limit: z5.number().int().min(1).max(500).default(100) }),
-      output: z5.object({ contacts: z5.array(contactSchema), total: z5.number() }),
-      annotations: { readOnlyHint: true },
-      handler: ({ limit }) => ({
-        contacts: [...state.contacts.values()].slice(0, limit),
-        total: state.contacts.size
-      })
-    }),
-    defineTool({
-      name: "crm_get_contact",
-      description: "Fetch one contact by id. Read-only; NOT_FOUND when the id does not exist.",
-      input: z5.object({ id: z5.string() }),
-      output: contactSchema,
-      annotations: { readOnlyHint: true },
-      handler: ({ id }) => {
-        const c = state.contacts.get(id);
-        if (!c)
-          throw toolError(
-            "NOT_FOUND",
-            `no contact ${id}`,
-            "call crm_list_contacts and use an existing id"
-          );
-        return c;
-      }
-    }),
-    defineTool({
-      name: "crm_search",
-      description: "Search contacts by name or email substring. Returns matching contacts (no annotations on purpose).",
-      input: z5.object({ query: z5.string() }),
-      handler: ({ query }) => ({
-        contacts: [...state.contacts.values()].filter(
-          (c) => `${c.name} ${c.email}`.toLowerCase().includes(query.toLowerCase())
-        )
-      })
-    }),
-    defineTool({
-      name: "crm_create_contact",
-      description: "Create a contact. Returns the new id and created_at timestamp.",
-      input: z5.object({ name: z5.string(), email: z5.string() }),
-      output: z5.object({ id: z5.string(), created_at: z5.string() }),
-      annotations: { readOnlyHint: false, destructiveHint: false },
-      handler: ({ name, email }) => {
-        const id = nextId("c");
-        const now = (/* @__PURE__ */ new Date()).toISOString();
-        state.contacts.set(id, { id, name, email, updated_at: now });
-        state.mutations.push({ tool: "crm_create_contact", args: { name, email } });
-        return { id, created_at: now };
-      }
-    }),
-    defineTool({
-      name: "crm_update_contact",
-      description: "Update fields on a contact. Returns the id and updated_at; NOT_FOUND for unknown ids.",
-      input: z5.object({
-        id: z5.string(),
-        fields: z5.object({ name: z5.string().optional(), email: z5.string().optional() })
-      }),
-      output: z5.object({ id: z5.string(), updated_at: z5.string() }),
-      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
-      handler: ({ id, fields }) => {
-        const c = state.contacts.get(id);
-        if (!c)
-          throw toolError(
-            "NOT_FOUND",
-            `no contact ${id}`,
-            "call crm_list_contacts and use an existing id"
-          );
-        Object.assign(c, fields, { updated_at: (/* @__PURE__ */ new Date()).toISOString() });
-        state.mutations.push({ tool: "crm_update_contact", args: { id, fields } });
-        return { id, updated_at: c.updated_at };
-      }
-    }),
-    defineTool({
-      name: "crm_delete_contact",
-      description: "Permanently delete a contact. Irreversible. Returns { deleted, id }.",
-      input: z5.object({ id: z5.string() }),
-      output: z5.object({ deleted: z5.boolean(), id: z5.string() }),
-      annotations: { readOnlyHint: false, destructiveHint: true },
-      handler: ({ id }) => {
-        const existed = state.contacts.delete(id);
-        state.mutations.push({ tool: "crm_delete_contact", args: { id } });
-        return { deleted: existed, id };
-      }
-    }),
-    defineTool({
-      name: "crm_send_email",
-      description: "Send an email to a contact through the CRM. Returns the message id and sent_at.",
-      input: z5.object({ to: z5.string(), subject: z5.string(), body: z5.string() }),
-      output: z5.object({ message_id: z5.string(), sent_at: z5.string() }),
-      handler: ({ to, subject }) => {
-        state.emails.push({ to, subject });
-        state.mutations.push({ tool: "crm_send_email", args: { to, subject } });
-        return { message_id: nextId("msg"), sent_at: (/* @__PURE__ */ new Date()).toISOString() };
-      }
-    }),
-    defineTool({
-      name: "crm_charge_card",
-      description: "Charge a customer's card on file (amount in cents). Returns the charge id and amount_usd.",
-      input: z5.object({
-        customer_id: z5.string(),
-        amount_cents: z5.number().int().positive(),
-        currency: z5.string().default("usd")
-      }),
-      output: z5.object({ charge_id: z5.string(), amount_usd: z5.number() }),
-      handler: ({ customer_id, amount_cents }) => {
-        const amount_usd = amount_cents / 100;
-        state.charges.push({ customer_id, amount_usd });
-        state.mutations.push({ tool: "crm_charge_card", args: { customer_id, amount_usd } });
-        return { charge_id: nextId("ch"), amount_usd };
-      }
-    }),
-    defineTool({
-      name: "crm_frobnicate",
-      description: "A tool with no annotations and no recognizable verb \u2014 exists to test `unknown` handling.",
-      input: z5.object({}),
-      handler: () => {
-        state.mutations.push({ tool: "crm_frobnicate", args: {} });
-        return { frobnicated: true };
-      }
-    }),
-    defineTool({
-      name: "crm_fail",
-      description: "Always returns a structured UPSTREAM_ERROR result, for error-path tests.",
-      input: z5.object({}),
-      annotations: { readOnlyHint: true },
-      handler: () => {
-        throw toolError("UPSTREAM_ERROR", "the CRM is having a bad day", "retry in a minute", {
-          retryable: true
-        });
-      }
-    })
-  ];
-}
-function createCrmMcpServer(state = seedState()) {
-  return createMcpServer({
-    name: "fake-crm",
-    version: "0.1.0",
-    instructions: "A fake CRM for agentguard tests. Nothing here is real.",
-    tools: crmTools(state)
-  });
-}
-var isMain = process.argv[1] !== void 0 && /crm-server\.[cm]?[jt]s$/.test(process.argv[1]);
-if (isMain) {
-  const state = seedState();
-  if (process.argv.includes("--http")) {
-    const portArg = process.argv.find((a) => a.startsWith("--port="));
-    const port = portArg ? Number(portArg.slice("--port=".length)) : 0;
-    const handler = createHttpHandler(() => createCrmMcpServer(state), {
-      sessions: true,
-      jsonResponse: false,
-      allowedHosts: port ? localhostHosts(port) : void 0
-    });
-    const server = await serveNodeHttp({
-      handler,
-      port,
-      health: () => handleHealth({ name: "fake-crm", version: "0.1.0", tools: crmTools(state).length })
-    });
-    console.log(`fake-crm listening at ${server.url}`);
-  } else {
-    for (const signal of ["SIGTERM", "SIGINT"]) process.on(signal, () => process.exit(0));
-    await serveStdio(createCrmMcpServer(state));
-  }
-}
+  createCrmMcpServer,
+  crmTools,
+  seedState
+} from "../chunk-HPYZ3JDX.js";
+import "../chunk-ZSLWPKXI.js";
+import "../chunk-5WRI5ZAA.js";
 export {
   createCrmMcpServer,
   crmTools,