@coldiq/mcp 0.1.0

package/tests/gtm/12-bogus-domain-graceful.test.ts

@@ -0,0 +1,42 @@
+/**
+ * GTM-12: Edge case — nonexistent domain, graceful no-result
+ *
+ * The email lookup for a clearly fake domain should:
+ *   1. Call find_email (not crash, not skip the call)
+ *   2. Return no result (not a server error on our side)
+ *   3. Agent reports "not found" gracefully — does NOT proceed to verify_email
+ *
+ * Expected:   find_email called, isError falsy OR explicit no-result response
+ * Forbidden:  verify_email (nothing to verify when email is not found), crash
+ * Est. credits: ~1
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { runAgent, expectTool, expectNoTool, writeArtifact } from './harness.js'
+
+const RUN_LIVE =
+  process.env.LIVE_TESTS === '1' && !!process.env.ANTHROPIC_API_KEY && !!process.env.COLDIQ_API_KEY
+
+describe.runIf(RUN_LIVE)('gtm-12: bogus domain → graceful no-result', () => {
+  beforeAll(() => {
+    initClient(process.env.COLDIQ_API_URL, process.env.COLDIQ_API_KEY)
+  })
+
+  it('calls find_email, gets no result, does not proceed to verify, reports gracefully', async () => {
+    const result = await runAgent({
+      prompt:
+        'Find the professional email for Jane Smith at the company xyz-totally-fake-domain-9823746.io. ' +
+        'Their domain is xyz-totally-fake-domain-9823746.io.',
+      maxToolCalls: 4,
+    })
+
+    expectTool(result.transcript, 'find_email')
+    expectNoTool(result.transcript, 'verify_email')
+
+    // Final text should mention failure gracefully, not a 500 error
+    expect(result.finalText.length, 'Agent should produce a final response').toBeGreaterThan(0)
+
+    writeArtifact('12-bogus-domain-graceful', result)
+  }, 3 * 60_000)
+})

package/tests/gtm/13-private-linkedin-graceful.test.ts

@@ -0,0 +1,44 @@
+/**
+ * GTM-13: Edge case — private/nonexistent LinkedIn profile, graceful empty result
+ *
+ * find_phone on a profile with no public phone should:
+ *   1. Call find_phone (not skip, not enrich_person instead)
+ *   2. Return empty or no-result — not a thrown error
+ *   3. Agent acknowledges no phone was found
+ *
+ * Expected:   find_phone called, result gracefully empty
+ * Forbidden:  enrich_person (wrong tool for phone lookup), crash
+ * Est. credits: ~2
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { runAgent, expectTool, expectNoTool, writeArtifact } from './harness.js'
+
+const RUN_LIVE =
+  process.env.LIVE_TESTS === '1' && !!process.env.ANTHROPIC_API_KEY && !!process.env.COLDIQ_API_KEY
+
+describe.runIf(RUN_LIVE)('gtm-13: private/nonexistent LinkedIn → graceful phone result', () => {
+  beforeAll(() => {
+    initClient(process.env.COLDIQ_API_URL, process.env.COLDIQ_API_KEY)
+  })
+
+  it('calls find_phone on a profile that has no public number, reports gracefully', async () => {
+    const result = await runAgent({
+      prompt:
+        'Get the phone number for the person at this LinkedIn URL: ' +
+        'https://www.linkedin.com/in/john-doe-private-profile-xyz99887766. ' +
+        "Just the phone number. If you can't find one, say so.",
+      maxToolCalls: 4,
+    })
+
+    expectTool(result.transcript, 'find_phone')
+    expectNoTool(result.transcript, 'enrich_person')
+
+    // Agent must produce a final text — no crash, no infinite retry
+    expect(result.finalText.length, 'Agent should produce a final response').toBeGreaterThan(0)
+    expect(result.transcript.length, 'Should not retry excessively').toBeLessThanOrEqual(4)
+
+    writeArtifact('13-private-linkedin-graceful', result)
+  }, 4 * 60_000)
+})

package/tests/gtm/14-empty-handoff.test.ts

@@ -0,0 +1,43 @@
+/**
+ * GTM-14: Edge case — nonexistent company domain → empty enrich → agent stops cleanly
+ *
+ * When enrich_company returns no data for a clearly fake domain, the agent must NOT
+ * call find_people (nothing to hand off). Tests the empty-handoff stop behaviour.
+ *
+ * Note: search_companies with impossible filters is NOT reliable for this test because
+ * all live providers use semantic/approximate matching and always return something.
+ * enrich_company on a fake domain is the stable zero-result signal.
+ *
+ * Expected:   enrich_company called, returns empty/error, agent stops
+ * Forbidden:  find_people called after empty enrich_company result
+ * Est. credits: ~1
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { runAgent, expectTool, expectNoTool, writeArtifact } from './harness.js'
+
+const RUN_LIVE =
+  process.env.LIVE_TESTS === '1' && !!process.env.ANTHROPIC_API_KEY && !!process.env.COLDIQ_API_KEY
+
+describe.runIf(RUN_LIVE)('gtm-14: empty enrich result → agent stops chain cleanly', () => {
+  beforeAll(() => {
+    initClient(process.env.COLDIQ_API_URL, process.env.COLDIQ_API_KEY)
+  })
+
+  it('does not call find_people when enrich_company returns no data', async () => {
+    const result = await runAgent({
+      prompt:
+        'Enrich the company at domain xxy--totally-fake-99823746.io and then find their CEO.',
+      maxToolCalls: 6,
+    })
+
+    expectTool(result.transcript, 'enrich_company')
+    expectNoTool(result.transcript, 'find_people')
+
+    // Agent should explain there are no results — not crash or make up a company
+    expect(result.finalText.length, 'Agent should produce a final response').toBeGreaterThan(0)
+
+    writeArtifact('14-empty-handoff', result)
+  }, 4 * 60_000)
+})

package/tests/gtm/15-seo-reddit-research.test.ts

@@ -0,0 +1,38 @@
+/**
+ * GTM-15: Market research — SEO data + Reddit sentiment (parallel tools)
+ *
+ * Prompt: GTM engineer wants to understand market positioning and community sentiment.
+ * Expected flow: search_seo AND search_reddit (both must be called; order may vary)
+ * Forbidden:     search_web (for SERP queries, use search_seo; for community, use search_reddit)
+ * Est. credits:  ~4
+ */
+
+import { describe, it, beforeAll } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { runAgent, expectTool, expectNoTool, writeArtifact } from './harness.js'
+
+const RUN_LIVE =
+  process.env.LIVE_TESTS === '1' && !!process.env.ANTHROPIC_API_KEY && !!process.env.COLDIQ_API_KEY
+
+describe.runIf(RUN_LIVE)('gtm-15: SEO SERP + Reddit sentiment research', () => {
+  beforeAll(() => {
+    initClient(process.env.COLDIQ_API_URL, process.env.COLDIQ_API_KEY)
+  })
+
+  it('calls both search_seo and search_reddit for market research', async () => {
+    const result = await runAgent({
+      prompt:
+        "I want to understand the market for 'cold email tools'. " +
+        "1) Show me the top Google search results for the keyword 'cold email tool' (SERP, limit 2). " +
+        "2) Show me what people are saying about it on Reddit (limit 1 thread). " +
+        'Give me both results separately. Do not use a generic web search for either.',
+      maxToolCalls: 6,
+    })
+
+    expectTool(result.transcript, 'search_seo')
+    expectTool(result.transcript, 'search_reddit')
+    expectNoTool(result.transcript, 'search_web')
+
+    writeArtifact('15-seo-reddit-research', result)
+  }, 8 * 60_000)
+})

