import { MCPVerifier } from 'agentinit/verifier';
import { MCPServerType } from 'agentinit/types';

const verifier = new MCPVerifier();

const result = await verifier.verifyServer({
  name: 'everything',
  type: MCPServerType.STDIO,
  command: 'npx',
  args: ['-y', '@modelcontextprotocol/server-everything']
});

if (result.status === 'success') {
  console.log(`✅ Connected to ${result.server.name}`);
  console.log(`Tools: ${result.capabilities?.tools.length}`);
  console.log(`Total tokens: ${result.capabilities?.totalToolTokens}`);
}

// Fetch resource contents and prompt templates
const result = await verifier.verifyServer(
  serverConfig,
  {
    timeout: 15000,
    includeResourceContents: true,  // Fetch actual resource data
    includePromptDetails: true,     // Fetch prompt templates
    includeTokenCounts: true        // Calculate token usage (default)
  }
);

// Access detailed tool parameters
result.capabilities?.tools.forEach(tool => {
  console.log(`\nTool: ${tool.name}`);

  if (tool.inputSchema?.properties) {
    Object.entries(tool.inputSchema.properties).forEach(([name, schema]) => {
      console.log(`  - ${name}: ${schema.type} ${schema.description || ''}`);
    });
  }
});

// Import specific modules
import { MCPVerifier } from 'agentinit/verifier';
import { MCPServerType } from 'agentinit/types';
import type {
  MCPServerConfig,
  MCPVerificationResult,
  MCPVerificationOptions
} from 'agentinit/types';
import { countTokens, MCPParser } from 'agentinit/utils';

import { MCPVerifier, MCPServerType } from 'agentinit';

const verifier = new MCPVerifier(10000); // 10 second timeout

const result = await verifier.verifyServer({
  name: 'filesystem',
  type: MCPServerType.STDIO,
  command: 'npx',
  args: ['-y', '@modelcontextprotocol/server-filesystem', '/workspace'],
  env: {
    NODE_ENV: 'production'
  }
});

if (result.status === 'success') {
  result.capabilities?.tools.forEach(tool => {
    const tokens = result.capabilities?.toolTokenCounts?.get(tool.name) || 0;
    console.log(`  • ${tool.name} (${tokens} tokens)`);
  });
}

import { MCPVerifier, MCPServerType } from 'agentinit';

const result = await verifier.verifyServer({
  name: 'github-api',
  type: MCPServerType.HTTP,
  url: 'https://api.example.com/mcp',
  headers: {
    'Authorization': 'Bearer YOUR_TOKEN',
    'Content-Type': 'application/json'
  }
});

import { MCPVerifier, MCPServerType } from 'agentinit/verifier';

const servers = [
  {
    name: 'everything',
    type: MCPServerType.STDIO,
    command: 'npx',
    args: ['-y', '@modelcontextprotocol/server-everything']
  },
  {
    name: 'api-server',
    type: MCPServerType.HTTP,
    url: 'https://api.example.com/mcp'
  }
];

const verifier = new MCPVerifier();
const results = await verifier.verifyServers(servers);

// Display formatted results
console.log(verifier.formatResults(results));

// Or process results programmatically
const successful = results.filter(r => r.status === 'success').length;
console.log(`${successful}/${results.length} servers verified`);

// Inspect tool parameters and token usage
results.forEach(result => {
  if (result.status === 'success' && result.capabilities) {
    console.log(`\n${result.server.name}:`);
    result.capabilities.tools.forEach(tool => {
      const tokens = result.capabilities?.toolTokenCounts?.get(tool.name) || 0;
      console.log(`  • ${tool.name} (${tokens} tokens)`);
    });
  }
});

import { countTokens } from 'agentinit/utils';

const text = 'Hello, world!';
const tokens = countTokens(text);
console.log(`Token count: ${tokens}`);

import { MCPParser } from 'agentinit/utils';

const args = ['--mcp-stdio', 'test', 'node', 'server.js', '--args', 'arg1 arg2'];
const parsed = MCPParser.parseArguments(args);

console.log(parsed.servers); // Array of MCPServerConfig

new MCPVerifier(defaultTimeout?: number)

interface MCPVerificationOptions {
  timeout?: number;                    // Connection timeout (ms)
  includeResourceContents?: boolean;   // Fetch resource data
  includePromptDetails?: boolean;      // Fetch prompt templates
  includeTokenCounts?: boolean;        // Calculate tokens (default: true)
}

enum MCPServerType {
  STDIO = 'stdio',
  HTTP = 'http',
  SSE = 'sse'
}

interface MCPServerConfig {
  name: string;
  type: MCPServerType;

  // For STDIO servers
  command?: string;
  args?: string[];
  env?: Record<string, string>;

  // For HTTP/SSE servers
  url?: string;
  headers?: Record<string, string>;
}

interface MCPVerificationResult {
  server: MCPServerConfig;
  status: 'success' | 'error' | 'timeout';
  capabilities?: MCPCapabilities;
  error?: string;
  connectionTime?: number;
}

interface MCPCapabilities {
  tools: MCPTool[];           // Available tools with input schemas
  resources: MCPResource[];   // Available resources (with optional contents)
  prompts: MCPPrompt[];       // Available prompts (with optional templates)
  serverInfo?: {
    name: string;
    version: string;
  };
  totalToolTokens?: number;         // Total token usage for all tools
  toolTokenCounts?: Map<string, number>;  // Token count per tool
}

interface MCPTool {
  name: string;
  description?: string;
  inputSchema?: any;  // JSON Schema defining parameters
}

interface MCPResource {
  uri: string;
  name?: string;
  description?: string;
  mimeType?: string;
  contents?: string | Uint8Array;  // Only if includeResourceContents is true
}

interface MCPPrompt {
  name: string;
  description?: string;
  arguments?: Array<{
    name: string;
    description?: string;
    required?: boolean;
  }>;
  template?: string;  // Only if includePromptDetails is true
}