# Discovery endpoint
curl http://localhost:3000/.well-known/mcp.json

# Call a tool
curl -X POST http://localhost:3000/api/mcp/stream \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $ERP_JWT" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
      "name": "crm_search_deals",
      "arguments": { "limit": 10 }
    }
  }'

// extract-mcp-context.ts
export function extractMcpContext(req: Request): McpContext {
  const authHeader = req.header('authorization') ?? '';
  const bearer = authHeader.slice(7).trim();

  // Parse JWT claims WITHOUT verification
  const claims = parseJwtClaimsUnsafe(bearer);

  return {
    userId: claims?.userId ?? claims?.sub ?? 'anonymous',
    roles: normalizeRoles(claims),
    requestId: req.header('x-mcp-request-id') ?? randomUUID(),
    traceId: req.header('x-mcp-trace-id'),
    tenantId: req.header('x-mcp-tenant-id'),
  };
}

// McpAdapterProvider
@Injectable()
export class McpAdapterProvider {
  constructor(private config: ConfigService) {}

  forErpJwt(erpJwt: string): IERPAdapter {
    return new TwendeeERPAdapter({
      baseUrl: this.config.get('TWENDEE_ERP_BASE_URL'),
      jwtProvider: () => erpJwt,  // Injected per-request
      timeoutMs: 15000,
    });
  }
}

interface CrmToolDefinition<TInput extends z.ZodRawShape> {
  // Identity
  name: string;         // e.g., "crm_search_deals"
  title: string;        // Human-readable name
  description: string;  // What the tool does (shown to AI)

  // Input validation
  inputSchema: TInput;  // Zod schema for parameters

  // Metadata
  tier: 'essential' | 'advanced';  // Loading priority
  destructive: boolean;            // Requires confirmation?
  roleScoped: boolean;             // Needs ownership filter?

  // Implementation
  handler: (
    input: z.infer<z.ZodObject<TInput>>,
    adapter: ICRMAdapter,
    ctx: McpContext,
  ) => Promise<McpToolResult>;
}

interface McpToolResult {
  content: Array<{ type: 'text'; text: string }>;
  isError?: boolean;
}

import { z } from 'zod';
import type { ICRMAdapter, McpContext, DealQuery } from '@twd/erp-adapters';

// Helper to format results
function jsonResult(value: unknown): McpToolResult {
  return { content: [{ type: 'text', text: JSON.stringify(value, null, 2) }] };
}

// Role-based query scoping
function scopeDealQuery(query: DealQuery, ctx: McpContext): DealQuery {
  if (isManagerRole(ctx)) return query;
  return { ...query, followerId: ctx.userId };
}

// Tool definition
export const crmSearchDealsTool: CrmToolDefinition<{
  page: z.ZodOptional<z.ZodNumber>;
  limit: z.ZodOptional<z.ZodNumber>;
  search: z.ZodOptional<z.ZodString>;
  status: z.ZodOptional<z.ZodString>;
  companyId: z.ZodOptional<z.ZodString>;
}> = {
  name: 'crm_search_deals',
  title: 'Search CRM deals',
  description: `Search CRM deals (sales opportunities). Returns paginated list
    with name, status, type, value, currency. Rep users only see deals
    they created OR follow; manager-tier users see all.`,

  inputSchema: {
    page: z.number().int().positive().optional()
      .describe('Page number (1-based)'),
    limit: z.number().int().positive().max(100).optional()
      .describe('Items per page (max 100)'),
    search: z.string().optional()
      .describe('Free-text search'),
    status: z.string().optional()
      .describe('Deal status (DISCOVERY, PROPOSAL_SENT, WON, LOST)'),
    companyId: z.string().optional()
      .describe('Filter by company ID'),
  },

  tier: 'essential',
  destructive: false,
  roleScoped: true,

  handler: async (input, adapter, ctx) => {
    const query = scopeDealQuery(input as DealQuery, ctx);
    const result = await adapter.deals.findAll(query, ctx);
    return jsonResult(result);
  },
};

{
  "name": "twd-agents-hub",
  "version": "0.1.0",
  "protocolVersion": "2025-06-18",
  "transport": {
    "type": "streamable-http",
    "url": "https://hub.example.com/api/mcp/stream"
  },
  "capabilities": {
    "tools": { "listChanged": true }
  },
  "auth": {
    "required": true,
    "schemes": ["bearer"]
  }
}