const fromMatch = line.match(/^from\s+([A-Za-z0-9_.]+)\s+import\s+/);
if (fromMatch) {
  const base = fromMatch[1];
  if (!base.startsWith(".")) {
    modules.add(base.split(".")[0]);
  }
  continue;
}

const importMatch = line.match(/^import\s+(.+)/);
if (importMatch) {
  const targets = importMatch[1]
    .split(",")
    .map((segment) => segment.trim())
    .filter(Boolean);

  for (const target of targets) {
    if (target.startsWith(".")) continue;
    const base = target
      .split(/\s+as\s+/i)[0]
      .split(".")[0]
      .trim();
    if (base) modules.add(base);
  }
}

const importAlias = line.match(
  /^import\s+numpy\s+as\s+([A-Za-z_][A-Za-z0-9_]*)/
);
if (importAlias) {
  numpyAliases.add(importAlias[1]);
  importsNumpy = true;
  continue;
}

if (/^import\s+numpy\b/.test(line) || /^from\s+numpy\b/.test(line)) {
  numpyAliases.add("numpy");
  importsNumpy = true;
}

if (usesNpIdentifier && !hasNpAlias) {
  return {
    label: "NumPy Alias Safety",
    status: "fail",
    detail:
      "The code calls `np.` functions but never assigns the `np` alias. Import NumPy as `np` (not allowed here) or reference the chosen alias consistently.",
  };
}

if (overridesNp) {
  return {
    label: "NumPy Alias Safety",
    status: "fail",
    detail:
      "The identifier `np` is reassigned in the script, so subsequent calls like `np.exp()` will break. Avoid assigning new values to `np` after importing NumPy.",
  };
}

      try {
        const result = await generateText({
          model: openai("gpt-5"),
          messages: [
            {
              role: "user",
              content: [
                {
                  type: "text",
                  text: "Extract all text content from this PDF file.",
                },
                {
                  type: "file",
                  data: Buffer.from(arrayBuffer),
                  mediaType: "application/pdf",
                  filename: "document.pdf",
                },
              ],
            },
          ],
        });
        return result.text || "";
      } catch (error) {
        return `❌ Error processing PDF with AI SDK: ${
          error instanceof Error ? error.message : String(error)
        }`;
      }
    }
    const limit = maxBytes || 20 * 1024 * 1024;
    const chunks: Uint8Array[] = [];
    let downloaded = 0;
    while (true) {
      const { value, done } = await reader.read();
      if (done) break;
      if (value) {
        downloaded += value.byteLength;
        if (downloaded > limit) {
          return `❌ PDF exceeds maxBytes limit (${limit} bytes)`;
        }
        chunks.push(value);
      }
    }
    const buffer = Buffer.concat(chunks);

    // Use AI SDK for PDF processing instead of pdf-parse
    const { generateText } = await import("ai");
    const { openai } = await import("@ai-sdk/openai");

    try {
      const result = await generateText({
        model: openai("gpt-5"),
        messages: [
          {
            role: "user",
            content: [
              {
                type: "text",
                text: "Extract all text content from this PDF file.",
              },
              {
                type: "file",
                data: buffer,
                mediaType: "application/pdf",
                filename: "document.pdf",
              },
            ],
          },
        ],
      });
      return result.text || "";
    } catch (error) {
      return `❌ Error processing PDF with AI SDK: ${
        error instanceof Error ? error.message : String(error)
      }`;
    }
  } catch (err: any) {
    if (err?.name === "AbortError") {
      return "⏱️ Timeout fetching the PDF (20s).";
    }
    return `❌ Error parsing PDF: ${err?.message || String(err)}`;
  } finally {
    clearTimeout(timeout);
  }
},

CRITICAL: ALL FIVE FIELDS ARE REQUIRED:
1. title - Chart title (e.g., "Drug Efficacy Comparison", "Patient Response Rates")
2. type - Chart type: "line", "bar", or "area" 
3. xAxisLabel - X-axis label (e.g., "Time (weeks)", "Treatment Group")
4. yAxisLabel - Y-axis label (e.g., "Response Rate (%)", "Survival Probability")
5. dataSeries - Array of data series with this exact format:

Example complete tool call:
{
  "title": "CAR-T vs Chemotherapy Response Rates",
  "type": "line",
  "xAxisLabel": "Weeks Since Treatment",
  "yAxisLabel": "Response Rate (%)",
  "dataSeries": [
    {
      "name": "CAR-T Therapy",
      "data": [
        {"x": "Week 0", "y": 0},
        {"x": "Week 4", "y": 65.5},
        {"x": "Week 8", "y": 78.2}
      ]
    },
    {
      "name": "Standard Chemotherapy",
      "data": [
        {"x": "Week 0", "y": 0},
        {"x": "Week 4", "y": 32.1},
        {"x": "Week 8", "y": 38.5}
      ]
    }
  ]
}

