@cencori/mcp 0.2.0

package/dist/index.js

@@ -0,0 +1,955 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/index.ts
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+
+// src/config.ts
+var DEFAULT_BASE_URL = "https://cencori.com";
+var KNOWN_FEATURES = [
+  "docs",
+  "gateway",
+  "agents",
+  "memory",
+  "sessions",
+  "multimodal",
+  "governance",
+  "guidance"
+];
+function normalizeBaseUrl(value) {
+  return value.replace(/\/$/, "");
+}
+function parseBooleanEnv(value, defaultValue) {
+  if (value === void 0) {
+    return defaultValue;
+  }
+  return !["0", "false", "no", "off"].includes(value.trim().toLowerCase());
+}
+function isMcpFeature(value) {
+  return KNOWN_FEATURES.includes(value);
+}
+function allFeaturesEnabled() {
+  return {
+    docs: true,
+    gateway: true,
+    agents: true,
+    memory: true,
+    sessions: true,
+    multimodal: true,
+    governance: true,
+    guidance: true
+  };
+}
+function parseFeatures(value) {
+  if (!value || value.trim() === "") {
+    return allFeaturesEnabled();
+  }
+  const tokens = value.split(",").map((feature) => feature.trim().toLowerCase()).filter(Boolean);
+  const unrecognized = tokens.filter((token) => !isMcpFeature(token));
+  if (unrecognized.length > 0) {
+    console.error(
+      `[cencori-mcp] Ignoring unrecognized CENCORI_MCP_FEATURES value(s): ${unrecognized.join(", ")}. Known features: ${KNOWN_FEATURES.join(", ")}.`
+    );
+  }
+  const enabled = new Set(tokens.filter(isMcpFeature));
+  return {
+    docs: enabled.has("docs"),
+    gateway: enabled.has("gateway"),
+    agents: enabled.has("agents"),
+    memory: enabled.has("memory"),
+    sessions: enabled.has("sessions"),
+    multimodal: enabled.has("multimodal"),
+    governance: enabled.has("governance"),
+    guidance: enabled.has("guidance")
+  };
+}
+function loadConfig() {
+  const docsBaseUrl = normalizeBaseUrl(process.env.CENCORI_DOCS_BASE_URL ?? DEFAULT_BASE_URL);
+  const baseUrl = normalizeBaseUrl(process.env.CENCORI_BASE_URL ?? DEFAULT_BASE_URL);
+  const apiKey = process.env.CENCORI_API_KEY?.trim() || void 0;
+  const features = parseFeatures(process.env.CENCORI_MCP_FEATURES);
+  const destructive = parseBooleanEnv(process.env.CENCORI_MCP_DESTRUCTIVE, false);
+  const write = destructive || parseBooleanEnv(process.env.CENCORI_MCP_WRITE, false);
+  return {
+    docsBaseUrl,
+    baseUrl,
+    apiKey,
+    capabilities: { write, destructive },
+    features
+  };
+}
+
+// src/server.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+
+// src/http.ts
+var FETCH_TIMEOUT_MS = 15e3;
+function fetchSignal() {
+  return AbortSignal.timeout(FETCH_TIMEOUT_MS);
+}
+async function readHttpErrorMessage(response) {
+  const errorData = await response.json().catch(() => null);
+  if (typeof errorData?.error === "string") {
+    return errorData.error;
+  }
+  if (errorData?.error && typeof errorData.error === "object" && errorData.error.message) {
+    return errorData.error.message;
+  }
+  return response.statusText || `HTTP ${response.status}`;
+}
+
+// src/client.ts
+var PlatformClient = class {
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+  }
+  /**
+   * Low-level request against the Cencori API. Sends `Authorization: Bearer`,
+   * which the gateway accepts for both `/v1/*` and `/api/ai/*` routes.
+   */
+  async request(method, path, options = {}) {
+    const url = new URL(`/api${path}`, this.baseUrl);
+    if (options.searchParams) {
+      for (const [key, value] of Object.entries(options.searchParams)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, value);
+        }
+      }
+    }
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`
+    };
+    const init = { method, headers, signal: fetchSignal() };
+    if (options.body !== void 0) {
+      headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(options.body);
+    }
+    const response = await fetch(url, init);
+    if (!response.ok) {
+      const message = await readHttpErrorMessage(response);
+      throw new Error(`Cencori API error: ${message}`);
+    }
+    const text = await response.text();
+    if (!text) {
+      return void 0;
+    }
+    return JSON.parse(text);
+  }
+  get(path, searchParams) {
+    return this.request("GET", path, { searchParams });
+  }
+  post(path, body, searchParams) {
+    return this.request("POST", path, { body, searchParams });
+  }
+  patch(path, body) {
+    return this.request("PATCH", path, { body });
+  }
+  del(path) {
+    return this.request("DELETE", path);
+  }
+  listModels() {
+    return this.get("/v1/models");
+  }
+  getMetrics(period = "7d") {
+    return this.get("/v1/metrics", { period });
+  }
+  listAgents() {
+    return this.get("/v1/agents");
+  }
+  getAgent(agentId) {
+    return this.get(`/v1/agents/${agentId}`);
+  }
+};
+
+// src/docs/client.ts
+var DocsClient = class {
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+  }
+  async search(query) {
+    const url = new URL("/api/docs/search", this.baseUrl);
+    url.searchParams.set("q", query);
+    const response = await fetch(url, { signal: fetchSignal() });
+    if (!response.ok) {
+      const message = await readHttpErrorMessage(response);
+      throw new Error(`Docs search failed (${response.status}): ${message}`);
+    }
+    return response.json();
+  }
+  async getDoc(slug) {
+    const normalizedSlug = slug.replace(/^\/docs\//, "").replace(/^\//, "");
+    const url = new URL("/api/docs/raw", this.baseUrl);
+    url.searchParams.set("slug", normalizedSlug);
+    const response = await fetch(url, { signal: fetchSignal() });
+    if (response.status === 404) {
+      return { content: "", error: `Document not found: ${normalizedSlug}` };
+    }
+    if (!response.ok) {
+      const message = await readHttpErrorMessage(response);
+      throw new Error(`Docs fetch failed (${response.status}): ${message}`);
+    }
+    return response.json();
+  }
+  async listNavigation() {
+    const url = new URL("/api/docs/navigation", this.baseUrl);
+    const response = await fetch(url, { signal: fetchSignal() });
+    if (!response.ok) {
+      const message = await readHttpErrorMessage(response);
+      throw new Error(`Docs navigation failed (${response.status}): ${message}`);
+    }
+    return response.json();
+  }
+};
+
+// src/tools/docs.ts
+var import_zod = require("zod");
+
+// src/tools/shared.ts
+var READ_ONLY_ANNOTATIONS = {
+  title: "Read-only",
+  readOnlyHint: true,
+  destructiveHint: false,
+  openWorldHint: false
+};
+var WRITE_ANNOTATIONS = {
+  title: "Write",
+  readOnlyHint: false,
+  destructiveHint: false,
+  openWorldHint: false
+};
+function jsonResult(data) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(data, null, 2)
+      }
+    ]
+  };
+}
+
+// src/tools/docs.ts
+function registerDocsTools(server, docs, docsBaseUrl) {
+  server.registerTool(
+    "search_docs",
+    {
+      title: "Search Cencori docs",
+      description: "Search Cencori documentation by keyword. Returns matching pages with title, section, URL, and snippet.",
+      inputSchema: {
+        query: import_zod.z.string().min(2).describe('Search query (minimum 2 characters). Example: "rate limiting", "api keys", "failover".')
+      },
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async ({ query }) => {
+      const { results } = await docs.search(query);
+      return jsonResult({ query, count: results.length, results });
+    }
+  );
+  server.registerTool(
+    "get_doc",
+    {
+      title: "Get Cencori doc page",
+      description: 'Fetch the raw markdown content of a Cencori documentation page by slug. Example slugs: "quick-start", "ai/sdk", "api/chat".',
+      inputSchema: {
+        slug: import_zod.z.string().min(1).describe('Doc slug without /docs/ prefix. Example: "ai/gateway" or "security/scan".')
+      },
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async ({ slug }) => {
+      const doc = await docs.getDoc(slug);
+      const normalizedSlug = slug.replace(/^\/docs\//, "").replace(/^\//, "");
+      if (doc.error) {
+        return jsonResult({ slug: normalizedSlug, error: doc.error });
+      }
+      return jsonResult({
+        slug: normalizedSlug,
+        url: `${docsBaseUrl}/docs/${normalizedSlug}`,
+        content: doc.content
+      });
+    }
+  );
+  server.registerTool(
+    "list_docs",
+    {
+      title: "List Cencori docs",
+      description: "List the Cencori documentation table of contents grouped by section (Getting Started, Platform, AI, API Reference, etc.).",
+      inputSchema: {},
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async () => {
+      const navigation = await docs.listNavigation();
+      return jsonResult(navigation);
+    }
+  );
+}
+
+// src/tools/gateway.ts
+var import_zod2 = require("zod");
+function registerGatewayTools(server, client) {
+  server.registerTool(
+    "list_models",
+    {
+      title: "List Cencori gateway models",
+      description: "List models available through the Cencori gateway for the authenticated project.",
+      inputSchema: {},
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async () => {
+      const models = await client.listModels();
+      return jsonResult(models);
+    }
+  );
+  server.registerTool(
+    "get_metrics",
+    {
+      title: "Get Cencori gateway metrics",
+      description: "Get gateway usage metrics for the authenticated project, including requests, cost, tokens, latency, and model/provider breakdowns.",
+      inputSchema: {
+        period: import_zod2.z.enum(["1h", "24h", "7d", "30d", "mtd"]).optional().describe("Metrics time window. Allowed values: 1h, 24h, 7d, 30d, mtd.")
+      },
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async ({ period }) => {
+      const metrics = await client.getMetrics(period);
+      return jsonResult(metrics);
+    }
+  );
+  server.registerTool(
+    "get_health",
+    {
+      title: "Get Cencori gateway health",
+      description: "Check gateway/platform health for the authenticated project.",
+      inputSchema: {},
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async () => jsonResult(await client.get("/v1/health"))
+  );
+  server.registerTool(
+    "check_quota",
+    {
+      title: "Check billing quota",
+      description: "Check remaining quota/credits and usage limits for the authenticated project.",
+      inputSchema: {},
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async () => jsonResult(await client.get("/v1/billing/check-quota"))
+  );
+}
+
+// src/tools/agents.ts
+var import_zod3 = require("zod");
+function registerAgentsTools(server, client) {
+  server.registerTool(
+    "list_agents",
+    {
+      title: "List Cencori agents",
+      description: "List agents available to the authenticated project.",
+      inputSchema: {},
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async () => {
+      const agents = await client.listAgents();
+      return jsonResult(agents);
+    }
+  );
+  server.registerTool(
+    "get_agent",
+    {
+      title: "Get Cencori agent",
+      description: "Fetch the full configuration for one Cencori agent by ID.",
+      inputSchema: {
+        agent_id: import_zod3.z.string().min(1).describe("The agent ID to fetch.")
+      },
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async ({ agent_id }) => {
+      const agent = await client.getAgent(agent_id);
+      return jsonResult(agent);
+    }
+  );
+  server.registerTool(
+    "poll_agent_actions",
+    {
+      title: "Poll pending agent actions",
+      description: "Poll for pending actions queued for agents in the authenticated project.",
+      inputSchema: {},
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async () => jsonResult(await client.get("/v1/agent/actions/poll"))
+  );
+}
+
+// src/tools/memory.ts
+var import_zod4 = require("zod");
+var scopeShape = {
+  namespace: import_zod4.z.string().optional().describe("Memory namespace to scope to."),
+  scope: import_zod4.z.string().optional().describe("Memory scope (e.g. project, user, session)."),
+  user_id: import_zod4.z.string().optional().describe("Scope to a specific end-user id."),
+  session_id: import_zod4.z.string().optional().describe("Scope to a specific session id.")
+};
+function registerMemoryTools(server, client) {
+  server.registerTool(
+    "list_memories",
+    {
+      title: "List memories",
+      description: "List stored memories for the project, optionally scoped by namespace/user/session.",
+      inputSchema: {
+        ...scopeShape,
+        limit: import_zod4.z.number().int().positive().max(200).optional(),
+        cursor: import_zod4.z.string().optional().describe("Pagination cursor from a previous response.")
+      },
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async ({ namespace, scope, user_id, session_id, limit, cursor }) => jsonResult(
+      await client.get("/v1/memory/list", {
+        namespace,
+        scope,
+        userId: user_id,
+        sessionId: session_id,
+        limit: limit?.toString(),
+        cursor
+      })
+    )
+  );
+  server.registerTool(
+    "search_memory",
+    {
+      title: "Search memory (semantic)",
+      description: "Semantically search stored memories by query.",
+      inputSchema: {
+        query: import_zod4.z.string().min(1).describe("Natural-language search query."),
+        ...scopeShape,
+        top_k: import_zod4.z.number().int().positive().max(100).optional().describe("Max results."),
+        threshold: import_zod4.z.number().min(0).max(1).optional().describe("Similarity threshold.")
+      },
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async ({ query, namespace, scope, user_id, session_id, top_k, threshold }) => jsonResult(
+      await client.post("/v1/memory/search", {
+        query,
+        namespace,
+        scope,
+        userId: user_id,
+        sessionId: session_id,
+        topK: top_k,
+        threshold
+      })
+    )
+  );
+  server.registerTool(
+    "get_memory",
+    {
+      title: "Get a memory",
+      description: "Fetch a single memory by id.",
+      inputSchema: { memory_id: import_zod4.z.string().min(1).describe("The memory id.") },
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async ({ memory_id }) => jsonResult(await client.get(`/v1/memory/${memory_id}`))
+  );
+  server.registerTool(
+    "list_memory_entities",
+    {
+      title: "List memory entities",
+      description: "List entities resolved from the memory graph.",
+      inputSchema: scopeShape,
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async ({ namespace, scope, user_id, session_id }) => jsonResult(
+      await client.get("/v1/memory/entities", {
+        namespace,
+        scope,
+        userId: user_id,
+        sessionId: session_id
+      })
+    )
+  );
+  server.registerTool(
+    "get_memory_graph",
+    {
+      title: "Get memory entity graph",
+      description: "Traverse the memory entity graph from an optional starting entity.",
+      inputSchema: {
+        ...scopeShape,
+        entity: import_zod4.z.string().optional().describe("Entity to start traversal from."),
+        hops: import_zod4.z.number().int().positive().max(5).optional().describe("Traversal depth.")
+      },
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async ({ namespace, scope, user_id, session_id, entity, hops }) => jsonResult(
+      await client.get("/v1/memory/graph", {
+        namespace,
+        scope,
+        userId: user_id,
+        sessionId: session_id,
+        entity,
+        hops: hops?.toString()
+      })
+    )
+  );
+  server.registerTool(
+    "get_forget_suggestions",
+    {
+      title: "Get forget suggestions",
+      description: "List memories the system suggests forgetting (stale/superseded).",
+      inputSchema: scopeShape,
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async ({ namespace, scope, user_id, session_id }) => jsonResult(
+      await client.get("/v1/memory/forget-suggestions", {
+        namespace,
+        scope,
+        userId: user_id,
+        sessionId: session_id
+      })
+    )
+  );
+}
+
+// src/tools/sessions.ts
+var import_zod5 = require("zod");
+function registerSessionsTools(server, client) {
+  server.registerTool(
+    "list_sessions",
+    {
+      title: "List agent sessions",
+      description: "List agent sessions for the project, optionally filtered by status or agent.",
+      inputSchema: {
+        status: import_zod5.z.string().optional().describe("Filter by session status."),
+        agent_id: import_zod5.z.string().optional().describe("Filter by agent id."),
+        page: import_zod5.z.number().int().positive().optional(),
+        limit: import_zod5.z.number().int().positive().max(100).optional()
+      },
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async ({ status, agent_id, page, limit }) => jsonResult(
+      await client.get("/v1/sessions", {
+        status,
+        agent_id,
+        page: page?.toString(),
+        limit: limit?.toString()
+      })
+    )
+  );
+  server.registerTool(
+    "get_session",
+    {
+      title: "Get an agent session",
+      description: "Fetch one agent session by id.",
+      inputSchema: { session_id: import_zod5.z.string().min(1).describe("The session id.") },
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async ({ session_id }) => jsonResult(await client.get(`/v1/sessions/${session_id}`))
+  );
+  server.registerTool(
+    "get_session_events",
+    {
+      title: "Get agent session events",
+      description: "List the event timeline for one agent session.",
+      inputSchema: { session_id: import_zod5.z.string().min(1).describe("The session id.") },
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async ({ session_id }) => jsonResult(await client.get(`/v1/sessions/${session_id}/events`))
+  );
+}
+
+// src/tools/governance.ts
+var import_zod6 = require("zod");
+function registerGovernanceTools(server, client) {
+  server.registerTool(
+    "list_policies",
+    {
+      title: "List governance policies",
+      description: "List governance policies for the org, optionally filtered by status.",
+      inputSchema: {
+        status: import_zod6.z.enum(["draft", "pending_review", "active", "retired"]).optional()
+      },
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async ({ status }) => jsonResult(await client.get("/v1/governance/policies", { status }))
+  );
+  server.registerTool(
+    "list_roles",
+    {
+      title: "List governance roles",
+      description: "List governance roles defined for the org.",
+      inputSchema: {},
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async () => jsonResult(await client.get("/v1/governance/roles"))
+  );
+  server.registerTool(
+    "list_change_requests",
+    {
+      title: "List governance change requests",
+      description: "List maker-checker change requests for governance policies.",
+      inputSchema: {},
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async () => jsonResult(await client.get("/v1/governance/change-requests"))
+  );
+  server.registerTool(
+    "get_governance_ledger",
+    {
+      title: "Get governance audit ledger",
+      description: "Read the immutable governance audit ledger.",
+      inputSchema: {},
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async () => jsonResult(await client.get("/v1/governance/ledger"))
+  );
+  server.registerTool(
+    "get_governance_evidence",
+    {
+      title: "Get governance evidence",
+      description: "Read governance evidence records (enforcement decisions).",
+      inputSchema: {},
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async () => jsonResult(await client.get("/v1/governance/evidence"))
+  );
+  server.registerTool(
+    "list_governance_templates",
+    {
+      title: "List governance policy templates",
+      description: "List installable governance policy templates.",
+      inputSchema: {},
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async () => jsonResult(await client.get("/v1/governance/templates"))
+  );
+}
+
+// src/tools/multimodal.ts
+var import_zod7 = require("zod");
+var messageSchema = import_zod7.z.array(
+  import_zod7.z.object({
+    role: import_zod7.z.enum(["system", "user", "assistant"]),
+    content: import_zod7.z.string()
+  })
+).min(1).describe("Chat messages in OpenAI format.");
+var imageSourceShape = {
+  image_url: import_zod7.z.string().url().optional().describe("Public URL of the image."),
+  image_base64: import_zod7.z.string().optional().describe("Base64-encoded image bytes (use with mime_type)."),
+  mime_type: import_zod7.z.string().optional().describe("MIME type for image_base64, e.g. image/png."),
+  prompt: import_zod7.z.string().optional().describe("Optional instruction to steer the analysis."),
+  model: import_zod7.z.string().optional().describe("Override the model.")
+};
+var documentSourceShape = {
+  document_url: import_zod7.z.string().url().optional().describe("Public URL of the PDF/image."),
+  document_base64: import_zod7.z.string().optional().describe("Base64-encoded document bytes (use with mime_type)."),
+  mime_type: import_zod7.z.string().optional().describe("MIME type for document_base64, e.g. application/pdf."),
+  model: import_zod7.z.string().optional().describe("Override the model.")
+};
+function registerMultimodalTools(server, client) {
+  server.registerTool(
+    "generate_text",
+    {
+      title: "Generate text (chat completion)",
+      description: "Run a chat completion through the Cencori gateway. Incurs usage/cost.",
+      inputSchema: {
+        model: import_zod7.z.string().describe("Model id, e.g. llama-3.1-8b-instant or claude-opus-5."),
+        messages: messageSchema,
+        temperature: import_zod7.z.number().min(0).max(2).optional(),
+        max_tokens: import_zod7.z.number().int().positive().optional()
+      },
+      annotations: WRITE_ANNOTATIONS
+    },
+    async ({ model, messages, temperature, max_tokens }) => jsonResult(await client.post("/v1/chat/completions", { model, messages, temperature, max_tokens }))
+  );
+  server.registerTool(
+    "generate_rag",
+    {
+      title: "RAG chat over a memory namespace",
+      description: "Answer a question grounded in stored memories for a namespace. Incurs usage/cost.",
+      inputSchema: {
+        model: import_zod7.z.string().describe("Model id for the answer."),
+        messages: messageSchema,
+        namespace: import_zod7.z.string().min(1).describe("Memory namespace to retrieve context from."),
+        limit: import_zod7.z.number().int().positive().optional().describe("Max memories to retrieve.")
+      },
+      annotations: WRITE_ANNOTATIONS
+    },
+    async ({ model, messages, namespace, limit }) => jsonResult(await client.post("/ai/rag", { model, messages, namespace, limit }))
+  );
+  server.registerTool(
+    "create_embeddings",
+    {
+      title: "Create embeddings",
+      description: "Generate vector embeddings for text. Incurs usage/cost.",
+      inputSchema: {
+        input: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.array(import_zod7.z.string())]).describe("Text or array of texts to embed."),
+        model: import_zod7.z.string().optional().describe("Embedding model. Defaults to text-embedding-3-small."),
+        dimensions: import_zod7.z.number().int().positive().optional()
+      },
+      annotations: WRITE_ANNOTATIONS
+    },
+    async ({ input, model, dimensions }) => jsonResult(await client.post("/ai/embeddings", { input, model, dimensions }))
+  );
+  server.registerTool(
+    "moderate_content",
+    {
+      title: "Moderate content",
+      description: "Classify text for policy violations via the moderation endpoint.",
+      inputSchema: {
+        input: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.array(import_zod7.z.string())]).describe("Text or array of texts to moderate."),
+        model: import_zod7.z.string().optional()
+      },
+      annotations: WRITE_ANNOTATIONS
+    },
+    async ({ input, model }) => jsonResult(await client.post("/ai/moderation", { input, model }))
+  );
+  server.registerTool(
+    "generate_image",
+    {
+      title: "Generate an image",
+      description: "Generate image(s) from a text prompt. Incurs usage/cost.",
+      inputSchema: {
+        prompt: import_zod7.z.string().min(1).describe("Text prompt describing the image."),
+        model: import_zod7.z.string().optional(),
+        n: import_zod7.z.number().int().positive().optional().describe("Number of images."),
+        size: import_zod7.z.string().optional().describe("Image size, e.g. 1024x1024.")
+      },
+      annotations: WRITE_ANNOTATIONS
+    },
+    async ({ prompt, model, n, size }) => jsonResult(await client.post("/ai/images/generate", { prompt, model, n, size }))
+  );
+  for (const [name, path, title] of [
+    ["describe_image", "/ai/vision/describe", "Describe an image"],
+    ["ocr_image", "/ai/vision/ocr", "Extract text from an image (OCR)"],
+    ["classify_image", "/ai/vision/classify", "Classify an image (JSON tags)"]
+  ]) {
+    server.registerTool(
+      name,
+      {
+        title,
+        description: `${title} via the Cencori vision endpoint. Incurs usage/cost.`,
+        inputSchema: imageSourceShape,
+        annotations: WRITE_ANNOTATIONS
+      },
+      async (args) => jsonResult(await client.post(path, args))
+    );
+  }
+  server.registerTool(
+    "extract_document",
+    {
+      title: "Extract text from a document",
+      description: "Extract clean text from a PDF or image (native extraction for text PDFs). Incurs usage/cost for OCR.",
+      inputSchema: documentSourceShape,
+      annotations: WRITE_ANNOTATIONS
+    },
+    async (args) => jsonResult(await client.post("/ai/documents/extract", args))
+  );
+  server.registerTool(
+    "summarize_document",
+    {
+      title: "Summarize a document",
+      description: "Extract and summarize a PDF or image. Incurs usage/cost.",
+      inputSchema: { ...documentSourceShape, prompt: import_zod7.z.string().optional().describe("Optional summary instruction.") },
+      annotations: WRITE_ANNOTATIONS
+    },
+    async (args) => jsonResult(await client.post("/ai/documents/summarize", args))
+  );
+  server.registerTool(
+    "query_document",
+    {
+      title: "Ask a question about a document",
+      description: "Extract a document and answer a question about it. Incurs usage/cost.",
+      inputSchema: {
+        ...documentSourceShape,
+        question: import_zod7.z.string().min(1).describe("The question to answer about the document.")
+      },
+      annotations: WRITE_ANNOTATIONS
+    },
+    async (args) => jsonResult(await client.post("/ai/documents/query", args))
+  );
+}
+
+// src/tools/guidance.ts
+var import_zod8 = require("zod");
+var orgProjectShape = {
+  org_slug: import_zod8.z.string().min(1).optional().describe("Your organization slug, to build an exact dashboard link."),
+  project_slug: import_zod8.z.string().min(1).optional().describe("Your project slug, to build an exact dashboard link.")
+};
+function registerGuide(server, name, title, description, buildPath, steps, baseUrl) {
+  server.registerTool(
+    name,
+    {
+      title,
+      description,
+      inputSchema: orgProjectShape,
+      annotations: READ_ONLY_ANNOTATIONS
+    },
+    async (args) => {
+      return jsonResult({
+        manual_action: true,
+        note: "This action is intentionally not automated. Tell the user to complete it themselves in the Cencori dashboard.",
+        steps,
+        dashboard_url: `${baseUrl}${buildPath(args)}`
+      });
+    }
+  );
+}
+var ORG = (s) => s.org_slug ?? "<your-org>";
+var PROJ = (s) => s.project_slug ?? "<your-project>";
+function registerGuidanceTools(server, baseUrl) {
+  registerGuide(
+    server,
+    "how_to_create_api_key",
+    "How to create a Cencori API key",
+    "Steps for the USER to create a Cencori project API key. The MCP never creates keys.",
+    (s) => `/${ORG(s)}/${PROJ(s)}/api-keys`,
+    [
+      "Open the Cencori dashboard and select your organization, then your project.",
+      "Go to the project\u2019s API Keys page.",
+      "Click \u201CCreate key\u201D, name it, choose the environment, and copy the `csk_...` secret.",
+      "Store it server-side as CENCORI_API_KEY \u2014 it is shown only once."
+    ],
+    baseUrl
+  );
+  registerGuide(
+    server,
+    "how_to_edit_api_key",
+    "How to edit a Cencori API key",
+    "Steps for the USER to rename or change scopes/limits on an API key. The MCP never edits keys.",
+    (s) => `/${ORG(s)}/${PROJ(s)}/api-keys`,
+    [
+      "Open the project\u2019s API Keys page in the dashboard.",
+      "Find the key and open its actions menu.",
+      "Update its name, environment, or limits and save."
+    ],
+    baseUrl
+  );
+  registerGuide(
+    server,
+    "how_to_revoke_api_key",
+    "How to revoke a Cencori API key",
+    "Steps for the USER to revoke/rotate an API key. The MCP never revokes keys.",
+    (s) => `/${ORG(s)}/${PROJ(s)}/api-keys`,
+    [
+      "Open the project\u2019s API Keys page in the dashboard.",
+      "Find the key to revoke and choose \u201CRevoke\u201D. This immediately invalidates it.",
+      "If rotating, create a new key first and update CENCORI_API_KEY before revoking the old one."
+    ],
+    baseUrl
+  );
+  registerGuide(
+    server,
+    "how_to_activate_policy",
+    "How to activate a governance policy",
+    "Steps for the USER to activate/retire a governance policy. Activation is a maker-checker human step \u2014 the MCP can draft a policy but never activates one.",
+    (s) => `/${ORG(s)}/~/governance`,
+    [
+      "Open the Governance page for your organization in the dashboard.",
+      "Find the draft (or pending-review) policy version.",
+      "Review it and, as an authorized checker, activate it. Exactly one version per policy can be active."
+    ],
+    baseUrl
+  );
+  registerGuide(
+    server,
+    "how_to_respond_to_change_request",
+    "How to respond to a governance change request",
+    "Steps for the USER (as checker) to approve or reject a governance change request. The MCP never approves/rejects on the user\u2019s behalf.",
+    (s) => `/${ORG(s)}/~/governance`,
+    [
+      "Open the Governance page and go to Change Requests.",
+      "Open the pending request and review the proposed change.",
+      "As an authorized checker, approve or reject it."
+    ],
+    baseUrl
+  );
+  registerGuide(
+    server,
+    "how_to_change_plan",
+    "How to change your Cencori plan",
+    "Steps for the USER to change plan/tier. The MCP never changes plans or charges.",
+    (s) => `/${ORG(s)}/~/billing`,
+    [
+      "Open the Billing page for your organization in the dashboard.",
+      "Choose the plan you want and confirm the change."
+    ],
+    baseUrl
+  );
+  registerGuide(
+    server,
+    "how_to_manage_billing",
+    "How to manage billing, payment methods, and credits",
+    "Steps for the USER to update payment methods or buy credits. The MCP never manages payment or credits.",
+    (s) => `/${ORG(s)}/~/billing`,
+    [
+      "Open the Billing page for your organization in the dashboard.",
+      "Update a payment method, or purchase credits, from the billing controls."
+    ],
+    baseUrl
+  );
+  registerGuide(
+    server,
+    "how_to_manage_members",
+    "How to manage members, roles, and SSO",
+    "Steps for the USER to invite/remove members, change roles, or configure SSO. The MCP never alters access.",
+    (s) => `/${ORG(s)}/~/teams`,
+    [
+      "Open the Teams page for your organization in the dashboard.",
+      "Invite or remove members, or change a member\u2019s role.",
+      "Configure SSO from the organization settings if applicable."
+    ],
+    baseUrl
+  );
+}
+
+// src/server.ts
+var SERVER_NAME = "cencori";
+var SERVER_VERSION = "0.2.0";
+function createServer(config) {
+  const server = new import_mcp.McpServer(
+    {
+      name: SERVER_NAME,
+      version: SERVER_VERSION,
+      websiteUrl: "https://cencori.com/docs"
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  const { features, capabilities } = config;
+  if (features.docs) {
+    const docs = new DocsClient(config.docsBaseUrl);
+    registerDocsTools(server, docs, config.docsBaseUrl);
+  }
+  if (features.guidance) {
+    registerGuidanceTools(server, config.baseUrl);
+  }
+  if (config.apiKey) {
+    const client = new PlatformClient(config.baseUrl, config.apiKey);
+    if (features.gateway) registerGatewayTools(server, client);
+    if (features.agents) registerAgentsTools(server, client);
+    if (features.memory) registerMemoryTools(server, client);
+    if (features.sessions) registerSessionsTools(server, client);
+    if (features.governance) registerGovernanceTools(server, client);
+    if (features.multimodal && capabilities.write) {
+      registerMultimodalTools(server, client);
+    }
+  }
+  return server;
+}
+
+// src/index.ts
+async function main() {
+  const config = loadConfig();
+  const server = createServer(config);
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+  const enabledFeatures = Object.entries(config.features).filter(([, enabled]) => enabled).map(([feature]) => feature).join(", ");
+  const tier = config.capabilities.destructive ? "read+write+destructive" : config.capabilities.write ? "read+write" : "read-only";
+  console.error(
+    `Cencori MCP server running (tier=${tier}, base=${config.baseUrl}, features=${enabledFeatures}, apiKey=${config.apiKey ? "configured" : "not set"})`
+  );
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map