One public MCP.
A full supplement storefront.

/**
 * Minimal MCP client for OK Capsule's public storefront MCP.
 *
 * Endpoint:  https://storefront.okcapsule.app/mcp/perfect-packs
 * Auth:      none — public, read-only-ish (pack-builder URL generation
 *            mutates nothing on OK Capsule's side until checkout).
 *
 * Speaks MCP Streamable HTTP (POST + JSON-RPC, SSE-framed responses).
 * Zero dependencies — runs under bun, deno, or node >= 20.
 */

const MCP_URL = "https://storefront.okcapsule.app/mcp/perfect-packs";

let sessionId: string | null = null;
let requestId = 0;
let initPromise: Promise<void> | null = null;

async function rpc(method: string, params?: unknown, isNotification = false) {
  const headers: Record<string, string> = {
    "Content-Type": "application/json",
    // REQUIRED by the MCP Streamable HTTP spec — servers reject calls
    // missing either media type with HTTP 406.
    Accept: "application/json, text/event-stream",
  };
  if (sessionId) headers["mcp-session-id"] = sessionId;

  const body: Record<string, unknown> = { jsonrpc: "2.0", method };
  if (!isNotification) body.id = ++requestId;
  if (params !== undefined) body.params = params;

  const res = await fetch(MCP_URL, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
  });

  // The server assigns a session ID on the first response; reuse it.
  const sid = res.headers.get("mcp-session-id");
  if (sid && !sessionId) sessionId = sid;

  if (isNotification) return null;
  if (!res.ok) {
    throw new Error(`MCP ${method} failed (${res.status}): ${(await res.text()).slice(0, 300)}`);
  }

  // Responses come back as either a single JSON object or as an SSE
  // stream with one "data: {...}" frame. Handle both.
  const text = await res.text();
  let payload: { result?: unknown; error?: { message: string } } | null = null;
  for (const line of text.split("\n")) {
    if (line.startsWith("data:")) {
      payload = JSON.parse(line.slice(5).trim());
      break;
    }
  }
  if (!payload) payload = JSON.parse(text);
  if (payload.error) throw new Error(`MCP ${method} error: ${payload.error.message}`);
  return payload.result;
}

async function ensureInit() {
  if (initPromise) return initPromise;
  initPromise = (async () => {
    await rpc("initialize", {
      protocolVersion: "2025-06-18",
      capabilities: {},
      clientInfo: { name: "okc-mcp-demo-kit", version: "1.0.0" },
    });
    // The "initialized" notification has no id and expects no response.
    await rpc("notifications/initialized", undefined, true);
  })();
  return initPromise;
}

/** List every tool the MCP server exposes. */
export async function listTools() {
  await ensureInit();
  return rpc("tools/list");
}

/**
 * Invoke a tool by name. Tool results come back as `content: [{type:"text",text}]`;
 * the text is usually a JSON string, so we try to parse it for you.
 */
export async function callTool(name: string, args: Record<string, unknown> = {}) {
  await ensureInit();
  const result = (await rpc("tools/call", { name, arguments: args })) as {
    content?: Array<{ text?: string }>;
  };
  const text = result?.content?.[0]?.text;
  if (!text) return result;
  try {
    return JSON.parse(text);
  } catch {
    return text;
  }
}

/**
 * List the full OK Capsule supplement catalog.
 *
 * Run:  bun run examples/list-catalog.ts
 *       (or)  node --experimental-strip-types examples/list-catalog.ts
 */
import { callTool } from "../mcp-client.ts";

const catalog = await callTool("okc_get_catalog");

const products: Array<{ id: string; product_name?: string; serving_size?: string }> =
  Array.isArray(catalog) ? catalog : (catalog?.products ?? []);

console.log(`Found ${products.length} products`);
for (const p of products.slice(0, 25)) {
  console.log(`  ${p.id.padEnd(8)}  ${p.product_name ?? "—"}`);
}
if (products.length > 25) console.log(`  …and ${products.length - 25} more`);

