@cencori/mcp 0.2.0 → 0.4.0

package/dist/index.mjs

@@ -217,6 +217,12 @@ var WRITE_ANNOTATIONS = {
   destructiveHint: false,
   openWorldHint: false
 };
+var DESTRUCTIVE_ANNOTATIONS = {
+  title: "Destructive",
+  readOnlyHint: false,
+  destructiveHint: true,
+  openWorldHint: false
+};
 function jsonResult(data) {
   return {
     content: [
@@ -338,7 +344,13 @@ function registerGatewayTools(server, client) {
 
 // src/tools/agents.ts
 import { z as z3 } from "zod";
-function registerAgentsTools(server, client) {
+var agentConfigShape = z3.object({
+  model: z3.string().optional(),
+  system_prompt: z3.string().optional(),
+  tools: z3.array(z3.string()).optional(),
+  temperature: z3.number().min(0).max(2).optional()
+}).optional().describe("Agent runtime config: model, system_prompt, tools, temperature.");
+function registerAgentsTools(server, client, caps) {
   server.registerTool(
     "list_agents",
     {
@@ -377,6 +389,60 @@ function registerAgentsTools(server, client) {
     },
     async () => jsonResult(await client.get("/v1/agent/actions/poll"))
   );
+  if (caps.write) {
+    server.registerTool(
+      "create_agent",
+      {
+        title: "Create an agent",
+        description: "Create a new agent in a project.",
+        inputSchema: {
+          project_id: z3.string().min(1).describe("The project id to create the agent in."),
+          name: z3.string().min(1).describe("Agent name."),
+          description: z3.string().optional(),
+          config: agentConfigShape
+        },
+        annotations: WRITE_ANNOTATIONS
+      },
+      async ({ project_id, name, description, config }) => jsonResult(await client.post("/v1/agents", { project_id, name, description, config }))
+    );
+    server.registerTool(
+      "update_agent",
+      {
+        title: "Update an agent",
+        description: "Update an agent\u2019s name, description, status, shadow mode, or config.",
+        inputSchema: {
+          agent_id: z3.string().min(1).describe("The agent id to update."),
+          name: z3.string().optional(),
+          description: z3.string().optional(),
+          is_active: z3.boolean().optional(),
+          shadow_mode: z3.boolean().optional(),
+          config: agentConfigShape
+        },
+        annotations: WRITE_ANNOTATIONS
+      },
+      async ({ agent_id, name, description, is_active, shadow_mode, config }) => jsonResult(
+        await client.patch(`/v1/agents/${agent_id}`, {
+          name,
+          description,
+          is_active,
+          shadow_mode,
+          config
+        })
+      )
+    );
+  }
+  if (caps.destructive) {
+    server.registerTool(
+      "delete_agent",
+      {
+        title: "Delete an agent",
+        description: "Permanently delete an agent by id. This cannot be undone.",
+        inputSchema: { agent_id: z3.string().min(1).describe("The agent id to delete.") },
+        annotations: DESTRUCTIVE_ANNOTATIONS
+      },
+      async ({ agent_id }) => jsonResult(await client.del(`/v1/agents/${agent_id}`))
+    );
+  }
 }
 
 // src/tools/memory.ts
@@ -387,7 +453,7 @@ var scopeShape = {
   user_id: z4.string().optional().describe("Scope to a specific end-user id."),
   session_id: z4.string().optional().describe("Scope to a specific session id.")
 };
-function registerMemoryTools(server, client) {
+function registerMemoryTools(server, client, caps) {
   server.registerTool(
     "list_memories",
     {
@@ -503,11 +569,93 @@ function registerMemoryTools(server, client) {
       })
     )
   );
+  if (caps.write) {
+    server.registerTool(
+      "remember_memory",
+      {
+        title: "Remember a conversation turn",
+        description: "Store a user/assistant exchange as memory for later retrieval.",
+        inputSchema: {
+          user: z4.string().min(1).describe("The user message."),
+          assistant: z4.string().min(1).describe("The assistant response."),
+          ...scopeShape
+        },
+        annotations: WRITE_ANNOTATIONS
+      },
+      async ({ user, assistant, namespace, scope, user_id, session_id }) => jsonResult(
+        await client.post("/v1/memory/remember", {
+          user,
+          assistant,
+          namespace,
+          scope,
+          userId: user_id,
+          sessionId: session_id
+        })
+      )
+    );
+    server.registerTool(
+      "write_memory",
+      {
+        title: "Write a memory",
+        description: "Store a single memory (a fact/note) directly.",
+        inputSchema: {
+          content: z4.string().min(1).describe("The memory content to store."),
+          importance: z4.number().min(0).max(1).optional().describe("Importance weight 0\u20131."),
+          ...scopeShape
+        },
+        annotations: WRITE_ANNOTATIONS
+      },
+      async ({ content, importance, namespace, scope, user_id, session_id }) => jsonResult(
+        await client.post("/v1/memory/write", {
+          content,
+          importance,
+          namespace,
+          scope,
+          userId: user_id,
+          sessionId: session_id
+        })
+      )
+    );
+    server.registerTool(
+      "create_namespace",
+      {
+        title: "Create a memory namespace",
+        description: "Create a new memory namespace.",
+        inputSchema: {
+          name: z4.string().min(1).describe("Namespace name."),
+          description: z4.string().optional(),
+          embedding_model: z4.string().optional().describe("Embedding model for this namespace."),
+          dimensions: z4.number().int().positive().optional()
+        },
+        annotations: WRITE_ANNOTATIONS
+      },
+      async ({ name, description, embedding_model, dimensions }) => jsonResult(
+        await client.post("/memory/namespaces", {
+          name,
+          description,
+          embeddingModel: embedding_model,
+          dimensions
+        })
+      )
+    );
+  }
+  if (caps.destructive) {
+    server.registerTool(
+      "delete_memory",
+      {
+        title: "Delete a memory",
+        description: "Permanently delete a memory by id. This cannot be undone.",
+        inputSchema: { memory_id: z4.string().min(1).describe("The memory id to delete.") },
+        annotations: DESTRUCTIVE_ANNOTATIONS
+      },
+      async ({ memory_id }) => jsonResult(await client.del(`/v1/memory/${memory_id}`))
+    );
+  }
 }
 
 // src/tools/sessions.ts
 import { z as z5 } from "zod";
-function registerSessionsTools(server, client) {
+function registerSessionsTools(server, client, caps) {
   server.registerTool(
     "list_sessions",
     {
@@ -550,11 +698,87 @@ function registerSessionsTools(server, client) {
     },
     async ({ session_id }) => jsonResult(await client.get(`/v1/sessions/${session_id}/events`))
   );
+  if (caps.write) {
+    server.registerTool(
+      "create_session",
+      {
+        title: "Create an agent session",
+        description: "Start a new session for an agent.",
+        inputSchema: {
+          agent_id: z5.string().min(1).describe("The agent id to start a session for."),
+          metadata: z5.record(z5.string(), z5.unknown()).optional().describe("Optional session metadata.")
+        },
+        annotations: WRITE_ANNOTATIONS
+      },
+      async ({ agent_id, metadata }) => jsonResult(await client.post("/v1/sessions", { agent_id, metadata }))
+    );
+    server.registerTool(
+      "add_session_turn",
+      {
+        title: "Add a turn to a session",
+        description: "Run a turn in an agent session. Incurs usage/cost.",
+        inputSchema: {
+          session_id: z5.string().min(1).describe("The session id."),
+          model: z5.string().min(1).describe("Model id for the turn."),
+          input: z5.string().min(1).describe("The user input for this turn."),
+          instructions: z5.string().optional().describe("Optional system instructions."),
+          temperature: z5.number().min(0).max(2).optional()
+        },
+        annotations: WRITE_ANNOTATIONS
+      },
+      async ({ session_id, model, input, instructions, temperature }) => jsonResult(
+        await client.post(`/v1/sessions/${session_id}/turns`, {
+          model,
+          input,
+          instructions,
+          temperature
+        })
+      )
+    );
+  }
+  if (caps.destructive) {
+    server.registerTool(
+      "delete_session",
+      {
+        title: "Delete an agent session",
+        description: "Permanently delete an agent session by id. This cannot be undone.",
+        inputSchema: { session_id: z5.string().min(1).describe("The session id to delete.") },
+        annotations: DESTRUCTIVE_ANNOTATIONS
+      },
+      async ({ session_id }) => jsonResult(await client.del(`/v1/sessions/${session_id}`))
+    );
+    server.registerTool(
+      "approve_session",
+      {
+        title: "Approve a pending session action",
+        description: "Approve a pending action in an agent session (human-in-the-loop).",
+        inputSchema: {
+          session_id: z5.string().min(1).describe("The session id."),
+          action_id: z5.string().optional().describe("Specific pending action id, if any.")
+        },
+        annotations: DESTRUCTIVE_ANNOTATIONS
+      },
+      async ({ session_id, action_id }) => jsonResult(await client.post(`/v1/sessions/${session_id}/approve`, { action_id }))
+    );
+    server.registerTool(
+      "reject_session",
+      {
+        title: "Reject a pending session action",
+        description: "Reject a pending action in an agent session (human-in-the-loop).",
+        inputSchema: {
+          session_id: z5.string().min(1).describe("The session id."),
+          action_id: z5.string().optional().describe("Specific pending action id, if any.")
+        },
+        annotations: DESTRUCTIVE_ANNOTATIONS
+      },
+      async ({ session_id, action_id }) => jsonResult(await client.post(`/v1/sessions/${session_id}/reject`, { action_id }))
+    );
+  }
 }
 
 // src/tools/governance.ts
 import { z as z6 } from "zod";
-function registerGovernanceTools(server, client) {
+function registerGovernanceTools(server, client, caps) {
   server.registerTool(
     "list_policies",
     {
@@ -617,6 +841,34 @@ function registerGovernanceTools(server, client) {
     },
     async () => jsonResult(await client.get("/v1/governance/templates"))
   );
+  if (caps.write) {
+    server.registerTool(
+      "create_policy",
+      {
+        title: "Draft a governance policy",
+        description: "Create a governance policy as a DRAFT. It is not enforced until a human activates it (see how_to_activate_policy).",
+        inputSchema: {
+          name: z6.string().min(1).describe("Policy name (unique per org)."),
+          spec: z6.record(z6.string(), z6.unknown()).describe("Policy spec object: match + rules + defaults + controls.")
+        },
+        annotations: WRITE_ANNOTATIONS
+      },
+      async ({ name, spec }) => jsonResult(await client.post("/v1/governance/policies", { name, spec }))
+    );
+    server.registerTool(
+      "install_template",
+      {
+        title: "Install a governance policy template",
+        description: "Install a policy template as a new DRAFT policy. Activation remains a manual human step (see how_to_activate_policy).",
+        inputSchema: {
+          template_id: z6.string().min(1).describe("The template id to install."),
+          name: z6.string().min(1).describe("Name for the new draft policy.")
+        },
+        annotations: WRITE_ANNOTATIONS
+      },
+      async ({ template_id, name }) => jsonResult(await client.post(`/v1/governance/templates/${template_id}/install`, { name }))
+    );
+  }
 }
 
 // src/tools/multimodal.ts
@@ -899,7 +1151,7 @@ function registerGuidanceTools(server, baseUrl) {
 
 // src/server.ts
 var SERVER_NAME = "cencori";
-var SERVER_VERSION = "0.2.0";
+var SERVER_VERSION = "0.4.0";
 function createServer(config) {
   const server = new McpServer(
     {
@@ -924,10 +1176,10 @@ function createServer(config) {
   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.agents) registerAgentsTools(server, client, capabilities);
+    if (features.memory) registerMemoryTools(server, client, capabilities);
+    if (features.sessions) registerSessionsTools(server, client, capabilities);
+    if (features.governance) registerGovernanceTools(server, client, capabilities);
     if (features.multimodal && capabilities.write) {
       registerMultimodalTools(server, client);
     }