veryfront 0.0.4 → 0.0.6

package/dist/ai/dev.js

@@ -0,0 +1,839 @@
+// src/ai/dev/testing/agent-tester.ts
+async function testAgent(agent, testCases) {
+  const suite = {
+    name: agent.id,
+    results: [],
+    passed: true,
+    totalTime: 0
+  };
+  const suiteStartTime = Date.now();
+  for (const testCase of testCases) {
+    const result = await runTestCase(agent, testCase);
+    suite.results.push(result);
+    if (!result.passed) {
+      suite.passed = false;
+    }
+  }
+  suite.totalTime = Date.now() - suiteStartTime;
+  return suite;
+}
+async function runTestCase(agent, testCase) {
+  const startTime = Date.now();
+  try {
+    const timeout = testCase.timeout || 3e4;
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error("Test timeout")), timeout);
+    });
+    const responsePromise = agent.generate({
+      input: testCase.input
+    });
+    const response = await Promise.race([responsePromise, timeoutPromise]);
+    const executionTime = Date.now() - startTime;
+    const toolCalls = response.toolCalls.map((tc) => tc.name);
+    let passed = true;
+    let error;
+    if (testCase.expected) {
+      if (testCase.expected instanceof RegExp) {
+        passed = testCase.expected.test(response.text);
+        if (!passed) {
+          error = `Output "${response.text}" does not match pattern ${testCase.expected}`;
+        }
+      } else {
+        passed = response.text.includes(testCase.expected);
+        if (!passed) {
+          error = `Output does not contain expected text: "${testCase.expected}"`;
+        }
+      }
+    }
+    if (passed && testCase.expectToolCalls) {
+      const expectedTools = testCase.expectToolCalls;
+      const missingTools = expectedTools.filter((t) => !toolCalls.includes(t));
+      if (missingTools.length > 0) {
+        passed = false;
+        error = `Expected tool calls not found: ${missingTools.join(", ")}`;
+      }
+    }
+    if (passed && testCase.validate) {
+      try {
+        passed = await testCase.validate(response);
+        if (!passed) {
+          error = "Custom validation failed";
+        }
+      } catch (err) {
+        passed = false;
+        error = `Custom validation error: ${err instanceof Error ? err.message : String(err)}`;
+      }
+    }
+    return {
+      name: testCase.name,
+      passed,
+      response,
+      error,
+      executionTime,
+      toolCalls
+    };
+  } catch (err) {
+    return {
+      name: testCase.name,
+      passed: false,
+      error: err instanceof Error ? err.message : String(err),
+      executionTime: Date.now() - startTime,
+      toolCalls: []
+    };
+  }
+}
+function printTestResults(suite) {
+  console.log(`
+=== Test Suite: ${suite.name} ===
+`);
+  const passed = suite.results.filter((r) => r.passed).length;
+  const total = suite.results.length;
+  suite.results.forEach((result, index) => {
+    const icon = result.passed ? "\u2705" : "\u274C";
+    console.log(`${icon} ${index + 1}. ${result.name}`);
+    if (!result.passed && result.error) {
+      console.log(`   Error: ${result.error}`);
+    }
+    if (result.toolCalls.length > 0) {
+      console.log(`   Tools used: ${result.toolCalls.join(", ")}`);
+    }
+    console.log(`   Time: ${result.executionTime}ms
+`);
+  });
+  console.log(`Results: ${passed}/${total} passed`);
+  console.log(`Total time: ${suite.totalTime}ms`);
+  console.log(`Status: ${suite.passed ? "\u2705 PASSED" : "\u274C FAILED"}
+`);
+}
+function assertContains(response, text) {
+  return response.text.toLowerCase().includes(text.toLowerCase());
+}
+function assertToolCalled(response, toolName) {
+  return response.toolCalls.some((tc) => tc.name === toolName);
+}
+function assertCompleted(response) {
+  return response.status === "completed";
+}
+
+// src/ai/dev/testing/tool-tester.ts
+async function testTool(tool, testCases) {
+  const results = [];
+  for (const testCase of testCases) {
+    const result = await runToolTest(tool, testCase);
+    results.push(result);
+  }
+  return results;
+}
+async function runToolTest(tool, testCase) {
+  const startTime = Date.now();
+  try {
+    const result = await tool.execute(testCase.input);
+    const executionTime = Date.now() - startTime;
+    if (testCase.shouldThrow) {
+      return {
+        name: testCase.name,
+        passed: false,
+        error: "Expected tool to throw error but it succeeded",
+        executionTime
+      };
+    }
+    let passed = true;
+    let error;
+    if (testCase.expectedOutput !== void 0) {
+      passed = deepMatch(result, testCase.expectedOutput);
+      if (!passed) {
+        error = `Output mismatch. Expected: ${JSON.stringify(testCase.expectedOutput)}, Got: ${JSON.stringify(result)}`;
+      }
+    }
+    if (passed && testCase.validate) {
+      try {
+        passed = await testCase.validate(result);
+        if (!passed) {
+          error = "Custom validation failed";
+        }
+      } catch (err) {
+        passed = false;
+        error = `Validation error: ${err instanceof Error ? err.message : String(err)}`;
+      }
+    }
+    return {
+      name: testCase.name,
+      passed,
+      result,
+      error,
+      executionTime
+    };
+  } catch (err) {
+    const executionTime = Date.now() - startTime;
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    if (testCase.shouldThrow) {
+      let passed = true;
+      let error;
+      if (testCase.expectedError) {
+        if (testCase.expectedError instanceof RegExp) {
+          passed = testCase.expectedError.test(errorMessage);
+        } else {
+          passed = errorMessage.includes(testCase.expectedError);
+        }
+        if (!passed) {
+          error = `Error message mismatch. Expected pattern: ${testCase.expectedError}, Got: ${errorMessage}`;
+        }
+      }
+      return {
+        name: testCase.name,
+        passed,
+        error,
+        executionTime
+      };
+    }
+    return {
+      name: testCase.name,
+      passed: false,
+      error: `Unexpected error: ${errorMessage}`,
+      executionTime
+    };
+  }
+}
+function deepMatch(actual, expected) {
+  if (expected === actual)
+    return true;
+  if (typeof expected !== "object" || expected === null)
+    return false;
+  if (typeof actual !== "object" || actual === null)
+    return false;
+  for (const key in expected) {
+    if (!(key in actual))
+      return false;
+    const expectedValue = expected[key];
+    const actualValue = actual[key];
+    if (typeof expectedValue === "object" && expectedValue !== null) {
+      if (!deepMatch(actualValue, expectedValue))
+        return false;
+    } else {
+      if (actualValue !== expectedValue)
+        return false;
+    }
+  }
+  return true;
+}
+function printToolTestResults(toolId, results) {
+  console.log(`
+=== Tool Tests: ${toolId} ===
+`);
+  const passed = results.filter((r) => r.passed).length;
+  const total = results.length;
+  results.forEach((result, index) => {
+    const icon = result.passed ? "\u2705" : "\u274C";
+    console.log(`${icon} ${index + 1}. ${result.name}`);
+    if (!result.passed && result.error) {
+      console.log(`   Error: ${result.error}`);
+    }
+    if (result.result !== void 0) {
+      console.log(`   Result: ${JSON.stringify(result.result)}`);
+    }
+    console.log(`   Time: ${result.executionTime}ms
+`);
+  });
+  console.log(`Results: ${passed}/${total} passed`);
+  console.log(`Status: ${passed === total ? "\u2705 ALL PASSED" : "\u274C SOME FAILED"}
+`);
+}
+
+// src/ai/utils/zod-json-schema.ts
+import { ZodFirstPartyTypeKind } from "zod";
+function zodToJsonSchema(schema) {
+  if (!schema || typeof schema !== "object" || !("_def" in schema)) {
+    throw new Error("Invalid Zod schema: missing _def property");
+  }
+  const details = unwrapSchema(schema);
+  const json = convert(details.schema);
+  if (details.nullable) {
+    return { anyOf: [json, { type: "null" }] };
+  }
+  return json;
+}
+function isOptionalSchema(schema) {
+  const { optional } = unwrapSchema(schema);
+  return optional;
+}
+function convert(schema) {
+  switch (schema._def.typeName) {
+    case ZodFirstPartyTypeKind.ZodString:
+      return { type: "string" };
+    case ZodFirstPartyTypeKind.ZodNumber:
+      return { type: "number" };
+    case ZodFirstPartyTypeKind.ZodBoolean:
+      return { type: "boolean" };
+    case ZodFirstPartyTypeKind.ZodBigInt:
+      return { type: "integer" };
+    case ZodFirstPartyTypeKind.ZodLiteral: {
+      const literal = schema._def.value;
+      return {
+        const: literal,
+        type: typeof literal === "string" ? "string" : typeof literal === "number" ? "number" : typeof literal === "boolean" ? "boolean" : void 0
+      };
+    }
+    case ZodFirstPartyTypeKind.ZodEnum:
+      return {
+        type: "string",
+        enum: schema._def.values
+      };
+    case ZodFirstPartyTypeKind.ZodNativeEnum:
+      return {
+        enum: Object.values(schema._def.values).filter(
+          (value) => typeof value !== "number"
+        )
+      };
+    case ZodFirstPartyTypeKind.ZodObject: {
+      const obj = schema;
+      const properties = {};
+      const required = [];
+      const shape = typeof obj._def.shape === "function" ? obj._def.shape() : obj._def.shape;
+      for (const [key, value] of Object.entries(shape || {})) {
+        const zodSchema = value;
+        properties[key] = zodToJsonSchema(zodSchema);
+        if (!isOptionalSchema(zodSchema)) {
+          required.push(key);
+        }
+      }
+      const json = { type: "object", properties };
+      if (required.length > 0) {
+        json.required = required;
+      }
+      return json;
+    }
+    case ZodFirstPartyTypeKind.ZodArray: {
+      const array = schema;
+      return {
+        type: "array",
+        items: zodToJsonSchema(array._def.type)
+      };
+    }
+    case ZodFirstPartyTypeKind.ZodTuple: {
+      const tuple = schema;
+      return {
+        type: "array",
+        prefixItems: tuple._def.items.map((item) => zodToJsonSchema(item)),
+        minItems: tuple._def.items.length,
+        maxItems: tuple._def.items.length
+      };
+    }
+    case ZodFirstPartyTypeKind.ZodUnion: {
+      const union = schema;
+      return {
+        anyOf: union._def.options.map((option) => zodToJsonSchema(option))
+      };
+    }
+    case ZodFirstPartyTypeKind.ZodDiscriminatedUnion: {
+      const union = schema;
+      return {
+        anyOf: Array.from(union._def.options.values()).map((option) => zodToJsonSchema(option))
+      };
+    }
+    case ZodFirstPartyTypeKind.ZodRecord:
+      return {
+        type: "object",
+        additionalProperties: zodToJsonSchema(schema._def.valueType)
+      };
+    case ZodFirstPartyTypeKind.ZodDefault: {
+      const def = schema;
+      const inner = zodToJsonSchema(def._def.innerType);
+      const defaultValue = def._def.defaultValue();
+      if (typeof inner === "object" && !("anyOf" in inner)) {
+        inner.default = defaultValue;
+      }
+      return inner;
+    }
+    case ZodFirstPartyTypeKind.ZodLazy:
+      return convert(schema._def.getter());
+    case ZodFirstPartyTypeKind.ZodEffects:
+      return convert(schema._def.schema);
+    default:
+      return { type: "object" };
+  }
+}
+function unwrapSchema(schema) {
+  let current = schema;
+  let nullable = false;
+  let optional = false;
+  while (true) {
+    switch (current._def.typeName) {
+      case ZodFirstPartyTypeKind.ZodNullable:
+        nullable = true;
+        current = current._def.innerType;
+        continue;
+      case ZodFirstPartyTypeKind.ZodOptional:
+        optional = true;
+        current = current._def.innerType;
+        continue;
+      case ZodFirstPartyTypeKind.ZodEffects:
+        current = current._def.schema;
+        continue;
+      default:
+        return { schema: current, nullable, optional };
+    }
+  }
+}
+
+// src/core/utils/runtime-guards.ts
+function hasDenoRuntime(global) {
+  return typeof global === "object" && global !== null && "Deno" in global && typeof global.Deno?.env?.get === "function";
+}
+function hasNodeProcess(global) {
+  return typeof global === "object" && global !== null && "process" in global && typeof global.process?.env === "object";
+}
+
+// src/core/utils/logger/env.ts
+function getEnvironmentVariable(name) {
+  try {
+    if (typeof Deno !== "undefined" && hasDenoRuntime(globalThis)) {
+      const value = globalThis.Deno?.env.get(name);
+      return value === "" ? void 0 : value;
+    }
+    if (hasNodeProcess(globalThis)) {
+      const value = globalThis.process?.env[name];
+      return value === "" ? void 0 : value;
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+
+// src/core/utils/logger/logger.ts
+var cachedLogLevel;
+function resolveLogLevel(force = false) {
+  if (force || cachedLogLevel === void 0) {
+    cachedLogLevel = getDefaultLevel();
+  }
+  return cachedLogLevel;
+}
+var ConsoleLogger = class {
+  constructor(prefix, level = resolveLogLevel()) {
+    this.prefix = prefix;
+    this.level = level;
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  getLevel() {
+    return this.level;
+  }
+  debug(message, ...args) {
+    if (this.level <= 0 /* DEBUG */) {
+      console.debug(`[${this.prefix}] DEBUG: ${message}`, ...args);
+    }
+  }
+  info(message, ...args) {
+    if (this.level <= 1 /* INFO */) {
+      console.log(`[${this.prefix}] ${message}`, ...args);
+    }
+  }
+  warn(message, ...args) {
+    if (this.level <= 2 /* WARN */) {
+      console.warn(`[${this.prefix}] WARN: ${message}`, ...args);
+    }
+  }
+  error(message, ...args) {
+    if (this.level <= 3 /* ERROR */) {
+      console.error(`[${this.prefix}] ERROR: ${message}`, ...args);
+    }
+  }
+  async time(label, fn) {
+    const start = performance.now();
+    try {
+      const result = await fn();
+      const end = performance.now();
+      this.debug(`${label} completed in ${(end - start).toFixed(2)}ms`);
+      return result;
+    } catch (error) {
+      const end = performance.now();
+      this.error(`${label} failed after ${(end - start).toFixed(2)}ms`, error);
+      throw error;
+    }
+  }
+};
+function parseLogLevel(levelString) {
+  if (!levelString)
+    return void 0;
+  const upper = levelString.toUpperCase();
+  switch (upper) {
+    case "DEBUG":
+      return 0 /* DEBUG */;
+    case "WARN":
+      return 2 /* WARN */;
+    case "ERROR":
+      return 3 /* ERROR */;
+    case "INFO":
+      return 1 /* INFO */;
+    default:
+      return void 0;
+  }
+}
+var getDefaultLevel = () => {
+  const envLevel = getEnvironmentVariable("LOG_LEVEL");
+  const parsedLevel = parseLogLevel(envLevel);
+  if (parsedLevel !== void 0)
+    return parsedLevel;
+  const debugFlag = getEnvironmentVariable("VERYFRONT_DEBUG");
+  if (debugFlag === "1" || debugFlag === "true")
+    return 0 /* DEBUG */;
+  return 1 /* INFO */;
+};
+var trackedLoggers = /* @__PURE__ */ new Set();
+function createLogger(prefix) {
+  const logger2 = new ConsoleLogger(prefix);
+  trackedLoggers.add(logger2);
+  return logger2;
+}
+var cliLogger = createLogger("CLI");
+var serverLogger = createLogger("SERVER");
+var rendererLogger = createLogger("RENDERER");
+var bundlerLogger = createLogger("BUNDLER");
+var agentLogger = createLogger("AGENT");
+var logger = createLogger("VERYFRONT");
+
+// src/core/errors/veryfront-error.ts
+function createError(error) {
+  return error;
+}
+function toError(veryfrontError) {
+  const error = new Error(veryfrontError.message);
+  error.name = `VeryfrontError[${veryfrontError.type}]`;
+  Object.defineProperty(error, "context", {
+    value: veryfrontError,
+    enumerable: false,
+    configurable: true
+  });
+  return error;
+}
+
+// src/ai/utils/tool.ts
+var ToolRegistryClass = class {
+  constructor() {
+    this.tools = /* @__PURE__ */ new Map();
+  }
+  register(id, toolInstance) {
+    if (this.tools.has(id)) {
+      agentLogger.warn(`Tool "${id}" is already registered. Overwriting.`);
+    }
+    this.tools.set(id, toolInstance);
+  }
+  /**
+   * Get a tool by ID
+   */
+  get(id) {
+    return this.tools.get(id);
+  }
+  /**
+   * Check if a tool exists
+   */
+  has(id) {
+    return this.tools.has(id);
+  }
+  /**
+   * Get all tool IDs
+   */
+  getAllIds() {
+    return Array.from(this.tools.keys());
+  }
+  /**
+   * Get all tools
+   */
+  getAll() {
+    return new Map(this.tools);
+  }
+  /**
+   * Clear all tools (for testing)
+   */
+  clear() {
+    this.tools.clear();
+  }
+  getToolsForProvider() {
+    return Array.from(this.tools.values()).map(toolToProviderDefinition);
+  }
+};
+var toolRegistry = new ToolRegistryClass();
+function toolToProviderDefinition(tool) {
+  const jsonSchema = tool.inputSchemaJson || zodToJsonSchema(tool.inputSchema);
+  agentLogger.info(
+    `[TOOL] Using ${tool.inputSchemaJson ? "pre-converted" : "runtime-converted"} schema for "${tool.id}"`
+  );
+  return {
+    name: tool.id,
+    description: tool.description,
+    parameters: jsonSchema
+  };
+}
+
+// src/ai/mcp/resource.ts
+var ResourceRegistryClass = class {
+  constructor() {
+    this.resources = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a resource
+   */
+  register(id, resourceInstance) {
+    if (this.resources.has(id)) {
+      agentLogger.warn(`Resource "${id}" is already registered. Overwriting.`);
+    }
+    this.resources.set(id, resourceInstance);
+  }
+  /**
+   * Get a resource by ID
+   */
+  get(id) {
+    return this.resources.get(id);
+  }
+  /**
+   * Get resource by pattern matching
+   */
+  findByPattern(uri) {
+    for (const resource of this.resources.values()) {
+      if (this.matchesPattern(uri, resource.pattern)) {
+        return resource;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Check if URI matches pattern
+   * Uses regex-based pattern matching with named capture groups.
+   * Supports Express-style patterns like "/users/:userId/profile"
+   */
+  matchesPattern(uri, pattern) {
+    const patternRegex = new RegExp(
+      "^" + pattern.replace(/:(\w+)/g, "(?<$1>[^/]+)") + "$"
+    );
+    return patternRegex.test(uri);
+  }
+  /**
+   * Extract params from URI using pattern
+   */
+  extractParams(uri, pattern) {
+    const patternRegex = new RegExp(
+      "^" + pattern.replace(/:(\w+)/g, "(?<$1>[^/]+)") + "$"
+    );
+    const match = uri.match(patternRegex);
+    return match?.groups || {};
+  }
+  /**
+   * Get all resources
+   */
+  getAll() {
+    return new Map(this.resources);
+  }
+  /**
+   * Clear all resources
+   */
+  clear() {
+    this.resources.clear();
+  }
+};
+var resourceRegistry = new ResourceRegistryClass();
+
+// src/ai/mcp/prompt.ts
+var PromptRegistryClass = class {
+  constructor() {
+    this.prompts = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a prompt
+   */
+  register(id, promptInstance) {
+    if (this.prompts.has(id)) {
+      agentLogger.warn(`Prompt "${id}" is already registered. Overwriting.`);
+    }
+    this.prompts.set(id, promptInstance);
+  }
+  /**
+   * Get a prompt by ID
+   */
+  get(id) {
+    return this.prompts.get(id);
+  }
+  /**
+   * Get prompt content by ID
+   */
+  async getContent(id, variables) {
+    const promptInstance = this.get(id);
+    if (!promptInstance) {
+      throw toError(createError({
+        type: "agent",
+        message: `Prompt "${id}" not found`
+      }));
+    }
+    return await promptInstance.getContent(variables);
+  }
+  /**
+   * Get all prompts
+   */
+  getAll() {
+    return new Map(this.prompts);
+  }
+  /**
+   * Clear all prompts
+   */
+  clear() {
+    this.prompts.clear();
+  }
+};
+var promptRegistry = new PromptRegistryClass();
+
+// src/ai/mcp/registry.ts
+function getMCPRegistry() {
+  return {
+    tools: toolRegistry.getAll(),
+    resources: resourceRegistry.getAll(),
+    prompts: promptRegistry.getAll()
+  };
+}
+function getMCPStats() {
+  const registry = getMCPRegistry();
+  return {
+    tools: registry.tools.size,
+    resources: registry.resources.size,
+    prompts: registry.prompts.size,
+    total: registry.tools.size + registry.resources.size + registry.prompts.size
+  };
+}
+
+// src/ai/dev/debug/inspector.ts
+async function inspectAgent(agent, input) {
+  const startTime = Date.now();
+  const _memoryStatsBefore = await agent.getMemoryStats();
+  const response = await agent.generate({ input });
+  const executionTime = Date.now() - startTime;
+  const memoryStatsAfter = await agent.getMemoryStats();
+  const availableTools = agent.config.tools ? Object.keys(agent.config.tools) : [];
+  return {
+    agent: {
+      id: agent.id,
+      model: agent.config.model,
+      maxSteps: agent.config.maxSteps || 20,
+      memoryType: agent.config.memory?.type || "conversation"
+    },
+    execution: {
+      input,
+      output: response.text,
+      status: response.status,
+      steps: response.toolCalls.length + 1,
+      // Tool calls + final response
+      executionTime
+    },
+    tools: {
+      called: response.toolCalls.map((tc) => ({
+        name: tc.name,
+        args: tc.args,
+        result: tc.result,
+        executionTime: tc.executionTime,
+        status: tc.status
+      })),
+      available: availableTools
+    },
+    memory: {
+      messagesCount: memoryStatsAfter.totalMessages,
+      estimatedTokens: memoryStatsAfter.estimatedTokens
+    },
+    usage: response.usage
+  };
+}
+function printInspectionReport(report) {
+  agentLogger.info("\n=== Agent Inspection Report ===\n");
+  agentLogger.info("Agent:");
+  agentLogger.info(`  ID: ${report.agent.id}`);
+  agentLogger.info(`  Model: ${report.agent.model}`);
+  agentLogger.info(`  Max Steps: ${report.agent.maxSteps}`);
+  agentLogger.info(`  Memory: ${report.agent.memoryType}
+`);
+  agentLogger.info("Execution:");
+  agentLogger.info(
+    `  Input: ${typeof report.execution.input === "string" ? report.execution.input : `${report.execution.input.length} messages`}`
+  );
+  agentLogger.info(`  Output: ${report.execution.output.substring(0, 100)}...`);
+  agentLogger.info(`  Status: ${report.execution.status}`);
+  agentLogger.info(`  Steps: ${report.execution.steps}`);
+  agentLogger.info(`  Time: ${report.execution.executionTime}ms
+`);
+  agentLogger.info("Tools:");
+  agentLogger.info(
+    `  Available: ${report.tools.available.length} (${report.tools.available.join(", ")})`
+  );
+  agentLogger.info(`  Called: ${report.tools.called.length}`);
+  if (report.tools.called.length > 0) {
+    report.tools.called.forEach((tool, i) => {
+      agentLogger.info(`    ${i + 1}. ${tool.name}(${JSON.stringify(tool.args)})`);
+      agentLogger.info(`       Status: ${tool.status}`);
+      agentLogger.info(`       Time: ${tool.executionTime}ms`);
+      agentLogger.info(`       Result: ${JSON.stringify(tool.result).substring(0, 100)}...`);
+    });
+  }
+  agentLogger.info("");
+  agentLogger.info("Memory:");
+  agentLogger.info(`  Messages: ${report.memory.messagesCount}`);
+  agentLogger.info(`  Estimated Tokens: ${report.memory.estimatedTokens}
+`);
+  if (report.usage) {
+    agentLogger.info("Token Usage:");
+    agentLogger.info(`  Prompt: ${report.usage.promptTokens}`);
+    agentLogger.info(`  Completion: ${report.usage.completionTokens}`);
+    agentLogger.info(`  Total: ${report.usage.totalTokens}
+`);
+  }
+}
+function getRegistryOverview() {
+  const registry = getMCPRegistry();
+  const stats = getMCPStats();
+  return {
+    tools: Array.from(registry.tools.values()).map((t) => ({
+      id: t.id,
+      description: t.description
+    })),
+    resources: Array.from(registry.resources.values()).map((r) => ({
+      id: r.id,
+      pattern: r.pattern,
+      description: r.description
+    })),
+    prompts: Array.from(registry.prompts.values()).map((p) => ({
+      id: p.id,
+      description: p.description
+    })),
+    stats
+  };
+}
+function printRegistryOverview() {
+  const overview = getRegistryOverview();
+  agentLogger.info("\n=== MCP Registry Overview ===\n");
+  agentLogger.info(`Total: ${overview.stats.total} items
+`);
+  agentLogger.info(`Tools (${overview.stats.tools}):`);
+  overview.tools.forEach((t) => {
+    agentLogger.info(`  \u2022 ${t.id}: ${t.description}`);
+  });
+  agentLogger.info("");
+  agentLogger.info(`Resources (${overview.stats.resources}):`);
+  overview.resources.forEach((r) => {
+    agentLogger.info(`  \u2022 ${r.id} (${r.pattern}): ${r.description}`);
+  });
+  agentLogger.info("");
+  agentLogger.info(`Prompts (${overview.stats.prompts}):`);
+  overview.prompts.forEach((p) => {
+    agentLogger.info(`  \u2022 ${p.id}: ${p.description}`);
+  });
+  agentLogger.info("");
+}
+export {
+  assertCompleted,
+  assertContains,
+  assertToolCalled,
+  getRegistryOverview,
+  inspectAgent,
+  printInspectionReport,
+  printRegistryOverview,
+  printTestResults,
+  printToolTestResults,
+  testAgent,
+  testTool
+};
+//# sourceMappingURL=dev.js.map