package/tests/gtm/README.md

@@ -0,0 +1,59 @@
+# GTM Prompt-Based Eval Suite
+
+End-to-end scenarios that verify the MCP server routes plain-English prompts to the correct tools and produces valid data. Each file is independent and runnable individually.
+
+## Required env vars
+
+| Var | Purpose |
+|---|---|
+| `COLDIQ_API_KEY` | ColdIQ API key (live provider calls) |
+| `COLDIQ_API_URL` | API base URL (default: `http://localhost:8787`) |
+| `ANTHROPIC_API_KEY` | Anthropic API key (Claude agent loop) |
+| `AGENT_MODEL` | Override Claude model (default: `claude-sonnet-4-6`) |
+
+## Run commands
+
+```bash
+cd mcp
+
+# Full suite (~50 ColdIQ credits, ~$1-3 Anthropic, 5–15 min)
+LIVE_TESTS=1 ANTHROPIC_API_KEY=… COLDIQ_API_KEY=… COLDIQ_API_URL=https://api.coldiq.com npm run test:gtm
+
+# Single scenario (cheap, ~1–4 credits)
+LIVE_TESTS=1 ANTHROPIC_API_KEY=… COLDIQ_API_KEY=… COLDIQ_API_URL=https://api.coldiq.com \
+  npx vitest run tests/gtm/11-find-vs-enrich-routing.test.ts --reporter=verbose
+
+# Without LIVE_TESTS=1, all GTM tests are silently skipped (safe for CI)
+npm test
+```
+
+## Scenario index
+
+| File | Scenario | Key routing assertion | Est. credits |
+|---|---|---|---|
+| 01 | ICP → emails (CSV) | search_companies → find_people → find_email → verify_email | 4 |
+| 02 | Multi-company bulk emails | find_people → find_emails (batch, not per-person) | 4 |
+| 03 | Person → phone number | find_people → find_phone (not enrich_person) | 3 |
+| 04 | Funding signal → outreach | find_signals(funding) → find_people → find_email | 4 |
+| 05 | Job posting → VP Sales | search_jobs (not find_signals) → find_people | 4 |
+| 06 | Intent signal → outreach | find_signals(intent) → find_people → find_email | 4 |
+| 07 | Place → website content | search_places → fetch_page_content | 3 |
+| 08 | Domain → account intel | enrich_company → find_people → find_email | 4 |
+| 09 | LinkedIn URL → full profile | enrich_person → enrich_company (not find_people) | 3 |
+| 10 | Routing: jobs vs signals | search_jobs only (NOT find_signals) | 2 |
+| 11 | Routing: find_email vs enrich | find_email only (NOT enrich_person) | 1 |
+| 12 | Bogus domain graceful | find_email → no result → no verify_email | 1 |
+| 13 | Private LinkedIn graceful | find_phone → empty → agent stops | 2 |
+| 14 | Empty handoff | search_companies → 0 results → no find_people | 1 |
+| 15 | SEO + Reddit research | search_seo + search_reddit (not search_web) | 4 |
+
+## Artifacts
+
+Each test run writes `tests/gtm/.artifacts/<slug>.json` with the full transcript: every tool called, its input params, the parsed output, elapsed time, and the `_meta.provider` field. Inspect these to debug failures or audit credit usage. The `.artifacts/` directory is gitignored.
+
+## What a failure means
+
+- **Wrong tool called** or **expected tool not called** → routing bug in a tool description or schema. Fix the description, re-run.
+- **Tool called with wrong params** → schema field description is unclear. Fix the `describe()` on the Zod field.
+- **`isError: true` on every provider** → provider is down or API key is invalid. Not an MCP bug; re-run later.
+- **Timeout** → async provider (search_jobs, search_places, search_reddit) is slow. Increase timeout or check provider health.