/**
 * Fetch deep "product intelligence" for a single supplement:
 * benefits, mechanism of action, suggested stacks, contraindications, etc.
 *
 * Run:  bun run examples/product-detail.ts <product_id>
 */
import { callTool } from "../mcp-client.ts";

const productId = process.argv[2];
if (!productId) {
  console.error("Usage: product-detail.ts <product_id>");
  console.error("Tip: run list-catalog.ts first to find IDs.");
  process.exit(1);
}

const detail = await callTool("okc_get_product_intelligence", { product_id: productId });
console.log(JSON.stringify(detail, null, 2));

/**
 * Build a personalized 28-day pack and get a pre-filled checkout URL.
 *
 * Run:  bun run examples/build-pack.ts
 */
import { callTool } from "../mcp-client.ts";

const result = await callTool("okc_pack_builder_url", {
  pack_name: "Demo Pack",
  items: [
    { product_id: "MAG-001", serving_size: 1, toa: "pm", cycle: "daily", duration: 28 },
    { product_id: "OMEGA-3", serving_size: 1, toa: "am", cycle: "daily", duration: 28 },
    { product_id: "VIT-D",   serving_size: 1, toa: "am", cycle: "daily", duration: 28 },
  ],
});

const url =
  (typeof result === "string" && result) ||
  (result as { url?: string; checkout_url?: string; pack_builder_url?: string })?.url ||
  (result as { checkout_url?: string })?.checkout_url ||
  (result as { pack_builder_url?: string })?.pack_builder_url;

console.log("Pack checkout URL:");
console.log(url ?? result);

/**
 * Build an aggregate Supplement Facts Panel for a personalized pack using
 * only the OK Capsule MCP catalog. Demonstrates that the per-product
 * `strength` and `serving_size` fields are enough to render a draft FDA-style
 * panel client-side — the final regulatory label is produced at fulfillment.
 *
 * Run:  bun run examples/aggregate-sfp.ts
 */
import { callTool } from "../mcp-client.ts";

type CatalogProduct = {
  id: string;
  product_name?: string;
  description?: string;
  serving_size?: number | string;
  pill_type?: string;
};

const STRENGTH_RE = /(\d+(?:[.,]\d+)?)\s*(mg|mcg|g|iu)\b/i;
const CFU_RE = /(\d+(?:[.,]\d+)?)\s*billion\s*cfu/i;

function extractStrength(desc = ""): string | undefined {
  const cfu = desc.match(CFU_RE);
  if (cfu) return `${cfu[1]} billion CFU`;
  const m = desc.match(STRENGTH_RE);
  if (!m) return undefined;
  const unit = m[2].toLowerCase() === "iu" ? "IU" : m[2].toLowerCase();
  return `${m[1]}${unit === "IU" ? " " : ""}${unit}`;
}

const catalog = (await callTool("okc_get_catalog")) as
  | CatalogProduct[]
  | { products?: CatalogProduct[] };
const products: CatalogProduct[] = Array.isArray(catalog) ? catalog : (catalog?.products ?? []);

// Demo pack: pick the first 4 products with a parseable strength.
const pack = products
  .map((p) => ({ ...p, strength: extractStrength(p.description) }))
  .filter((p) => p.strength)
  .slice(0, 4);

console.log("Draft Supplement Facts");
console.log("Serving size: " + pack.length + " capsules daily");
console.log("Servings per container: 28");
console.log("---------------------------------------------");
console.log("Ingredient                Amount/serving");
console.log("---------------------------------------------");
for (const p of pack) {
  const name = (p.product_name ?? "").padEnd(26);
  console.log(`${name}${p.strength}`);
}
console.log("---------------------------------------------");
console.log("† Daily Value not established for some ingredients.");
console.log("Final regulatory label is generated at fulfillment by OK Capsule.");