easypost-mcp 2.1.0 → 3.1.0

package/src/resources/ResourceManager.js

@@ -0,0 +1,244 @@
+import { ResourceCache } from "./cache.js";
+import { CARRIERS, COUNTRIES, PACKAGE_TYPES, PAYMENT_METHODS, SERVICES_BY_CARRIER, STATES_BY_COUNTRY } from "./staticResources.js";
+import { fuzzySuggest, normalizeCandidate } from "./fuzzy.js";
+
+const CACHE_KEYS = Object.freeze({
+  carriers: "carriers",
+  services: "services",
+  packageTypes: "packageTypes",
+  countries: "countries",
+  carrierAccounts: "carrierAccounts",
+  warehouses: "warehouses",
+  states: "states",
+  paymentMethods: "paymentMethods",
+});
+
+function validationResult({ valid, confidence = 1, issues = [], suggestions = [], value = null }) {
+  return { valid, confidence, issues, suggestions, value };
+}
+
+class ResourceManager {
+  constructor(easypostClient, { ttlMs = 15 * 60 * 1000 } = {}) {
+    this.easypost = easypostClient;
+    this.cache = new ResourceCache({ ttlMs });
+    this.initialized = false;
+    this.initializePromise = null;
+  }
+
+  async initialize(context = {}) {
+    if (this.initialized) return;
+    if (this.initializePromise) return this.initializePromise;
+
+    this.initializePromise = this.refresh(context).finally(() => {
+      this.initialized = true;
+      this.initializePromise = null;
+    });
+
+    return this.initializePromise;
+  }
+
+  async refresh(context = {}) {
+    this.cache.set(CACHE_KEYS.carriers, CARRIERS);
+    this.cache.set(CACHE_KEYS.services, SERVICES_BY_CARRIER);
+    this.cache.set(CACHE_KEYS.packageTypes, PACKAGE_TYPES);
+    this.cache.set(CACHE_KEYS.countries, COUNTRIES);
+    this.cache.set(CACHE_KEYS.states, STATES_BY_COUNTRY);
+    this.cache.set(CACHE_KEYS.paymentMethods, PAYMENT_METHODS);
+    this.cache.set(CACHE_KEYS.warehouses, []);
+
+    try {
+      const carrierAccounts = await this.easypost.execute(
+        "carrier_accounts.list",
+        (client) => client.CarrierAccount.all(),
+        context
+      );
+      this.cache.set(CACHE_KEYS.carrierAccounts, Array.isArray(carrierAccounts) ? carrierAccounts : []);
+    } catch (error) {
+      context.logger?.warn(
+        { err: { name: error.name, code: error.code, message: error.message } },
+        "Carrier account resource refresh failed; continuing with static resources"
+      );
+      this.cache.set(CACHE_KEYS.carrierAccounts, []);
+    }
+  }
+
+  async ensureFresh(context = {}) {
+    if (!this.initialized || !this.cache.hasFresh(CACHE_KEYS.carriers)) {
+      await this.initialize(context);
+    }
+  }
+
+  getCarriers() {
+    return this.cache.get(CACHE_KEYS.carriers) || CARRIERS;
+  }
+
+  getServices(carrierCode) {
+    const services = this.cache.get(CACHE_KEYS.services) || SERVICES_BY_CARRIER;
+    return carrierCode ? services[carrierCode] || [] : services;
+  }
+
+  getCarrierAccounts() {
+    return this.cache.get(CACHE_KEYS.carrierAccounts) || [];
+  }
+
+  getPackageTypes() {
+    return this.cache.get(CACHE_KEYS.packageTypes) || PACKAGE_TYPES;
+  }
+
+  getCountries() {
+    return this.cache.get(CACHE_KEYS.countries) || COUNTRIES;
+  }
+
+  getStates(countryCode) {
+    const states = this.cache.get(CACHE_KEYS.states) || STATES_BY_COUNTRY;
+    return countryCode ? states[countryCode] || [] : states;
+  }
+
+  getPaymentMethods() {
+    return this.cache.get(CACHE_KEYS.paymentMethods) || PAYMENT_METHODS;
+  }
+
+  getOperationalContext() {
+    return {
+      resources: {
+        carriers_count: this.getCarriers().length,
+        package_types_count: (this.cache.get(CACHE_KEYS.packageTypes) || []).length,
+        countries_count: (this.cache.get(CACHE_KEYS.countries) || []).length,
+        user_shipping_accounts_count: this.getCarrierAccounts().length,
+        cache: Object.fromEntries(
+          Object.values(CACHE_KEYS).map((key) => [key, this.cache.metadata(key)])
+        ),
+      },
+    };
+  }
+
+  validateCarrier(input) {
+    const carriers = this.getCarriers();
+    const normalized = normalizeCandidate(input);
+    const exact = carriers.find((carrier) => {
+      const labels = [carrier.code, carrier.name, ...(carrier.aliases || [])];
+      return labels.some((label) => normalizeCandidate(label) === normalized);
+    });
+
+    if (exact) {
+      return validationResult({ valid: true, confidence: 1, value: exact.code });
+    }
+
+    return validationResult({
+      valid: false,
+      confidence: 0,
+      issues: [{ code: "UNKNOWN_CARRIER", message: `Unsupported carrier: ${input}` }],
+      suggestions: fuzzySuggest(input, carriers),
+    });
+  }
+
+  validateService(carrierInput, serviceInput) {
+    const carrier = this.validateCarrier(carrierInput);
+    if (!carrier.valid) return carrier;
+
+    const services = this.getServices(carrier.value);
+    const exact = services.find((service) => normalizeCandidate(service) === normalizeCandidate(serviceInput));
+    if (exact) {
+      return validationResult({ valid: true, confidence: 1, value: exact });
+    }
+
+    return validationResult({
+      valid: false,
+      confidence: 0,
+      issues: [{
+        code: "UNSUPPORTED_SERVICE_FOR_CARRIER",
+        message: `Unsupported service for ${carrier.value}: ${serviceInput}`,
+      }],
+      suggestions: fuzzySuggest(
+        serviceInput,
+        services.map((service) => ({ code: service, name: service })),
+        { threshold: 0.7 }
+      ),
+    });
+  }
+
+  validateCarrierAccount(input) {
+    const accounts = this.getCarrierAccounts();
+    if (!accounts.length) return validationResult({ valid: true, confidence: 0.6, value: input });
+    const match = accounts.find((account) => account.id === input);
+    if (match) return validationResult({ valid: true, confidence: 1, value: input });
+    return validationResult({
+      valid: false,
+      confidence: 0,
+      issues: [{ code: "UNKNOWN_CARRIER_ACCOUNT", message: `Unknown carrier account: ${input}` }],
+      suggestions: accounts.slice(0, 5).map((account) => ({
+        id: account.id,
+        carrier: account.carrier,
+        description: account.description,
+      })),
+    });
+  }
+
+  validatePackageType(input) {
+    const packageTypes = this.getPackageTypes();
+    const exact = packageTypes.find((packageType) => normalizeCandidate(packageType) === normalizeCandidate(input));
+    if (exact) return validationResult({ valid: true, confidence: 1, value: exact });
+    return validationResult({
+      valid: false,
+      confidence: 0,
+      issues: [{ code: "UNKNOWN_PACKAGE_TYPE", message: `Unknown package type: ${input}` }],
+      suggestions: fuzzySuggest(
+        input,
+        packageTypes.map((packageType) => ({ code: packageType, name: packageType })),
+        { threshold: 0.72 }
+      ),
+    });
+  }
+
+  validateCountry(input) {
+    const countries = this.getCountries();
+    const exact = countries.find((country) => {
+      const labels = [country.code, country.name];
+      return labels.some((label) => normalizeCandidate(label) === normalizeCandidate(input));
+    });
+    if (exact) return validationResult({ valid: true, confidence: 1, value: exact.code });
+    return validationResult({
+      valid: false,
+      confidence: 0,
+      issues: [{ code: "UNKNOWN_COUNTRY", message: `Unknown country: ${input}` }],
+      suggestions: fuzzySuggest(input, countries, { threshold: 0.72 }),
+    });
+  }
+
+  validateState(countryInput, stateInput) {
+    const country = this.validateCountry(countryInput);
+    if (!country.valid) return country;
+    const states = this.getStates(country.value);
+    if (!states.length) return validationResult({ valid: true, confidence: 0.6, value: stateInput });
+    const exact = states.find((state) => normalizeCandidate(state) === normalizeCandidate(stateInput));
+    if (exact) return validationResult({ valid: true, confidence: 1, value: exact });
+    return validationResult({
+      valid: false,
+      confidence: 0,
+      issues: [{ code: "UNKNOWN_STATE", message: `Unknown state/province for ${country.value}: ${stateInput}` }],
+      suggestions: fuzzySuggest(
+        stateInput,
+        states.map((state) => ({ code: state, name: state })),
+        { threshold: 0.7 }
+      ),
+    });
+  }
+
+  validatePaymentMethod(input) {
+    const methods = this.getPaymentMethods();
+    const exact = methods.find((method) => normalizeCandidate(method) === normalizeCandidate(input));
+    if (exact) return validationResult({ valid: true, confidence: 1, value: exact });
+    return validationResult({
+      valid: false,
+      confidence: 0,
+      issues: [{ code: "UNKNOWN_PAYMENT_METHOD", message: `Unknown payment method: ${input}` }],
+      suggestions: fuzzySuggest(
+        input,
+        methods.map((method) => ({ code: method, name: method })),
+        { threshold: 0.7 }
+      ),
+    });
+  }
+}
+
+export { ResourceManager };

