@bolloon/bolloon-agent 0.1.0

package/src/cli/interface.ts

@@ -0,0 +1,211 @@
+import * as readline from 'readline';
+import { documentReader } from '../documents/reader.js';
+import { getMinimax } from '../constraints/index.js';
+import { AgentProtocol } from '../agents/protocol.js';
+import { p2pNetwork, P2PNode } from '../network/p2p.js';
+
+export class CLIInterface {
+  private agent: AgentProtocol | null = null;
+  private localNode: P2PNode | null = null;
+  private rl: readline.Interface;
+
+  constructor() {
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+  }
+
+  async start(): Promise<void> {
+    console.log('\n🤖 AI文档智能体 P2P 网络');
+    console.log('========================\n');
+
+    await this.initP2PNode();
+    await this.initLLM();
+    this.initAgent();
+
+    this.showHelp();
+    await this.runLoop();
+  }
+
+  private async initP2PNode(): Promise<void> {
+    console.log('初始化P2P节点...');
+
+    const bootstrapPeers = process.env.BOOTSTRAP_PEERS?.split(',');
+
+    this.localNode = await p2pNetwork.createNode({ bootstrapPeers });
+
+    console.log(`节点已启动!`);
+    console.log(`Peer ID: ${this.localNode.peerId}`);
+    console.log(`地址: ${this.localNode.multiaddrs.join(', ')}\n`);
+
+    this.syncOfflineMessages();
+  }
+
+  private async initLLM(): Promise<void> {
+    const apiKey = process.env.MINIMAX_API_KEY;
+
+    if (!apiKey) {
+      console.warn('⚠️  MINIMAX_API_KEY 未设置，摘要功能将使用模拟模式');
+      return;
+    }
+
+    getMinimax();
+    console.log('LLM已初始化\n');
+  }
+
+  private initAgent(): void {
+    if (!this.localNode) throw new Error('P2P node not initialized');
+    this.agent = new AgentProtocol(this.localNode.peerId);
+    console.log('Agent协议已初始化\n');
+  }
+
+  private async syncOfflineMessages(): Promise<void> {
+    if (!this.localNode) return;
+
+    const messages = p2pNetwork.getOfflineMessages(this.localNode.peerId);
+    for (const msg of messages) {
+      const messageStr = new TextDecoder().decode(msg);
+      const [type, ...payloadParts] = messageStr.split(':');
+      console.log(`📬 收到离线消息 [${type}]: ${payloadParts.join(':')}`);
+    }
+  }
+
+  private showHelp(): void {
+    console.log('\n可用命令:');
+    console.log('  read <file>     - 读取并处理文档');
+    console.log('  peers           - 显示已连接的对等节点');
+    console.log('  send <peer>     - 向指定节点发送消息');
+    console.log('  broadcast       - 广播任务到所有节点');
+    console.log('  summary <text>  - 总结文本');
+    console.log('  help            - 显示帮助');
+    console.log('  exit            - 退出\n');
+  }
+
+  private async runLoop(): Promise<void> {
+    while (true) {
+      const input = await this.prompt('> ');
+
+      if (!input) continue;
+
+      const [cmd, ...args] = input.trim().split(/\s+/);
+
+      try {
+        switch (cmd.toLowerCase()) {
+          case 'read':
+            await this.handleRead(args[0]);
+            break;
+          case 'peers':
+            this.handlePeers();
+            break;
+          case 'send':
+            await this.handleSend(args[0]);
+            break;
+          case 'broadcast':
+            await this.handleBroadcast();
+            break;
+          case 'summary':
+            await this.handleSummary(args.join(' '));
+            break;
+          case 'help':
+            this.showHelp();
+            break;
+          case 'exit':
+            await this.shutdown();
+            return;
+          default:
+            console.log('未知命令，输入 help 查看可用命令');
+        }
+      } catch (e) {
+        console.error('错误:', e);
+      }
+    }
+  }
+
+  private prompt(question: string): Promise<string> {
+    return new Promise(resolve => {
+      this.rl.question(question, resolve);
+    });
+  }
+
+  private async handleRead(filePath?: string): Promise<void> {
+    if (!filePath) {
+      console.log('请提供文件路径: read <file>');
+      return;
+    }
+
+    console.log(`📄 读取文档: ${filePath}`);
+    const content = await documentReader.read(filePath);
+    console.log(`文档大小: ${content.metadata.size} 字节`);
+    console.log(`内容预览: ${content.text.substring(0, 200)}...\n`);
+
+    const llm = getMinimax();
+    const chunks = documentReader.chunk(content.text);
+    const summaries: string[] = [];
+
+    for (let i = 0; i < chunks.length; i++) {
+      console.log(`处理块 ${i + 1}/${chunks.length}...`);
+      const result = await llm.summarize(chunks[i]);
+      summaries.push(result.summary);
+
+      if (result.qualityScore >= 0.7) {
+        console.log(`  ✅ 质量评分: ${(result.qualityScore * 10).toFixed(1)}/10`);
+      } else {
+        console.log(`  ⚠️ 质量评分: ${(result.qualityScore * 10).toFixed(1)}/10, 需要审核`);
+      }
+    }
+
+    console.log('\n📝 生成的摘要:');
+    console.log(summaries.join('\n\n'));
+  }
+
+  private handlePeers(): void {
+    const peers = p2pNetwork.getPeers();
+    if (peers.length === 0) {
+      console.log('当前无连接的对等节点');
+    } else {
+      console.log('已连接节点:');
+      for (const peer of peers) {
+        console.log(`  - ${peer}`);
+      }
+    }
+  }
+
+  private async handleSend(peerId?: string): Promise<void> {
+    if (!peerId) {
+      console.log('请提供目标节点ID: send <peer-id>');
+      return;
+    }
+
+    const message = await this.prompt('输入消息: ');
+    await p2pNetwork.sendMessage(peerId, 'message', message);
+    console.log('消息已发送');
+  }
+
+  private async handleBroadcast(): Promise<void> {
+    const message = await this.prompt('输入广播消息: ');
+    await p2pNetwork.broadcast('message', message);
+    console.log('广播已发送');
+  }
+
+  private async handleSummary(text: string): Promise<void> {
+    if (!text) {
+      console.log('请提供要总结的文本: summary <text>');
+      return;
+    }
+
+    const llm = getMinimax();
+    const result = await llm.summarize(text);
+
+    console.log('\n📝 摘要结果:');
+    console.log(result.summary);
+    console.log(`\n质量评分: ${(result.qualityScore * 10).toFixed(1)}/10`);
+  }
+
+  private async shutdown(): Promise<void> {
+    console.log('\n正在关闭...');
+    await p2pNetwork.shutdown();
+    this.rl.close();
+    console.log('已退出');
+  }
+}

