Model Context Protocol

// Tool Registry with Capability Declaration
const billingAdvisorCapabilities = {
  name: "BillingAdvisor",
  version: "2.5.0",
  capabilities: [
    {
      domain: "billing",
      actions: ["getCPTCode", "checkPriorAuth"],
      supportedEntities: ["aetna", "bluecross"]
    }
  ],
  contextRequirements: {
    required: ["insurer"],
    optional: ["patient_age", "diagnosis"]
  }
};

// Register with the capability registry
registry.registerTool(billingAdvisorCapabilities, getBillingInfo);

// Orchestrator dynamically selects tools based on context
function selectTools(contextFrame) {
  // Get tools that can handle the context
  const candidateTools = registry.findToolsForContext(contextFrame);
  
  // Filter by matching capabilities to context hints
  return candidateTools.filter(tool => {
    const toolDomains = tool.capabilities.map(cap => cap.domain);
    const hasMatchingDomain = contextFrame.hints.some(hint => 
      toolDomains.includes(hint)
    );
    return hasMatchingDomain;
  });
}

// Content-addressed provenance record
function recordProvenance(toolName, contextFrame, output, sources) {
  // Create provenance record with inputs and outputs
  const provenance = {
    tool: {
      name: toolName,
      version: getToolVersion(toolName)
    },
    timestamp: new Date().toISOString(),
    context_hash: contextFrame.hash,
    sources: sources.map(source => ({
      id: source.id,
      type: source.type,
      matches: source.matches || []
    })),
    output_summary: summarizeOutput(output)
  };
  
  // Link to previous record (creating a chain)
  const previousHash = store.getLatestHash();
  if (previousHash) {
    provenance.previous_hash = previousHash;
  }
  
  // Generate hash and sign the record
  const hash = generateProvenanceHash(provenance);
  provenance.hash = hash;
  provenance.signature = generateSignature(provenance);
  
  // Store immutably
  store.store(hash, provenance);
  
  return hash;
}

$ ./src/index.js trace bill123abc

┬─ BillingAdvisor v2.5.0  @2025-05-20T15:22:44Z
│ context_hash: 2d19…
│ previous_hash: sche42a9b1
│ signature: f78e91ab567d4c2e
├─ RULE MATCH  billing.rules/pa_required.json   → true
│            insurance="Aetna PPO"  age=12
├─ RULE MATCH  billing.rules/cpt_mapping.yaml   → 90867
└─ OUTPUT  CPT=90867  prior_auth=true  reimbursement=312.14

// Multi-factor tool scoring algorithm
function scoreTools(tools, context, history) {
  return tools.map(tool => {
    // Start with rule-based matching score
    let score = calculateRuleMatchScore(tool, context);
    
    // Add performance factor (prioritize faster, reliable tools)
    const performance = getHistoricalPerformance(tool.name, history);
    score += (1 / (performance.avgLatency + 1)) * LATENCY_WEIGHT;
    score -= (performance.failureRate) * FAILURE_WEIGHT;
    
    // Add entropy contribution factor (information gain)
    const entropyContribution = calculateEntropyContribution(
      tool, context, history
    );
    score += entropyContribution * ENTROPY_WEIGHT;
    
    return { tool, score };
  }).sort((a, b) => b.score - a.score);
}

// Records performance metrics for tool invocations
async function invokeTool(tool, contextFrame) {
  const startTime = performance.now();
  let success = false;
  
  try {
    const result = await tool.handler(contextFrame);
    success = true;
    return {
      tool: tool.name,
      data: result.data,
      provenanceHash: result.provenanceHash
    };
  } catch (error) {
    return { tool: tool.name, error: error.message };
  } finally {
    const endTime = performance.now();
    const latency = endTime - startTime;
    
    // Update tool performance statistics
    registry.recordInvocation(tool.name, success, latency);
  }
}

// Example policy declaration
policyEngine.registerPolicy({
  name: "HIPAA Compliant Tools Only",
  description: "Only allows tools that declare HIPAA compliance",
  scope: "global",
  rules: [
    {
      condition: "tool.capabilities.compliance.hipaa === true",
      action: "ALLOW",
      message: "Tool declares HIPAA compliance"
    },
    {
      condition: "true",
      action: "DENY",
      message: "Tool does not declare HIPAA compliance"
    }
  ]
});

// Pre-execution policy gate enforcement
async function invokeTool(tool, contextFrame) {
  try {
    // Validate invocation request against schema
    const requestValidation = validateInvocationRequest({
      contextFrame,
      tool: tool.name,
      timestamp: new Date().toISOString()
    });
    
    if (!requestValidation.isValid) {
      throw new Error(`Invalid request: ${requestValidation.errors.join(', ')}`);
    }
    
    // Apply policy gates before execution
    const policyResult = applyPolicyGates(tool, contextFrame);
    if (!policyResult.allowed) {
      throw new Error(`Policy gate denied execution: ${policyResult.messages.join(', ')}`);
    }
    
    // Only if validation passes do we execute
    const result = await tool.handler(contextFrame);
    return result;
  } catch (error) {
    throw error;
  }
}