package/src/resources/cache.js

@@ -0,0 +1,41 @@
+class ResourceCache {
+  constructor({ ttlMs = 15 * 60 * 1000 } = {}) {
+    this.ttlMs = ttlMs;
+    this.entries = new Map();
+  }
+
+  get(key) {
+    const entry = this.entries.get(key);
+    if (!entry) return null;
+    if (Date.now() >= entry.expiresAt) {
+      this.entries.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+
+  set(key, value, ttlMs = this.ttlMs) {
+    this.entries.set(key, {
+      value,
+      expiresAt: Date.now() + ttlMs,
+      loadedAt: new Date().toISOString(),
+    });
+    return value;
+  }
+
+  hasFresh(key) {
+    return this.get(key) !== null;
+  }
+
+  metadata(key) {
+    const entry = this.entries.get(key);
+    if (!entry) return null;
+    return {
+      loaded_at: entry.loadedAt,
+      expires_at: new Date(entry.expiresAt).toISOString(),
+      stale: Date.now() >= entry.expiresAt,
+    };
+  }
+}
+
+export { ResourceCache };

package/src/resources/fuzzy.js

@@ -0,0 +1,57 @@
+function normalizeCandidate(value) {
+  return String(value || "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "");
+}
+
+function levenshtein(a, b) {
+  const left = normalizeCandidate(a);
+  const right = normalizeCandidate(b);
+  if (left === right) return 0;
+  if (!left.length) return right.length;
+  if (!right.length) return left.length;
+
+  const previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+  const current = new Array(right.length + 1);
+
+  for (let i = 1; i <= left.length; i += 1) {
+    current[0] = i;
+    for (let j = 1; j <= right.length; j += 1) {
+      const cost = left[i - 1] === right[j - 1] ? 0 : 1;
+      current[j] = Math.min(
+        current[j - 1] + 1,
+        previous[j] + 1,
+        previous[j - 1] + cost
+      );
+    }
+    previous.splice(0, previous.length, ...current);
+  }
+
+  return previous[right.length];
+}
+
+function similarity(a, b) {
+  const left = normalizeCandidate(a);
+  const right = normalizeCandidate(b);
+  const maxLength = Math.max(left.length, right.length);
+  if (!maxLength) return 1;
+  return 1 - levenshtein(left, right) / maxLength;
+}
+
+function fuzzySuggest(input, candidates, { threshold = 0.72, limit = 5 } = {}) {
+  const normalizedInput = normalizeCandidate(input);
+  if (!normalizedInput) return [];
+
+  return candidates
+    .map((candidate) => {
+      const labels = [candidate.code, candidate.name, ...(candidate.aliases || [])].filter(Boolean);
+      const score = Math.max(...labels.map((label) => similarity(normalizedInput, label)));
+      return { ...candidate, score: Number(score.toFixed(3)) };
+    })
+    .filter((candidate) => candidate.score >= threshold)
+    .sort((a, b) => b.score - a.score || String(a.code).localeCompare(String(b.code)))
+    .slice(0, limit);
+}
+
+export { normalizeCandidate, similarity, fuzzySuggest };

package/src/resources/staticResources.js

@@ -0,0 +1,89 @@
+const CARRIERS = [
+  { code: "USPS", name: "USPS", aliases: ["united states postal service"] },
+  { code: "FedEx", name: "FedEx", aliases: ["federal express"] },
+  { code: "UPS", name: "UPS", aliases: ["united parcel service"] },
+  { code: "DHLExpress", name: "DHL Express", aliases: ["dhl"] },
+  { code: "CanadaPost", name: "Canada Post", aliases: ["canadapost"] },
+];
+
+const SERVICES_BY_CARRIER = {
+  USPS: [
+    "GroundAdvantage",
+    "First",
+    "Priority",
+    "Express",
+    "ParcelSelect",
+    "MediaMail",
+    "LibraryMail",
+  ],
+  FedEx: [
+    "FEDEX_GROUND",
+    "FEDEX_2_DAY",
+    "FEDEX_2_DAY_AM",
+    "STANDARD_OVERNIGHT",
+    "PRIORITY_OVERNIGHT",
+    "FIRST_OVERNIGHT",
+    "GROUND_HOME_DELIVERY",
+    "INTERNATIONAL_PRIORITY",
+    "INTERNATIONAL_ECONOMY",
+  ],
+  UPS: [
+    "Ground",
+    "UPSStandard",
+    "UPSSaver",
+    "NextDayAir",
+    "NextDayAirSaver",
+    "2ndDayAir",
+    "3DaySelect",
+    "WorldwideExpress",
+    "WorldwideExpedited",
+  ],
+  DHLExpress: [
+    "ExpressWorldwide",
+    "ExpressEasy",
+    "ExpressEnvelope",
+    "MedicalExpress",
+  ],
+  CanadaPost: [
+    "RegularParcel",
+    "ExpeditedParcel",
+    "Xpresspost",
+    "Priority",
+  ],
+};
+
+const PACKAGE_TYPES = [
+  "Parcel",
+  "FlatRateEnvelope",
+  "FlatRateLegalEnvelope",
+  "FlatRatePaddedEnvelope",
+  "FlatRateSmallBox",
+  "FlatRateMediumBox",
+  "FlatRateLargeBox",
+];
+
+const COUNTRIES = [
+  { code: "US", name: "United States" },
+  { code: "CA", name: "Canada" },
+  { code: "GB", name: "United Kingdom" },
+  { code: "AU", name: "Australia" },
+  { code: "DE", name: "Germany" },
+  { code: "FR", name: "France" },
+  { code: "IN", name: "India" },
+];
+
+const STATES_BY_COUNTRY = {
+  US: [
+    "AL", "AK", "AZ", "AR", "CA", "CO", "CT", "DE", "FL", "GA",
+    "HI", "ID", "IL", "IN", "IA", "KS", "KY", "LA", "ME", "MD",
+    "MA", "MI", "MN", "MS", "MO", "MT", "NE", "NV", "NH", "NJ",
+    "NM", "NY", "NC", "ND", "OH", "OK", "OR", "PA", "RI", "SC",
+    "SD", "TN", "TX", "UT", "VT", "VA", "WA", "WV", "WI", "WY",
+    "DC",
+  ],
+  CA: ["AB", "BC", "MB", "NB", "NL", "NS", "NT", "NU", "ON", "PE", "QC", "SK", "YT"],
+};
+
+const PAYMENT_METHODS = ["SENDER", "THIRD_PARTY", "RECEIVER"];
+
+export { CARRIERS, SERVICES_BY_CARRIER, PACKAGE_TYPES, COUNTRIES, STATES_BY_COUNTRY, PAYMENT_METHODS };

package/src/schemas/addressSchemas.js

@@ -1,4 +1,4 @@
-import { z, nonEmptyString, optionalNonEmptyString } from "./commonSchemas.js";
+import { z, nonEmptyString, optionalNonEmptyString, confirmationFields } from "./commonSchemas.js";
 
 const addressSchema = z.object({
   name: optionalNonEmptyString,
@@ -17,11 +17,13 @@ const addressSchema = z.object({
 const verifyAddressSchema = z.object({
   address: addressSchema,
   verifications: z.array(z.enum(["delivery", "zip4"])).default(["delivery"]),
+  ...confirmationFields,
 }).strict();
 
 const createAddressSchema = z.object({
   address: addressSchema,
   verify: z.boolean().default(false),
+  ...confirmationFields,
 }).strict();
 
 export { addressSchema, verifyAddressSchema, createAddressSchema };

package/src/schemas/batchSchemas.js

@@ -1,4 +1,4 @@
-import { z, easypostId } from "./commonSchemas.js";
+import { z, easypostId, confirmationFields } from "./commonSchemas.js";
 import { createShipmentSchema } from "./shipmentSchemas.js";
 
 const batchShipmentCreateSchema = createShipmentSchema.extend({
@@ -17,6 +17,7 @@ const createBatchSchema = z.object({
 
 const buyBatchSchema = z.object({
   batch_id: easypostId,
+  ...confirmationFields,
 }).strict();
 
 const batchStatusSchema = buyBatchSchema;

package/src/schemas/commonSchemas.js

@@ -5,6 +5,10 @@ const optionalNonEmptyString = nonEmptyString.optional();
 const easypostId = z.string().trim().regex(/^[a-z]+_[A-Za-z0-9]+$/, "Invalid EasyPost id format");
 
 const currencyAmount = z.union([z.string().trim().regex(/^\d+(\.\d{1,2})?$/), z.number().nonnegative()]);
+const idempotencyKey = z.string().trim().min(8).max(128).regex(/^[A-Za-z0-9_.:-]+$/, "Invalid idempotency key");
+const confirmationFields = {
+  confirm: z.literal(true).optional(),
+};
 
 const paginationSchema = z.object({
   page_size: z.number().int().min(1).max(100).optional(),
@@ -12,4 +16,4 @@ const paginationSchema = z.object({
   after_id: z.string().trim().optional(),
 }).strict();
 
-export { z, nonEmptyString, optionalNonEmptyString, easypostId, currencyAmount, paginationSchema };
+export { z, nonEmptyString, optionalNonEmptyString, easypostId, currencyAmount, idempotencyKey, confirmationFields, paginationSchema };

package/src/schemas/pickupSchemas.js

@@ -1,4 +1,4 @@
-import { z, easypostId, nonEmptyString } from "./commonSchemas.js";
+import { z, easypostId, nonEmptyString, idempotencyKey, confirmationFields } from "./commonSchemas.js";
 import { addressSchema } from "./addressSchemas.js";
 
 const schedulePickupSchema = z.object({
@@ -8,10 +8,13 @@ const schedulePickupSchema = z.object({
   max_datetime: nonEmptyString,
   instructions: z.string().trim().max(500).optional(),
   carrier_accounts: z.array(nonEmptyString).optional(),
+  idempotency_key: idempotencyKey.optional(),
+  ...confirmationFields,
 }).strict();
 
 const cancelPickupSchema = z.object({
   pickup_id: easypostId,
+  ...confirmationFields,
 }).strict();
 
 export { schedulePickupSchema, cancelPickupSchema };

package/src/schemas/resourceSchemas.js

@@ -0,0 +1,16 @@
+import { z, nonEmptyString } from "./commonSchemas.js";
+
+const listResourcesSchema = z.object({
+  refresh: z.boolean().optional(),
+}).strict();
+
+const validateCarrierSchema = z.object({
+  carrier: nonEmptyString,
+}).strict();
+
+const validateServiceSchema = z.object({
+  carrier: nonEmptyString,
+  service: nonEmptyString,
+}).strict();
+
+export { listResourcesSchema, validateCarrierSchema, validateServiceSchema };

package/src/schemas/returnSchemas.js

@@ -1,4 +1,4 @@
-import { z, easypostId } from "./commonSchemas.js";
+import { z, easypostId, confirmationFields, idempotencyKey } from "./commonSchemas.js";
 import { addressSchema } from "./addressSchemas.js";
 import { parcelSchema } from "./parcelSchemas.js";
 
@@ -9,6 +9,10 @@ const createReturnLabelSchema = z.object({
   parcel: parcelSchema,
   carrier: z.string().trim().optional(),
   service: z.string().trim().optional(),
+  rate_id: easypostId.optional(),
+  rate_option: z.number().int().min(1).optional(),
+  idempotency_key: idempotencyKey.optional(),
+  ...confirmationFields,
 }).strict();
 
 export { createReturnLabelSchema };

package/src/schemas/shipmentSchemas.js

@@ -1,4 +1,4 @@
-import { z, easypostId, nonEmptyString, paginationSchema, currencyAmount } from "./commonSchemas.js";
+import { z, easypostId, nonEmptyString, paginationSchema, currencyAmount, idempotencyKey, confirmationFields } from "./commonSchemas.js";
 import { addressSchema } from "./addressSchemas.js";
 import { parcelSchema } from "./parcelSchemas.js";
 
@@ -19,17 +19,17 @@ const createShipmentSchema = z.object({
   customs_info: customsInfoSchema,
   options: shipmentOptionsSchema,
   reference: z.string().trim().max(255).optional(),
+  idempotency_key: idempotencyKey.optional(),
 }).strict();
 
 const buyShippingLabelSchema = z.object({
   shipment_id: easypostId,
   rate_id: easypostId.optional(),
-  carrier: nonEmptyString.optional(),
-  service: nonEmptyString.optional(),
+  rate_option: z.number().int().min(1).optional(),
   insurance: currencyAmount.optional(),
-}).strict().refine((input) => input.rate_id || (input.carrier && input.service), {
-  message: "Provide either rate_id or carrier and service",
-});
+  idempotency_key: idempotencyKey,
+  ...confirmationFields,
+}).strict();
 
 const getShipmentSchema = z.object({
   shipment_id: easypostId,
@@ -44,6 +44,7 @@ const estimateRatesSchema = createShipmentSchema;
 
 const refundShipmentSchema = z.object({
   shipment_id: easypostId,
+  ...confirmationFields,
 }).strict();
 
 const cancelShipmentSchema = refundShipmentSchema;
@@ -51,6 +52,7 @@ const cancelShipmentSchema = refundShipmentSchema;
 const insureShipmentSchema = z.object({
   shipment_id: easypostId,
   amount: currencyAmount,
+  ...confirmationFields,
 }).strict();
 
 export { createShipmentSchema, buyShippingLabelSchema, getShipmentSchema, listShipmentsSchema, estimateRatesSchema, refundShipmentSchema, cancelShipmentSchema, insureShipmentSchema };

package/src/server/createServer.js

@@ -11,6 +11,8 @@ import { createInMemoryRateLimiter } from "../middleware/rateLimiter.js";
 import { createServices } from "../services/index.js";
 import { createToolRegistry } from "../tools/index.js";
 import { redactForLogs } from "../utils/sanitize.js";
+import { AuditLogger } from "../audit/AuditLogger.js";
+import { ExecutionPipeline } from "../pipeline/ExecutionPipeline.js";
 
 function readPackageVersion() {
   const pkgPath = path.resolve(
@@ -35,6 +37,13 @@ export function createMcpServer() {
   const config = getConfig();
   const logger = getLoggerSync();
   const services = createServices();
+  const auditLogger = new AuditLogger(logger);
+  const pipeline = new ExecutionPipeline({
+    resourceManager: services.resources,
+    elicitationService: services.elicitation,
+    workflowState: services.workflowState,
+    auditLogger,
+  });
   const registry = createToolRegistry(services);
   const limiter = createInMemoryRateLimiter({
     limit: config.rateLimit.perMinute,
@@ -53,12 +62,23 @@ export function createMcpServer() {
     }
   );
 
+  services.resources.initialize({ logger: logger.child({ operation: "resources.initialize" }) })
+    .then(() => {
+      logger.info(services.resources.getOperationalContext(), "Resource grounding initialized");
+    })
+    .catch((error) => {
+      logger.warn(
+        { err: { name: error.name, code: error.code, message: error.message } },
+        "Resource grounding initialization failed; retrying lazily on first tool call"
+      );
+    });
+
   server.setRequestHandler(ListToolsRequestSchema, async () => {
     logger.debug({ toolCount: registry.list().length }, "Listing MCP tools");
     return { tools: registry.list() };
   });
 
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
     const correlationId = createCorrelationId();
     const toolName = request.params.name;
     const childLogger = logger.child({ correlationId, toolName });
@@ -75,6 +95,10 @@ export function createMcpServer() {
         const result = await tool.execute(request.params.arguments, {
           correlationId,
           logger: childLogger,
+          pipeline,
+          resources: services.resources,
+          server,
+          requestExtra: extra,
         });
 
         childLogger.info({ result: redactForLogs(result) }, "MCP tool completed");