package/src/constraint-runtime/package-lock.json

@@ -0,0 +1,48 @@
+{
+  "name": "@bolloon/constraint-runtime",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@bolloon/constraint-runtime",
+      "version": "0.1.0",
+      "devDependencies": {
+        "@types/node": "^25.8.0",
+        "@types/platform": "^1.3.6",
+        "platform": "^1.3.6"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "25.8.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-25.8.0.tgz",
+      "integrity": "sha512-TCFSk8IZh+iLX1xtksoBVtdmgL+1IX0fC9BeU4QqFSuNdN/K+HUlhqOzEmSYYpZUVsLYcPqc9KX+60iDuninSQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": ">=7.24.0 <7.24.7"
+      }
+    },
+    "node_modules/@types/platform": {
+      "version": "1.3.6",
+      "resolved": "https://registry.npmjs.org/@types/platform/-/platform-1.3.6.tgz",
+      "integrity": "sha512-ZmSaqHuvzv+jC232cFoz2QqPUkaj6EvMmCrWcx3WRr7xTPVFCMUOTcOq8m2d+Zw1iKRc1kDiaA+jtNrV0hkVew==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/platform": {
+      "version": "1.3.6",
+      "resolved": "https://registry.npmjs.org/platform/-/platform-1.3.6.tgz",
+      "integrity": "sha512-fnWVljUchTro6RiCFvCXBbNhJc2NijN7oIQxbwsyL0buWJPG85v81ehlHI9fXrJsMNgTofEoWIQeClKpgxFLrg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/undici-types": {
+      "version": "7.24.6",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.24.6.tgz",
+      "integrity": "sha512-WRNW+sJgj5OBN4/0JpHFqtqzhpbnV0GuB+OozA9gCL7a993SmU+1JBZCzLNxYsbMfIeDL+lTsphD5jN5N+n0zg==",
+      "dev": true,
+      "license": "MIT"
+    }
+  }
+}

