@dotsetlabs/bellwether 1.0.3 → 2.0.0

package/dist/baseline/response-fingerprint.js

@@ -103,7 +103,11 @@ function extractResponseContent(response) {
                 return item.text;
             }
         }
-        return item;
+        const decoded = decodeDataContent(item.data, item.mimeType);
+        if (decoded !== null) {
+            return decoded;
+        }
+        return summarizeBinaryItem(item);
     }
     // Multiple content items - return as array
     return response.content.map((item) => {
@@ -115,9 +119,42 @@ function extractResponseContent(response) {
                 return item.text;
             }
         }
-        return item;
+        const decoded = decodeDataContent(item.data, item.mimeType);
+        if (decoded !== null) {
+            return decoded;
+        }
+        return summarizeBinaryItem(item);
     });
 }
+function decodeDataContent(data, mimeType) {
+    if (!data || typeof data !== 'string')
+        return null;
+    const mime = (mimeType ?? '').toLowerCase();
+    if (mime.includes('json') || mime.startsWith('text/')) {
+        try {
+            const decoded = Buffer.from(data, 'base64').toString('utf8');
+            try {
+                return JSON.parse(decoded);
+            }
+            catch {
+                return decoded;
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+function summarizeBinaryItem(item) {
+    const size = item.data ? Buffer.byteLength(item.data, 'utf8') : 0;
+    return {
+        type: item.type ?? 'unknown',
+        mimeType: item.mimeType,
+        uri: item.uri,
+        size,
+    };
+}
 /**
  * Compute a structure hash that captures shape but not values.
  */

package/dist/baseline/saver.js

@@ -3,12 +3,12 @@
  */
 import { readFileSync, writeFileSync, existsSync, statSync } from 'fs';
 import { z } from 'zod';
-import { getBaselineVersion, parseVersion, formatVersion, } from './version.js';
-import { createCloudBaseline } from './converter.js';
+import { getBaselineVersion, parseVersion, formatVersion } from './version.js';
+import { createBaselineFromInterview } from './converter.js';
 import { calculateBaselineHash } from './baseline-hash.js';
 import { PAYLOAD_LIMITS } from '../constants.js';
 import { getLogger } from '../logging/logger.js';
-const cloudAssertionSchema = z.object({
+const baselineAssertionSchema = z.object({
     type: z.enum(['expects', 'requires', 'warns', 'notes']),
     condition: z.string(),
     tool: z.string().optional(),
@@ -19,7 +19,16 @@ const cloudAssertionSchema = z.object({
  */
 const responseFingerprintSchema = z.object({
     structureHash: z.string(),
-    contentType: z.enum(['text', 'object', 'array', 'primitive', 'empty', 'error', 'mixed', 'binary']),
+    contentType: z.enum([
+        'text',
+        'object',
+        'array',
+        'primitive',
+        'empty',
+        'error',
+        'mixed',
+        'binary',
+    ]),
     fields: z.array(z.string()).optional(),
     arrayItemStructure: z.string().optional(),
     size: z.enum(['tiny', 'small', 'medium', 'large']),
@@ -68,6 +77,9 @@ const toolCapabilitySchema = z.object({
     description: z.string(),
     inputSchema: z.record(z.unknown()),
     schemaHash: z.string(),
+    observedArgsSchemaHash: z.string().optional(),
+    observedArgsSchemaConsistency: z.number().min(0).max(1).optional(),
+    observedArgsSchemaVariations: z.number().int().min(0).optional(),
     responseFingerprint: responseFingerprintSchema.optional(),
     inferredOutputSchema: inferredSchemaSchema.optional(),
     errorPatterns: z.array(errorPatternSchema).optional(),
@@ -137,21 +149,40 @@ const baselineSchema = z.object({
     server: serverFingerprintSchema,
     capabilities: z.object({
         tools: z.array(toolCapabilitySchema),
-        resources: z.array(z.record(z.unknown())).optional(),
-        prompts: z.array(z.record(z.unknown())).optional(),
+        resources: z
+            .array(z.object({
+            uri: z.string(),
+            name: z.string(),
+            description: z.string().optional(),
+            mimeType: z.string().optional(),
+        }))
+            .optional(),
+        prompts: z
+            .array(z.object({
+            name: z.string(),
+            description: z.string().optional(),
+            arguments: z
+                .array(z.object({
+                name: z.string(),
+                description: z.string().optional(),
+                required: z.boolean().optional(),
+            }))
+                .optional(),
+        }))
+            .optional(),
     }),
     interviews: z.array(z.record(z.unknown())),
     toolProfiles: z.array(z.object({
         name: z.string(),
         description: z.string().optional(),
         schemaHash: z.string().optional(),
-        assertions: z.array(cloudAssertionSchema),
+        assertions: z.array(baselineAssertionSchema),
         securityNotes: z.array(z.string()).optional(),
         limitations: z.array(z.string()).optional(),
         behavioralNotes: z.array(z.string()).optional(),
     })),
     workflows: z.array(workflowSignatureSchema).optional(),
-    assertions: z.array(cloudAssertionSchema),
+    assertions: z.array(baselineAssertionSchema),
     summary: z.string(),
     hash: z.string(),
     acceptance: driftAcceptanceSchema.optional(),
@@ -164,7 +195,7 @@ const baselineSchema = z.object({
  * Explore mode results are for documentation only.
  */
 export function createBaseline(result, serverCommand) {
-    return createCloudBaseline(result, serverCommand);
+    return createBaselineFromInterview(result, serverCommand);
 }
 /**
  * Save baseline to a file.
@@ -280,7 +311,7 @@ export function acceptDrift(currentBaseline, diff, options = {}) {
     const acceptedDiff = {
         toolsAdded: [...diff.toolsAdded],
         toolsRemoved: [...diff.toolsRemoved],
-        toolsModified: diff.toolsModified.map(t => t.tool),
+        toolsModified: diff.toolsModified.map((t) => t.tool),
         severity: diff.severity,
         breakingCount: diff.breakingCount,
         warningCount: diff.warningCount,

package/dist/baseline/schema-compare.d.ts

@@ -25,8 +25,19 @@ interface SchemaProperty {
     default?: unknown;
     items?: SchemaProperty;
     properties?: Record<string, SchemaProperty>;
+    patternProperties?: Record<string, SchemaProperty>;
+    dependentRequired?: Record<string, string[]>;
+    if?: SchemaProperty;
+    then?: SchemaProperty;
+    else?: SchemaProperty;
+    oneOf?: SchemaProperty[];
+    anyOf?: SchemaProperty[];
+    allOf?: SchemaProperty[];
     required?: string[];
     additionalProperties?: boolean | SchemaProperty;
+    $ref?: string;
+    minProperties?: number;
+    maxProperties?: number;
 }
 /**
  * Input schema for a tool.
@@ -34,8 +45,19 @@ interface SchemaProperty {
 interface InputSchema {
     type?: string;
     properties?: Record<string, SchemaProperty>;
+    patternProperties?: Record<string, SchemaProperty>;
+    dependentRequired?: Record<string, string[]>;
+    if?: SchemaProperty;
+    then?: SchemaProperty;
+    else?: SchemaProperty;
+    oneOf?: SchemaProperty[];
+    anyOf?: SchemaProperty[];
+    allOf?: SchemaProperty[];
     required?: string[];
     additionalProperties?: boolean | SchemaProperty;
+    $ref?: string;
+    minProperties?: number;
+    maxProperties?: number;
 }
 /**
  * Schema change type.

package/dist/baseline/schema-compare.js

@@ -25,7 +25,7 @@ export function computeSchemaHash(schema) {
         return 'empty';
     // Create normalized representation for hashing with circular reference protection
     const seen = new WeakSet();
-    const normalized = normalizeSchema(schema, 0, seen);
+    const normalized = normalizeSchema(schema, 0, seen, schema);
     const serialized = JSON.stringify(normalized);
     return createHash('sha256').update(serialized).digest('hex').slice(0, 16);
 }
@@ -70,7 +70,7 @@ function checkCircularRef(obj, seen) {
  * @param depth - Current recursion depth
  * @param seen - WeakSet tracking visited objects for circular reference detection
  */
-function normalizeSchema(schema, depth = 0, seen = new WeakSet()) {
+function normalizeSchema(schema, depth = 0, seen = new WeakSet(), root = schema) {
     // Check depth limit
     const depthLimit = checkDepthLimit(depth);
     if (depthLimit)
@@ -80,6 +80,16 @@ function normalizeSchema(schema, depth = 0, seen = new WeakSet()) {
     if (circularRef)
         return circularRef;
     const result = {};
+    // Handle $ref (resolve local refs to include referenced structure in hash)
+    if (schema.$ref) {
+        const ref = schema.$ref;
+        const resolved = resolveLocalRef(root, ref);
+        const refResult = { $ref: ref };
+        if (resolved && typeof resolved === 'object') {
+            refResult.$ref_resolved = normalizeSchema(resolved, depth + 1, seen, root);
+        }
+        return refResult;
+    }
     // Sort and normalize simple fields
     if (schema.type !== undefined) {
         result.type = Array.isArray(schema.type) ? schema.type.sort() : schema.type;
@@ -91,7 +101,16 @@ function normalizeSchema(schema, depth = 0, seen = new WeakSet()) {
         result.enum = [...schema.enum].sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
     }
     // Constraints - normalize numeric values to handle 1.0 vs 1
-    const constraintFields = ['minimum', 'maximum', 'minLength', 'maxLength', 'pattern', 'default'];
+    const constraintFields = [
+        'minimum',
+        'maximum',
+        'minLength',
+        'maxLength',
+        'pattern',
+        'default',
+        'minProperties',
+        'maxProperties',
+    ];
     for (const field of constraintFields) {
         const value = schema[field];
         if (value !== undefined) {
@@ -112,21 +131,61 @@ function normalizeSchema(schema, depth = 0, seen = new WeakSet()) {
     if (schema.properties) {
         const props = {};
         // Normalize Unicode in property keys and sort
-        const sortedKeys = Object.keys(schema.properties)
-            .map(normalizeUnicodeKey)
-            .sort();
+        const sortedKeys = Object.keys(schema.properties).map(normalizeUnicodeKey).sort();
         for (const key of sortedKeys) {
             // Find the original key (may differ in Unicode representation)
-            const originalKey = Object.keys(schema.properties).find(k => normalizeUnicodeKey(k) === key);
+            const originalKey = Object.keys(schema.properties).find((k) => normalizeUnicodeKey(k) === key);
             if (originalKey) {
-                props[key] = normalizeSchema(schema.properties[originalKey], depth + 1, seen);
+                props[key] = normalizeSchema(schema.properties[originalKey], depth + 1, seen, root);
             }
         }
         result.properties = props;
     }
+    // Pattern properties - normalize keys and values
+    if (schema.patternProperties) {
+        const patternProps = schema.patternProperties ?? {};
+        const props = {};
+        const sortedKeys = Object.keys(patternProps).sort();
+        for (const key of sortedKeys) {
+            const prop = patternProps[key];
+            props[key] = normalizeSchema(prop, depth + 1, seen, root);
+        }
+        result.patternProperties = props;
+    }
+    // Dependent required - normalize keys and sort arrays
+    if (schema.dependentRequired) {
+        const deps = schema.dependentRequired ?? {};
+        const normalizedDeps = {};
+        const sortedKeys = Object.keys(deps).map(normalizeUnicodeKey).sort();
+        for (const key of sortedKeys) {
+            const values = deps[key] ?? [];
+            normalizedDeps[key] = [...values].map(normalizeUnicodeKey).sort();
+        }
+        result.dependentRequired = normalizedDeps;
+    }
+    // Conditional schemas (if/then/else)
+    if (schema.if) {
+        result.if = normalizeSchema(schema.if, depth + 1, seen, root);
+    }
+    if (schema.then) {
+        result.then = normalizeSchema(schema.then, depth + 1, seen, root);
+    }
+    if (schema.else) {
+        result.else = normalizeSchema(schema.else, depth + 1, seen, root);
+    }
+    // oneOf/anyOf/allOf variants
+    if (schema.oneOf) {
+        result.oneOf = normalizeSchemaArray(schema.oneOf, depth, seen, root);
+    }
+    if (schema.anyOf) {
+        result.anyOf = normalizeSchemaArray(schema.anyOf, depth, seen, root);
+    }
+    if (schema.allOf) {
+        result.allOf = normalizeSchemaArray(schema.allOf, depth, seen, root);
+    }
     // Items for arrays
     if (schema.items) {
-        result.items = normalizeSchema(schema.items, depth + 1, seen);
+        result.items = normalizeSchema(schema.items, depth + 1, seen, root);
     }
     // Additional properties
     if (schema.additionalProperties !== undefined) {
@@ -134,11 +193,39 @@ function normalizeSchema(schema, depth = 0, seen = new WeakSet()) {
             result.additionalProperties = schema.additionalProperties;
         }
         else {
-            result.additionalProperties = normalizeSchema(schema.additionalProperties, depth + 1, seen);
+            result.additionalProperties = normalizeSchema(schema.additionalProperties, depth + 1, seen, root);
         }
     }
     return result;
 }
+/**
+ * Normalize a list of schemas (oneOf/anyOf/allOf) into a stable, sorted array.
+ */
+function normalizeSchemaArray(variants, depth, seen, root) {
+    const normalized = variants.map((variant) => normalizeSchema(variant, depth + 1, seen, root));
+    // Sort by JSON string for stable hashing (order-insensitive for oneOf/anyOf/allOf)
+    return normalized.sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
+}
+/**
+ * Resolve a local JSON pointer reference (e.g., "#/properties/foo").
+ */
+function resolveLocalRef(root, ref) {
+    if (!ref.startsWith('#/')) {
+        return null;
+    }
+    const pointer = ref.slice(2);
+    const parts = pointer.split('/').map((part) => part.replace(/~1/g, '/').replace(/~0/g, '~'));
+    let current = root;
+    for (const part of parts) {
+        if (current && typeof current === 'object' && part in current) {
+            current = current[part];
+        }
+        else {
+            return null;
+        }
+    }
+    return current ?? null;
+}
 /**
  * Compare two schemas and return detailed differences.
  */
@@ -262,8 +349,8 @@ function compareProperties(prev, curr, path, changes) {
     if (!arraysEqual(prev.enum, curr.enum)) {
         const prevSet = new Set((prev.enum ?? []).map(String));
         const currSet = new Set((curr.enum ?? []).map(String));
-        const removed = [...prevSet].filter(v => !currSet.has(v));
-        const added = [...currSet].filter(v => !prevSet.has(v));
+        const removed = [...prevSet].filter((v) => !currSet.has(v));
+        const added = [...currSet].filter((v) => !prevSet.has(v));
         changes.push({
             path,
             changeType: 'enum_changed',
@@ -279,6 +366,8 @@ function compareProperties(prev, curr, path, changes) {
     compareConstraint(prev, curr, path, 'minLength', changes);
     compareConstraint(prev, curr, path, 'maxLength', changes);
     compareConstraint(prev, curr, path, 'pattern', changes);
+    compareConstraint(prev, curr, path, 'minProperties', changes);
+    compareConstraint(prev, curr, path, 'maxProperties', changes);
     // Compare nested properties
     if (prev.properties || curr.properties) {
         const prevNested = prev.properties ?? {};
@@ -339,6 +428,18 @@ function compareProperties(prev, curr, path, changes) {
             });
         }
     }
+    // Compare patternProperties
+    comparePatternProperties(prev, curr, path, changes);
+    // Compare dependentRequired
+    compareDependentRequired(prev, curr, path, changes);
+    // Compare conditional schemas (if/then/else)
+    compareConditionalSchemas(prev, curr, path, changes);
+    // Compare compositional schemas (oneOf/anyOf/allOf)
+    compareSchemaVariants(prev, curr, path, changes, 'oneOf');
+    compareSchemaVariants(prev, curr, path, changes, 'anyOf');
+    compareSchemaVariants(prev, curr, path, changes, 'allOf');
+    // Compare additionalProperties
+    compareAdditionalProperties(prev, curr, path, changes);
 }
 /**
  * Compare a single constraint.
@@ -349,8 +450,8 @@ function compareConstraint(prev, curr, path, field, changes) {
     if (prevValue !== currValue) {
         // Determine if breaking
         let breaking = false;
-        const isMinConstraint = field === 'minimum' || field === 'minLength';
-        const isMaxConstraint = field === 'maximum' || field === 'maxLength';
+        const isMinConstraint = field === 'minimum' || field === 'minLength' || field === 'minProperties';
+        const isMaxConstraint = field === 'maximum' || field === 'maxLength' || field === 'maxProperties';
         if (isMinConstraint) {
             // Increasing minimum is breaking (more restrictive)
             breaking = currValue !== undefined && (prevValue === undefined || currValue > prevValue);
@@ -373,6 +474,148 @@ function compareConstraint(prev, curr, path, field, changes) {
         });
     }
 }
+/**
+ * Compare patternProperties between two schemas.
+ */
+function comparePatternProperties(prev, curr, path, changes) {
+    const prevPatterns = prev.patternProperties ?? {};
+    const currPatterns = curr.patternProperties ?? {};
+    const prevKeys = new Set(Object.keys(prevPatterns));
+    const currKeys = new Set(Object.keys(currPatterns));
+    for (const key of currKeys) {
+        if (!prevKeys.has(key)) {
+            changes.push({
+                path: `${path}{${key}}`,
+                changeType: 'property_added',
+                before: undefined,
+                after: summarizeProperty(currPatterns[key]),
+                breaking: false,
+                description: `Pattern property "${key}" added`,
+            });
+        }
+    }
+    for (const key of prevKeys) {
+        if (!currKeys.has(key)) {
+            changes.push({
+                path: `${path}{${key}}`,
+                changeType: 'property_removed',
+                before: summarizeProperty(prevPatterns[key]),
+                after: undefined,
+                breaking: true,
+                description: `Pattern property "${key}" removed`,
+            });
+        }
+    }
+    for (const key of prevKeys) {
+        if (currKeys.has(key)) {
+            compareProperties(prevPatterns[key], currPatterns[key], `${path}{${key}}`, changes);
+        }
+    }
+}
+/**
+ * Compare dependentRequired constraints.
+ */
+function compareDependentRequired(prev, curr, path, changes) {
+    const prevDeps = prev.dependentRequired ?? {};
+    const currDeps = curr.dependentRequired ?? {};
+    const keys = new Set([...Object.keys(prevDeps), ...Object.keys(currDeps)]);
+    for (const key of keys) {
+        const prevReqs = prevDeps[key] ?? [];
+        const currReqs = currDeps[key] ?? [];
+        if (!arraysEqual(prevReqs, currReqs)) {
+            const added = currReqs.filter((req) => !prevReqs.includes(req));
+            const removed = prevReqs.filter((req) => !currReqs.includes(req));
+            const breaking = added.length > 0;
+            changes.push({
+                path: `${path}.dependentRequired.${key}`,
+                changeType: 'constraint_changed',
+                before: prevReqs,
+                after: currReqs,
+                breaking,
+                description: `Dependent required fields for "${key}" changed (${added.length} added, ${removed.length} removed)`,
+            });
+        }
+    }
+}
+/**
+ * Compare conditional schemas (if/then/else).
+ */
+function compareConditionalSchemas(prev, curr, path, changes) {
+    const prevIf = prev.if;
+    const currIf = curr.if;
+    const prevThen = prev.then;
+    const currThen = curr.then;
+    const prevElse = prev.else;
+    const currElse = curr.else;
+    if (prevIf || currIf || prevThen || currThen || prevElse || currElse) {
+        const prevSig = JSON.stringify(normalizeSchema(prev, 0, new WeakSet(), prev));
+        const currSig = JSON.stringify(normalizeSchema(curr, 0, new WeakSet(), curr));
+        if (prevSig !== currSig) {
+            const breaking = !!currIf && !prevIf;
+            changes.push({
+                path: `${path}.ifThenElse`,
+                changeType: 'constraint_changed',
+                before: prevIf ? 'conditional present' : 'none',
+                after: currIf ? 'conditional present' : 'none',
+                breaking,
+                description: 'Conditional schema (if/then/else) changed',
+            });
+        }
+    }
+}
+/**
+ * Compare oneOf/anyOf/allOf variants.
+ */
+function compareSchemaVariants(prev, curr, path, changes, field) {
+    const prevVariants = prev[field] ?? [];
+    const currVariants = curr[field] ?? [];
+    if (prevVariants.length === 0 && currVariants.length === 0) {
+        return;
+    }
+    const prevNormalized = normalizeSchemaArray(prevVariants, 0, new WeakSet(), prev);
+    const currNormalized = normalizeSchemaArray(currVariants, 0, new WeakSet(), curr);
+    const prevSet = new Set(prevNormalized.map((v) => JSON.stringify(v)));
+    const currSet = new Set(currNormalized.map((v) => JSON.stringify(v)));
+    const removed = [...prevSet].filter((v) => !currSet.has(v));
+    const added = [...currSet].filter((v) => !prevSet.has(v));
+    if (removed.length > 0 || added.length > 0) {
+        changes.push({
+            path: `${path}.${field}`,
+            changeType: 'constraint_changed',
+            before: `variants:${prevVariants.length}`,
+            after: `variants:${currVariants.length}`,
+            breaking: removed.length > 0,
+            description: `${field} variants changed (${removed.length} removed, ${added.length} added)`,
+        });
+    }
+}
+/**
+ * Compare additionalProperties between schemas.
+ */
+function compareAdditionalProperties(prev, curr, path, changes) {
+    const prevAdditional = prev.additionalProperties;
+    const currAdditional = curr.additionalProperties;
+    if (prevAdditional === undefined && currAdditional === undefined) {
+        return;
+    }
+    const prevSig = typeof prevAdditional === 'boolean'
+        ? String(prevAdditional)
+        : JSON.stringify(normalizeSchema(prevAdditional ?? {}, 0, new WeakSet(), prev));
+    const currSig = typeof currAdditional === 'boolean'
+        ? String(currAdditional)
+        : JSON.stringify(normalizeSchema(currAdditional ?? {}, 0, new WeakSet(), curr));
+    if (prevSig !== currSig) {
+        const breaking = currAdditional === false || currAdditional === undefined;
+        changes.push({
+            path: `${path}.additionalProperties`,
+            changeType: 'constraint_changed',
+            before: prevAdditional ?? 'unspecified',
+            after: currAdditional ?? 'unspecified',
+            breaking,
+            description: 'additionalProperties constraint changed',
+        });
+    }
+}
 /**
  * Normalize type to string for comparison.
  */
@@ -444,7 +687,7 @@ function generateVisualDiff(_previous, _current, changes) {
     }
     // Format each path's changes
     for (const [path, pathChanges] of byPath) {
-        const marker = pathChanges.some(c => c.breaking) ? '!' : '~';
+        const marker = pathChanges.some((c) => c.breaking) ? '!' : '~';
         lines.push(`${marker} ${path}:`);
         for (const change of pathChanges) {
             const prefix = change.breaking ? '  [BREAKING]' : '  [info]';
@@ -458,7 +701,7 @@ function generateVisualDiff(_previous, _current, changes) {
         }
     }
     // Summary
-    const breakingCount = changes.filter(c => c.breaking).length;
+    const breakingCount = changes.filter((c) => c.breaking).length;
     const nonBreakingCount = changes.length - breakingCount;
     lines.push('');
     lines.push(`Summary: ${breakingCount} breaking, ${nonBreakingCount} non-breaking change(s)`);

package/dist/baseline/types.d.ts

@@ -3,8 +3,9 @@
  */
 import type { ToolProfile } from '../interview/types.js';
 import type { ResponseFingerprint, InferredSchema, ErrorPattern } from './response-fingerprint.js';
-import type { BellwetherBaseline, BaselineMode as CloudBaselineMode, DriftAcceptance, AcceptedDiff } from './cloud-types.js';
+import type { BellwetherBaseline, DriftAcceptance, AcceptedDiff } from './baseline-format.js';
 export type { DriftAcceptance, AcceptedDiff };
+export type { BaselineMode } from './baseline-format.js';
 /**
  * Re-export ErrorPattern for use by other modules.
  */
@@ -30,7 +31,7 @@ export type ChangeSeverity = 'none' | 'info' | 'warning' | 'breaking';
 /**
  * Aspect of tool behavior that changed.
  */
-export type BehaviorAspect = 'response_format' | 'response_structure' | 'response_schema_evolution' | 'error_handling' | 'error_pattern' | 'security' | 'performance' | 'schema' | 'description';
+export type BehaviorAspect = 'response_format' | 'response_structure' | 'response_schema_evolution' | 'error_handling' | 'error_pattern' | 'security' | 'performance' | 'schema' | 'description' | 'prompt' | 'resource' | 'server' | 'capability';
 /**
  * A single behavioral assertion about a tool.
  */
@@ -228,8 +229,14 @@ export interface ToolFingerprint {
     name: string;
     description: string;
     schemaHash: string;
-    /** Full input schema for the tool (preserved for cloud upload) */
+    /** Full input schema for the tool (preserved for export/analysis) */
     inputSchema?: Record<string, unknown>;
+    /** Hash of observed arguments schema (from actual calls) */
+    observedArgsSchemaHash?: string;
+    /** Consistency of observed argument schemas (0-1) */
+    observedArgsSchemaConsistency?: number;
+    /** Number of observed schema variations */
+    observedArgsSchemaVariations?: number;
     assertions: BehavioralAssertion[];
     securityNotes: string[];
     limitations: string[];
@@ -280,10 +287,6 @@ export interface SemanticInferenceRecord {
     /** Confidence level (0-1) */
     confidence: number;
 }
-/**
- * Server fingerprint for baseline comparison.
- */
-export type BaselineMode = CloudBaselineMode;
 /**
  * Baseline for an MCP server.
  */

package/dist/cache/response-cache.d.ts

@@ -48,6 +48,8 @@ export interface CacheConfig {
     maxSizeBytes?: number;
     /** Whether to enable cache (default: true) */
     enabled?: boolean;
+    /** Optional cache directory for persistence */
+    dir?: string;
 }
 /**
  * In-memory content-addressable cache.
@@ -57,6 +59,7 @@ export declare class ResponseCache {
     private config;
     private stats;
     private totalSizeBytes;
+    private cacheDir?;
     constructor(config?: CacheConfig);
     /**
      * Generate a cache key from input data.
@@ -108,6 +111,11 @@ export declare class ResponseCache {
      * Estimate the size of a value in bytes.
      */
     private estimateSize;
+    private ensureCacheDir;
+    private getCachePath;
+    private saveToDisk;
+    private loadFromDisk;
+    private deleteFromDisk;
 }
 /**
  * Specialized cache for tool responses.