@kya-os/mcp-i 1.2.5 → 1.2.7

package/dist/runtime/utils/server.js

@@ -8,6 +8,12 @@ const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const tools_1 = require("./tools");
 // @ts-expect-error: injected by compiler
 exports.injectedTools = INJECTED_TOOLS;
+// Parse identity config from injected variable
+// @ts-expect-error: injected by compiler
+const rawIdentityConfig = typeof IDENTITY_CONFIG !== "undefined" ? IDENTITY_CONFIG : undefined;
+const identityConfig = rawIdentityConfig
+    ? JSON.parse(rawIdentityConfig)
+    : undefined;
 exports.INJECTED_CONFIG = {
     // TODO get from project config
     name: "MCP Server",
@@ -20,7 +26,7 @@ exports.INJECTED_CONFIG = {
 };
 /** Loads tools and injects them into the server */
 async function configureServer(server, toolModules) {
-    (0, tools_1.addToolsToServer)(server, toolModules);
+    await (0, tools_1.addToolsToServer)(server, toolModules, identityConfig);
     // TODO: implement addResourcesToServer, addPromptsToServer
     return server;
 }

package/dist/runtime/utils/tools.d.ts

@@ -1,8 +1,20 @@
 import { Server as McpServer } from "@modelcontextprotocol/sdk/server/index.js";
 import { ZodTypeAny } from "zod";
 import { ToolFile } from "./server";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { DetachedProof } from "@kya-os/contracts/proof";
 export type ZodRawShape = {
     [k: string]: ZodTypeAny;
 };
+export type MCPICallToolResult = CallToolResult & {
+    _meta?: {
+        proof?: DetachedProof;
+        [key: string]: unknown;
+    };
+};
 /** Loads tools and injects them into the server */
-export declare function addToolsToServer(server: McpServer, toolModules: Map<string, ToolFile>): McpServer;
+export declare function addToolsToServer(server: McpServer, toolModules: Map<string, ToolFile>, identityConfig?: {
+    enabled: boolean;
+    debug?: boolean;
+    environment?: string;
+}): Promise<McpServer>;

package/dist/runtime/utils/tools.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addToolsToServer = addToolsToServer;
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const proof_1 = require("../proof");
+const identity_1 = require("../identity");
 /** Validates if a value is a valid Zod schema object */
 function isZodRawShape(value) {
     if (typeof value !== "object" || value === null) {
@@ -23,7 +25,25 @@ function pathToName(path) {
     return fileName.replace(/\.[^/.]+$/, "");
 }
 /** Loads tools and injects them into the server */
-function addToolsToServer(server, toolModules) {
+async function addToolsToServer(server, toolModules, identityConfig) {
+    // Initialize identity manager if identity is enabled
+    let identityManager = null;
+    if (identityConfig?.enabled) {
+        try {
+            identityManager = new identity_1.IdentityManager({
+                environment: identityConfig.environment || "development",
+            });
+            // Ensure identity exists (loads or generates it)
+            const identity = await identityManager.ensureIdentity();
+            if (identityConfig.debug) {
+                console.error(`[MCPI] Identity enabled - DID: ${identity.did}`);
+            }
+        }
+        catch (error) {
+            console.error("[MCPI] Failed to initialize identity:", error);
+            // Continue without identity if initialization fails
+        }
+    }
     // Collect all tools and their handlers
     const tools = [];
     const toolHandlers = new Map();
@@ -89,8 +109,10 @@ function addToolsToServer(server, toolModules) {
             };
         }
         try {
+            // Execute the tool handler
             const result = await handler(args || {});
-            return {
+            // Build base response
+            const baseResponse = {
                 content: [
                     {
                         type: "text",
@@ -98,6 +120,54 @@ function addToolsToServer(server, toolModules) {
                     },
                 ],
             };
+            // If identity is enabled, generate cryptographic proof
+            if (identityManager) {
+                try {
+                    // Ensure identity exists
+                    const identity = await identityManager.ensureIdentity();
+                    // Create a session context for this request
+                    const toolRequest = {
+                        method: name,
+                        params: args || {},
+                    };
+                    const toolResponse = {
+                        data: result,
+                    };
+                    // Create a session context for standalone tool calls
+                    // In a full implementation, this would use proper handshake
+                    const timestamp = Math.floor(Date.now() / 1000);
+                    const session = {
+                        sessionId: `tool-${Date.now()}`,
+                        nonce: `${Date.now()}`,
+                        audience: "client",
+                        createdAt: timestamp,
+                        timestamp,
+                        lastActivity: timestamp,
+                        ttlMinutes: 30,
+                    };
+                    // Generate proof using the proof generator
+                    const proofGen = new proof_1.ProofGenerator(identity);
+                    const proof = await proofGen.generateProof(toolRequest, toolResponse, session);
+                    if (identityConfig?.debug) {
+                        console.error(`[MCPI] Generated proof for tool "${name}" - DID: ${proof.meta.did}`);
+                    }
+                    // Return response with proof metadata
+                    return {
+                        ...baseResponse,
+                        _meta: {
+                            proof,
+                        },
+                    };
+                }
+                catch (proofError) {
+                    if (identityConfig?.debug) {
+                        console.error(`[MCPI] Failed to generate proof for tool "${name}":`, proofError);
+                    }
+                    // Return base response without proof if generation fails
+                    return baseResponse;
+                }
+            }
+            return baseResponse;
         }
         catch (error) {
             return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kya-os/mcp-i",
-  "version": "1.2.5",
+  "version": "1.2.7",
   "description": "The TypeScript MCP framework with identity features built-in",
   "type": "commonjs",
   "main": "dist/index.js",
@@ -79,6 +79,9 @@
     "webpack-node-externals": "^3.0.0",
     "webpack-virtual-modules": "^0.5.0"
   },
+  "optionalDependencies": {
+    "@modelcontextprotocol/inspector": "^0.16.6"
+  },
   "devDependencies": {
     "@aws-sdk/client-dynamodb": "^3.0.0",
     "@types/content-type": "^1.1.9",