package/src/constraint-runtime/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@bolloon/constraint-runtime",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Constraint-based AI agent runtime with workflow orchestration",
+  "author": "Bolloon Team",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": ["dist/**/*"],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "@types/node": "^25.8.0",
+    "@types/platform": "^1.3.6",
+    "platform": "^1.3.6"
+  },
+  "dependencies": {
+    "@jackwener/opencli": "^1.7.22",
+    "@safe-global/api-kit": "^4.1.0",
+    "@safe-global/protocol-kit": "^7.1.0",
+    "@safe-global/relay-kit": "^5.0.0",
+    "ethers": "^6.13.4",
+    "polymarket-sdk": "^1.0.2"
+  }
+}

package/src/constraint-runtime/src/_archive_helper.ts

@@ -0,0 +1,16 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export function loadArchiveMetadata(packageName: string): Record<string, unknown> {
+  const snapshotPath = path.join(
+    __dirname,
+    'reference_data',
+    'subsystems',
+    `${packageName}.json`
+  );
+  return JSON.parse(fs.readFileSync(snapshotPath, 'utf-8'));
+}

package/src/constraint-runtime/src/agent/coordinator.ts

@@ -0,0 +1,71 @@
+import { DeepThinkingEngine } from '../thinking/engine.js';
+
+export interface SubTask {
+  id: string;
+  description: string;
+  priority: number;
+}
+
+export interface AgentResult {
+  taskId: string;
+  output: string;
+  success: boolean;
+  metadata?: Record<string, unknown>;
+}
+
+export class AgentCoordinator {
+  private engine: DeepThinkingEngine;
+
+  constructor(maxDepth: number = 3) {
+    this.engine = new DeepThinkingEngine(maxDepth);
+  }
+
+  async dispatch(prompt: string, parallelCount: number = 3): Promise<AgentResult[]> {
+    const tasks = this.splitTask(prompt, parallelCount);
+
+    const results = await Promise.all(
+      tasks.map(task => this.executeTask(task))
+    );
+
+    return this.aggregate(results);
+  }
+
+  private splitTask(prompt: string, count: number): SubTask[] {
+    const words = prompt.split(/\s+/);
+    const chunkSize = Math.ceil(words.length / count);
+    const chunks: SubTask[] = [];
+
+    for (let i = 0; i < count; i++) {
+      const chunk = words.slice(i * chunkSize, (i + 1) * chunkSize).join(' ');
+      if (chunk) {
+        chunks.push({
+          id: `task-${i}`,
+          description: chunk,
+          priority: i
+        });
+      }
+    }
+    return chunks;
+  }
+
+  private async executeTask(task: SubTask): Promise<AgentResult> {
+    try {
+      const thinkResult = await this.engine.think(task.description);
+      return {
+        taskId: task.id,
+        output: thinkResult.finalOutput,
+        success: true
+      };
+    } catch (error) {
+      return {
+        taskId: task.id,
+        output: String(error),
+        success: false
+      };
+    }
+  }
+
+  private aggregate(results: AgentResult[]): AgentResult[] {
+    return results.sort((a, b) => a.taskId.localeCompare(b.taskId));
+  }
+}

package/src/constraint-runtime/src/agent/index.ts

@@ -0,0 +1 @@
+export { AgentCoordinator, type SubTask, type AgentResult } from './coordinator.js';

package/src/constraint-runtime/src/assistant/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('assistant');
+
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'] as string;
+export const MODULE_COUNT = SNAPSHOT['module_count'] as number;
+export const SAMPLE_FILES = SNAPSHOT['sample_files'] as string[];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+
+export default {
+  ARCHIVE_NAME,
+  MODULE_COUNT,
+  PORTING_NOTE,
+  SAMPLE_FILES,
+};

package/src/constraint-runtime/src/bootstrap/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('bootstrap');
+
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'] as string;
+export const MODULE_COUNT = SNAPSHOT['module_count'] as number;
+export const SAMPLE_FILES = SNAPSHOT['sample_files'] as string[];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+
+export default {
+  ARCHIVE_NAME,
+  MODULE_COUNT,
+  PORTING_NOTE,
+  SAMPLE_FILES,
+};

