server.prompt(
  "customer_service_mode",
  "Activate customer service assistant mode, loading store policies and FAQ",
  [],
  async () => ({
    messages: [{
      role: "assistant",
      content: {
        type: "text",
        text: "You are a professional customer service assistant. Answer questions based on store policies. Suggest transferring to a human agent for complaints you cannot handle."
      }
    }]
  })
);

server.tool("create_return_request", "Create a return request", {
  orderId: { type: "string" }
}, async ({ orderId }, { requestElicitation }) => {
  // Request user confirmation via Elicitation
  const confirmation = await requestElicitation({
    message: "Please confirm the return details",
    requestedSchema: {
      type: "object",
      properties: {
        reason: { type: "string", enum: ["Quality issue", "Wrong size", "Changed mind", "Other"] },
        refundMethod: { type: "string", enum: ["Original payment method", "Store credit"] }
      },
      required: ["reason", "refundMethod"]
    }
  });
  // Create return...
  return {
    content: [{ type: "text", text: `Return request created. Refund method: ${confirmation.refundMethod}` }]
  };
});

User: Where is my order ORD-20260410-001?
AI: [calls get_order_status] Your order has been shipped, tracking number SF1234567890.
    [calls track_shipment] Latest status: April 10, 15:23 - Arrived at the
    regional distribution center. Estimated delivery: tomorrow.

server.tool("query_supplier_inventory", "Query supplier inventory and pricing", {
  productCode: { type: "string", description: "Product code" },
  quantity: { type: "number", description: "Required quantity" },
  supplierId: { type: "string", description: "Supplier ID" }
}, async ({ productCode, quantity, supplierId }) => {
  const quote = await supplierApi.getQuote(supplierId, productCode, quantity);
  const data = {
    supplier: quote.supplierName,
    product: quote.productName,
    unitPrice: quote.unitPrice,
    totalPrice: quote.totalPrice,
    currency: quote.currency,
    leadTime: quote.leadTimeDays,
    moq: quote.minimumOrderQuantity,
    inStock: quote.availableQuantity
  };
  return {
    content: [{
      type: "text",
      text: JSON.stringify(data, null, 2)
    }],
    structuredContent: data
  };
});

server.tool("compare_suppliers", "Compare quotes from multiple suppliers", {
  productCode: { type: "string", description: "Product code" },
  quantity: { type: "number", description: "Required quantity" },
  supplierIds: { type: "string", description: "Supplier ID list, comma-separated" }
}, async ({ productCode, quantity, supplierIds }) => {
  const ids = supplierIds.split(",").map(s => s.trim());
  const quotes = await Promise.all(
    ids.map(id => supplierApi.getQuote(id, productCode, quantity))
  );
  const comparison = quotes
    .sort((a, b) => a.unitPrice - b.unitPrice)
    .map((q, i) => ({
      rank: i + 1,
      supplier: q.supplierName,
      unitPrice: q.unitPrice,
      leadTime: q.leadTimeDays,
      moq: q.minimumOrderQuantity
    }));
  return {
    content: [{
      type: "text",
      text: JSON.stringify(comparison, null, 2)
    }]
  };
});

server.tool("procurement_advice", "Generate procurement advice based on quote data", {
  productCode: { type: "string" },
  quantity: { type: "number" }
}, async ({ productCode, quantity }, { requestSampling }) => {
  const quotes = await supplierApi.getAllQuotes(productCode, quantity);
  // Request LLM analysis via Sampling
  const analysis = await requestSampling({
    messages: [{
      role: "user",
      content: {
        type: "text",
        text: `Analyze the following supplier quotes and recommend the optimal procurement plan:\n${JSON.stringify(quotes, null, 2)}`
      }
    }],
    maxTokens: 500,
    modelPreferences: {
      intelligencePriority: 0.8,
      costPriority: 0.2
    }
  });
  return {
    content: [{ type: "text", text: analysis.content.text }]
  };
});

server.resource(
  "stores://platforms",
  "Connected e-commerce platforms",
  "application/json",
  async () => {
    return JSON.stringify([
      { id: "shopify-main", platform: "Shopify", name: "Main Store", status: "active" },
      { id: "woo-1", platform: "WooCommerce", name: "Secondary Store", status: "active" },
      { id: "self-hosted", platform: "Custom", name: "Self-hosted Store", status: "active" }
    ], null, 2);
  }
);

User: Compare the sales performance of my three stores this week.
AI: [calls get_store_stats x 3]

    This week's sales comparison:
    | Store            | Orders | Revenue   | Conversion |
    |------------------|--------|-----------|------------|
    | Shopify Main     | 142    | $8,940    | 3.2%       |
    | WooCommerce      | 68     | $4,210    | 2.8%       |
    | Self-hosted      | 35     | $2,860    | 4.1%       |

    The self-hosted store has the highest conversion rate but the least traffic.
    Consider applying Shopify's traffic strategies to the self-hosted store.

server.tool("verify_merchant", "Verify merchant trustworthiness", {
  domain: { type: "string", description: "Merchant domain" }
}, async ({ domain }) => {
  const otrResponse = await fetch(
    `https://${domain}/.well-known/otr/verify`
  );

  if (!otrResponse.ok) {
    return {
      content: [{
        type: "text",
        text: `${domain} has not deployed the OTR protocol. Unable to verify trust. Exercise caution.`
      }],
      isError: false  // This is not an error, just missing OTR data
    };
  }

  const otr = await otrResponse.json();
  return {
    content: [{
      type: "text",
      text: JSON.stringify({
        domain: otr.domain,
        trustScore: otr.trustScore,
        badges: otr.badges,
        dimensions: {
          identity: otr.dimensions?.I,
          security: otr.dimensions?.S,
          transparency: otr.dimensions?.T,
          reputation: otr.dimensions?.R,
          durability: otr.dimensions?.D,
          financial: otr.dimensions?.F
        },
        recommendation: otr.trustScore >= 70
          ? "Good trust score. Safe for transactions."
          : otr.trustScore >= 40
          ? "Average trust score. Recommended to learn more before deciding."
          : "Low trust score. Exercise caution."
      }, null, 2)
    }]
  };
});

User: Help me find a reliable outdoor gear store.
AI: [calls search_products to search outdoor gear]
    [calls verify_merchant for outdoorgear.com]
    [calls verify_merchant for hikestore.com]

    Two OTR-verified outdoor gear stores recommended:

    1. outdoorgear.com - OTR Trust Score 82/100
       V (Verification) A / S (Security) A / G (Governance) B / T (Transparency) B / D (Data Quality) A / F (Fulfillment) Pending Auth

    2. hikestore.com - OTR Trust Score 71/100
       V (Verification) B / S (Security) B / G (Governance) B / T (Transparency) C / D (Data Quality) B / F (Fulfillment) Pending Auth

    Both have passed basic trust verification. outdoorgear.com has the higher overall score.

Help me build an MCP Server.

I have read the MCP protocol documentation (modelcontextprotocol.io)
and now need your help with the implementation.

Requirements:
- Language: TypeScript
- Protocol version: 2025-11-25
- Tool list:
  1. [tool name]: [functionality], input [parameters], returns [data]
  2. [tool name]: [functionality], input [parameters], returns [data]
- Resources: [data resources to expose]
- Prompts: [predefined prompt templates]
- Data source: [database connection / API endpoint]
- Transport: [stdio / Streamable HTTP]

Please provide:
1. Complete runnable code (with outputSchema and structuredContent)
2. package.json
3. tsconfig.json
4. Claude Desktop configuration file
5. Testing commands