NEVER omit any of the five required fields. Each data point must have x (date/label) and y (numeric value).`,
inputSchema: z.object({
  title: z
    .string()
    .describe('Chart title (e.g., "Apple vs Microsoft Stock Performance")'),
  type: z
    .enum(["line", "bar", "area"])
    .describe(
      'Chart type - use "line" for time series data like stock prices'
    ),
  xAxisLabel: z
    .string()
    .describe('X-axis label (e.g., "Date", "Quarter", "Year")'),
  yAxisLabel: z
    .string()
    .describe(
      'Y-axis label (e.g., "Price ($)", "Revenue (Millions)", "Percentage (%)")'
    ),
  dataSeries: z
    .array(
      z.object({
        name: z
          .string()
          .describe(
            'Series name - include company/ticker for stocks (e.g., "Apple (AAPL)", "Tesla Revenue")'
          ),
        data: z
          .array(
            z.object({
              x: z
                .union([z.string(), z.number()])
                .describe(
                  'X-axis value - use date strings like "2024-01-01" for time series'
                ),
              y: z
                .number()
                .describe(
                  "Y-axis numeric value - stock price, revenue, percentage, etc."
                ),
            })
          )
          .describe(
            "Array of data points with x (date/label) and y (value) properties"
          ),
      })
    )
    .describe(
      "REQUIRED: Array of data series - each series has name and data array with x,y objects"
    ),
  description: z
    .string()
    .optional()
    .describe("Optional description explaining what the chart shows"),
}),
execute: async ({
  title,
  type,
  xAxisLabel,
  yAxisLabel,
  dataSeries,
  description,
}) => {
  // Track chart creation
  await track("Chart Created", {
    chartType: type,
    title: title,
    seriesCount: dataSeries.length,
    totalDataPoints: dataSeries.reduce(
      (sum, series) => sum + series.data.length,
      0
    ),
    hasDescription: !!description,
  });

  // Enhanced date parsing for multiple formats (same logic as FinancialChart)
  const parseDate = (dateStr: string | number): Date | null => {
    if (typeof dateStr === "number") return new Date(dateStr);

    // Try multiple date formats in order of preference
    const formats = [
      // ISO format (YYYY-MM-DD, YYYY-MM-DDTHH:mm:ss, etc.)
      (str: string) => {
        const date = new Date(str);
        return !isNaN(date.getTime()) ? date : null;
      },
      // YYYY-MM-DD format
      (str: string) => {
        const match = str.match(/^(\d{4})-(\d{1,2})-(\d{1,2})$/);
        if (match) {
          const [, year, month, day] = match;
          return new Date(
            parseInt(year),
            parseInt(month) - 1,
            parseInt(day)
          );
        }
        return null;
      },
      // DD/MM/YYYY format (common in European/international contexts)
      (str: string) => {
        const match = str.match(/^(\d{1,2})\/(\d{1,2})\/(\d{4})$/);
        if (match) {
          const [, day, month, year] = match;
          const dayNum = parseInt(day);
          const monthNum = parseInt(month);
          const yearNum = parseInt(year);

          // Validate that day <= 31 and month <= 12 (basic validation)
          if (dayNum <= 31 && monthNum <= 12) {
            const parsedDate = new Date(yearNum, monthNum - 1, dayNum);
            // Additional validation: check if the parsed date components match
            if (
              parsedDate.getDate() === dayNum &&
              parsedDate.getMonth() === monthNum - 1
            ) {
              return parsedDate;
            }
          }
        }
        return null;
      },
      // MM/DD/YYYY format (common in US contexts)
      (str: string) => {
        const match = str.match(/^(\d{1,2})\/(\d{1,2})\/(\d{4})$/);
        if (match) {
          const [, month, day, year] = match;
          const monthNum = parseInt(month);
          const dayNum = parseInt(day);
          const yearNum = parseInt(year);

          // Validate that month <= 12 and day <= 31 (basic validation)
          if (monthNum <= 12 && dayNum <= 31) {
            const parsedDate = new Date(yearNum, monthNum - 1, dayNum);
            // Additional validation: check if the parsed date components match
            if (
              parsedDate.getMonth() === monthNum - 1 &&
              parsedDate.getDate() === dayNum
            ) {
              return parsedDate;
            }
          }
        }
        return null;
      },
    ];

    for (const format of formats) {
      try {
        const date = format(dateStr);
        if (date && !isNaN(date.getTime())) {
          return date;
        }
      } catch (e) {
        // Continue to next format
      }
    }
    return null;
  };

  // Sort data series by x-axis values (dates) to ensure chronological order
  const sortedDataSeries = dataSeries.map((series) => ({
    ...series,
    data: [...series.data].sort((a, b) => {
      // Sort by x value (handles both strings and numbers)
      if (typeof a.x === "string" && typeof b.x === "string") {
        const dateA = parseDate(a.x);
        const dateB = parseDate(b.x);

        // If both are valid dates, sort chronologically (earliest first)
        if (dateA && dateB) {
          return dateA.getTime() - dateB.getTime();
        }

        // Fallback to string comparison for non-date strings
        return a.x.localeCompare(b.x);
      }
      return Number(a.x) - Number(b.x);
    }),
  }));

  // Log chart creation details
  console.log("[Chart Creation] Creating chart:", {
    title,
    type,
    xAxisLabel,
    yAxisLabel,
    seriesCount: dataSeries.length,
    totalDataPoints: dataSeries.reduce(
      (sum, series) => sum + series.data.length,
      0
    ),
    seriesNames: dataSeries.map((s) => s.name),
    dataSorted: true,
  });

  // Return structured chart data for the UI to render
  const chartData = {
    chartType: type,
    title,
    xAxisLabel,
    yAxisLabel,
    dataSeries: sortedDataSeries,
    description,
    metadata: {
      totalSeries: dataSeries.length,
      totalDataPoints: dataSeries.reduce(
        (sum, series) => sum + series.data.length,
        0
      ),
      dateRange:
        sortedDataSeries.length > 0 && sortedDataSeries[0].data.length > 0
          ? {
              start: sortedDataSeries[0].data[0].x,
              end: sortedDataSeries[0].data[
                sortedDataSeries[0].data.length - 1
              ].x,
            }
          : null,
    },
  };

  console.log(
    "[Chart Creation] Chart data size:",
    JSON.stringify(chartData).length,
    "bytes"
  );

  return chartData;
},

REQUIRED FORMAT - Your Python code MUST include print statements:

IMPORTANT INSTRUCTIONS:
- No installs / no network: Do not install, upgrade, or import anything that requires downloads. Use only Python stdlib, NumPy, and pandas already present. If an import is missing, fail fast with a clear message; do not attempt pip or network calls.
- Array-safe numerics: Use NumPy for all array operations (np.exp, np.sqrt, np.log, etc.). Do not call math.* on arrays.
- Normal CDF / p-values: Do not use SciPy or np.erf. Use a provided norm_cdf that works on scalars and arrays.
- Shape discipline: All inputs must be strictly 1-D or 2-D. Before any linear algebra or broadcasting, assert shapes and length alignment (e.g., len(time) == len(event) == X.shape[0]). If a mismatch exists, raise a clear error immediately.
- Determinism: Use np.random.default_rng(<fixed_seed>) for randomness.
- I/O and side-effects: No background downloads; no writes outside /mnt/data. Keep console output concise and human-readable.
- Stability: Standardize numeric features when appropriate; add small ridge terms (e.g., 1e-6) if matrices are near-singular; avoid holding giant (n,p,p) tensors unless necessary.
- Clarity on failure: If any step cannot be satisfied under these rules, stop and print a single clear reason (do not auto-retry with different libraries or shapes).
- Your entire code MUST be strictly **under 10,000 characters** (including all whitespace and comments). If your code is too long, shorten or simplify it.

Example for financial calculations:
# Calculate compound interest
principal = 10000
rate = 0.07
time = 5
amount = principal * (1 + rate) ** time
print(f"Initial investment: $\{principal:,.2f}")
print(f"Annual interest rate: \{rate*100:.1f}%")
print(f"Time period: \{time} years")
print(f"Final amount: $\{amount:,.2f}")
print(f"Interest earned: $\{amount - principal:,.2f}")

Example for data analysis:
import math
values = [100, 150, 200, 175, 225]
average = sum(values) / len(values)
std_dev = math.sqrt(sum((x - average) ** 2 for x in values) / len(values))
print(f"Data: \{values}")
print(f"Average: \{average:.2f}")
print(f"Standard deviation: \{std_dev:.2f}")

IMPORTANT: 
- Always end with print() statements showing final results
- Use descriptive labels and proper formatting
- Include units, currency symbols, or percentages where appropriate
- Show intermediate steps for complex calculations`,
inputSchema: z.object({
  code: z
    .string()
    .describe(
      "Python code to execute - MUST include print() statements to display results. Use descriptive output formatting with labels, units, and proper number formatting."
    ),
  description: z
    .string()
    .optional()
    .describe(
      'Brief description of what the calculation or analysis does (e.g., "Calculate future value with compound interest", "Analyze portfolio risk metrics")'
    ),
}),
execute: async ({ code, description }, options) => {
  const userId = (options as any)?.experimental_context?.userId;
  const sessionId = (options as any)?.experimental_context?.sessionId;
  const userTier = (options as any)?.experimental_context?.userTier;
  const isDevelopment = process.env.NEXT_PUBLIC_APP_MODE === "development";

  const startTime = Date.now();

  try {
    console.log("[Code Execution] Executing Python code:", {
      description,
      codeLength: code.length,
      codePreview: code.substring(0, 100) + "...",
    });

    // Check for reasonable code length
    if (code.length > 10000) {
      return "🚫 **Error**: Code too long. Please limit your code to 10,000 characters.";
    }

    // Initialize Daytona client
    const daytonaApiKey = process.env.DAYTONA_API_KEY;
    if (!daytonaApiKey) {
      return "❌ **Configuration Error**: Daytona API key is not configured. Please set DAYTONA_API_KEY in your environment.";
    }

    const daytona = new Daytona({
      apiKey: daytonaApiKey,
      // Optional overrides if provided
      serverUrl: process.env.DAYTONA_API_URL,
      target: (process.env.DAYTONA_TARGET as any) || undefined,
    });

    let sandbox: any | null = null;
    try {
      // Create a Python sandbox
      sandbox = await daytona.create({ language: "python" });

      // Execute the user's code
      const execution = await sandbox.process.codeRun(code);
      const executionTime = Date.now() - startTime;

      // Track code execution
      await track("Python Code Executed", {
        success: execution.exitCode === 0,
        codeLength: code.length,
        outputLength: execution.result?.length || 0,
        executionTime: executionTime,
        hasDescription: !!description,
        hasError: execution.exitCode !== 0,
        hasArtifacts: !!execution.artifacts,
      });

      // Track usage for pay-per-use customers with Polar events
      if (
        userId &&
        sessionId &&
        userTier === "pay_per_use" &&
        execution.exitCode === 0 &&
        !isDevelopment
      ) {
        try {
          const polarTracker = new PolarEventTracker();

          console.log(
            "[CodeExecution] Tracking Daytona usage with Polar:",
            {
              userId,
              sessionId,
              executionTime,
            }
          );

          await polarTracker.trackDaytonaUsage(
            userId,
            sessionId,
            executionTime,
            {
              codeLength: code.length,
              hasArtifacts: !!execution.artifacts,
              success: execution.exitCode === 0,
              description: description || "Code execution",
            }
          );
        } catch (error) {
          console.error(
            "[CodeExecution] Failed to track Daytona usage:",
            error
          );
          // Don't fail the tool execution if usage tracking fails
        }
      }

      // Handle execution errors
      if (execution.exitCode !== 0) {
        // Provide helpful error messages for common issues
        let helpfulError = execution.result || "Unknown execution error";
        if (helpfulError.includes("NameError")) {
          helpfulError = `${helpfulError}\n\n💡 **Tip**: Make sure all variables are defined before use. If you're trying to calculate something, include the full calculation in your code.`;
        } else if (helpfulError.includes("SyntaxError")) {
          helpfulError = `${helpfulError}\n\n💡 **Tip**: Check your Python syntax. Make sure all parentheses, quotes, and indentation are correct.`;
        } else if (helpfulError.includes("ModuleNotFoundError")) {
          helpfulError = `${helpfulError}\n\n💡 **Tip**: You can install packages inside the Daytona sandbox using pip if needed (e.g., pip install numpy).`;
        }

        return `❌ **Execution Error**: ${helpfulError}`;
      }

      console.log("[Code Execution] Success:", {
        outputLength: execution.result?.length || 0,
        executionTime,
        hasArtifacts: !!execution.artifacts,
      });

      // Format the successful execution result
      return `🐍 **Python Code Execution (Daytona Sandbox)**

    return `❌ **Error**: Failed to execute Python code. ${
      error.message || "Unknown error occurred"
    }`;
  }
},

  try {
    // Check if Valyu API key is available
    const apiKey = process.env.VALYU_API_KEY;
    if (!apiKey) {
      return "❌ Valyu API key not configured. Please add VALYU_API_KEY to your environment variables to enable financial search.";
    }
    const valyu = new Valyu(apiKey, "https://api.valyu.network/v1");

    // Configure search based on data type
    let searchOptions: any = {
      maxNumResults: maxResults || 10,
    };

    const sessionKey = buildToolKey(
      "financialSearch",
      query,
      searchOptions
    );
    const response = await withSessionMemo(sessionId, sessionKey, () =>
      once(
        "financialSearch",
        canonQuery(query),
        canonOptions(searchOptions),
        () => valyu.search(query, searchOptions)
      )
    );

    // Track Valyu financial search call
    await track("Valyu API Call", {
      toolType: "financialSearch",
      query: query,
      dataType: dataType || "auto",
      maxResults: maxResults || 10,
      resultCount: response?.results?.length || 0,
      hasApiKey: !!apiKey,
      cost: (response as any)?.total_deduction_dollars || null,
      txId: (response as any)?.tx_id || null,
    });

    // Track usage for pay-per-use customers with Polar events
    console.log("[FinancialSearch] Tracking Valyu API usage with Polar:", {
      userId,
      sessionId,
      userTier,
      isDevelopment,
    });

    if (
      userId &&
      sessionId &&
      userTier === "pay_per_use" &&
      !isDevelopment
    ) {
      console.log("[FinancialSearch] Tracking Valyu API usage with Polar:");
      try {
        const polarTracker = new PolarEventTracker();
        // Use the actual Valyu API cost from response
        const valyuCostDollars =
          (response as any)?.total_deduction_dollars || 0;

        // Bright green color: \x1b[92m ... \x1b[0m
        console.log(
          "\x1b[92m[FinancialSearch] Tracking Valyu API usage with Polar:\x1b[0m",
          {
            userId,
            sessionId,
            valyuCostDollars,
            resultCount: response?.results?.length || 0,
          }
        );

        await polarTracker.trackValyuAPIUsage(
          userId,
          sessionId,
          "financialSearch",
          valyuCostDollars,
          {
            query,
            resultCount: response?.results?.length || 0,
            dataType: dataType || "auto",
            success: true,
            tx_id: (response as any)?.tx_id,
          }
        );
      } catch (error) {
        console.error(
          "[FinancialSearch] Failed to track Valyu API usage:",
          error
        );
        // Don't fail the search if usage tracking fails
      }
    }

    // // Log the full API response for debugging
    // console.log(
    //   "[Financial Search] Full API Response:",
    //   JSON.stringify(response, null, 2)
    // );

    if (!response || !response.results || response.results.length === 0) {
      return `🔍 No financial data found for "${query}". Try rephrasing your search or checking if the company/symbol exists.`;
    }

    // // Log key information about the search
    // console.log("[Financial Search] Summary:", {
    //   query,
    //   dataType,
    //   resultCount: response.results.length,
    //   totalCost: (response as any).price || "N/A",
    //   txId: (response as any).tx_id || "N/A",
    //   firstResultTitle: response.results[0]?.title,
    //   firstResultLength: response.results[0]?.length,
    // });

    // Map + dedupe by canonical id
    const mapped = (response?.results || []).map((r: any) => {
      const key = normalizeUrl(r.url);
      return {
        id: key ? keyToUuid(key) : resultId(r),
        title: r.title || "Financial Data",
        url: r.url,
        content: r.content,
        date: r.metadata?.date,
        source: r.metadata?.source,
        dataType: r.data_type,
        length: r.length,
        image_url: r.image_url || {},
        relevance_score: r.relevance_score,
      };
    });
    const unique = dedupeBy(mapped, (x) => x.id);
    const final = dedupeAgainstRequest(requestId, unique, (x) => x.id);

    // Return structured data for the model to process
    const formattedResponse = {
      type: "financial_search",
      query: query,
      dataType: dataType,
      resultCount: final.length,
      results: final.map((r: any) => ({
        id: r.id,
        title: r.title,
        url: r.url,
        content: r.content,
        date: r.date,
        source: r.source,
        dataType: r.dataType,
        length: r.length,
        image_url: r.image_url || {},
        relevance_score: r.relevance_score,
      })),
    };

    console.log(
      "[Financial Search] Formatted response size:",
      JSON.stringify(formattedResponse).length,
      "bytes"
    );

    return JSON.stringify(formattedResponse, null, 2);
  } catch (error) {
    if (error instanceof Error) {
      if (
        error.message.includes("401") ||
        error.message.includes("unauthorized")
      ) {
        return "🔐 Invalid Valyu API key. Please check your VALYU_API_KEY environment variable.";
      }
      if (error.message.includes("429")) {
        return "⏱️ Rate limit exceeded. Please try again in a moment.";
      }
      if (
        error.message.includes("network") ||
        error.message.includes("fetch")
      ) {
        return "🌐 Network error connecting to Valyu API. Please check your internet connection.";
      }
    }

    return `❌ Error searching financial data: ${
      error instanceof Error ? error.message : "Unknown error"
    }`;
  }
},

  try {
    // Check if Valyu API key is available
    const apiKey = process.env.VALYU_API_KEY;
    if (!apiKey) {
      return "❌ Valyu API key not configured. Please add VALYU_API_KEY to your environment variables to enable Wiley search.";
    }
    const valyu = new Valyu(apiKey, "https://api.valyu.network/v1");

    // Configure search options for Wiley sources
    const searchOptions: any = {
      maxNumResults: maxResults || 10,
      includedSources: [
        "wiley/wiley-finance-papers",
        "wiley/wiley-finance-books",
      ],
    };
    if (searchOptions.includedSources?.sort)
      searchOptions.includedSources.sort();

    const sessionKey = buildToolKey("wileySearch", query, searchOptions);
    const response = await withSessionMemo(sessionId, sessionKey, () =>
      once(
        "wileySearch",
        canonQuery(query),
        canonOptions(searchOptions),
        () => valyu.search(query, searchOptions)
      )
    );

    // Track Valyu Wiley search call
    await track("Valyu API Call", {
      toolType: "wileySearch",
      query: query,
      maxResults: maxResults || 10,
      resultCount: response?.results?.length || 0,
      hasApiKey: !!apiKey,
      cost: (response as any)?.total_deduction_dollars || null,
      txId: (response as any)?.tx_id || null,
    });

    // Track usage for pay-per-use customers with Polar events
    if (
      userId &&
      sessionId &&
      userTier === "pay_per_use" &&
      !isDevelopment
    ) {
      try {
        const polarTracker = new PolarEventTracker();
        const valyuCostDollars =
          (response as any)?.total_deduction_dollars || 0;
        console.log("[WileySearch] Tracking Valyu API usage with Polar:", {
          userId,
          sessionId,
          valyuCostDollars,
          resultCount: response?.results?.length || 0,
        });
        await polarTracker.trackValyuAPIUsage(
          userId,
          sessionId,
          "wileySearch",
          valyuCostDollars,
          {
            query,
            resultCount: response?.results?.length || 0,
            success: true,
            tx_id: (response as any)?.tx_id,
          }
        );
      } catch (error) {
        console.error(
          "[WileySearch] Failed to track Valyu API usage:",
          error
        );
        // Don't fail the search if usage tracking fails
      }
    }

    if (!response || !response.results || response.results.length === 0) {
      return `🔍 No Wiley academic results found for "${query}". Try rephrasing your search.`;
    }

    // Map and dedupe by canonical id
    const mapped = (response?.results || []).map((r: any) => {
      const pmid = r.metadata?.pmid ? String(r.metadata.pmid) : undefined;
      const doi =
        extractDoi(r.metadata?.doi) ||
        extractDoi(r.url) ||
        extractDoi(r.content);
      const arxiv = extractArxivId(r.url);
      const normalized = normalizeUrl(r.url);
      const key = pmid || doi || arxiv || normalized;
      return {
        id: key ? keyToUuid(key) : resultId(r),
        title: r.title || "Wiley Academic Result",
        url: r.url,
        content: r.content,
        date: r.metadata?.date,
        source: r.metadata?.source,
        dataType: r.data_type,
        length: r.length,
        image_url: r.image_url || {},
        relevance_score: r.relevance_score,
      };
    });
    const unique = dedupeBy(mapped, (x) => x.id);
    const final = dedupeAgainstRequest(requestId, unique, (x) => x.id);

    // Return structured data for the model to process
    return JSON.stringify(
      {
        type: "wiley_search",
        query: query,
        resultCount: final.length,
        results: final,
      },
      null,
      2
    );
  } catch (error) {
    if (error instanceof Error) {
      if (
        error.message.includes("401") ||
        error.message.includes("unauthorized")
      ) {
        return "🔐 Invalid Valyu API key. Please check your VALYU_API_KEY environment variable.";
      }
      if (error.message.includes("429")) {
        return "⏱️ Rate limit exceeded. Please try again in a moment.";
      }
      if (
        error.message.includes("network") ||
        error.message.includes("fetch")
      ) {
        return "🌐 Network error connecting to Valyu API. Please check your internet connection.";
      }
    }

    return `❌ Error searching Wiley academic data: ${
      error instanceof Error ? error.message : "Unknown error"
    }`;
  }
},

  try {
    const apiKey = process.env.VALYU_API_KEY;
    if (!apiKey) {
      return "❌ Valyu API key not configured. Please add VALYU_API_KEY to your environment variables to enable clinical trials search.";
    }
    const valyu = new Valyu(apiKey, "https://api.valyu.network/v1");

    // Always request 6 results for UI display, but we'll limit what we send to the model
    const searchOptions: any = {
      maxNumResults: 6, // Fixed at 6 for UI display
      searchType: "proprietary",
      includedSources: ["valyu/valyu-clinical-trials"],
      relevanceThreshold: 0.4,
      isToolCall: true,
    };
    if (searchOptions.includedSources?.sort)
      searchOptions.includedSources.sort();

    if (startDate) searchOptions.startDate = startDate;
    if (endDate) searchOptions.endDate = endDate;

    const sessionKey = buildToolKey(
      "clinicalTrialsSearch",
      query,
      searchOptions
    );
    const response = await withSessionMemo(sessionId, sessionKey, () =>
      once(
        "clinicalTrialsSearch",
        canonQuery(query),
        canonOptions(searchOptions),
        () => valyu.search(query, searchOptions)
      )
    );

    const mapped = response.results.map((r: any) => {
      const key = r.nct_id || r.data?.nct_id;
      return {
        id: key ? keyToUuid(key) : resultId(r),
        title: r.title,
        url: r.url,
        content: r.content,
        date: r.metadata?.date,
        source: r.metadata?.source || r.source,
      };
    });

    const unique = dedupeBy(mapped, (x) => x.id);
    const final = dedupeAgainstRequest(requestId, unique, (x) => x.id);
    logDedupe(
      "clinicalTrialsSearch",
      requestId,
      response?.results?.length || 0,
      mapped.length,
      unique.length,
      final
    );

    await track("Valyu API Call", {
      toolType: "clinicalTrialsSearch",
      query: query,
      maxResults: maxResults || 10,
      resultCount: final.length || 0,
      hasApiKey: !!apiKey,
      cost: (response as any)?.total_deduction_dollars || null,
      txId: (response as any)?.tx_id || null,
    });

    if (
      userId &&
      sessionId &&
      userTier === "pay_per_use" &&
      !isDevelopment
    ) {
      try {
        const polarTracker = new PolarEventTracker();
        const valyuCostDollars =
          (response as any)?.total_deduction_dollars || 0;
        await polarTracker.trackValyuAPIUsage(
          userId,
          sessionId,
          "clinicalTrialsSearch",
          valyuCostDollars,
          {
            query,
            resultCount: final.length || 0,
            success: true,
            tx_id: (response as any)?.tx_id,
          }
        );
      } catch (error) {
        console.error(
          "[ClinicalTrialsSearch] Failed to track Valyu API usage:",
          error
        );
      }
    }

    if (!response || !response.results || response.results.length === 0) {
      return JSON.stringify(
        {
          type: "clinical_trials",
          query: query,
          resultCount: final.length,
          results: final,
          message: `No clinical trials found for "${query}". Try using different search terms or checking ClinicalTrials.gov directly.`,
        },
        null,
        2
      );
    }

    // Extract overview information for each trial
    const extractOverview = (content: string) => {
      try {
        const data = JSON.parse(content);

        // Return just the key overview fields
        return {
          nct_id: data.nct_id,
          title: data.brief_title || data.official_title,
          status: data.overall_status,
          phase: data.phases,
          enrollment: data.enrollment_count,
          conditions: data.conditions,
          // Keep full brief summary - this is the most important part
          brief_summary: data.brief_summary || "No summary available",
          // Just the names of interventions
          interventions: data.interventions
            ? data.interventions
                .slice(0, 3)
                .map((i: any) => i.name)
                .filter(Boolean)
            : [],
          start_date: data.start_date,
          completion_date: data.completion_date,
        };
      } catch (e) {
        console.error("Failed to parse clinical trial data:", e);
        return null;
      }
    };

    // Create overview version for both model and UI
    const overviewResults = response.results
      .map((result: any) => {
        const overview = extractOverview(result.content);
        if (!overview) return null;

        return {
          ...overview,
          url: result.url,
          source: "valyu/valyu-clinical-trials",
          dataType: "clinical_trials",
          relevance_score: result.relevance_score,
        };
      })
      .filter(Boolean);

    // Return overview results - this is what both model and UI will use
    const formattedResponse = {
      type: "clinical_trials_overview",
      query: query,
      resultCount: overviewResults.length,
      results: overviewResults,
      note: `Found ${overviewResults.length} clinical trials. Use 'getClinicalTrialDetails' tool with NCT ID for full details of any specific trial.`,
    };

    return JSON.stringify(formattedResponse, null, 2);
  } catch (error) {
    if (error instanceof Error) {
      if (
        error.message.includes("401") ||
        error.message.includes("unauthorized")
      ) {
        return "🔐 Invalid Valyu API key. Please check your VALYU_API_KEY environment variable.";
      }
    }
    return `❌ Error searching clinical trials: ${
      error instanceof Error ? error.message : "Unknown error"
    }`;
  }
},

  try {
    const apiKey = process.env.VALYU_API_KEY;
    if (!apiKey) {
      return "❌ Valyu API key not configured. Please add VALYU_API_KEY to your environment variables.";
    }
    const valyu = new Valyu(apiKey, "https://api.valyu.network/v1");

    // Search for the specific NCT ID
    const searchOptions: any = {
      maxNumResults: 5,
      searchType: "proprietary",
      includedSources: ["valyu/valyu-clinical-trials"],
      relevanceThreshold: 0.1, // Lower threshold since we're looking for exact match
      isToolCall: true,
    };
    if (searchOptions.includedSources?.sort)
      searchOptions.includedSources.sort();

    const sessionKey = buildToolKey(
      "getClinicalTrialDetails",
      nctId,
      searchOptions
    );
    const response = await withSessionMemo(sessionId, sessionKey, () =>
      once(
        "getClinicalTrialDetails",
        canonQuery(nctId),
        canonOptions(searchOptions),
        () => valyu.search(`clinical trial: ${nctId}`, searchOptions)
      )
    );

    const mapped = response.results.map((r: any) => {
      const key = r.nct_id || r.metadata?.nct_id;
      return {
        id: key ? keyToUuid(key) : resultId(r),
        title: r.title,
        url: r.url,
        content: r.content,
        date: r.metadata?.date,
        source: r.metadata?.source || r.source,
      };
    });

    const unique = dedupeBy(mapped, (x) => x.id);
    const final = dedupeAgainstRequest(requestId, unique, (x) => x.id);
    logDedupe(
      "getClinicalTrialDetails",
      requestId,
      response?.results?.length || 0,
      mapped.length,
      unique.length,
      final
    );

    await track("Valyu API Call", {
      toolType: "getClinicalTrialDetails",
      nctId: nctId,
      resultCount: response?.results?.length || 0,
      hasApiKey: !!apiKey,
      cost: (response as any)?.total_deduction_dollars || null,
      txId: (response as any)?.tx_id || null,
    });

    if (
      userId &&
      sessionId &&
      userTier === "pay_per_use" &&
      !isDevelopment
    ) {
      try {
        const polarTracker = new PolarEventTracker();
        const valyuCostDollars =
          (response as any)?.total_deduction_dollars || 0;
        await polarTracker.trackValyuAPIUsage(
          userId,
          sessionId,
          "getClinicalTrialDetails",
          valyuCostDollars,
          {
            nctId,
            resultCount: response?.results?.length || 0,
            success: true,
            tx_id: (response as any)?.tx_id,
          }
        );
      } catch (error) {
        console.error(
          "[GetClinicalTrialDetails] Failed to track Valyu API usage:",
          error
        );
      }
    }

    if (!response || !response.results || response.results.length === 0) {
      return JSON.stringify(
        {
          type: "clinical_trial_details",
          nctId: nctId,
          found: false,
          message: `No clinical trial found with NCT ID: ${nctId}`,
        },
        null,
        2
      );
    }

    // Parse the full trial data
    const result = response.results[0];
    let trialData;
    try {
      trialData = JSON.parse(result.content);
    } catch (e) {
      // If parsing fails, return the raw content
      return JSON.stringify(
        {
          type: "clinical_trial_details",
          nctId: nctId,
          found: true,
          title: result.title,
          url: result.url,
          content: result.content,
          note: "Raw content provided - parsing failed",
        },
        null,
        2
      );
    }

    // Return the full parsed trial data
    const formattedResponse = {
      type: "clinical_trial_details",
      nctId: nctId,
      found: true,
      title: result.title,
      url: result.url,
      data: trialData, // Full trial data
      note: `Full details for clinical trial ${nctId}`,
    };

    return JSON.stringify(formattedResponse, null, 2);
  } catch (error) {
    if (error instanceof Error) {
      if (
        error.message.includes("401") ||
        error.message.includes("unauthorized")
      ) {
        return "🔐 Invalid Valyu API key. Please check your VALYU_API_KEY environment variable.";
      }
    }
    return `❌ Error fetching clinical trial details: ${
      error instanceof Error ? error.message : "Unknown error"
    }`;
  }
},

  try {
    const apiKey = process.env.VALYU_API_KEY;
    if (!apiKey) {
      return "❌ Valyu API key not configured. Please add VALYU_API_KEY to your environment variables to enable drug information search.";
    }
    const valyu = new Valyu(apiKey, "https://api.valyu.network/v1");

    const searchOptions: any = {
      maxNumResults: maxResults || 5,
      searchType: "proprietary",
      includedSources: ["valyu/valyu-drug-labels"],
      relevanceThreshold: 0.5,
      isToolCall: true,
      responseLength: "large",
    };
    if (searchOptions.includedSources?.sort)
      searchOptions.includedSources.sort();

    // Use once() for deduplication/caching
    const sessionKey = buildToolKey(
      "drugInformationSearch",
      query,
      searchOptions
    );
    const response = await withSessionMemo(sessionId, sessionKey, () =>
      once(
        "drugInformationSearch",
        canonQuery(query),
        canonOptions(searchOptions),
        () => valyu.search(query, searchOptions)
      )
    );

    // Attach deterministic IDs derived from setid or normalized URL
    const mapped = (response?.results || []).map((r: any) => {
      const key = r.metadata?.setid || normalizeUrl(r.url);
      return {
        id: key ? keyToUuid(key) : resultId(r),
        title: r.title || "Drug Information",
        url: r.url,
        content: r.content,
        source: "valyu/valyu-drug-labels",
        dataType: "drug label",
        length: r.length,
        relevance_score: r.relevance_score,
      };
    });

    const unique = dedupeBy(mapped, (x) => x.id);
    const final = dedupeAgainstRequest(requestId, unique, (x) => x.id);
    logDedupe(
      "drugInformationSearch",
      requestId,
      response?.results?.length || 0,
      mapped.length,
      unique.length,
      final
    );

    await track("Valyu API Call", {
      toolType: "drugInformationSearch",
      query: query,
      maxResults: maxResults || 5,
      resultCount: final.length || 0,
      hasApiKey: !!apiKey,
      cost: (response as any)?.total_deduction_dollars || null,
      txId: (response as any)?.tx_id || null,
    });

    if (
      userId &&
      sessionId &&
      userTier === "pay_per_use" &&
      !isDevelopment
    ) {
      try {
        const polarTracker = new PolarEventTracker();
        const valyuCostDollars =
          (response as any)?.total_deduction_dollars || 0;
        await polarTracker.trackValyuAPIUsage(
          userId,
          sessionId,
          "drugInformationSearch",
          valyuCostDollars,
          {
            query,
            resultCount: final.length || 0,
            success: true,
            tx_id: (response as any)?.tx_id,
          }
        );
      } catch (error) {
        console.error(
          "[DrugInformationSearch] Failed to track Valyu API usage:",
          error
        );
      }
    }

    if (
      !response ||
      !response.results ||
      response.results.length === 0 ||
      final.length === 0
    ) {
      return JSON.stringify(
        {
          type: "drug_information",
          query: query,
          resultCount: 0,
          results: [],
          message: `No drug information found for "${query}". Try searching with the generic drug name or active ingredient.`,
        },
        null,
        2
      );
    }

    const formattedResponse = {
      type: "drug_information",
      query: query,
      resultCount: final.length,
      results: final.map((result: any) => ({
        id: result.id,
        title: result.title || "Drug Information",
        url: result.url,
        content: result.content,
        source: result.source,
        dataType: result.dataType,
        length: result.length,
        relevance_score: result.relevance_score,
      })),
    };

    return JSON.stringify(formattedResponse, null, 2);
  } catch (error) {
    if (error instanceof Error) {
      if (
        error.message.includes("401") ||
        error.message.includes("unauthorized")
      ) {
        return "🔐 Invalid Valyu API key. Please check your VALYU_API_KEY environment variable.";
      }
    }
    return `❌ Error searching drug information: ${
      error instanceof Error ? error.message : "Unknown error"
    }`;
  }
},

  try {
    const apiKey = process.env.VALYU_API_KEY;
    if (!apiKey) {
      return "❌ Valyu API key not configured. Please add VALYU_API_KEY to your environment variables to enable biomedical literature search.";
    }
    const valyu = new Valyu(apiKey, "https://api.valyu.network/v1");

    const includedSources = [
      "valyu/valyu-pubmed",
      "valyu/valyu-arxiv",
      "wiley/wiley-finance-papers",
      "wiley/wiley-finance-books",
    ];
    includedSources.sort();

    const searchOptions: any = {
      maxNumResults: maxResults || 10,
      searchType: "proprietary",
      includedSources: includedSources,
      isToolCall: true,
      relevanceThreshold: 0.4,
    };

    const sessionKey = buildToolKey(
      "biomedicalLiteratureSearch",
      query,
      searchOptions
    );
    const response = await withSessionMemo(sessionId, sessionKey, () =>
      once(
        "biomedicalLiteratureSearch",
        canonQuery(query),
        canonOptions(searchOptions),
        () => valyu.search(query, searchOptions)
      )
    );

    console.log("response", response);

    const mapped = response.results.map((r: any) => {
      const pmid = r.metadata?.pmid ? String(r.metadata.pmid) : undefined;
      const doi = r.doi || r.metadata?.doi;
      const arxiv = extractArxivId(r.url);
      const normalized = normalizeUrl(r.url);
      const key = pmid || doi || arxiv || normalized;
      return {
        id: key ? keyToUuid(key) : resultId(r),
        title: r.title,
        url: r.url,
        content: r.content,
        date: r.metadata?.date || r.publication_date,
        source: r.metadata?.source || r.source,
        doi: doi,
        citation: r.citation,
        authors: r.authors,
        references: r.references,
        pmid: pmid,
      };
    });

    const unique = dedupeBy(mapped, (x) => x.id);
    const final = dedupeAgainstRequest(requestId, unique, (x) => x.id);
    logDedupe(
      "biomedicalLiteratureSearch",
      requestId,
      response?.results?.length || 0,
      mapped.length,
      unique.length,
      final
    );

    await track("Valyu API Call", {
      toolType: "biomedicalLiteratureSearch",
      query: query,
      maxResults: maxResults || 10,
      resultCount: final.length || 0,
      hasApiKey: !!apiKey,
      sources: includedSources?.join(",") || "all",
      cost: (response as any)?.total_deduction_dollars || null,
      txId: (response as any)?.tx_id || null,
    });

    if (
      userId &&
      sessionId &&
      userTier === "pay_per_use" &&
      !isDevelopment
    ) {
      try {
        const polarTracker = new PolarEventTracker();
        const valyuCostDollars =
          (response as any)?.total_deduction_dollars || 0;
        await polarTracker.trackValyuAPIUsage(
          userId,
          sessionId,
          "biomedicalLiteratureSearch",
          valyuCostDollars,
          {
            query,
            resultCount: final.length || 0,
            sources: includedSources?.join(",") || "all",
            success: true,
            tx_id: (response as any)?.tx_id,
          }
        );
      } catch (error) {
        console.error(
          "[BiomedicalLiteratureSearch] Failed to track Valyu API usage:",
          error
        );
      }
    }

    // If no results, return empty result set with message
    if (
      !response ||
      !response.results ||
      response.results.length === 0 ||
      final.length === 0
    ) {
      return JSON.stringify(
        {
          type: "biomedical_literature",
          query: query,
          resultCount: 0,
          results: [],
          message: `No biomedical literature found for "${query}". Try using different medical terminology or MeSH terms.`,
        },
        null,
        2
      );
    }

    // Return deduped, structured results
    return JSON.stringify(
      {
        type: "biomedical_literature",
        query,
        resultCount: final.length,
        results: final.map((result: any) => ({
          id: result.id,
          title: result.title || "Research Paper",
          url: result.url,
          content: result.content,
          date: result.date,
          source: result.source,
          dataType: "literature",
          length: result.length,
          image_url: result.image_url || {},
          relevance_score: result.relevance_score,
          doi: result.doi,
          citation: result.citation,
          authors: result.authors,
          references: result.references,
          pmid: result.pmid,
        })),
      },
      null,
      2
    );
  } catch (error) {
    if (error instanceof Error) {
      if (
        error.message.includes("401") ||
        error.message.includes("unauthorized")
      ) {
        return "🔐 Invalid Valyu API key. Please check your VALYU_API_KEY environment variable.";
      }
    }
    return `❌ Error searching biomedical literature: ${
      error instanceof Error ? error.message : "Unknown error"
    }`;
  }
},

  try {
    const apiKey = process.env.VALYU_API_KEY;
    if (!apiKey) {
      return "❌ Valyu API key not configured. Please add VALYU_API_KEY to your environment variables to enable pharma company analysis.";
    }
    const valyu = new Valyu(apiKey, "https://api.valyu.network/v1");

    const sources: string[] = [];
    if (dataTypes.includes("sec_filings")) {
      sources.push("valyu/valyu-sec-filings");
    }
    if (dataTypes.includes("stock_price")) {
      sources.push("valyu/valyu-stocks-US");
    }
    if (dataTypes.includes("earnings")) {
      sources.push("valyu/valyu-earnings-US");
    }

    const query = `${company} ${timePeriod || ""}`.trim();

    let searchOptions: any = {
      maxNumResults: maxResults || 15,
      relevanceThreshold: 0.4,
      isToolCall: true,
    };

    if (sources.length > 0) {
      sources.sort();
      searchOptions.searchType = "proprietary";
      searchOptions.includedSources = sources;
    } else if (dataTypes.includes("news")) {
      searchOptions.searchType = "all"; // Search both proprietary and web
    }

    // Use once() for deduplication/caching
    const sessionKey = buildToolKey(
      "pharmaCompanyAnalysis",
      query,
      searchOptions
    );
    const response = await withSessionMemo(sessionId, sessionKey, () =>
      once(
        "pharmaCompanyAnalysis",
        canonQuery(query),
        canonOptions(searchOptions),
        () => valyu.search(query, searchOptions)
      )
    );

    // pharmaCompanyAnalysis: normalized URL + date (or source+title)
    const mapped = (response?.results || []).map((r: any) => {
      const normalized = normalizeUrl(r.url);
      const key =
        normalized && r.metadata?.date
          ? `${normalized}_${r.metadata?.date}`
          : r.source && r.title
          ? `${r.source}_${r.title.toLowerCase()}`
          : normalized;
      return {
        id: key ? keyToUuid(key) : resultId(r),
        title: r.title || "Company Data",
        url: r.url,
        content: r.content,
        date: r.metadata?.date,
        source: r.metadata?.source || r.source,
        dataType: r.data_type,
        length: r.length,
        image_url: r.image_url || {},
        relevance_score: r.relevance_score,
      };
    });

    const unique = dedupeBy(mapped, (x) => x.id);
    const final = dedupeAgainstRequest(requestId, unique, (x) => x.id);

    await track("Valyu API Call", {
      toolType: "pharmaCompanyAnalysis",
      query: query,
      company: company,
      dataTypes: dataTypes.join(","),
      maxResults: maxResults || 15,
      resultCount: final.length || 0,
      hasApiKey: !!apiKey,
      cost: (response as any)?.total_deduction_dollars || null,
      txId: (response as any)?.tx_id || null,
    });

    if (
      userId &&
      sessionId &&
      userTier === "pay_per_use" &&
      !isDevelopment
    ) {
      try {
        const polarTracker = new PolarEventTracker();
        const valyuCostDollars =
          (response as any)?.total_deduction_dollars || 0;
        await polarTracker.trackValyuAPIUsage(
          userId,
          sessionId,
          "pharmaCompanyAnalysis",
          valyuCostDollars,
          {
            company,
            dataTypes: dataTypes.join(","),
            resultCount: response?.results?.length || 0,
            success: true,
            tx_id: (response as any)?.tx_id,
          }
        );
      } catch (error) {
        console.error(
          "[PharmaCompanyAnalysis] Failed to track Valyu API usage:",
          error
        );
      }
    }

    if (
      !response ||
      !response.results ||
      response.results.length === 0 ||
      final.length === 0
    ) {
      return JSON.stringify(
        {
          type: "pharma_company_analysis",
          query: query,
          company: company,
          resultCount: 0,
          results: [],
          message: `No data found for "${company}". Ensure the company name is correct and try again.`,
        },
        null,
        2
      );
    }

    const formattedResponse = {
      type: "pharma_company_analysis",
      company: company,
      timePeriod: timePeriod,
      resultCount: final.length,
      results: final.map((result: any) => ({
        id: result.id,
        title: result.title || "Company Data",
        url: result.url,
        content: result.content,
        date: result.date,
        source: result.source,
        dataType: result.dataType,
        length: result.length,
        image_url: result.image_url || {},
        relevance_score: result.relevance_score,
      })),
    };

    return JSON.stringify(formattedResponse, null, 2);
  } catch (error) {
    if (error instanceof Error) {
      if (
        error.message.includes("401") ||
        error.message.includes("unauthorized")
      ) {
        return "🔐 Invalid Valyu API key. Please check your VALYU_API_KEY environment variable.";
      }
    }
    return `❌ Error analyzing pharma company: ${
      error instanceof Error ? error.message : "Unknown error"
    }`;
  }
},

  try {
    const apiKey = process.env.VALYU_API_KEY;
    if (!apiKey) {
      return "❌ Valyu API key not configured. Please add VALYU_API_KEY to your environment variables to enable comprehensive healthcare search.";
    }
    const valyu = new Valyu(apiKey, "https://api.valyu.network/v1");

    const sources: string[] = [];

    if (includeClinicalTrials) {
      sources.push("valyu/valyu-clinical-trials");
    }
    if (includeDrugLabels) {
      sources.push("valyu/valyu-drug-labels");
    }
    if (includeLiterature) {
      sources.push("valyu/valyu-pubmed", "valyu/valyu-arxiv");
    }
    if (includeFinancial) {
      sources.push("valyu/valyu-sec-filings", "valyu/valyu-stocks-US");
    }

    const searchOptions: any = {
      maxNumResults: maxResults || 20,
      searchType: sources.length > 0 ? "proprietary" : "all",
      relevanceThreshold: 0.4,
      isToolCall: true,
    };

    if (sources.length > 0) {
      sources.sort();
      searchOptions.includedSources = sources;
    }

    // Use once() for deduplication/caching
    const sessionKey = buildToolKey(
      "comprehensiveHealthcareSearch",
      query,
      searchOptions
    );
    const response = await withSessionMemo(sessionId, sessionKey, () =>
      once(
        "comprehensiveHealthcareSearch",
        canonQuery(query),
        canonOptions(searchOptions),
        () => valyu.search(query, searchOptions)
      )
    );

    // For comprehensiveHealthcareSearch, derive deterministic UUIDs from normalized URLs
    const mapped = (response?.results || []).map((r: any) => {
      const key = normalizeUrl(r.url);
      return {
        id: key ? keyToUuid(key) : resultId(r),
        title: r.title || "Healthcare Data",
        url: r.url,
        content: r.content,
        date: r.metadata?.date,
        source: r.metadata?.source || r.source,
        dataType: r.data_type || "healthcare",
        length: r.length,
        image_url: r.image_url || {},
        relevance_score: r.relevance_score,
      };
    });

    const unique = dedupeBy(mapped, (x) => x.id);
    const final = dedupeAgainstRequest(requestId, unique, (x) => x.id);

    await track("Valyu API Call", {
      toolType: "comprehensiveHealthcareSearch",
      query: query,
      maxResults: maxResults || 20,
      resultCount: final.length || 0,
      hasApiKey: !!apiKey,
      includedTypes: [
        includeClinicalTrials && "trials",
        includeDrugLabels && "drugs",
        includeLiterature && "literature",
        includeFinancial && "financial",
      ]
        .filter(Boolean)
        .join(","),
      cost: (response as any)?.total_deduction_dollars || null,
      txId: (response as any)?.tx_id || null,
    });

    if (
      userId &&
      sessionId &&
      userTier === "pay_per_use" &&
      !isDevelopment
    ) {
      try {
        const polarTracker = new PolarEventTracker();
        const valyuCostDollars =
          (response as any)?.total_deduction_dollars || 0;
        await polarTracker.trackValyuAPIUsage(
          userId,
          sessionId,
          "comprehensiveHealthcareSearch",
          valyuCostDollars,
          {
            query,
            resultCount: response?.results?.length || 0,
            includedTypes: sources.join(","),
            success: true,
            tx_id: (response as any)?.tx_id,
          }
        );
      } catch (error) {
        console.error(
          "[ComprehensiveHealthcareSearch] Failed to track Valyu API usage:",
          error
        );
      }
    }

    if (
      !response ||
      !response.results ||
      response.results.length === 0 ||
      final.length === 0
    ) {
      return JSON.stringify(
        {
          type: "comprehensive_healthcare",
          query: query,
          resultCount: 0,
          results: [],
          message: `No healthcare data found for "${query}". Try using more specific medical terms or adjusting search parameters.`,
        },
        null,
        2
      );
    }

    const formattedResponse = {
      type: "comprehensive_healthcare",
      query: query,
      resultCount: final.length,
      results: final.map((result: any) => ({
        id: result.id,
        title: result.title || "Healthcare Data",
        url: result.url,
        content: result.content,
        date: result.date,
        source: result.source,
        dataType: result.dataType || "healthcare",
        length: result.length,
        image_url: result.image_url || {},
        relevance_score: result.relevance_score,
      })),
    };

    return JSON.stringify(formattedResponse, null, 2);
  } catch (error) {
    if (error instanceof Error) {
      if (
        error.message.includes("401") ||
        error.message.includes("unauthorized")
      ) {
        return "🔐 Invalid Valyu API key. Please check your VALYU_API_KEY environment variable.";
      }
    }
    return `❌ Error performing comprehensive healthcare search: ${
      error instanceof Error ? error.message : "Unknown error"
    }`;
  }
},

  try {
    // Initialize Valyu client (uses default/free tier if no API key)
    const valyu = new Valyu(
      process.env.VALYU_API_KEY,
      "https://api.valyu.network/v1"
    );

    // Configure search options
    const searchOptions = {
      searchType: "all" as const, // Search both proprietary and web sources
      maxNumResults: maxResults || 5,
      isToolCall: true, // true for AI agents/tools
    };

    // Use per-session memo + in-flight dedupe
    const sessionKey = buildToolKey("webSearch", query, searchOptions);
    const response = await withSessionMemo(sessionId, sessionKey, () =>
      once(
        "webSearch",
        canonQuery(query),
        canonOptions(searchOptions),
        () => valyu.search(query, searchOptions)
      )
    );

    // Attach canonical id (DOI -> arXiv -> URL) mapped to deterministic UUIDs
    const mapped = (response?.results || []).map((r: any) => {
      const doi = extractDoi(r.url) || extractDoi(r.content);
      const arxiv = extractArxivId(r.url);
      const normalized = normalizeUrl(r.url);
      const key = doi || arxiv || normalized;
      return {
        id: key ? keyToUuid(key) : resultId(r),
        title: r.title || "Web Result",
        url: r.url,
        content: r.content,
        date: r.metadata?.date,
        source: r.metadata?.source,
        dataType: r.data_type,
        length: r.length,
        image_url: r.image_url || {},
        relevance_score: r.relevance_score,
      };
    });

    const unique = dedupeBy(mapped, (x) => x.id);
    const final = dedupeAgainstRequest(requestId, unique, (x) => x.id);

    // Track Valyu web search call
    await track("Valyu API Call", {
      toolType: "webSearch",
      query: query,
      maxResults: maxResults || 5,
      resultCount: final.length || 0,
      hasApiKey: !!process.env.VALYU_API_KEY,
      cost:
        (response as any)?.metadata?.totalCost ||
        (response as any)?.total_deduction_dollars ||
        null,
      searchTime: (response as any)?.metadata?.searchTime || null,
      txId: (response as any)?.tx_id || null,
    });

    // Track usage for pay-per-use customers with Polar events
    if (
      userId &&
      sessionId &&
      userTier === "pay_per_use" &&
      !isDevelopment
    ) {
      try {
        const polarTracker = new PolarEventTracker();
        // Use the actual Valyu API cost from response
        const valyuCostDollars =
          (response as any)?.total_deduction_dollars || 0;

        console.log("[WebSearch] Tracking Valyu API usage with Polar:", {
          userId,
          sessionId,
          valyuCostDollars,
          resultCount: response?.results?.length || 0,
        });

        await polarTracker.trackValyuAPIUsage(
          userId,
          sessionId,
          "webSearch",
          valyuCostDollars,
          {
            query,
            resultCount: response?.results?.length || 0,
            success: true,
            tx_id: (response as any)?.tx_id,
            search_time: (response as any)?.metadata?.searchTime,
          }
        );
      } catch (error) {
        console.error(
          "[WebSearch] Failed to track Valyu API usage:",
          error
        );
        // Don't fail the search if usage tracking fails
      }
    }

    // Log the full API response for debugging
    console.log(
      "[Web Search] Full API Response:",
      JSON.stringify(response, null, 2)
    );

    if (
      !response ||
      !response.results ||
      response.results.length === 0 ||
      final.length === 0
    ) {
      return `🔍 No web results found for "${query}". Try rephrasing your search with different keywords.`;
    }

    // Log key information about the search
    const metadata = (response as any).metadata;
    console.log("[Web Search] Summary:", {
      query,
      resultCount: final.length,
      totalCost:
        metadata?.totalCost ||
        (response as any).total_deduction_dollars ||
        "N/A",
      searchTime: metadata?.searchTime || "N/A",
      txId: (response as any).tx_id || "N/A",
      firstResultTitle: final[0]?.title,
      firstResultLength: final[0]?.length,
    });

    // Return structured data for the model to process
    const formattedResponse = {
      type: "web_search",
      query: query,
      resultCount: final.length,
      metadata: {
        totalCost: metadata?.totalCost,
        searchTime: metadata?.searchTime,
      },
      results: final.map((result: any) => ({
        id: result.id,
        title: result.title || "Web Result",
        url: result.url,
        content: result.content,
        date: result.date,
        source: result.source,
        dataType: result.dataType,
        length: result.length,
        image_url: result.image_url || {},
        relevance_score: result.relevance_score,
      })),
    };

    console.log(
      "[Web Search] Formatted response size:",
      JSON.stringify(formattedResponse).length,
      "bytes"
    );

    return JSON.stringify(formattedResponse, null, 2);
  } catch (error) {
    if (error instanceof Error) {
      if (
        error.message.includes("401") ||
        error.message.includes("unauthorized")
      ) {
        return "🔐 Authentication error with Valyu API. Please check your configuration.";
      }
      if (error.message.includes("429")) {
        return "⏱️ Rate limit exceeded. Please try again in a moment.";
      }
      if (
        error.message.includes("network") ||
        error.message.includes("fetch")
      ) {
        return "🌐 Network error connecting to Valyu API. Please check your internet connection.";
      }
      if (
        error.message.includes("price") ||
        error.message.includes("cost")
      ) {
        return "💰 Search cost exceeded maximum budget. Try reducing maxPrice or using more specific queries.";
      }
    }

    return `❌ Error performing web search: ${
      error instanceof Error ? error.message : "Unknown error"
    }`;
  }
},