package/src/constraint-runtime/src/bootstrap_graph.ts

@@ -0,0 +1,17 @@
+export interface BootstrapGraph {
+  stages: string[];
+}
+
+export function buildBootstrapGraph(): BootstrapGraph {
+  return {
+    stages: [
+      'top-level prefetch side effects',
+      'warning handler and environment guards',
+      'CLI parser and pre-action trust gate',
+      'setup() + commands/agents parallel load',
+      'deferred init after trust',
+      'mode routing: local / remote / ssh / teleport / direct-connect / deep-link',
+      'query engine submit loop',
+    ],
+  };
+}

package/src/constraint-runtime/src/bridge/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('bridge');
+
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'] as string;
+export const MODULE_COUNT = SNAPSHOT['module_count'] as number;
+export const SAMPLE_FILES = SNAPSHOT['sample_files'] as string[];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+
+export default {
+  ARCHIVE_NAME,
+  MODULE_COUNT,
+  PORTING_NOTE,
+  SAMPLE_FILES,
+};

package/src/constraint-runtime/src/buddy/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('buddy');
+
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'] as string;
+export const MODULE_COUNT = SNAPSHOT['module_count'] as number;
+export const SAMPLE_FILES = SNAPSHOT['sample_files'] as string[];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+
+export default {
+  ARCHIVE_NAME,
+  MODULE_COUNT,
+  PORTING_NOTE,
+  SAMPLE_FILES,
+};

package/src/constraint-runtime/src/cli/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('cli');
+
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'] as string;
+export const MODULE_COUNT = SNAPSHOT['module_count'] as number;
+export const SAMPLE_FILES = SNAPSHOT['sample_files'] as string[];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+
+export default {
+  ARCHIVE_NAME,
+  MODULE_COUNT,
+  PORTING_NOTE,
+  SAMPLE_FILES,
+};

package/src/constraint-runtime/src/command_graph.ts

@@ -0,0 +1,20 @@
+import { PortingModule } from './models.js';
+import { getCommands } from './commands.js';
+
+export interface CommandGraph {
+  builtins: PortingModule[];
+  pluginLike: PortingModule[];
+  skillLike: PortingModule[];
+}
+
+export function buildCommandGraph(): CommandGraph {
+  const commands = getCommands();
+  return {
+    builtins: commands.filter(m => 
+      !m.sourceHint.toLowerCase().includes('plugin') && 
+      !m.sourceHint.toLowerCase().includes('skills')
+    ),
+    pluginLike: commands.filter(m => m.sourceHint.toLowerCase().includes('plugin')),
+    skillLike: commands.filter(m => m.sourceHint.toLowerCase().includes('skills')),
+  };
+}

package/src/constraint-runtime/src/commands.ts

@@ -0,0 +1,83 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { PortingModule } from './models.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const SNAPSHOT_PATH = path.join(__dirname, 'reference_data', 'commands_snapshot.json');
+
+export interface CommandExecution {
+  name: string;
+  sourceHint: string;
+  prompt: string;
+  handled: boolean;
+  message: string;
+}
+
+function loadCommandSnapshot(): PortingModule[] {
+  try {
+    if (!fs.existsSync(SNAPSHOT_PATH)) {
+      console.warn(`[commands] Snapshot not found: ${SNAPSHOT_PATH}, using empty list`);
+      return [];
+    }
+    const raw = JSON.parse(fs.readFileSync(SNAPSHOT_PATH, 'utf-8'));
+    return raw.map((e: any) => ({
+      name: e.name,
+      responsibility: e.responsibility,
+      sourceHint: e.source_hint,
+      status: 'mirrored' as const,
+    }));
+  } catch (error) {
+    console.warn(`[commands] Failed to load snapshot: ${error}, using empty list`);
+    return [];
+  }
+}
+
+export const PORTED_COMMANDS = loadCommandSnapshot();
+
+export { PortingModule };
+
+export function builtInCommandNames(): Set<string> {
+  return new Set(PORTED_COMMANDS.map(m => m.name));
+}
+
+export function getCommand(name: string): PortingModule | undefined {
+  const needle = name.toLowerCase();
+  return PORTED_COMMANDS.find(m => m.name.toLowerCase() === needle);
+}
+
+export function getCommands(
+  includePluginCommands: boolean = true,
+  includeSkillCommands: boolean = true
+): PortingModule[] {
+  let commands = [...PORTED_COMMANDS];
+  if (!includePluginCommands) {
+    commands = commands.filter(m => !m.sourceHint.toLowerCase().includes('plugin'));
+  }
+  if (!includeSkillCommands) {
+    commands = commands.filter(m => !m.sourceHint.toLowerCase().includes('skills'));
+  }
+  return commands;
+}
+
+export function findCommands(query: string, limit: number = 20): PortingModule[] {
+  const needle = query.toLowerCase();
+  return PORTED_COMMANDS.filter(
+    m => m.name.toLowerCase().includes(needle) || m.sourceHint.toLowerCase().includes(needle)
+  ).slice(0, limit);
+}
+
+export function executeCommand(name: string, prompt: string = ''): CommandExecution {
+  const module = getCommand(name);
+  if (!module) {
+    return { name, sourceHint: '', prompt, handled: false, message: `Unknown mirrored command: ${name}` };
+  }
+  return {
+    name: module.name,
+    sourceHint: module.sourceHint,
+    prompt,
+    handled: true,
+    message: `Mirrored command '${module.name}' from ${module.sourceHint} would handle prompt.`,
+  };
+}

