@kya-os/mcp-i 1.5.3-canary.1 → 1.5.4

package/dist/runtime/transports/http/index.js

@@ -12,7 +12,9 @@ const middleware = INJECTED_MIDDLEWARE;
 // oauth config
 // @ts-expect-error: injected by compiler
 const oauthConfigRaw = OAUTH_CONFIG;
-const oauthConfig = (oauthConfigRaw && JSON.parse(oauthConfigRaw));
+const oauthConfig = (oauthConfigRaw && typeof oauthConfigRaw === 'string'
+    ? JSON.parse(oauthConfigRaw)
+    : oauthConfigRaw);
 async function main() {
     const options = {
         port: httpConfig?.port,

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

@@ -0,0 +1,80 @@
+/**
+ * Time Formatting Utilities
+ *
+ * Provides human-readable time formatting for intervals and durations.
+ * Used by audit logging and other time-based features.
+ *
+ * @example
+ * ```typescript
+ * import { formatTimeInterval } from './utils/time';
+ *
+ * formatTimeInterval(86400000);  // "daily"
+ * formatTimeInterval(3600000);   // "hourly"
+ * formatTimeInterval(7200000);   // "2-hourly"
+ * formatTimeInterval(123456);    // "123456ms"
+ * ```
+ */
+/**
+ * Common time intervals in milliseconds
+ *
+ * These constants provide standard time intervals that can be used
+ * throughout the codebase for consistency.
+ *
+ * @example
+ * ```typescript
+ * const dailyRotation = TIME_INTERVALS.DAY;  // 86400000
+ * const hourlyCheck = TIME_INTERVALS.HOUR;   // 3600000
+ * ```
+ */
+export declare const TIME_INTERVALS: {
+    /** 1 second in milliseconds */
+    readonly SECOND: 1000;
+    /** 1 minute in milliseconds */
+    readonly MINUTE: number;
+    /** 1 hour in milliseconds */
+    readonly HOUR: number;
+    /** 1 day in milliseconds */
+    readonly DAY: number;
+    /** 1 week in milliseconds */
+    readonly WEEK: number;
+};
+/**
+ * Format milliseconds into human-readable interval string
+ *
+ * Converts a time interval in milliseconds to a descriptive string
+ * that's easier for humans to understand and for logging purposes.
+ *
+ * **Format Priority:**
+ * 1. Weekly intervals (e.g., "weekly", "2-weekly")
+ * 2. Daily intervals (e.g., "daily", "3-daily")
+ * 3. Hourly intervals (e.g., "hourly", "12-hourly")
+ * 4. Minute intervals (e.g., "minutely", "30-minutely")
+ * 5. Second intervals (e.g., "every-second", "5-secondly")
+ * 6. Custom milliseconds (e.g., "123456ms")
+ *
+ * @param ms - Milliseconds to format (undefined returns "unknown")
+ * @returns Human-readable interval string
+ *
+ * @example Standard intervals
+ * ```typescript
+ * formatTimeInterval(86400000);           // "daily"
+ * formatTimeInterval(3600000);            // "hourly"
+ * formatTimeInterval(604800000);          // "weekly"
+ * formatTimeInterval(60000);              // "minutely"
+ * ```
+ *
+ * @example Multiple intervals
+ * ```typescript
+ * formatTimeInterval(172800000);          // "2-daily" (2 days)
+ * formatTimeInterval(7200000);            // "2-hourly" (2 hours)
+ * formatTimeInterval(1800000);            // "30-minutely" (30 minutes)
+ * ```
+ *
+ * @example Edge cases
+ * ```typescript
+ * formatTimeInterval(undefined);          // "unknown"
+ * formatTimeInterval(123456);             // "123456ms" (custom)
+ * formatTimeInterval(1000);               // "every-second"
+ * ```
+ */
+export declare function formatTimeInterval(ms: number | undefined): string;

package/dist/runtime/utils/time.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * Time Formatting Utilities
+ *
+ * Provides human-readable time formatting for intervals and durations.
+ * Used by audit logging and other time-based features.
+ *
+ * @example
+ * ```typescript
+ * import { formatTimeInterval } from './utils/time.js';
+ *
+ * formatTimeInterval(86400000);  // "daily"
+ * formatTimeInterval(3600000);   // "hourly"
+ * formatTimeInterval(7200000);   // "2-hourly"
+ * formatTimeInterval(123456);    // "123456ms"
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIME_INTERVALS = void 0;
+exports.formatTimeInterval = formatTimeInterval;
+/**
+ * Common time intervals in milliseconds
+ *
+ * These constants provide standard time intervals that can be used
+ * throughout the codebase for consistency.
+ *
+ * @example
+ * ```typescript
+ * const dailyRotation = TIME_INTERVALS.DAY;  // 86400000
+ * const hourlyCheck = TIME_INTERVALS.HOUR;   // 3600000
+ * ```
+ */
+exports.TIME_INTERVALS = {
+    /** 1 second in milliseconds */
+    SECOND: 1000,
+    /** 1 minute in milliseconds */
+    MINUTE: 60 * 1000,
+    /** 1 hour in milliseconds */
+    HOUR: 60 * 60 * 1000,
+    /** 1 day in milliseconds */
+    DAY: 24 * 60 * 60 * 1000,
+    /** 1 week in milliseconds */
+    WEEK: 7 * 24 * 60 * 60 * 1000,
+};
+/**
+ * Format milliseconds into human-readable interval string
+ *
+ * Converts a time interval in milliseconds to a descriptive string
+ * that's easier for humans to understand and for logging purposes.
+ *
+ * **Format Priority:**
+ * 1. Weekly intervals (e.g., "weekly", "2-weekly")
+ * 2. Daily intervals (e.g., "daily", "3-daily")
+ * 3. Hourly intervals (e.g., "hourly", "12-hourly")
+ * 4. Minute intervals (e.g., "minutely", "30-minutely")
+ * 5. Second intervals (e.g., "every-second", "5-secondly")
+ * 6. Custom milliseconds (e.g., "123456ms")
+ *
+ * @param ms - Milliseconds to format (undefined returns "unknown")
+ * @returns Human-readable interval string
+ *
+ * @example Standard intervals
+ * ```typescript
+ * formatTimeInterval(86400000);           // "daily"
+ * formatTimeInterval(3600000);            // "hourly"
+ * formatTimeInterval(604800000);          // "weekly"
+ * formatTimeInterval(60000);              // "minutely"
+ * ```
+ *
+ * @example Multiple intervals
+ * ```typescript
+ * formatTimeInterval(172800000);          // "2-daily" (2 days)
+ * formatTimeInterval(7200000);            // "2-hourly" (2 hours)
+ * formatTimeInterval(1800000);            // "30-minutely" (30 minutes)
+ * ```
+ *
+ * @example Edge cases
+ * ```typescript
+ * formatTimeInterval(undefined);          // "unknown"
+ * formatTimeInterval(123456);             // "123456ms" (custom)
+ * formatTimeInterval(1000);               // "every-second"
+ * ```
+ */
+function formatTimeInterval(ms) {
+    if (ms === undefined || ms === null)
+        return "unknown";
+    // Handle 0 explicitly (0 % anything === 0, so check first)
+    if (ms === 0)
+        return "0ms";
+    // Check for exact weekly intervals
+    if (ms % exports.TIME_INTERVALS.WEEK === 0) {
+        const weeks = ms / exports.TIME_INTERVALS.WEEK;
+        return weeks === 1 ? "weekly" : `${weeks}-weekly`;
+    }
+    // Check for exact daily intervals
+    if (ms % exports.TIME_INTERVALS.DAY === 0) {
+        const days = ms / exports.TIME_INTERVALS.DAY;
+        return days === 1 ? "daily" : `${days}-daily`;
+    }
+    // Check for exact hourly intervals
+    if (ms % exports.TIME_INTERVALS.HOUR === 0) {
+        const hours = ms / exports.TIME_INTERVALS.HOUR;
+        return hours === 1 ? "hourly" : `${hours}-hourly`;
+    }
+    // Check for exact minute intervals
+    if (ms % exports.TIME_INTERVALS.MINUTE === 0) {
+        const minutes = ms / exports.TIME_INTERVALS.MINUTE;
+        return minutes === 1 ? "minutely" : `${minutes}-minutely`;
+    }
+    // Check for exact second intervals
+    if (ms % exports.TIME_INTERVALS.SECOND === 0) {
+        const seconds = ms / exports.TIME_INTERVALS.SECOND;
+        return seconds === 1 ? "every-second" : `${seconds}-secondly`;
+    }
+    // Fall back to milliseconds for custom intervals
+    return `${ms}ms`;
+}

package/dist/runtime/utils/tools.js

@@ -12,7 +12,10 @@ const proof_batch_queue_1 = require("../proof-batch-queue");
 // Parse runtime config path from injected variable
 // @ts-expect-error: injected by compiler
 const rawRuntimeConfigPath = typeof RUNTIME_CONFIG_PATH !== "undefined" ? RUNTIME_CONFIG_PATH : undefined;
-const runtimeConfigPath = rawRuntimeConfigPath ? JSON.parse(rawRuntimeConfigPath) : null;
+// Single-parse to match single-stringify from webpack DefinePlugin
+const runtimeConfigPath = rawRuntimeConfigPath
+    ? (typeof rawRuntimeConfigPath === 'string' ? JSON.parse(rawRuntimeConfigPath) : rawRuntimeConfigPath)
+    : null;
 /** Validates if a value is a valid Zod schema object */
 function isZodRawShape(value) {
     if (typeof value !== "object" || value === null) {
@@ -375,9 +378,25 @@ async function addToolsToServer(server, toolModules, identityConfig) {
                             lastActivity: timestamp,
                             ttlMinutes: 30,
                         };
-                        // Generate proof using the proof generator
+                        // Determine scopeId from tool protection configuration
+                        // This enables AgentShield tool auto-discovery
+                        let scopeId;
+                        const toolProtection = tool_protection_registry_1.toolProtectionRegistry.get(name);
+                        if (toolProtection?.requiredScopes && toolProtection.requiredScopes.length > 0) {
+                            // Use the first required scope as the scopeId (e.g., "files:read")
+                            scopeId = toolProtection.requiredScopes[0];
+                        }
+                        else {
+                            // Fallback: Use tool name with "execute" action for unprotected tools
+                            scopeId = `${name}:execute`;
+                        }
+                        if (identityConfig?.debug) {
+                            console.error(`[MCPI] Proof scopeId for tool "${name}": ${scopeId}`);
+                        }
+                        // Generate proof using the proof generator with scopeId
                         const proofGen = new proof_1.ProofGenerator(identity);
-                        const proof = await proofGen.generateProof(toolRequest, toolResponse, session);
+                        const proof = await proofGen.generateProof(toolRequest, toolResponse, session, { scopeId } // Pass scopeId for tool auto-discovery
+                        );
                         if (identityConfig?.debug) {
                             console.error(`[MCPI] Generated proof for tool "${name}" - DID: ${proof.meta.did}`);
                         }

package/dist/runtime/verifier-middleware.js

@@ -218,7 +218,7 @@ function verifyExpress(config) {
                 req.ctx = req.ctx || {};
                 req.ctx.agent = {
                     did: result.headers[verifier_1.AGENT_HEADERS.DID],
-                    keyId: result.headers[verifier_1.AGENT_HEADERS.KEY_ID],
+                    kid: result.headers[verifier_1.AGENT_HEADERS.KEY_ID],
                     session: result.headers[verifier_1.AGENT_HEADERS.SESSION],
                     scopes: result.headers[verifier_1.AGENT_HEADERS.SCOPES]?.split(",") || [],
                     delegationRef: result.headers[verifier_1.AGENT_HEADERS.DELEGATION_REF],

package/dist/runtime/well-known.d.ts

@@ -102,10 +102,6 @@ export declare class WellKnownManager {
      * Encode public key as multibase (base58btc with 'z' prefix for Ed25519)
      */
     private encodePublicKeyMultibase;
-    /**
-     * Simple base58 encoding (use proper library in production)
-     */
-    private encodeBase58;
     /**
      * Update configuration
      */

package/dist/runtime/well-known.js

@@ -11,6 +11,11 @@ exports.createWellKnownHandler = createWellKnownHandler;
 exports.validateDIDDocument = validateDIDDocument;
 exports.validateAgentDocument = validateAgentDocument;
 exports.extractDIDFromPath = extractDIDFromPath;
+// Load base-x synchronously using require (mcp-i is CommonJS)
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const baseX = require("base-x");
+const base58 = baseX.default || baseX;
+const base58Encoder = base58('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');
 /**
  * Well-known endpoints manager
  */
@@ -26,7 +31,7 @@ class WellKnownManager {
      * Requirements: 7.1, 7.5
      */
     generateDIDDocument() {
-        const keyId = `#${this.identity.keyId}`;
+        const kid = `#${this.identity.kid}`;
         // Convert base64 public key to multibase format
         const publicKeyMultibase = this.encodePublicKeyMultibase(this.identity.publicKey);
         const didDocument = {
@@ -37,14 +42,14 @@ class WellKnownManager {
             id: this.identity.did,
             verificationMethod: [
                 {
-                    id: keyId,
+                    id: kid,
                     type: "Ed25519VerificationKey2020",
                     controller: this.identity.did,
                     publicKeyMultibase,
                 },
             ],
-            authentication: [keyId],
-            assertionMethod: [keyId],
+            authentication: [kid],
+            assertionMethod: [kid],
         };
         return didDocument;
     }
@@ -108,34 +113,15 @@ class WellKnownManager {
      */
     encodePublicKeyMultibase(base64PublicKey) {
         // For Ed25519, we use base58btc encoding with 'z' prefix
-        // This is a simplified implementation - in production, use proper multibase library
         const publicKeyBytes = Buffer.from(base64PublicKey, "base64");
         // Ed25519 public key prefix (0xed01) + key bytes
         const prefixedKey = Buffer.concat([
             Buffer.from([0xed, 0x01]), // Ed25519 multicodec prefix
             publicKeyBytes,
         ]);
-        // Convert to base58btc (simplified - use proper base58 library in production)
-        const base58 = this.encodeBase58(prefixedKey);
-        return `z${base58}`; // 'z' prefix indicates base58btc
-    }
-    /**
-     * Simple base58 encoding (use proper library in production)
-     */
-    encodeBase58(buffer) {
-        const alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-        let num = BigInt("0x" + buffer.toString("hex"));
-        let result = "";
-        while (num > 0) {
-            const remainder = num % 58n;
-            result = alphabet[Number(remainder)] + result;
-            num = num / 58n;
-        }
-        // Handle leading zeros
-        for (let i = 0; i < buffer.length && buffer[i] === 0; i++) {
-            result = "1" + result;
-        }
-        return result;
+        // Convert to base58btc using base-x library
+        const base58Encoded = base58Encoder.encode(prefixedKey);
+        return `z${base58Encoded}`; // 'z' prefix indicates base58btc
     }
     /**
      * Update configuration

package/dist/storage/delegation.js

@@ -31,7 +31,7 @@ class DefaultDelegationManager {
             ref: `del_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
             contentHash: `sha256:${Array.from({ length: 64 }, () => Math.floor(Math.random() * 16).toString(16)).join("")}`,
             action: "issue",
-            ts: now,
+            ts: new Date().toISOString(),
             logIndex: Math.floor(Math.random() * 10000),
             logRoot: Array.from({ length: 64 }, () => Math.floor(Math.random() * 16).toString(16)).join(""),
             inclusionProof: [
@@ -56,7 +56,7 @@ class DefaultDelegationManager {
             ref: `rev_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
             contentHash: `sha256:${Array.from({ length: 64 }, () => Math.floor(Math.random() * 16).toString(16)).join("")}`,
             action: "revoke",
-            ts: Math.floor(Date.now() / 1000),
+            ts: new Date().toISOString(),
             logIndex: Math.floor(Math.random() * 10000),
             logRoot: Array.from({ length: 64 }, () => Math.floor(Math.random() * 16).toString(16)).join(""),
             inclusionProof: [

package/dist/test/deterministic-keys.d.ts

@@ -14,7 +14,7 @@ export declare function generateDeterministicKeyPair(seed: string): {
  */
 export declare function generateTestIdentity(testName: string, options?: {
     did?: string;
-    keyId?: string;
+    kid?: string;
     seed?: string;
 }): MockIdentity;
 /**

package/dist/test/deterministic-keys.js

@@ -43,12 +43,12 @@ function generateTestIdentity(testName, options = {}) {
     (0, test_environment_1.ensureTestMode)();
     const seed = options.seed || (0, test_environment_1.getCurrentTestSeed)(testName);
     const did = options.did || test_1.TEST_DIDS.AGENT_1;
-    const keyId = options.keyId || test_1.TEST_KEY_IDS.KEY_TEST_1;
-    const { privateKey, publicKey } = generateDeterministicKeyPair(`${seed}-${testName}-${did}-${keyId}`);
+    const kid = options.kid || test_1.TEST_KEY_IDS.KEY_TEST_1;
+    const { privateKey, publicKey } = generateDeterministicKeyPair(`${seed}-${testName}-${did}-${kid}`);
     const now = new Date().toISOString();
     return {
         did,
-        keyId,
+        kid,
         privateKey,
         publicKey,
         createdAt: now,
@@ -63,15 +63,15 @@ function getPredefinedTestIdentities() {
     return {
         agent1: generateTestIdentity("agent1", {
             did: test_1.TEST_DIDS.AGENT_1,
-            keyId: test_1.TEST_KEY_IDS.KEY_TEST_1,
+            kid: test_1.TEST_KEY_IDS.KEY_TEST_1,
         }),
         agent2: generateTestIdentity("agent2", {
             did: test_1.TEST_DIDS.AGENT_2,
-            keyId: test_1.TEST_KEY_IDS.KEY_TEST_2,
+            kid: test_1.TEST_KEY_IDS.KEY_TEST_2,
         }),
         verifier1: generateTestIdentity("verifier1", {
             did: test_1.TEST_DIDS.VERIFIER_1,
-            keyId: test_1.TEST_KEY_IDS.KEY_VERIFIER_1,
+            kid: test_1.TEST_KEY_IDS.KEY_VERIFIER_1,
         }),
     };
 }

package/dist/test/examples/test-usage-example.d.ts

@@ -38,7 +38,7 @@ export declare function exampleProofTesting(): Promise<{
     };
     errors: string[];
     did?: string | undefined;
-    keyId?: string | undefined;
+    kid?: string | undefined;
 }>;
 /**
  * Example: Intercepting KTA calls
@@ -61,11 +61,11 @@ export declare function exampleKTAInterception(): Promise<{
 export declare function exampleRuntimeIntegration(): {
     testIdentity: {
         did: string;
-        keyId: string;
+        kid: string;
         privateKey: string;
         publicKey: string;
         createdAt: string;
-        lastRotated: string;
+        lastRotated?: string | undefined;
     };
     sessionContext: {
         sessionId: string;
@@ -104,7 +104,7 @@ export declare function exampleCompleteTestScenario(): Promise<{
         };
         errors: string[];
         did?: string | undefined;
-        keyId?: string | undefined;
+        kid?: string | undefined;
     };
     ktaResults: {
         registrationResult: {
@@ -121,11 +121,11 @@ export declare function exampleCompleteTestScenario(): Promise<{
     runtimeResults: {
         testIdentity: {
             did: string;
-            keyId: string;
+            kid: string;
             privateKey: string;
             publicKey: string;
             createdAt: string;
-            lastRotated: string;
+            lastRotated?: string | undefined;
         };
         sessionContext: {
             sessionId: string;

package/dist/test/examples/test-usage-example.js

@@ -42,12 +42,12 @@ function exampleMockIdentityProvider() {
     // Generate a custom test identity
     const customIdentity = (0, index_js_1.generateTestIdentity)("my-custom-test", {
         did: "did:test:my-custom-agent",
-        keyId: "key-custom-1",
+        kid: "key-custom-1",
     });
     // Set the identity in the provider
     mockProvider.setIdentity("custom", customIdentity);
     // Set delegation status
-    mockProvider.setDelegation(`${customIdentity.did}:${customIdentity.keyId}`, "active");
+    mockProvider.setDelegation(`${customIdentity.did}:${customIdentity.kid}`, "active");
     // Simulate KTA failures for testing error scenarios
     mockProvider.simulateKTAFailure("network");
     return mockProvider;
@@ -75,7 +75,7 @@ async function exampleProofTesting() {
     // Create a mock proof
     const mockProof = (0, index_js_1.createMockProof)({
         did: test_1.TEST_DIDS.AGENT_1,
-        keyId: test_1.TEST_KEY_IDS.KEY_TEST_1,
+        kid: test_1.TEST_KEY_IDS.KEY_TEST_1,
         request: mockRequest,
         response: mockResponse,
         sessionId: "sess_test_example",
@@ -87,7 +87,7 @@ async function exampleProofTesting() {
     console.log("Proof verification result:", {
         valid: verificationResult.valid,
         did: verificationResult.did,
-        keyId: verificationResult.keyId,
+        kid: verificationResult.kid,
         signatureValid: verificationResult.signature.valid,
         proofValid: verificationResult.proof.valid,
         sessionValid: verificationResult.session.valid,
@@ -132,7 +132,7 @@ function exampleRuntimeIntegration() {
     const testIdentity = (0, index_js_1.getTestIdentityForRuntime)("agent1");
     console.log("Test identity for runtime:", {
         did: testIdentity.did,
-        keyId: testIdentity.keyId,
+        kid: testIdentity.kid,
         // Don't log private key in real usage
     });
     // Create test session context

package/dist/test/local-verification.d.ts

@@ -19,7 +19,7 @@ export declare function verifyDIDDocumentLocally(did: string): Promise<{
  */
 export declare function createMockProof(options: {
     did?: string;
-    keyId?: string;
+    kid?: string;
     request?: any;
     response?: any;
     sessionId?: string;

package/dist/test/local-verification.js

@@ -166,16 +166,16 @@ async function verifyProofLocally(proof, request, response) {
         }
         let signatureValid = false;
         let did;
-        let keyId;
+        let kid;
         if (proofCheck.structure && proof?.meta) {
             did = proof.meta.did;
-            keyId = proof.meta.kid;
+            kid = proof.meta.kid;
             // Get mock identity for verification
             const mockProvider = (0, mock_identity_provider_1.getMockIdentityProvider)();
             const identity = mockProvider.getIdentity("agent1") ||
                 mockProvider.getIdentity("agent2") ||
                 mockProvider.getIdentity("verifier1");
-            if (identity && identity.did === did && identity.keyId === keyId) {
+            if (identity && identity.did === did && identity.kid === kid) {
                 // Verify signature using mock implementation
                 const canonicalMeta = canonicalizeJSON(proof.meta);
                 const signatureCheck = verifySignature(canonicalMeta, proof.jws, identity.publicKey);
@@ -185,7 +185,7 @@ async function verifyProofLocally(proof, request, response) {
                 }
             }
             else {
-                errors.push(`No matching identity found for DID: ${did}, KeyID: ${keyId}`);
+                errors.push(`No matching identity found for DID: ${did}, KeyID: ${kid}`);
             }
         }
         // Verify session
@@ -212,7 +212,7 @@ async function verifyProofLocally(proof, request, response) {
         const result = {
             valid: errors.length === 0,
             did,
-            keyId,
+            kid,
             signature: {
                 valid: signatureValid,
                 algorithm: "EdDSA",
@@ -273,14 +273,14 @@ async function verifyDIDDocumentLocally(did) {
             id: did,
             verificationMethod: [
                 {
-                    id: `${did}#${identity.keyId}`,
+                    id: `${did}#${identity.kid}`,
                     type: "Ed25519VerificationKey2020",
                     controller: did,
                     publicKeyMultibase: `z${identity.publicKey}`,
                 },
             ],
-            authentication: [`${did}#${identity.keyId}`],
-            assertionMethod: [`${did}#${identity.keyId}`],
+            authentication: [`${did}#${identity.kid}`],
+            assertionMethod: [`${did}#${identity.kid}`],
         };
         return {
             valid: true,
@@ -308,7 +308,7 @@ function createMockProof(options) {
     }
     const now = Math.floor(Date.now() / 1000);
     const did = options.did || identity.did;
-    const keyId = options.keyId || identity.keyId;
+    const kid = options.kid || identity.kid;
     const sessionId = options.sessionId || "sess_test_mock";
     const nonce = options.nonce || "mock_nonce";
     const audience = options.audience || "test.example.com";
@@ -320,7 +320,7 @@ function createMockProof(options) {
         : "sha256:mock_response_hash";
     const meta = {
         did,
-        kid: keyId,
+        kid: kid,
         ts: now,
         nonce,
         audience,

package/dist/test/mock-identity-provider.d.ts

@@ -32,7 +32,7 @@ export declare class MockIdentityProvider {
      */
     generateIdentity(key: string, testName: string, options?: {
         did?: string;
-        keyId?: string;
+        kid?: string;
     }): MockIdentity;
     /**
      * Set delegation status for a DID:KeyID combination
@@ -41,7 +41,7 @@ export declare class MockIdentityProvider {
     /**
      * Get delegation status
      */
-    getDelegationStatus(did: string, keyId: string): MockDelegationStatus;
+    getDelegationStatus(did: string, kid: string): MockDelegationStatus;
     /**
      * Simulate KTA failure scenarios
      */
@@ -61,7 +61,7 @@ export declare class MockIdentityProvider {
     /**
      * Mock KTA registration call
      */
-    mockRegister(did: string, _keyId: string): Promise<{
+    mockRegister(did: string, _kid: string): Promise<{
         success: boolean;
         agentURL?: string;
         error?: string;
@@ -69,7 +69,7 @@ export declare class MockIdentityProvider {
     /**
      * Mock KTA delegation check
      */
-    mockCheckDelegation(did: string, keyId: string): Promise<{
+    mockCheckDelegation(did: string, kid: string): Promise<{
         status: MockDelegationStatus;
         error?: string;
     }>;