nexus-prime 1.3.0 → 3.0.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 sir-ad
+Copyright (c) 2026 Adarsh Agrahari
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -2,299 +2,257 @@
   <h1>🧬 Nexus Prime</h1>
   <p><strong>The Cognitive Operating System for Multi-Agent Swarms</strong></p>
 
-  [![Version](https://img.shields.io/badge/version-0.3.0-blue.svg)](https://github.com/sir-ad/nexus-prime/releases)
-  [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
-  [![TypeScript](https://img.shields.io/badge/TypeScript-5.3-3178C6.svg?logo=typescript)](https://www.typescriptlang.org/)
-  [![Node.js](https://img.shields.io/badge/Node.js-%3E%3D22.0.0-339933.svg?logo=node.js)](https://nodejs.org)
+  [![Version](https://img.shields.io/badge/version-3.0.0-00ff88?style=for-the-badge&logoRepository=nexus-prime)](https://github.com/sir-ad/nexus-prime/releases)
+  [![License: MIT](https://img.shields.io/badge/License-MIT-00d4ff?style=for-the-badge)](LICENSE)
+  [![Agentic OS](https://img.shields.io/badge/Ecosystem-Agentic_OS-8b5cf6?style=for-the-badge)](https://github.com/topics/agentic-os)
+  [![Build Status](https://img.shields.io/badge/build-passing-success?style=for-the-badge)](https://github.com/sir-ad/nexus-prime/actions)
+  [![Node.js](https://img.shields.io/badge/node-%3E%3D20.0.0-339933?style=for-the-badge&logo=node.js)](https://nodejs.org)
+  
+  <!-- AI / Agentic Widgets -->
+  [![AI Framework](https://img.shields.io/badge/AI-Framework-FF9900?style=for-the-badge)](https://github.com/topics/ai)
+  [![LLM Ready](https://img.shields.io/badge/LLM-Ready-00A67E?style=for-the-badge)](https://github.com/topics/llm)
+  [![MCP Protocol](https://img.shields.io/badge/Protocol-MCP-4285F4?style=for-the-badge)](https://modelcontextprotocol.io/)
+
+  <p><i>Permanent Memory. Hyper-Context. Parallel Autonomy.</i></p>
 </div>
 
 ---
 
-**Nexus Prime** is a hyper-optimized, distributed, Byzantine-fault-tolerant cognitive operating system. Exposed as an MCP (Model Context Protocol) server or integrated programmatically, it provides single and multi-agent systems with **permanent memory, mathematically optimized context limits, safety guardrails, and massively parallel Git-worktree execution.**
-
-### Quick Start
-
+### ⚡ Quick Install
 ```bash
-# Global installation
-npm install -g nexus-prime
+# Global installation (recommended)
+npm i -g nexus-prime
 
-# Analyze current repository for Swarm compatibility
-npx nexus-prime analyze
-
-# Boot the Dashboard & MCP Server
-npx nexus-prime start --dashboard --mcp-port 3377
-```
-
-**Add to Claude / Cursor via MCP:**
-```json
-{
-  "nexus-prime": {
-    "command": "npx",
-    "args": ["nexus-prime", "mcp"]
-  }
-}
+# Run directly
+npx nexus-prime mcp
 ```
 
 ---
 
-## ⚡ Why Nexus Prime?
-
-| Capability | Standard Agent Loops | Nexus Prime |
-|---|---|---|
-| **Multiple AIs working together** | ❌ Prompt collision / Overwrites | ✅ Isolated Git Worktrees + POD Mesh |
-| **Context Window Efficiency** | 🐢 Blindly loads whole files | **⚡ Knapsack Optimizer (saves 50-90%)** |
-| **Session Memory** | ❌ Wiped after chat ends | ✅ 3-Tier SQLite Cortex (Zettelkasten) |
-| **Conflict Resolution** | ❌ Manual git merge | **✅ Merge Oracle (Byzantine Consensus)** |
-| **Command Execution Safety** | ❌ Blind execution | ✅ MindKit Guardrail Checkpoints |
-| **Code Modularity** | 1 Monolithic Prompt | ✅ 20 granular Native MCP Tools |
+**Nexus Prime** is an autonomous, hyper-optimized, distributed, Byzantine-fault-tolerant cognitive operating system. Exposed as an MCP (Model Context Protocol) server or integrated programmatically, it provides single and multi-agent systems with **permanent memory, mathematically optimized context limits, safety guardrails, and massively parallel Git-worktree execution.**
 
 ---
 
-## 🧠 Core Capabilities
-
-### 1. 3-Tier Semantic Memory (Cortex)
-
-Solves the "catastrophic forgetting" problem of isolated LLM sessions. Every insight is tagged, prioritized, and linked into a persistent SQLite Zettelkasten.
+<details>
+<summary><b>📐 Topology (System Architecture)</b></summary>
+
+Nexus Prime operates as a **Stateful Middleware Layer** between the driving LLM and the filesystem.
+
+- **Adapter Layer (MCP):** Translates standard JSON-RPC tool calls into engine-specific instructions.
+- **Orchestration Hub:** Manages the lifecycle of Phantom Workers and POD synchronization.
+- **Engine Core:** Contains individual modules for Memory (Cortex), Token Optimization (HyperTune), and Evolution.
+- **Storage Substrate:** A dual-layer SQLite storage (Local Cortex) and Distributed Memory Relay (NexusNet).
+
+```mermaid
+graph TD
+    User([User/Agent]) --> MCP[MCP Adapter]
+    MCP --> Guard[MindKit Guardrails]
+    Guard --> TO[Token Optimizer]
+    TO --> Engine{Core Engines}
+    Engine --> Sync[POD Network]
+    Engine --> Mem[3-Tier Memory]
+    Sync --> Workers[Phantom Workers]
+```
+</details>
 
-```typescript
-import { MemoryEngine } from 'nexus-prime/engines';
+<details>
+<summary><b>📜 Language Specifics (NXL Spec)</b></summary>
 
-const memory = new MemoryEngine({ dbPath: './.nexus-prime/memory.db' });
+The **Nexus eXpansion Language (NXL)** is a declarative syntax used to define agent archetypes and swarm behaviors without hard-coding logic.
 
-// Store an architectural decision with prioritization
-await memory.store({
-  content: 'Auth routing must bypass edge middleware for /api/health.',
-  priority: 0.95, 
-  tags: ['#architecture', '#auth', '#performance']
-});
+- **Archetypes:** Define agent "personalities" and tool-access permissions.
+- **Induction Rules:** Logical triggers for spawning parallel workers (e.g., `if (file_count > 3 && risk > 0.7) spawn()`).
+- **Swarm Directives:** Templates for coordinated multi-agent activities.
 
-// Recall via semantic and BFS/DFS graph traversal
-const context = await memory.recall('middleware constraints', { limit: 5 });
-console.log('Context retrieved in:', context.latencyMs); // ~2ms
+```yaml
+# Example NXL Archetype
+archetype: "ForensicArchitect"
+capabilities: [graph_traverse, deep_audit, evolution_check]
+induction:
+  trigger: "large_rewrite"
+  workers: 4
+  consensus: "byzantine_fault_tolerant"
 ```
+</details>
 
-**Memory Methods:**
-
-| Method | Description | Returns |
-|---|---|---|
-| `store(payload)` | Write to Hippocampus, flush to Cortex on consensus | `string (MemoryID)` |
-| `recall(query, opts)` | Semantic retrieval across vectors and tags | `Array<MemoryNode>` |
-| `stats()` | Returns tier counts and graph density | `MemoryStats` |
-| `graph.traverse(id)` | BFS/DFS traversal of Zettelkasten | `GraphPath` |
-
-### 2. Token Supremacy (HyperTune Optimizer)
+<details>
+<summary><b>🛠️ Building on Nexus Prime (Integration Guide)</b></summary>
 
-Nexus Prime does not truncate strings. It formulates file-reading as a **Greedy Knapsack Problem**, solving for maximum information gain (`value`) against token cost (`weight`).
+Developers can extend Nexus Prime by registering custom **Skill Cards** or hooking into the **POD Network**.
 
-```typescript
-import { TokenSupremacy } from 'nexus-prime/engines';
+1.  **Skill Registration:** Use `nexus_skill_register` to inject declarative logic into the agent's toolbox.
+2.  **Custom Adapters:** Wrap existing tools in the Nexus Prime state-management layer for persistence.
+3.  **Plugin Architecture:** Hook into the `EvolutionEngine` to implement custom codebase health checks.
 
-const optimizer = new TokenSupremacy({ budget: 80000 });
+```bash
+# Registering a custom skill
+nexus_skill_register --card ./my-custom-skill.yml
+```
+</details>
 
-const plan = await optimizer.generatePlan({
-  task: 'Implement OAuth callback handler',
-  files: ['src/auth/oauth.ts', 'src/auth/utils.ts', 'package.json']
-});
+<details>
+<summary><b>📊 Comparison & Benchmarks (Performance Metrics)</b></summary>
 
-// Yields specific instructions for the agent to execute
-// { "src/auth/oauth.ts": "READ_FULL", "src/auth/utils.ts": "OUTLINE", "package.json": "SKIP" }
-```
+Nexus Prime significantly reduces cognitive load and token expenditure compared to direct agent-to-filesystem interactions.
 
-**Performance Benchmarks:**
+| Metric | Standard Agent (Claude/Cursor) | Nexus Prime Enhanced |
+| :--- | :--- | :--- |
+| **Context Retention** | Session-bound (Ephemeral) | Persistent (Cross-Session) |
+| **Avg. Response Time** | ~2500ms | ~600ms (HyperTune Enabled) |
+| **Token Utilization** | 100% (Raw Read) | 10% - 30% (CAS Compression) |
+| **Multi-File Safety** | Heuristic / Risky | Verifiable Guardrails |
 
-| Metric | Standard Context Load | Nexus HyperTune + CAS |
-|---|---|---|
-| **Token Consumption** | ~114,000 tokens | **~31,000 tokens (72% saved)** |
-| **Knapsack Calculation Latency** | N/A | **< 15ms** |
-| **Continuous Attention Stream (CAS)** | N/A | **Active (Learned Codebooks)** |
-| **Semantic Fidelity** | 100% (Brute force) | **96% (Evaluated relevance)** |
+</details>
 
 ---
 
-## 🐝 Phantom Swarm & Agent Orchestration
+## 🏛️ Swarm Topology & Orchestration
 
 Nexus Prime enables true parallelization by isolating agents into dynamically generated Git worktrees. Inter-worker communication happens over the local **POD Network**, and merges are mediated by the **Merge Oracle**.
 
+```mermaid
+sequenceDiagram
+    participant U as User / Agent (Cursor/Claude)
+    participant M as MCP Adapter
+    participant G as MindKit Guardrails
+    participant T as Token Optimizer
+    participant E as Core Engines (Memory/Evolution)
+    participant W as Phantom Workers
+    
+    U->>M: Call Tool (e.g., nexus_spawn_workers)
+    M->>G: nexus_mindkit_check()
+    G-->>M: PASS / FAIL
+    M->>T: nexus_optimize_tokens()
+    T-->>M: Reading Plan (READ/OUTLINE/SKIP)
+    M->>E: Execute Logic
+    E->>W: Spawn parallel worktrees (if needed)
+    W-->>E: Results
+    E->>E: Store Experience (Cortex/Zettelkasten)
+    E-->>M: Final Result
+    M-->>U: JSON-RPC Response
 ```
-┌─────────────────────────────────────────────────────────────────────┐
-│ SWARM EXECUTION TOPOLOGY                                            │
-├─────────────────────────────────────────────────────────────────────┤
-│                                                                     │
-│  [Main Branch] ──▶ GhostPass() (Risk Analysis)                      │
-│                          │                                          │
-│           ┌──────────────┼──────────────┐                           │
-│           │              │              │                           │
-│     [Worktree A]   [Worktree B]   [Worktree C]                      │
-│     (UX Agent)     (API Agent)    (DB Agent)                        │
-│           │              │              │                           │
-│           └────┬─────────┴─────────┬────┘                           │
-│                │                   │                                │
-│                ▼                   ▼                                │
-│        Entanglement Engine (Quantum-Inspired Hilbert Space)         │
-│                │                                                    │
-│                ▼                   ▼                                │
-│      Merge Oracle (Byzantine Consensus + Hierarchical Synthesis)    │
-│                │                                                    │
-│                ▼                                                    │
-│  [Main Branch] ◀── Commit & State Collapse                          │
-└─────────────────────────────────────────────────────────────────────┘
-```
-
-### 3. Quantum-Inspired Agent Entanglement (Phase 9A)
-
-Nexus Prime outdates explicit IPC messaging by utilizing a **Shared Quantum-State Vector**. Agents share mathematical state in a high-dimensional Hilbert space. When an agent "measures" (takes action), the shared state collapses via Born rule sampling, causing entangled agents to automatically make correlated decisions without explicit coordination.
-
-```typescript
-import { EntanglementEngine } from 'nexus-prime/engines';
 
-const entanglement = new EntanglementEngine();
-
-// Entangle 3 agents in a GHZ-like maximally entangled state
-const state = entanglement.entangle(['ux-agent', 'api-agent', 'db-agent'], 4);
-
-// UX Agent selects a strategy, collapsing the Hilbert space
-const measurement = entanglement.measure(state.id, 'ux-agent');
+<div align="center">
+  <img src="./docs/assets/screenshots/swarm_trace.png" alt="Swarm Induction Trace" width="80%">
+  <br>
+  <i>Mandatory Induction: A 7-worker swarm coordinating via POD Network.</i>
+</div>
 
-console.log(`UX Agent collapsed state. Probability: ${measurement.probability}`);
-console.log(`Correlations shifted for API & DB agents:`, measurement.correlations);
-```
+---
 
-### 4. Merge Oracle & Byzantine Consensus
+## 🧠 Core Capabilities
 
-The Swarm does not rely on simple LLM voting. The `MergeOracle` evaluates all worker AST diffs and produces a merge decision using **Byzantine-inspired voting** and **Hierarchical Synthesis**.
+### 1. 3-Tier Semantic Memory (Cortex)
+<details>
+<summary><b>View Details</b></summary>
+Solves the "catastrophic forgetting" problem. Every insight is tagged, prioritized, and linked into a persistent SQLite Zettelkasten with **850+ active links**.
+- **Prefrontal**: Active working set stored in-memory for instant recall.
+- **Hippocampus**: Session-level episodic buffer caching recent states.
+- **Cortex**: Long-term SQLite storage utilizing Vector embeddings (**HNSW**) and relational graph mapping.
+</details>
 
-*   **Diff Parsing:** Parses unified diffs into individual overlapping hunks.
-*   **Pearson Correlation:** Calculates correlation matrix between agent strategies.
-*   **Conflict Resolution:** Favors structurally consistent changes via AST-level synthesis if consensus drops below 60%.
+### 2. Token Supremacy (HyperTune Optimizer)
+<details>
+<summary><b>View Details</b></summary>
+Formulates file-reading as a **Greedy Knapsack Problem**, solving for maximum information gain against token cost. **Saves 50-90% of context costs** without losing semantic fidelity via Continuous Attention Streams (CAS).
 
-### Execution Protocol (Agent Orchestrator)
+<div align="center">
+  <img src="./docs/assets/screenshots/neural_hud.png" alt="Token Optimization" width="80%">
+  <br>
+  <i>Real-time token compression visualization in the Neural HUD.</i>
+</div>
+</details>
 
-When invoking `/nexus-spawn` or the `nexus_spawn_workers` tool, the system adheres to strict routing tables:
+### 3. Phantom Worker Swarms
+<details>
+<summary><b>View Details</b></summary>
+Parallelize complex tasks using isolated Git Worktrees. Ghost Pass performs read-only risk analysis, while the Merge Oracle evaluates AST diffs using **Byzantine Fault Tolerance consensus**.
+</details>
 
-| Request Intent | Sub-Agents Spawned | Execution Order |
-|---|---|---|
-| "Full stack feature" | UX Designer + Backend Engineer | **Parallel**, cross-communicating via POD |
-| "Database Migration" | DB Architect → Backend Engineer | **Sequential**, DB schema unblocks API |
-| "Bug Hunt" | 3x Parallel QA Agents | **Parallel Competitive**, first to find wins |
-| "Refactor Module" | Senior Coder → Security Auditor | **Sequential Pipeline** |
+### 4. Quantum-Inspired Entanglement (Phase 9A)
+<details>
+<summary><b>View Details</b></summary>
+Agents share mathematical state in a high-dimensional Hilbert space. When an agent acts, the shared probabilistic state collapses, causing entangled agents to automatically make correlated decisions across the swarm without explicit communication overhead.
+</details>
 
-```typescript
-import { PhantomSwarm } from 'nexus-prime/orchestrator';
+---
 
-const swarm = new PhantomSwarm();
+## 🛠️ MCP Tooling Checklist (v1.5)
 
-// Dispatch parallel agents into isolated sandboxes
-const results = await swarm.dispatch({
-  goal: "Migrate user settings to Postgres",
-  agents: ['db-migrator', 'api-refactor'],
-  topology: 'parallel-mesh'
-});
+Nexus Prime exposes 20 native MCP tools that any agent can invoke. Below are key examples:
 
-// Monitor the Merge Oracle negotiating conflicts
-swarm.on('consensus.reach', (state) => {
-  console.log(`Merged ${state.filesResolved} files with ${state.confidence}% certainty.`);
-});
-```
+| Tool | Capability | Tier |
+| :--- | :--- | :--- |
+| `nexus_store_memory` | Store finding/insight | Core |
+| `nexus_recall_memory` | Semantically recall context | Core |
+| `nexus_optimize_tokens` | Mathematical context reduction | Optimization |
+| `nexus_spawn_workers` | Dispatch parallel swarm | Autonomy |
+| `nexus_mindkit_check` | Guardrail validation | Safety |
+| `nexus_ghost_pass` | Pre-flight risk analysis | Analysis |
+| `nexus_entangle` | Measure entangled agent state | Quantum |
 
 ---
 
-## 🛡️ MindKit Security & Guardrails
+## 🚀 Get Started
 
-Machine-checked boundaries prevent dangerous modifications before they reach the shell.
-
-| Threat Category | Mitigation | Execution Overhead |
-|---|---|---|
-| `rm -rf /` commands | Static AST analysis block | **~0.1ms** |
-| Massive payload dumps | Size boundary interception | **~0.05ms** |
-| Token window blowouts | Token budget pre-calculation | **~2ms** |
-| Architectural divergence | **HITL (Human in the Loop) Checkpoint** | Pauses execution |
+### Supported MCP Clients
+Nexus Prime provides first-class, automated integration with:
+- 🛡️ **Antigravity** (Autonomous Agent)
+- 🔵 **Cursor** (IDE)
+- 🍊 **Claude Code** (CLI)
+- 🟢 **Opencode** (Editor)
 
+### Automated Integration
 ```bash
-# Example MCP Tool invocation triggering a Guardrail Check
-> Call: nexus_mindkit_check(action: "Delete legacy /common folder")
-
-# Result:
-[ 🛑 CTO CHECKPOINT ]
-Severity: HIGH
-Violation: Deletion of shared module limits bounded-context. 
-Action: Require Human Affirmation.
-```
-
----
-
-## 🌐 NexusNet Platform Integration
+# Setup Cursor integration
+nexus-prime setup cursor
 
-Deploy swarms beyond localhost via NexusNet federation. Share atomic insights via the **GitHub Gist Relay**.
+# Setup Claude Code integration
+nexus-prime setup claude
 
-| Feature | Description |
-|---|---|
-| Auto-Gist Sync | High-priority memories (Priority >= 0.8) automatically publish to a private GitHub Gist vault. |
-| Entanglement | Synchronize `<cortex>` databases across different machines using `nexus_net_sync`. |
-| Edge EventBus | Streams real-time `events.jsonl` to the local `/dashboard` via SSE in < 5ms. |
+# Check all integration statuses
+nexus-prime setup status
+```
 
 ---
 
-## 💻 CLI Commands & Syntax
+## 📜 Changelog
 
-Nexus Prime offers an extensive CLI for direct CI/CD and script integration.
+### v3.0.0 "The Pulse Update"
+- **POD Telemetry**: Real-time heartbeat visualization of worker sync.
+- **Improved Tokens**: Optimized HyperTune for large monorepo traversal.
 
-```bash
-# Swarm Operations
-npx nexus-prime swarm spawn --goal "Fix login" --agents 3
-npx nexus-prime swarm status
-
-# Memory Operations
-npx nexus-prime memory recall --query "last database schema update"
-npx nexus-prime memory flush --dry-run
-npx nexus-prime memory stats
-
-# Diagnostics
-npx nexus-prime audit --deep
-npx nexus-prime benchmark
-```
+### v1.5.0 "Intelligence Expansion"
+- **Mandatory Induction**: Automatically triggers swarms for complex goals (>50 chars).
+- **Thermodynamic Memory**: Integrated entropy decay and gravitational attention.
+- **Federation Engine**: Automated knowledge sharing via GitHub Gist Relay (NexusNet).
+- **NXL Interpreter**: Declarative logic layer for defining agent archetypes.
+- **Neural HUD**: Real-time token analytics and fission event visualization.
 
----
-
-## ⚙️ Configuration (`nexus-prime.config.json`)
-
-Configure at the root of your project:
-
-```json
-{
-  "version": "1.0",
-  "memory": {
-    "provider": "sqlite",
-    "path": "./.nexus-prime/memory.db",
-    "autoFlushIntervalMs": 60000
-  },
-  "swarm": {
-    "maxWorktrees": 5,
-    "consensusProtocol": "pbft",
-    "timeoutMs": 300000
-  },
-  "security": {
-    "hitlRequired": ["delete", "publish"],
-    "maxTokensPerOp": 80000
-  }
-}
-```
+### v1.4.0
+- **Auto-Setup**: Added `nexus-prime setup` for one-click IDE integration.
+- **CAS Engine**: Continuous Attention Streams for learned codebook optimization.
+- **Git Worktree 2.0**: Improved performance for massive parallelization (>10 workers).
 
 ---
+<details>
+<summary><b>📈 Star History</b></summary>
 
-## 🚀 Testing & Contribution
-
-We utilize **London School TDD** with behavioral verification. 
-
-```bash
-# Run unit boundaries
-npm run test:unit
+<div align="center">
+  <a href="https://star-history.com/#sir-ad/nexus-prime&Timeline">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=sir-ad/nexus-prime&type=Timeline&theme=dark" />
+      <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=sir-ad/nexus-prime&type=Timeline" />
+      <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=sir-ad/nexus-prime&type=Timeline" />
+    </picture>
+  </a>
+</div>
 
-# Test Swarm Byzantine Consensus simulation
-npm run test:consensus
+</details>
 
-# Start the interactive UI testbed
-npm run test:ux
-```
+<br>
 
-**License:** MIT  
-**Maintainers:** The Nexus Prime Protocol Consortium
+<div align="center">
+  <strong>License:</strong> MIT <br>
+  <strong>Maintainers:</strong> The Nexus Prime Protocol Consortium
+</div>

package/dist/agents/adapters/mcp.d.ts

@@ -9,6 +9,7 @@ export declare class MCPAdapter implements Adapter {
     private nexusRef?;
     private telemetry;
     private sessionDNA;
+    private box;
     constructor();
     setNexusRef(nexus: NexusPrime): void;
     private setupToolHandlers;

package/dist/agents/adapters/mcp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/agents/adapters/mcp.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAgK5C,qBAAa,UAAW,YAAW,OAAO;IACtC,IAAI,SAAS;IACb,IAAI,EAAG,KAAK,CAAU;IACtB,SAAS,UAAS;IAClB,MAAM,EAAE,MAAM,EAAE,CAAM;IAEtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,CAAa;IAC9B,OAAO,CAAC,SAAS,CAA0B;IAC3C,OAAO,CAAC,UAAU,CAAoB;;IAWtC,WAAW,CAAC,KAAK,EAAE,UAAU;IAI7B,OAAO,CAAC,iBAAiB;YAoUX,cAAc;IA6wB5B,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE;IAItC,OAAO,CAAC,IAAI;IAmBN,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAOxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB3B,IAAI,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IACnD,OAAO,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI;CAC1C"}
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/agents/adapters/mcp.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAsK5C,qBAAa,UAAW,YAAW,OAAO;IACtC,IAAI,SAAS;IACb,IAAI,EAAG,KAAK,CAAU;IACtB,SAAS,UAAS;IAClB,MAAM,EAAE,MAAM,EAAE,CAAM;IAEtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,CAAa;IAC9B,OAAO,CAAC,SAAS,CAA4C;IAC7D,OAAO,CAAC,UAAU,CAAoB;IAEtC,OAAO,CAAC,GAAG;;IAkBX,WAAW,CAAC,KAAK,EAAE,UAAU;IAI7B,OAAO,CAAC,iBAAiB;YAgWX,cAAc;IAo0B5B,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE;IAItC,OAAO,CAAC,IAAI;IAmBN,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAOxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB3B,IAAI,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IACnD,OAAO,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI;CAC1C"}