package/src/constraint-runtime/src/components/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('components');
+
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'] as string;
+export const MODULE_COUNT = SNAPSHOT['module_count'] as number;
+export const SAMPLE_FILES = SNAPSHOT['sample_files'] as string[];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+
+export default {
+  ARCHIVE_NAME,
+  MODULE_COUNT,
+  PORTING_NOTE,
+  SAMPLE_FILES,
+};

package/src/constraint-runtime/src/constants/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('constants');
+
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'] as string;
+export const MODULE_COUNT = SNAPSHOT['module_count'] as number;
+export const SAMPLE_FILES = SNAPSHOT['sample_files'] as string[];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+
+export default {
+  ARCHIVE_NAME,
+  MODULE_COUNT,
+  PORTING_NOTE,
+  SAMPLE_FILES,
+};

package/src/constraint-runtime/src/constraint/budget.ts

@@ -0,0 +1,25 @@
+import { UsageSummary } from '../models.js';
+
+export class BudgetTracker {
+  constructor(
+    public maxBudgetTokens: number = 2000,
+    public maxTurns: number = 8,
+    public compactAfterTurns: number = 12
+  ) {}
+
+  addTurn(inputTokens: number, outputTokens: number): UsageSummary {
+    return { inputTokens, outputTokens };
+  }
+
+  isBudgetExceeded(usage: UsageSummary): boolean {
+    return usage.inputTokens + usage.outputTokens > this.maxBudgetTokens;
+  }
+
+  isTurnLimitExceeded(currentTurns: number): boolean {
+    return currentTurns >= this.maxTurns;
+  }
+
+  shouldCompact(turnCount: number): boolean {
+    return turnCount > this.compactAfterTurns;
+  }
+}

package/src/constraint-runtime/src/constraint/index.ts

@@ -0,0 +1,3 @@
+export { ToolPermissionContext } from './permission.js';
+export { BudgetTracker } from './budget.js';
+export type { UsageSummary } from '../models.js';

package/src/constraint-runtime/src/constraint/permission.ts

@@ -0,0 +1,28 @@
+import { PermissionDenial } from '../models.js';
+
+export class ToolPermissionContext {
+  private denyTools: Set<string>;
+  private denyPrefixes: string[];
+
+  private constructor(denyTools: Set<string>, denyPrefixes: string[]) {
+    this.denyTools = denyTools;
+    this.denyPrefixes = denyPrefixes;
+  }
+
+  static fromIterables(denyTools: string[] = [], denyPrefixes: string[] = []): ToolPermissionContext {
+    return new ToolPermissionContext(
+      new Set(denyTools.map(t => t.toLowerCase())),
+      denyPrefixes
+    );
+  }
+
+  blocks(name: string): boolean {
+    const lower = name.toLowerCase();
+    if (this.denyTools.has(lower)) return true;
+    return this.denyPrefixes.some(p => lower.startsWith(p.toLowerCase()));
+  }
+
+  createDenial(toolName: string, reason: string): PermissionDenial {
+    return { toolName, reason };
+  }
+}