interface ToolDefinition {
  id: string;
  name: string;
  description: string;
  capabilities: string[];
  examples: string[];
  contextRequirements?: string[];
  outputFormats: string[];
}

class ToolRegistry {
  private tools: Map<string, ToolDefinition> = new Map();
  
  register(tool: ToolDefinition): void {
    this.tools.set(tool.id, tool);
  }
  
  getAll(): ToolDefinition[] {
    return Array.from(this.tools.values());
  }
  
  findByCapability(capability: string): ToolDefinition[] {
    return this.getAll().filter(tool => 
      tool.capabilities.includes(capability)
    );
  }
}

// Example tool registration
const registry = new ToolRegistry();

registry.register({
  id: "product-search-ui",
  name: "Product Search Interface",
  description: "E-commerce product search with filters, sorting, and shopping cart functionality",
  capabilities: ["search", "filter", "sort", "cart", "e-commerce"],
  examples: [
    "Find wireless headphones under $200",
    "Search for office furniture with reviews",
    "Browse laptops with technical specifications"
  ],
  contextRequirements: ["product_catalog"],
  outputFormats: ["ag-ui"]
});

registry.register({
  id: "data-viz-ui", 
  name: "Data Visualization",
  description: "Interactive charts, graphs, and dashboard components",
  capabilities: ["charts", "graphs", "analytics", "dashboard"],
  examples: [
    "Show sales trends over time",
    "Create a revenue dashboard",
    "Visualize user engagement metrics"
  ],
  contextRequirements: ["data_source"],
  outputFormats: ["ag-ui", "react"]
});

class SamplingRouter {
  constructor(
    private gateway: SuperModelGateway,
    private registry: ToolRegistry
  ) {}

  async route(
    request: string, 
    context: UserContext
  ): Promise<RoutingDecision> {
    const availableTools = this.registry.getAll();
    const routingPrompt = this.buildRoutingPrompt(request, context, availableTools);

    const samplingResponse = await this.gateway.sample({
      messages: [{
        role: "user",
        content: { type: "text", text: routingPrompt }
      }],
      systemPrompt: this.getRoutingSystemPrompt(),
      maxTokens: 200
    });

    const decision = JSON.parse(samplingResponse.content.text);
    
    return {
      tool: decision.tool,
      params: decision.params,
      confidence: decision.confidence,
      reasoning: decision.reasoning
    };
  }

  private buildRoutingPrompt(
    request: string,
    context: UserContext,
    tools: ToolDefinition[]
  ): string {
    return `
User Request: "${request}"

User Context:
${JSON.stringify({
  journey: context.journey,
  preferences: context.preferences,
  data: context.data
}, null, 2)}

Available Tools:
${tools.map(tool => `
- ${tool.id}: ${tool.description}
  Capabilities: ${tool.capabilities.join(', ')}
  Examples: ${tool.examples.slice(0, 2).join('; ')}
`).join('\n')}

Which tool should handle this request? Consider:
1. User's current journey stage
2. Request intent and context
3. Tool capabilities and examples
4. User's demonstrated preferences

Return JSON:
{
  "tool": "tool-id",
  "params": {
    // Parameters to pass to the tool
  },
  "confidence": 0.0-1.0,
  "reasoning": "Why this tool is the best choice"
}`;
  }

  private getRoutingSystemPrompt(): string {
    return `You are an intelligent routing assistant for a UI generation system. 

Your job is to analyze user requests and context to select the most appropriate tool for generating a UI response.

Rules:
1. Always return valid JSON with the specified structure
2. Consider user context and journey stage
3. Match request intent to tool capabilities
4. Provide confidence score based on certainty of match
5. Give clear reasoning for the selection

Be decisive - users expect a specific tool selection, not multiple options.`;
  }
}

// Gateway initialization
const gateway = new SuperModelGateway({
  configPath: './supermodel.config.json'
});

// Register tools
gateway.registerTool('product-search-ui', new ProductSearchTool(gateway));
gateway.registerTool('bundle-builder-ui', new BundleBuilderTool(gateway));
gateway.registerTool('data-viz-ui', new DataVisualizationTool(gateway));

// Start serving
gateway.listen(3000, () => {
  console.log('SuperModel Gateway running on port 3000');
});

class GatewayAnalytics {
  trackRouting(decision: RoutingDecision, context: UserContext): void {
    this.metrics.increment('routing.decisions', {
      tool: decision.tool,
      confidence: this.bucketConfidence(decision.confidence),
      journey_stage: this.inferJourneyStage(context)
    });
  }

  trackToolPerformance(tool: string, responseTime: number): void {
    this.metrics.histogram('tool.response_time', responseTime, {
      tool: tool
    });
  }
}