@inf-mcp/mcp-server 0.1.0

package/dist/index.js

@@ -0,0 +1,1696 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z, ZodError } from 'zod';
+import { readFile } from 'fs/promises';
+import * as path from 'path';
+import { basename } from 'path';
+import * as fs2 from 'fs';
+
+var ApiKeySchema = z.string().startsWith("inf_", "API key must start with 'inf_'");
+var InflectivApiError = class extends Error {
+  constructor(status, body) {
+    const msg = typeof body === "object" && body !== null && "detail" in body ? String(body.detail) : JSON.stringify(body);
+    super(`HTTP ${status}: ${msg}`);
+    this.status = status;
+    this.body = body;
+    this.name = "InflectivApiError";
+  }
+};
+var InflectivClient = class {
+  apiKey;
+  baseUrl;
+  constructor(apiKey, baseUrl) {
+    this.apiKey = apiKey ? ApiKeySchema.parse(apiKey) : null;
+    this.baseUrl = (baseUrl ?? "https://app.inflectiv.ai/api/platform").replace(/\/$/, "");
+  }
+  /** Returns the API path prefix based on environment:
+   *  - Production (app.inflectiv.ai/api/platform): no prefix (proxy adds /ext/)
+   *  - Railway dev: /api/platform prefix (Next.js proxy)
+   *  - Localhost: /api/v2 prefix (direct API access)
+   */
+  get pathPrefix() {
+    if (this.baseUrl.includes("app.inflectiv.ai")) {
+      return "";
+    }
+    if (this.baseUrl.includes("localhost") || this.baseUrl.includes("127.0.0.1")) {
+      return "/api/v2";
+    }
+    return "/api/platform";
+  }
+  headers(extra) {
+    const h = {};
+    if (this.apiKey) {
+      h["X-API-Key"] = this.apiKey;
+    }
+    return { ...h, ...extra };
+  }
+  async request(method, path2, body) {
+    const url = `${this.baseUrl}${path2}`.replace(/\/+$/, "");
+    const init = {
+      method,
+      headers: this.headers(
+        body !== void 0 ? { "Content-Type": "application/json" } : void 0
+      ),
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    };
+    const res = await fetch(url, init);
+    if (!res.ok) {
+      let errorBody;
+      try {
+        errorBody = await res.json();
+      } catch {
+        errorBody = await res.text();
+      }
+      throw new InflectivApiError(res.status, errorBody);
+    }
+    return res.json();
+  }
+  async get(path2) {
+    return this.request("GET", path2);
+  }
+  async post(path2, body) {
+    return this.request("POST", path2, body);
+  }
+  async put(path2, body) {
+    return this.request("PUT", path2, body);
+  }
+  async patch(path2, body) {
+    return this.request("PATCH", path2, body);
+  }
+  async delete(path2) {
+    return this.request("DELETE", path2);
+  }
+  async uploadFile(path2, fileBuffer, filename, title) {
+    const formData = new FormData();
+    const blob = new Blob([fileBuffer]);
+    formData.append("file", blob, filename);
+    if (title) {
+      formData.append("title", title);
+    }
+    const url = `${this.baseUrl}${path2}`.replace(/\/+$/, "");
+    const res = await fetch(url, {
+      method: "POST",
+      headers: this.headers(),
+      body: formData
+    });
+    if (!res.ok) {
+      let errorBody;
+      try {
+        errorBody = await res.json();
+      } catch {
+        errorBody = await res.text();
+      }
+      throw new InflectivApiError(res.status, errorBody);
+    }
+    return res.json();
+  }
+};
+function formatError(err) {
+  let message;
+  if (err instanceof InflectivApiError) {
+    const body = err.body;
+    let detail = err.message;
+    if (typeof body === "object" && body !== null) {
+      const b = body;
+      if (b.detail) detail = String(b.detail);
+      if (b.credits_required) {
+        detail += `
+
+Insufficient credits. Required: ${b.credits_required}, Available: ${b.credits_available ?? "unknown"}. Top up at https://app.inflectiv.ai`;
+      }
+    }
+    message = `Inflectiv API Error (${err.status}): ${detail}`;
+  } else if (err instanceof ZodError) {
+    const issues = err.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
+    message = `Validation Error:
+${issues}`;
+  } else if (err instanceof Error) {
+    message = err.message.includes("fetch failed") ? `Network error: Could not reach Inflectiv API. Check your INFLECTIV_BASE_URL and network connection.` : `Error: ${err.message}`;
+  } else {
+    message = `Unknown error: ${String(err)}`;
+  }
+  return {
+    content: [{ type: "text", text: message }],
+    isError: true
+  };
+}
+
+// src/tools/agents.ts
+function registerAgentTools(server, client) {
+  server.tool(
+    "inflectiv_list_agents",
+    "List all agents owned by you that have the API key's dataset attached. Free.",
+    {},
+    async () => {
+      try {
+        const data = await client.get(`${client.pathPrefix}/ext/agents/`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_create_agent",
+    "Create a new AI agent attached to the API key's dataset. Costs 5 credits.",
+    {
+      name: z.string().min(1).max(255).describe("Agent name"),
+      description: z.string().max(1e3).optional().describe("Agent description"),
+      personality: z.string().optional().describe(
+        'Agent personality style (default: "professional")'
+      ),
+      system_instructions: z.string().max(2e3).optional().describe("Custom system instructions for the agent"),
+      response_length: z.string().optional().describe('Response length preference (default: "concise")'),
+      model_name: z.string().optional().describe('LLM model name (default: "gpt-4o-mini")'),
+      temperature: z.number().int().min(0).max(100).optional().describe("Temperature 0-100 (default: 70)")
+    },
+    async (params) => {
+      try {
+        const data = await client.post(`${client.pathPrefix}/ext/agents/`, params);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_get_agent",
+    "Get details of a specific agent. Free.",
+    {
+      agent_id: z.number().int().describe("Agent ID")
+    },
+    async ({ agent_id }) => {
+      try {
+        const data = await client.get(`${client.pathPrefix}/ext/agents/${agent_id}`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_update_agent_config",
+    "Update an agent's configuration (personality, instructions, model, temperature, etc.). Costs 2 credits.",
+    {
+      agent_id: z.number().int().describe("Agent ID"),
+      name: z.string().min(1).max(255).optional().describe("Agent name"),
+      description: z.string().max(1e3).optional().describe("Agent description"),
+      personality: z.string().optional().describe("Agent personality style"),
+      system_instructions: z.string().max(2e3).optional().describe("Custom system instructions"),
+      response_length: z.string().optional().describe("Response length preference"),
+      model_name: z.string().optional().describe("LLM model name"),
+      temperature: z.number().int().min(0).max(100).optional().describe("Temperature 0-100")
+    },
+    async ({ agent_id, ...body }) => {
+      try {
+        const data = await client.put(
+          `${client.pathPrefix}/ext/agents/${agent_id}/config`,
+          body
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_chat_with_agent",
+    "Send a message to an agent and get a RAG-enabled response. Costs 1 credit. Provide conversation_history as an array of {role, content} objects for multi-turn chat.",
+    {
+      agent_id: z.number().int().describe("Agent ID"),
+      message: z.string().min(1).max(4e3).describe("Message to send"),
+      conversation_history: z.array(
+        z.object({
+          role: z.string().describe('Message role (e.g. "user", "assistant")'),
+          content: z.string().describe("Message content")
+        })
+      ).optional().describe("Previous conversation messages for context")
+    },
+    async ({ agent_id, message, conversation_history }) => {
+      try {
+        const data = await client.post(`${client.pathPrefix}/ext/agents/${agent_id}/chat`, {
+          message,
+          conversation_history: conversation_history ?? []
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_list_agent_datasets",
+    "List all datasets attached to an agent. Free.",
+    {
+      agent_id: z.number().int().describe("Agent ID")
+    },
+    async ({ agent_id }) => {
+      try {
+        const data = await client.get(`${client.pathPrefix}/ext/agents/${agent_id}/datasets`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_attach_dataset",
+    'Attach a dataset to an agent. Free. Mode can be "read_only" or "self_learning".',
+    {
+      agent_id: z.number().int().describe("Agent ID"),
+      dataset_id: z.number().int().describe("Dataset ID to attach"),
+      mode: z.enum(["read_only", "self_learning"]).optional().describe('Dataset mode (default: "read_only")')
+    },
+    async ({ agent_id, dataset_id, mode }) => {
+      try {
+        const data = await client.post(
+          `${client.pathPrefix}/ext/agents/${agent_id}/datasets`,
+          {
+            dataset_id,
+            mode: mode ?? "read_only"
+          }
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_update_dataset_mode",
+    'Update the mode of a dataset attached to an agent. Mode: "read_only" or "self_learning". Free.',
+    {
+      agent_id: z.number().int().describe("Agent ID"),
+      dataset_id: z.number().int().describe("Dataset ID"),
+      mode: z.enum(["read_only", "self_learning"]).describe("New dataset mode")
+    },
+    async ({ agent_id, dataset_id, mode }) => {
+      try {
+        const data = await client.patch(
+          `${client.pathPrefix}/ext/agents/${agent_id}/datasets/${dataset_id}`,
+          { mode }
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+}
+function registerDatasetTools(server, client) {
+  server.tool(
+    "inflectiv_list_datasets",
+    "List datasets accessible via this API key. Free.",
+    {},
+    async () => {
+      try {
+        const data = await client.get(`${client.pathPrefix}/ext/datasets/`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_update_dataset",
+    "Update dataset name and/or description. Only dataset owner can update. Free.",
+    {
+      name: z.string().min(1).max(255).optional().describe("New dataset name"),
+      description: z.string().max(1e3).optional().describe("New dataset description")
+    },
+    async (params) => {
+      try {
+        const data = await client.put(`${client.pathPrefix}/ext/datasets/`, params);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_reindex_dataset",
+    "Reindex dataset vectors. Useful after bulk changes. Costs 2 credits.",
+    {},
+    async () => {
+      try {
+        const data = await client.post(`${client.pathPrefix}/ext/datasets/reindex`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_search_dataset",
+    "Semantic search across the dataset's knowledge base. Costs 1 credit.",
+    {
+      query: z.string().min(1).max(2e3).describe("Search query"),
+      top_k: z.number().int().min(1).max(20).optional().describe("Number of results to return (default: 5)"),
+      score_threshold: z.number().min(0).max(1).optional().describe("Minimum similarity score 0.0-1.0 (default: 0.6)")
+    },
+    async (params) => {
+      try {
+        const data = await client.post(`${client.pathPrefix}/ext/datasets/query`, params);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_batch_search",
+    "Run multiple semantic searches in a single call. Costs 1 credit per query.",
+    {
+      queries: z.array(z.string()).min(1).max(20).describe("List of search queries (1-20)"),
+      top_k: z.number().int().min(1).max(20).optional().describe("Number of results per query (default: 5)"),
+      score_threshold: z.number().min(0).max(1).optional().describe("Minimum similarity score 0.0-1.0 (default: 0.6)")
+    },
+    async (params) => {
+      try {
+        const data = await client.post(
+          `${client.pathPrefix}/ext/datasets/query/batch`,
+          params
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_write_intelligence",
+    "Write a single intelligence entry to the dataset. Costs 1 credit (0 if duplicate detected). Content is embedded and becomes searchable.",
+    {
+      agent_id: z.number().int().describe("Agent ID that owns this intelligence"),
+      content: z.string().min(1).max(5e4).describe("Intelligence content text"),
+      title: z.string().max(255).optional().describe("Title for the intelligence entry"),
+      source_type: z.enum(["agent_text", "agent_url"]).optional().describe('Source type (default: "agent_text")'),
+      source_identifier: z.string().max(2e3).optional().describe("Source identifier (e.g. URL)")
+    },
+    async ({ agent_id, ...body }) => {
+      try {
+        const data = await client.post(
+          `${client.pathPrefix}/ext/datasets/intelligence?agent_id=${agent_id}`,
+          body
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_batch_write_intelligence",
+    "Write multiple intelligence entries in a single call. Costs 1 credit per new entry (duplicates are free). Max 50 entries.",
+    {
+      agent_id: z.number().int().describe("Agent ID that owns these intelligence entries"),
+      entries: z.array(
+        z.object({
+          content: z.string().min(1).max(5e4).describe("Intelligence content text"),
+          title: z.string().max(255).optional().describe("Entry title"),
+          source_type: z.enum(["agent_text", "agent_url"]).optional().describe('Source type (default: "agent_text")'),
+          source_identifier: z.string().max(2e3).optional().describe("Source identifier")
+        })
+      ).min(1).max(50).describe("Intelligence entries to write (1-50)")
+    },
+    async ({ agent_id, entries }) => {
+      try {
+        const data = await client.post(
+          `${client.pathPrefix}/ext/datasets/intelligence/batch?agent_id=${agent_id}`,
+          { entries }
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_list_intelligence",
+    "List intelligence entries in the dataset. Free. Filter by agent_id, status, with pagination.",
+    {
+      agent_id: z.number().int().optional().describe("Filter by agent ID"),
+      status: z.enum(["processing", "processed", "failed"]).optional().describe("Filter by processing status"),
+      limit: z.number().int().min(1).max(100).optional().describe("Number of entries to return (default: 50)"),
+      offset: z.number().int().min(0).optional().describe("Offset for pagination (default: 0)")
+    },
+    async ({ agent_id, status, limit, offset }) => {
+      try {
+        const params = new URLSearchParams();
+        if (agent_id !== void 0) params.set("agent_id", String(agent_id));
+        if (status) params.set("status", status);
+        if (limit !== void 0) params.set("limit", String(limit));
+        if (offset !== void 0) params.set("offset", String(offset));
+        const qs = params.toString();
+        const path2 = `${client.pathPrefix}/ext/datasets/intelligence${qs ? `?${qs}` : ""}`;
+        const data = await client.get(path2);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+}
+var SUPPORTED_EXTENSIONS = [
+  ".pdf",
+  ".docx",
+  ".txt",
+  ".md",
+  ".html",
+  ".csv",
+  ".json",
+  ".jsonl",
+  ".tsv",
+  ".xlsx",
+  ".xls",
+  ".parquet",
+  ".xml"
+];
+function registerFileTools(server, client) {
+  server.tool(
+    "inflectiv_list_files",
+    "List files (knowledge sources) in the dataset. Free.",
+    {
+      skip: z.number().int().min(0).optional().describe("Number of files to skip (default: 0)"),
+      limit: z.number().int().min(1).max(100).optional().describe("Number of files to return (default: 50)")
+    },
+    async ({ skip, limit }) => {
+      try {
+        const params = new URLSearchParams();
+        if (skip !== void 0) params.set("skip", String(skip));
+        if (limit !== void 0) params.set("limit", String(limit));
+        const qs = params.toString();
+        const path2 = `${client.pathPrefix}/ext/files/${qs ? `?${qs}` : ""}`;
+        const data = await client.get(path2);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_get_file",
+    "Get details of a specific file (knowledge source). Free.",
+    {
+      file_id: z.number().int().describe("File ID")
+    },
+    async ({ file_id }) => {
+      try {
+        const data = await client.get(`${client.pathPrefix}/ext/files/${file_id}`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_upload_file",
+    `Upload a local file to the dataset as a knowledge source. Costs 5 credits base + 1/MB over 5MB. Supported formats: ${SUPPORTED_EXTENSIONS.join(", ")}`,
+    {
+      file_path: z.string().describe("Absolute path to the local file to upload"),
+      title: z.string().max(255).optional().describe("Display title for the file")
+    },
+    async ({ file_path, title }) => {
+      try {
+        const ext = "." + file_path.split(".").pop()?.toLowerCase();
+        if (!SUPPORTED_EXTENSIONS.includes(ext)) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Unsupported file type "${ext}". Supported: ${SUPPORTED_EXTENSIONS.join(", ")}`
+              }
+            ],
+            isError: true
+          };
+        }
+        const fileBuffer = await readFile(file_path);
+        const filename = basename(file_path);
+        const data = await client.uploadFile(
+          `${client.pathPrefix}/ext/files/upload`,
+          fileBuffer,
+          filename,
+          title
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_reprocess_file",
+    "Reprocess a previously uploaded file. Useful after processing failures. Costs 5 credits.",
+    {
+      file_id: z.number().int().describe("File ID to reprocess")
+    },
+    async ({ file_id }) => {
+      try {
+        const data = await client.post(`${client.pathPrefix}/ext/files/${file_id}/reprocess`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+}
+function registerKnowledgeSourceTools(server, client) {
+  server.tool(
+    "inflectiv_list_knowledge_sources",
+    "List ALL knowledge sources in the dataset (files, URLs, manual text, AI-generated, etc.). Free.",
+    {
+      source_type: z.enum([
+        "file",
+        "url",
+        "manual",
+        "ai_generated",
+        "agent_text",
+        "agent_url",
+        "token_pair"
+      ]).optional().describe("Filter by source type"),
+      status: z.enum(["processing", "processed", "failed"]).optional().describe("Filter by processing status"),
+      skip: z.number().int().min(0).optional().describe("Number of items to skip (default: 0)"),
+      limit: z.number().int().min(1).max(100).optional().describe("Number of items to return (default: 50)")
+    },
+    async ({ source_type, status, skip, limit }) => {
+      try {
+        const params = new URLSearchParams();
+        if (source_type) params.set("source_type", source_type);
+        if (status) params.set("status", status);
+        if (skip !== void 0) params.set("skip", String(skip));
+        if (limit !== void 0) params.set("limit", String(limit));
+        const qs = params.toString();
+        const path2 = `${client.pathPrefix}/ext/knowledge-sources/${qs ? `?${qs}` : ""}`;
+        const data = await client.get(path2);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+}
+function registerMarketplaceTools(server, client) {
+  server.tool(
+    "inflectiv_browse_skill_marketplace",
+    "Browse published skill marketplace listings. Free. Supports search, tag filtering, price filtering, and sorting.",
+    {
+      query: z.string().max(200).optional().describe("Search query"),
+      tags: z.array(z.string()).max(10).optional().describe("Filter by tags"),
+      price_type: z.enum(["free", "one_time"]).optional().describe("Filter by price type"),
+      sort_by: z.enum(["newest", "popular", "highest_rated", "price_low", "price_high"]).optional().describe("Sort order (default: newest)"),
+      platform: z.string().optional().describe("Filter by platform (evm, dogecoin)"),
+      skip: z.number().int().min(0).optional().describe("Pagination offset"),
+      limit: z.number().int().min(1).max(100).optional().describe("Pagination limit (default: 20)")
+    },
+    async (params) => {
+      try {
+        const searchParams = new URLSearchParams();
+        if (params.query) searchParams.set("query", params.query);
+        if (params.tags) params.tags.forEach((t) => searchParams.append("tags", t));
+        if (params.price_type) searchParams.set("price_type", params.price_type);
+        if (params.sort_by) searchParams.set("sort_by", params.sort_by);
+        if (params.platform) searchParams.set("platform", params.platform);
+        if (params.skip !== void 0) searchParams.set("skip", String(params.skip));
+        if (params.limit !== void 0) searchParams.set("limit", String(params.limit));
+        const qs = searchParams.toString();
+        const path2 = `${client.pathPrefix}/skill-marketplace/listings${qs ? `?${qs}` : ""}`;
+        const data = await client.get(path2);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_get_skill_listing",
+    "Get detailed information about a skill marketplace listing. Free.",
+    {
+      listing_id: z.number().describe("Skill listing ID")
+    },
+    async (params) => {
+      try {
+        const data = await client.get(
+          `${client.pathPrefix}/skill-marketplace/listings/${params.listing_id}`
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_acquire_skill",
+    "Acquire a skill from the marketplace. Free skills cost nothing. Paid skills deduct credits.",
+    {
+      listing_id: z.number().describe("Skill listing ID to acquire")
+    },
+    async (params) => {
+      try {
+        const data = await client.post(
+          `${client.pathPrefix}/skill-marketplace/listings/${params.listing_id}/acquire`
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_browse_dataset_marketplace",
+    "Browse published dataset marketplace listings. Free. No auth required.",
+    {
+      query: z.string().max(200).optional().describe("Search query"),
+      tags: z.array(z.string()).max(10).optional().describe("Filter by tags"),
+      sort_by: z.enum(["newest", "popular", "highest_rated", "price_low", "price_high"]).optional().describe("Sort order"),
+      skip: z.number().int().min(0).optional().describe("Pagination offset"),
+      limit: z.number().int().min(1).max(100).optional().describe("Pagination limit")
+    },
+    async (params) => {
+      try {
+        const searchParams = new URLSearchParams();
+        if (params.query) searchParams.set("query", params.query);
+        if (params.tags) params.tags.forEach((t) => searchParams.append("tags", t));
+        if (params.sort_by) searchParams.set("sort_by", params.sort_by);
+        if (params.skip !== void 0) searchParams.set("skip", String(params.skip));
+        if (params.limit !== void 0) searchParams.set("limit", String(params.limit));
+        const qs = searchParams.toString();
+        const path2 = `${client.pathPrefix}/marketplace/listings${qs ? `?${qs}` : ""}`;
+        const data = await client.get(path2);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_browse_agent_marketplace",
+    "Browse published agent marketplace listings. Free. No auth required.",
+    {
+      query: z.string().max(200).optional().describe("Search query"),
+      tags: z.array(z.string()).max(10).optional().describe("Filter by tags"),
+      sort_by: z.enum(["newest", "popular", "highest_rated", "price_low", "price_high"]).optional().describe("Sort order"),
+      platform: z.string().optional().describe("Filter by platform"),
+      skip: z.number().int().min(0).optional().describe("Pagination offset"),
+      limit: z.number().int().min(1).max(100).optional().describe("Pagination limit")
+    },
+    async (params) => {
+      try {
+        const searchParams = new URLSearchParams();
+        if (params.query) searchParams.set("query", params.query);
+        if (params.tags) params.tags.forEach((t) => searchParams.append("tags", t));
+        if (params.sort_by) searchParams.set("sort_by", params.sort_by);
+        if (params.platform) searchParams.set("platform", params.platform);
+        if (params.skip !== void 0) searchParams.set("skip", String(params.skip));
+        if (params.limit !== void 0) searchParams.set("limit", String(params.limit));
+        const qs = searchParams.toString();
+        const path2 = `${client.pathPrefix}/agent-marketplace/listings${qs ? `?${qs}` : ""}`;
+        const data = await client.get(path2);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+}
+var PROJECT_MARKERS = [
+  ".git",
+  "package.json",
+  "pyproject.toml",
+  "Cargo.toml",
+  "go.mod",
+  "pom.xml",
+  "build.gradle",
+  "Makefile"
+];
+var INFLECTIV_DIR = ".inflectiv";
+var MEMORY_DIR = "memory";
+var CONFIG_FILE = "config.json";
+var ENTRIES_FILE = "entries.jsonl";
+var INDEX_FILE = "index.json";
+function findProjectRoot(startDir) {
+  let dir = startDir ?? process.cwd();
+  const root = path.parse(dir).root;
+  while (dir !== root) {
+    for (const marker of PROJECT_MARKERS) {
+      if (fs2.existsSync(path.join(dir, marker))) {
+        return dir;
+      }
+    }
+    dir = path.dirname(dir);
+  }
+  return startDir ?? process.cwd();
+}
+function getMemoryDir(projectRoot) {
+  return path.join(projectRoot, INFLECTIV_DIR, MEMORY_DIR);
+}
+function getConfigPath(projectRoot) {
+  return path.join(projectRoot, INFLECTIV_DIR, CONFIG_FILE);
+}
+function getEntriesPath(projectRoot) {
+  return path.join(projectRoot, INFLECTIV_DIR, MEMORY_DIR, ENTRIES_FILE);
+}
+function getIndexPath(projectRoot) {
+  return path.join(projectRoot, INFLECTIV_DIR, MEMORY_DIR, INDEX_FILE);
+}
+function generateProjectId() {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < 8; i++) {
+    result += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return result;
+}
+function ensureProjectStructure(projectRoot) {
+  const configPath = getConfigPath(projectRoot);
+  if (fs2.existsSync(configPath)) {
+    return JSON.parse(fs2.readFileSync(configPath, "utf-8"));
+  }
+  const memoryDir = getMemoryDir(projectRoot);
+  fs2.mkdirSync(memoryDir, { recursive: true });
+  const config = {
+    project_id: generateProjectId(),
+    project_name: path.basename(projectRoot),
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    memory_count: 0
+  };
+  fs2.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  fs2.writeFileSync(getEntriesPath(projectRoot), "");
+  fs2.writeFileSync(
+    getIndexPath(projectRoot),
+    JSON.stringify({ version: 1, tag_index: {}, category_index: {}, word_index: {} })
+  );
+  return config;
+}
+
+// src/memory/memory-store.ts
+var MAX_CONTENT_LENGTH = 1e4;
+var MAX_TAGS = 10;
+function generateId() {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < 8; i++) {
+    result += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return result;
+}
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length > 2);
+}
+var MemoryStore = class {
+  projectRoot;
+  config;
+  constructor(startDir) {
+    this.projectRoot = findProjectRoot(startDir);
+    this.config = ensureProjectStructure(this.projectRoot);
+  }
+  get projectName() {
+    return this.config.project_name;
+  }
+  get projectId() {
+    return this.config.project_id;
+  }
+  get memoryCount() {
+    return this.config.memory_count;
+  }
+  write(content, category, tags = [], importance = "medium", sourceContext) {
+    if (content.length > MAX_CONTENT_LENGTH) {
+      throw new Error(`Content exceeds maximum length of ${MAX_CONTENT_LENGTH} characters`);
+    }
+    if (tags.length > MAX_TAGS) {
+      throw new Error(`Maximum ${MAX_TAGS} tags allowed`);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = {
+      id: generateId(),
+      content,
+      category,
+      tags: tags.map((t) => t.toLowerCase().trim()),
+      importance,
+      created_at: now,
+      updated_at: now,
+      source_context: sourceContext
+    };
+    const entriesPath = getEntriesPath(this.projectRoot);
+    fs2.appendFileSync(entriesPath, JSON.stringify(entry) + "\n");
+    this.addToIndex(entry);
+    this.config.memory_count++;
+    this.saveConfig();
+    return entry;
+  }
+  list(category, tags, importance, limit = 20, offset = 0) {
+    let entries = this.readAllEntries();
+    if (category) {
+      entries = entries.filter((e) => e.category === category);
+    }
+    if (tags && tags.length > 0) {
+      const lowerTags = tags.map((t) => t.toLowerCase());
+      entries = entries.filter((e) => lowerTags.some((t) => e.tags.includes(t)));
+    }
+    if (importance) {
+      entries = entries.filter((e) => e.importance === importance);
+    }
+    entries.sort((a, b) => b.created_at.localeCompare(a.created_at));
+    const total = entries.length;
+    return {
+      entries: entries.slice(offset, offset + limit),
+      total
+    };
+  }
+  search(query, category, limit = 10) {
+    const index = this.readIndex();
+    const queryTokens = tokenize(query);
+    if (queryTokens.length === 0) {
+      return this.list(category, void 0, void 0, limit).entries;
+    }
+    const scores = /* @__PURE__ */ new Map();
+    for (const token of queryTokens) {
+      const ids = index.word_index[token] ?? [];
+      for (const id of ids) {
+        scores.set(id, (scores.get(id) ?? 0) + 1);
+      }
+    }
+    let entries = this.readAllEntries();
+    if (category) {
+      entries = entries.filter((e) => e.category === category);
+    }
+    const entryMap = new Map(entries.map((e) => [e.id, e]));
+    return Array.from(scores.entries()).filter(([id]) => entryMap.has(id)).sort((a, b) => {
+      if (b[1] !== a[1]) return b[1] - a[1];
+      const ea = entryMap.get(a[0]);
+      const eb = entryMap.get(b[0]);
+      return eb.created_at.localeCompare(ea.created_at);
+    }).slice(0, limit).map(([id]) => entryMap.get(id)).filter(Boolean);
+  }
+  delete(memoryId) {
+    const entries = this.readAllEntries();
+    const filtered = entries.filter((e) => e.id !== memoryId);
+    if (filtered.length === entries.length) {
+      return false;
+    }
+    const entriesPath = getEntriesPath(this.projectRoot);
+    fs2.writeFileSync(entriesPath, filtered.map((e) => JSON.stringify(e)).join("\n") + (filtered.length > 0 ? "\n" : ""));
+    this.rebuildIndex(filtered);
+    this.config.memory_count = filtered.length;
+    this.saveConfig();
+    return true;
+  }
+  suggestSkillCreation() {
+    const entries = this.readAllEntries();
+    const breakdown = {};
+    for (const entry of entries) {
+      breakdown[entry.category] = (breakdown[entry.category] ?? 0) + 1;
+    }
+    const coverage = [];
+    const highImportance = entries.filter((e) => e.importance === "high").length;
+    if (entries.length >= 10) coverage.push("Sufficient memory volume (10+)");
+    else coverage.push(`Low memory volume (${entries.length}/10 minimum recommended)`);
+    if (Object.keys(breakdown).length >= 3) coverage.push("Good category diversity");
+    else coverage.push("Limited category diversity - consider adding more categories");
+    if (highImportance >= 3) coverage.push("Has high-importance entries for core knowledge");
+    else coverage.push("Few high-importance entries - mark key decisions as high importance");
+    const hasDocs = entries.some(
+      (e) => e.category === "architecture" || e.category === "convention" || e.category === "workflow"
+    );
+    if (hasDocs) coverage.push("Contains structural knowledge (architecture/conventions/workflows)");
+    else coverage.push("Missing structural knowledge - add architecture or convention entries");
+    const ready = entries.length >= 5 && Object.keys(breakdown).length >= 2;
+    const recommendation = ready ? "Your memories are ready for skill creation. Use inflectiv_create_skill to synthesize them into a reusable skill document." : "Continue accumulating memories across more categories before creating a skill.";
+    return {
+      memory_count: entries.length,
+      category_breakdown: breakdown,
+      coverage_analysis: coverage,
+      recommendation,
+      ready
+    };
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  updateSyncTime() {
+    this.config.last_sync_at = (/* @__PURE__ */ new Date()).toISOString();
+    this.saveConfig();
+  }
+  readAllEntries() {
+    const entriesPath = getEntriesPath(this.projectRoot);
+    if (!fs2.existsSync(entriesPath)) return [];
+    const content = fs2.readFileSync(entriesPath, "utf-8").trim();
+    if (!content) return [];
+    return content.split("\n").filter(Boolean).map((line) => JSON.parse(line));
+  }
+  readIndex() {
+    const indexPath = getIndexPath(this.projectRoot);
+    if (!fs2.existsSync(indexPath)) {
+      return { version: 1, tag_index: {}, category_index: {}, word_index: {} };
+    }
+    return JSON.parse(fs2.readFileSync(indexPath, "utf-8"));
+  }
+  addToIndex(entry) {
+    const index = this.readIndex();
+    for (const tag of entry.tags) {
+      if (!index.tag_index[tag]) index.tag_index[tag] = [];
+      index.tag_index[tag].push(entry.id);
+    }
+    if (!index.category_index[entry.category]) index.category_index[entry.category] = [];
+    index.category_index[entry.category].push(entry.id);
+    const words = tokenize(entry.content);
+    for (const word of words) {
+      if (!index.word_index[word]) index.word_index[word] = [];
+      if (!index.word_index[word].includes(entry.id)) {
+        index.word_index[word].push(entry.id);
+      }
+    }
+    fs2.writeFileSync(getIndexPath(this.projectRoot), JSON.stringify(index));
+  }
+  rebuildIndex(entries) {
+    const index = { version: 1, tag_index: {}, category_index: {}, word_index: {} };
+    for (const entry of entries) {
+      for (const tag of entry.tags) {
+        if (!index.tag_index[tag]) index.tag_index[tag] = [];
+        index.tag_index[tag].push(entry.id);
+      }
+      if (!index.category_index[entry.category]) index.category_index[entry.category] = [];
+      index.category_index[entry.category].push(entry.id);
+      const words = tokenize(entry.content);
+      for (const word of words) {
+        if (!index.word_index[word]) index.word_index[word] = [];
+        if (!index.word_index[word].includes(entry.id)) {
+          index.word_index[word].push(entry.id);
+        }
+      }
+    }
+    fs2.writeFileSync(getIndexPath(this.projectRoot), JSON.stringify(index));
+  }
+  saveConfig() {
+    const configPath = getConfigPath(this.projectRoot);
+    fs2.writeFileSync(configPath, JSON.stringify(this.config, null, 2));
+  }
+};
+
+// src/tools/skills.ts
+function registerSkillTools(server, client) {
+  server.tool(
+    "inflectiv_create_skill",
+    "Synthesize local memories into a reusable skill document and upload to Inflectiv. Costs 5 credits. Requires a global API key (inf_global_*).",
+    {
+      name: z.string().min(1).max(255).describe("Skill name"),
+      description: z.string().max(1e3).optional().describe("Skill description"),
+      domain: z.string().max(100).optional().describe("Domain (e.g., 'react', 'python', 'devops')"),
+      tags: z.array(z.string()).max(20).optional().describe("Tags for discovery"),
+      synthesized_content: z.string().min(10).max(1e5).describe("The synthesized skill document (Markdown). The agent should compose this from local memories."),
+      create_dataset: z.boolean().optional().describe("Create a backing dataset for RAG (default: true)"),
+      memory_ids: z.array(z.string()).optional().describe("Specific memory IDs to include (default: all)"),
+      agent_id: z.number().optional().describe("Auto-attach skill to this agent")
+    },
+    async (params) => {
+      try {
+        let memories = [];
+        try {
+          const store2 = new MemoryStore();
+          let entries = store2.readAllEntries();
+          if (params.memory_ids && params.memory_ids.length > 0) {
+            const ids = new Set(params.memory_ids);
+            entries = entries.filter((e) => ids.has(e.id));
+          }
+          memories = entries.map((e) => ({
+            content: e.content,
+            category: e.category,
+            tags: e.tags,
+            importance: e.importance,
+            source_context: e.source_context
+          }));
+        } catch {
+        }
+        const body = {
+          name: params.name,
+          synthesized_content: params.synthesized_content,
+          create_dataset: params.create_dataset ?? true,
+          memories
+        };
+        if (params.description) body.description = params.description;
+        if (params.domain) body.domain = params.domain;
+        if (params.tags) body.tags = params.tags;
+        if (params.agent_id) body.agent_id = params.agent_id;
+        try {
+          const store2 = new MemoryStore();
+          body.source_project_name = store2.projectName;
+        } catch {
+        }
+        const data = await client.post(`${client.pathPrefix}/ext/skills/create`, body);
+        try {
+          const store2 = new MemoryStore();
+          store2.updateSyncTime();
+        } catch {
+        }
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_apply_skill",
+    "Apply a skill to an agent. Injects the skill document into the agent's system prompt and optionally attaches the skill's dataset. Costs 2 credits.",
+    {
+      skill_id: z.number().describe("Skill ID to apply"),
+      agent_id: z.number().describe("Agent ID to apply the skill to"),
+      inject_as_prompt: z.boolean().optional().describe("Inject skill as system prompt context (default: true)"),
+      attach_dataset: z.boolean().optional().describe("Attach skill's dataset for RAG (default: true)")
+    },
+    async (params) => {
+      try {
+        const data = await client.post(
+          `${client.pathPrefix}/ext/skills/${params.skill_id}/apply`,
+          {
+            agent_id: params.agent_id,
+            inject_as_prompt: params.inject_as_prompt ?? true,
+            attach_dataset: params.attach_dataset ?? true
+          }
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_list_skills",
+    "List your skills (owned and acquired). Free.",
+    {},
+    async () => {
+      try {
+        const data = await client.get(`${client.pathPrefix}/ext/skills/`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_scan_skill_security",
+    "Preview security scan on skill content before creating. Runs passes 1-4 (secrets, PII, prompt injection, metadata) and returns findings WITHOUT spending credits. Free.",
+    {
+      synthesized_content: z.string().min(1).max(1e5).describe("The skill content to scan")
+    },
+    async (params) => {
+      try {
+        const data = await client.post(
+          `${client.pathPrefix}/ext/skills/scan-security`,
+          { synthesized_content: params.synthesized_content }
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+}
+var VALID_EVENTS = [
+  "intelligence.processed",
+  "intelligence.failed",
+  "intelligence.deduped",
+  "dataset.mode_changed"
+];
+function registerWebhookTools(server, client) {
+  server.tool(
+    "inflectiv_register_webhook",
+    `Register a webhook to receive event notifications. URL must use HTTPS. Valid events: ${VALID_EVENTS.join(", ")}. Max 10 webhooks per user. Free.`,
+    {
+      url: z.string().url().startsWith("https://", "Webhook URL must use HTTPS").min(10).max(2e3).describe("HTTPS webhook endpoint URL"),
+      events: z.array(z.enum(VALID_EVENTS)).min(1).describe("Events to subscribe to"),
+      description: z.string().max(500).optional().describe("Webhook description")
+    },
+    async (params) => {
+      try {
+        const data = await client.post(`${client.pathPrefix}/ext/webhooks/`, params);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_list_webhooks",
+    "List all registered webhooks. Free.",
+    {},
+    async () => {
+      try {
+        const data = await client.get(`${client.pathPrefix}/ext/webhooks/`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_test_webhook",
+    "Send a test event to a registered webhook to verify it's receiving payloads. Free.",
+    {
+      webhook_id: z.number().int().describe("Webhook ID to test")
+    },
+    async ({ webhook_id }) => {
+      try {
+        const data = await client.post(
+          `${client.pathPrefix}/ext/webhooks/${webhook_id}/test`
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        return formatError(err);
+      }
+    }
+  );
+}
+
+// src/memory/types.ts
+var MEMORY_CATEGORIES = [
+  "decision",
+  "constraint",
+  "workflow",
+  "architecture",
+  "gotcha",
+  "preference",
+  "convention",
+  "dependency",
+  "todo",
+  "general"
+];
+
+// src/tools/memory.ts
+var store = null;
+function getStore() {
+  if (!store) {
+    store = new MemoryStore();
+  }
+  return store;
+}
+function registerMemoryTools(server) {
+  server.tool(
+    "inflectiv_write_memory",
+    "Write a memory entry to the local project memory (.inflectiv/memory/). Free \u2014 local only, no API call.",
+    {
+      content: z.string().min(1).max(1e4).describe("Memory content (max 10,000 chars)"),
+      category: z.enum(MEMORY_CATEGORIES).describe(
+        "Category: decision, constraint, workflow, architecture, gotcha, preference, convention, dependency, todo, general"
+      ),
+      tags: z.array(z.string()).max(10).optional().describe("Up to 10 tags for filtering"),
+      importance: z.enum(["low", "medium", "high"]).optional().describe("Importance level (default: medium)"),
+      source_context: z.string().optional().describe("What prompted this memory (file path, topic)")
+    },
+    async (params) => {
+      try {
+        const s = getStore();
+        const entry = s.write(
+          params.content,
+          params.category,
+          params.tags ?? [],
+          params.importance ?? "medium",
+          params.source_context
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  status: "saved",
+                  memory_id: entry.id,
+                  project: s.projectName,
+                  total_memories: s.memoryCount,
+                  category: entry.category,
+                  tags: entry.tags
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error writing memory: ${err instanceof Error ? err.message : String(err)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_list_memories",
+    "List local project memories with optional filters. Free \u2014 local only.",
+    {
+      category: z.enum(MEMORY_CATEGORIES).optional().describe("Filter by category"),
+      tags: z.array(z.string()).optional().describe("Filter by tags (OR match)"),
+      importance: z.enum(["low", "medium", "high"]).optional().describe("Filter by importance"),
+      limit: z.number().min(1).max(100).optional().describe("Max entries to return (default: 20)"),
+      offset: z.number().min(0).optional().describe("Offset for pagination")
+    },
+    async (params) => {
+      try {
+        const s = getStore();
+        const result = s.list(
+          params.category,
+          params.tags,
+          params.importance,
+          params.limit ?? 20,
+          params.offset ?? 0
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  project: s.projectName,
+                  total: result.total,
+                  returned: result.entries.length,
+                  entries: result.entries
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error listing memories: ${err instanceof Error ? err.message : String(err)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_search_memories",
+    "Keyword search over local project memories. Free \u2014 local only.",
+    {
+      query: z.string().min(1).describe("Search query"),
+      category: z.enum(MEMORY_CATEGORIES).optional().describe("Filter by category"),
+      limit: z.number().min(1).max(50).optional().describe("Max results (default: 10)")
+    },
+    async (params) => {
+      try {
+        const s = getStore();
+        const results = s.search(params.query, params.category, params.limit ?? 10);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  project: s.projectName,
+                  query: params.query,
+                  results_count: results.length,
+                  results
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            { type: "text", text: `Error searching memories: ${err instanceof Error ? err.message : String(err)}` }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_delete_memory",
+    "Delete a memory entry by ID. Free \u2014 local only.",
+    {
+      memory_id: z.string().describe("ID of the memory entry to delete")
+    },
+    async (params) => {
+      try {
+        const s = getStore();
+        const deleted = s.delete(params.memory_id);
+        if (!deleted) {
+          return {
+            content: [{ type: "text", text: `Memory entry '${params.memory_id}' not found.` }],
+            isError: true
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  status: "deleted",
+                  memory_id: params.memory_id,
+                  remaining_memories: s.memoryCount
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            { type: "text", text: `Error deleting memory: ${err instanceof Error ? err.message : String(err)}` }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "inflectiv_suggest_skill_creation",
+    "Analyze local memories and recommend if they're ready for skill creation. Free \u2014 local only.",
+    {},
+    async () => {
+      try {
+        const s = getStore();
+        const analysis = s.suggestSkillCreation();
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                { project: s.projectName, ...analysis },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error analyzing memories: ${err instanceof Error ? err.message : String(err)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/resources/api-docs.ts
+function registerResources(server) {
+  server.resource(
+    "docs-overview",
+    "inflectiv://docs/overview",
+    {
+      description: "Inflectiv API overview \u2014 authentication, base URL, credit system",
+      mimeType: "text/markdown"
+    },
+    async () => ({
+      contents: [
+        {
+          uri: "inflectiv://docs/overview",
+          mimeType: "text/markdown",
+          text: OVERVIEW_DOC
+        }
+      ]
+    })
+  );
+  server.resource(
+    "docs-webhook-events",
+    "inflectiv://docs/webhook-events",
+    {
+      description: "Webhook event types and payload schemas",
+      mimeType: "text/markdown"
+    },
+    async () => ({
+      contents: [
+        {
+          uri: "inflectiv://docs/webhook-events",
+          mimeType: "text/markdown",
+          text: WEBHOOK_EVENTS_DOC
+        }
+      ]
+    })
+  );
+  server.resource(
+    "docs-credit-costs",
+    "inflectiv://docs/credit-costs",
+    {
+      description: "Credit cost table for all API operations",
+      mimeType: "text/markdown"
+    },
+    async () => ({
+      contents: [
+        {
+          uri: "inflectiv://docs/credit-costs",
+          mimeType: "text/markdown",
+          text: CREDIT_COSTS_DOC
+        }
+      ]
+    })
+  );
+}
+var OVERVIEW_DOC = `# Inflectiv API Overview
+
+## Authentication
+All requests require an API key passed via the \`X-API-Key\` header.
+API keys have the prefix \`inf_\` and are scoped to a single dataset.
+
+## Base URL
+Production (via Next.js proxy):
+\`\`\`
+https://app.inflectiv.ai/api/platform/ext/
+\`\`\`
+Local development:
+\`\`\`
+http://localhost:18001/api/v2/ext/
+\`\`\`
+
+## Concepts
+
+### Agents
+AI chatbots trained on your data. Each agent can have datasets attached for RAG-enabled conversations.
+
+### Datasets
+Collections of knowledge sources (files, intelligence entries) that agents use to answer questions.
+Each API key is scoped to one dataset.
+
+### Intelligence
+Programmatic knowledge entries written directly to a dataset. Useful for syncing external data.
+Duplicates are automatically detected and cost 0 credits.
+
+### Files
+Documents uploaded to a dataset. Supported formats: PDF, DOCX, TXT, MD, HTML, CSV, JSON, JSONL, TSV, XLSX, XLS, Parquet, XML.
+Files are chunked and embedded automatically.
+
+### Webhooks
+HTTPS endpoints that receive event notifications (e.g., when intelligence is processed).
+
+## Credit System
+Most operations cost credits. Free-tier operations include listing resources and managing webhooks.
+See the credit-costs resource for a full breakdown.
+
+## Getting Started
+1. Get an API key from the Inflectiv dashboard (Settings > API Keys)
+2. Use \`inflectiv_list_datasets\` to see your scoped dataset
+3. Use \`inflectiv_list_agents\` to see agents attached to the dataset
+4. Upload files or write intelligence to add knowledge
+5. Chat with agents using \`inflectiv_chat_with_agent\`
+`;
+var WEBHOOK_EVENTS_DOC = `# Webhook Events
+
+## Available Events
+
+### \`intelligence.processed\`
+Fired when an intelligence entry has been successfully embedded and indexed.
+\`\`\`json
+{
+  "event": "intelligence.processed",
+  "timestamp": "2025-01-01T00:00:00Z",
+  "data": {
+    "intelligence_id": 123,
+    "dataset_id": 456,
+    "title": "Entry title",
+    "status": "processed"
+  }
+}
+\`\`\`
+
+### \`intelligence.failed\`
+Fired when intelligence processing fails.
+\`\`\`json
+{
+  "event": "intelligence.failed",
+  "timestamp": "2025-01-01T00:00:00Z",
+  "data": {
+    "intelligence_id": 123,
+    "dataset_id": 456,
+    "title": "Entry title",
+    "status": "failed",
+    "error": "Processing error message"
+  }
+}
+\`\`\`
+
+### \`intelligence.deduped\`
+Fired when a duplicate intelligence entry is detected and skipped.
+\`\`\`json
+{
+  "event": "intelligence.deduped",
+  "timestamp": "2025-01-01T00:00:00Z",
+  "data": {
+    "intelligence_id": 123,
+    "dataset_id": 456,
+    "title": "Entry title",
+    "status": "deduped"
+  }
+}
+\`\`\`
+
+### \`dataset.mode_changed\`
+Fired when a dataset's mode is changed on an agent.
+\`\`\`json
+{
+  "event": "dataset.mode_changed",
+  "timestamp": "2025-01-01T00:00:00Z",
+  "data": {
+    "agent_id": 789,
+    "dataset_id": 456,
+    "old_mode": "read_only",
+    "new_mode": "self_learning"
+  }
+}
+\`\`\`
+
+## Webhook Security
+Each webhook receives a unique \`secret\` upon creation. Use this to verify payload signatures.
+The secret is only returned once during creation \u2014 store it securely.
+`;
+var CREDIT_COSTS_DOC = `# Credit Costs
+
+| Operation | Tool | Credits |
+|-----------|------|---------|
+| List agents | \`inflectiv_list_agents\` | Free |
+| Create agent | \`inflectiv_create_agent\` | 5 |
+| Get agent | \`inflectiv_get_agent\` | Free |
+| Update agent config | \`inflectiv_update_agent_config\` | 2 |
+| Chat with agent | \`inflectiv_chat_with_agent\` | 1 |
+| List agent datasets | \`inflectiv_list_agent_datasets\` | Free |
+| Attach dataset | \`inflectiv_attach_dataset\` | Free |
+| Update dataset mode | \`inflectiv_update_dataset_mode\` | Free |
+| List datasets | \`inflectiv_list_datasets\` | Free |
+| Update dataset | \`inflectiv_update_dataset\` | Free |
+| Reindex dataset | \`inflectiv_reindex_dataset\` | 2 |
+| Search dataset | \`inflectiv_search_dataset\` | 1 |
+| Batch search | \`inflectiv_batch_search\` | 1 per query |
+| Write intelligence | \`inflectiv_write_intelligence\` | 1 (0 if dup) |
+| Batch write intelligence | \`inflectiv_batch_write_intelligence\` | 1 per new entry |
+| List intelligence | \`inflectiv_list_intelligence\` | Free |
+| List files | \`inflectiv_list_files\` | Free |
+| Get file | \`inflectiv_get_file\` | Free |
+| Upload file | \`inflectiv_upload_file\` | 5 base + 1/MB over 5MB |
+| Reprocess file | \`inflectiv_reprocess_file\` | 5 |
+| Register webhook | \`inflectiv_register_webhook\` | Free |
+| List webhooks | \`inflectiv_list_webhooks\` | Free |
+| Test webhook | \`inflectiv_test_webhook\` | Free |
+`;
+
+// src/server.ts
+function createServer() {
+  const apiKey = process.env.INFLECTIV_API_KEY || null;
+  const walletKey = process.env.INFLECTIV_WALLET_PRIVATE_KEY;
+  if (!apiKey && !walletKey) {
+    console.error(
+      "Error: Either INFLECTIV_API_KEY or INFLECTIV_WALLET_PRIVATE_KEY is required.\nGet your API key from https://app.inflectiv.ai (Settings > API Keys).\nOr set INFLECTIV_WALLET_PRIVATE_KEY for X402 crypto payments."
+    );
+    process.exit(1);
+  }
+  const baseUrl = process.env.INFLECTIV_BASE_URL;
+  const client = new InflectivClient(apiKey, baseUrl);
+  const server = new McpServer({
+    name: "inflectiv",
+    version: "0.1.0"
+  });
+  registerAgentTools(server, client);
+  registerDatasetTools(server, client);
+  registerFileTools(server, client);
+  registerKnowledgeSourceTools(server, client);
+  registerSkillTools(server, client);
+  registerMarketplaceTools(server, client);
+  registerWebhookTools(server, client);
+  registerMemoryTools(server);
+  registerResources(server);
+  return server;
+}
+
+// src/index.ts
+async function main() {
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map