package/tests/gtm/harness.ts

@@ -0,0 +1,217 @@
+import Anthropic from '@anthropic-ai/sdk'
+import { zodToJsonSchema } from 'zod-to-json-schema'
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import * as url from 'node:url'
+
+import { MCP_TOOLS } from './tools-bridge.js'
+
+export interface ToolCall {
+  tool: string
+  input: Record<string, unknown>
+  output: Record<string, unknown>
+  ms: number
+  provider?: string
+  isError?: boolean
+}
+
+export interface AgentResult {
+  transcript: ToolCall[]
+  finalText: string
+  totalMs: number
+}
+
+export interface RunAgentOptions {
+  prompt: string
+  maxToolCalls?: number
+  model?: string
+}
+
+const SYSTEM_PROMPT = `You are a GTM engineer assistant with access to ColdIQ intelligence tools. Use them to answer the user's request.
+
+Rules:
+- Always use the minimum sample size: limit 1, max_profiles 1, or the smallest valid value for every size/count parameter.
+- Never invent company names, domains, emails, LinkedIn URLs, or IDs. Only use values returned by tools.
+- When chaining tools, pass actual values from the previous tool's output — never fabricate data.
+- If a tool returns no results, report that clearly and stop the chain. Do not retry with fabricated inputs.
+- Always call tools to answer the user's request — do not answer from your own training knowledge.`
+
+export async function runAgent(options: RunAgentOptions): Promise<AgentResult> {
+  const {
+    prompt,
+    maxToolCalls = 8,
+    model = process.env.AGENT_MODEL ?? 'claude-sonnet-4-6',
+  } = options
+
+  const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })
+
+  const anthropicTools: Anthropic.Tool[] = MCP_TOOLS.map((t) => ({
+    name: t.name,
+    description: t.description,
+    input_schema: zodToJsonSchema(t.schema, { target: 'openApi3' }) as Anthropic.Tool['input_schema'],
+  }))
+
+  const messages: Anthropic.MessageParam[] = [{ role: 'user', content: prompt }]
+  const transcript: ToolCall[] = []
+  const startMs = Date.now()
+  let finalText = ''
+
+  for (let round = 0; round < maxToolCalls; round++) {
+    const response = await client.messages.create({
+      model,
+      max_tokens: 4096,
+      system: SYSTEM_PROMPT,
+      tools: anthropicTools,
+      messages,
+    })
+
+    if (response.stop_reason !== 'tool_use') {
+      finalText = response.content
+        .filter((b): b is Anthropic.TextBlock => b.type === 'text')
+        .map((b) => b.text)
+        .join('\n')
+      break
+    }
+
+    const assistantContent = response.content
+    messages.push({ role: 'assistant', content: assistantContent })
+
+    const toolResults: Anthropic.ToolResultBlockParam[] = []
+
+    for (const block of assistantContent) {
+      if (block.type !== 'tool_use') continue
+
+      const entry = MCP_TOOLS.find((t) => t.name === block.name)
+
+      if (!entry) {
+        toolResults.push({
+          type: 'tool_result',
+          tool_use_id: block.id,
+          content: JSON.stringify({ error: `Unknown tool: ${block.name}` }),
+          is_error: true,
+        })
+        continue
+      }
+
+      const t0 = Date.now()
+      let rawResult: { content: { text: string }[]; isError?: boolean }
+
+      try {
+        rawResult = await entry.handler(block.input as Record<string, unknown>)
+      } catch (err) {
+        rawResult = {
+          content: [{ text: JSON.stringify({ error: String(err) }) }],
+          isError: true,
+        }
+      }
+
+      const ms = Date.now() - t0
+
+      let parsed: Record<string, unknown> = {}
+      try {
+        parsed = JSON.parse(rawResult.content[0].text) as Record<string, unknown>
+      } catch {
+        parsed = { raw: rawResult.content[0].text }
+      }
+
+      const meta = parsed._meta as Record<string, unknown> | undefined
+
+      transcript.push({
+        tool: block.name,
+        input: block.input as Record<string, unknown>,
+        output: parsed,
+        ms,
+        provider: meta?.provider as string | undefined,
+        isError: rawResult.isError,
+      })
+
+      toolResults.push({
+        type: 'tool_result',
+        tool_use_id: block.id,
+        content: rawResult.content[0].text,
+        is_error: rawResult.isError,
+      })
+    }
+
+    messages.push({ role: 'user', content: toolResults })
+  }
+
+  return { transcript, finalText, totalMs: Date.now() - startMs }
+}
+
+// ---------------------------------------------------------------------------
+// Assertion helpers — all throw with descriptive messages on failure
+// ---------------------------------------------------------------------------
+
+export function expectTool(transcript: ToolCall[], name: string): void {
+  if (!transcript.some((c) => c.tool === name)) {
+    const called = transcript.map((c) => c.tool).join(', ') || '(none)'
+    throw new Error(`Expected tool "${name}" to be called. Tools actually called: [${called}]`)
+  }
+}
+
+export function expectNoTool(transcript: ToolCall[], name: string): void {
+  const hit = transcript.find((c) => c.tool === name)
+  if (hit) {
+    throw new Error(
+      `Expected tool "${name}" NOT to be called, but it was called with: ${JSON.stringify(hit.input)}`,
+    )
+  }
+}
+
+export function expectOrder(transcript: ToolCall[], order: string[]): void {
+  const indices = order.map((name) => {
+    const idx = transcript.findIndex((c) => c.tool === name)
+    if (idx === -1)
+      throw new Error(`Cannot enforce ordering: tool "${name}" was never called. Transcript: [${transcript.map((c) => c.tool).join(', ')}]`)
+    return { name, idx }
+  })
+
+  for (let i = 1; i < indices.length; i++) {
+    const prev = indices[i - 1]
+    const curr = indices[i]
+    if (curr.idx <= prev.idx) {
+      throw new Error(`Expected "${prev.name}" (pos ${prev.idx}) before "${curr.name}" (pos ${curr.idx})`)
+    }
+  }
+}
+
+export function expectParam(
+  transcript: ToolCall[],
+  toolName: string,
+  key: string,
+  predicate: (value: unknown) => boolean,
+): void {
+  const calls = transcript.filter((c) => c.tool === toolName)
+  if (calls.length === 0) throw new Error(`Tool "${toolName}" was not called — cannot check param "${key}"`)
+  if (!calls.some((c) => predicate(c.input[key]))) {
+    throw new Error(
+      `Tool "${toolName}" was called but param "${key}" did not satisfy predicate. Values: ${JSON.stringify(calls.map((c) => c.input[key]))}`,
+    )
+  }
+}
+
+export function expectFinalContains(finalText: string, substrings: string[]): void {
+  for (const sub of substrings) {
+    if (!finalText.toLowerCase().includes(sub.toLowerCase())) {
+      const preview = finalText.slice(0, 400)
+      throw new Error(`Expected final text to contain "${sub}". Got (first 400 chars): ${preview}`)
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Artifact writer — writes JSON transcript to tests/gtm/.artifacts/<slug>.json
+// ---------------------------------------------------------------------------
+
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url))
+
+export function writeArtifact(slug: string, result: AgentResult): void {
+  const dir = path.join(__dirname, '.artifacts')
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+  const file = path.join(dir, `${slug}.json`)
+  fs.writeFileSync(
+    file,
+    JSON.stringify({ scenario: slug, timestamp: new Date().toISOString(), ...result }, null, 2),
+  )
+}

package/tests/gtm/tools-bridge.ts

@@ -0,0 +1,232 @@
+import { z } from 'zod'
+
+import {
+  searchCompaniesName,
+  searchCompaniesDescription,
+  searchCompaniesSchema,
+  searchCompaniesHandler,
+} from '../../src/tools/search-companies.js'
+
+import {
+  findPeopleName,
+  findPeopleDescription,
+  findPeopleSchema,
+  findPeopleHandler,
+} from '../../src/tools/find-people.js'
+
+import {
+  findEmailName,
+  findEmailDescription,
+  findEmailSchema,
+  findEmailHandler,
+} from '../../src/tools/find-email.js'
+
+import {
+  findEmailsName,
+  findEmailsDescription,
+  findEmailsSchema,
+  findEmailsHandler,
+} from '../../src/tools/find-emails.js'
+
+import {
+  verifyEmailName,
+  verifyEmailDescription,
+  verifyEmailSchema,
+  verifyEmailHandler,
+} from '../../src/tools/verify-email.js'
+
+import {
+  findPhoneName,
+  findPhoneDescription,
+  findPhoneSchema,
+  findPhoneHandler,
+} from '../../src/tools/find-phone.js'
+
+import {
+  enrichCompanyName,
+  enrichCompanyDescription,
+  enrichCompanySchema,
+  enrichCompanyHandler,
+} from '../../src/tools/enrich-company.js'
+
+import {
+  enrichPersonName,
+  enrichPersonDescription,
+  enrichPersonSchema,
+  enrichPersonHandler,
+} from '../../src/tools/enrich-person.js'
+
+import {
+  searchWebName,
+  searchWebDescription,
+  searchWebSchema,
+  searchWebHandler,
+} from '../../src/tools/search-web.js'
+
+import {
+  searchJobsName,
+  searchJobsDescription,
+  searchJobsSchema,
+  searchJobsHandler,
+} from '../../src/tools/search-jobs.js'
+
+import {
+  searchAdsName,
+  searchAdsDescription,
+  searchAdsSchema,
+  searchAdsHandler,
+} from '../../src/tools/search-ads.js'
+
+import {
+  searchPlacesName,
+  searchPlacesDescription,
+  searchPlacesSchema,
+  searchPlacesHandler,
+} from '../../src/tools/search-places.js'
+
+import {
+  findInfluencersName,
+  findInfluencersDescription,
+  findInfluencersSchema,
+  findInfluencersHandler,
+} from '../../src/tools/find-influencers.js'
+
+import {
+  searchRedditName,
+  searchRedditDescription,
+  searchRedditSchema,
+  searchRedditHandler,
+} from '../../src/tools/search-reddit.js'
+
+import {
+  searchSeoName,
+  searchSeoDescription,
+  searchSeoSchema,
+  searchSeoHandler,
+} from '../../src/tools/search-seo.js'
+
+import {
+  findSignalsName,
+  findSignalsDescription,
+  findSignalsSchema,
+  findSignalsHandler,
+} from '../../src/tools/find-signals.js'
+
+import {
+  fetchPageContentName,
+  fetchPageContentDescription,
+  fetchPageContentSchema,
+  fetchPageContentHandler,
+} from '../../src/tools/fetch-page-content.js'
+
+export interface McpToolEntry {
+  name: string
+  description: string
+  schema: z.ZodObject<z.ZodRawShape>
+  handler: (input: Record<string, unknown>) => Promise<{ content: { text: string }[]; isError?: boolean }>
+}
+
+export const MCP_TOOLS: McpToolEntry[] = [
+  {
+    name: searchCompaniesName,
+    description: searchCompaniesDescription,
+    schema: z.object(searchCompaniesSchema),
+    handler: searchCompaniesHandler,
+  },
+  {
+    name: findPeopleName,
+    description: findPeopleDescription,
+    schema: z.object(findPeopleSchema),
+    handler: findPeopleHandler,
+  },
+  {
+    name: findEmailName,
+    description: findEmailDescription,
+    schema: z.object(findEmailSchema),
+    handler: findEmailHandler,
+  },
+  {
+    name: findEmailsName,
+    description: findEmailsDescription,
+    schema: z.object(findEmailsSchema),
+    handler: findEmailsHandler,
+  },
+  {
+    name: verifyEmailName,
+    description: verifyEmailDescription,
+    schema: z.object(verifyEmailSchema),
+    handler: verifyEmailHandler,
+  },
+  {
+    name: findPhoneName,
+    description: findPhoneDescription,
+    schema: z.object(findPhoneSchema),
+    handler: findPhoneHandler,
+  },
+  {
+    name: enrichCompanyName,
+    description: enrichCompanyDescription,
+    schema: z.object(enrichCompanySchema),
+    handler: enrichCompanyHandler,
+  },
+  {
+    name: enrichPersonName,
+    description: enrichPersonDescription,
+    schema: z.object(enrichPersonSchema),
+    handler: enrichPersonHandler,
+  },
+  {
+    name: searchWebName,
+    description: searchWebDescription,
+    schema: z.object(searchWebSchema),
+    handler: searchWebHandler,
+  },
+  {
+    name: searchJobsName,
+    description: searchJobsDescription,
+    schema: z.object(searchJobsSchema),
+    handler: searchJobsHandler,
+  },
+  {
+    name: searchAdsName,
+    description: searchAdsDescription,
+    schema: z.object(searchAdsSchema),
+    handler: searchAdsHandler,
+  },
+  {
+    name: searchPlacesName,
+    description: searchPlacesDescription,
+    schema: z.object(searchPlacesSchema),
+    handler: searchPlacesHandler,
+  },
+  {
+    name: findInfluencersName,
+    description: findInfluencersDescription,
+    schema: z.object(findInfluencersSchema),
+    handler: findInfluencersHandler,
+  },
+  {
+    name: searchRedditName,
+    description: searchRedditDescription,
+    schema: z.object(searchRedditSchema),
+    handler: searchRedditHandler,
+  },
+  {
+    name: searchSeoName,
+    description: searchSeoDescription,
+    schema: z.object(searchSeoSchema),
+    handler: searchSeoHandler,
+  },
+  {
+    name: findSignalsName,
+    description: findSignalsDescription,
+    schema: z.object(findSignalsSchema),
+    handler: findSignalsHandler,
+  },
+  {
+    name: fetchPageContentName,
+    description: fetchPageContentDescription,
+    schema: z.object(fetchPageContentSchema),
+    handler: fetchPageContentHandler,
+  },
+]