[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10},"actionData","errors","root",{"_144":145,"_146":147},"routes/_app.x.$handle.$name",{"_16":17,"_20":21,"_82":65,"_83":31,"_63":-7,"_84":-5,"_13":85,"_86":87,"_11":88,"_89":90,"_91":92,"_93":-5,"_94":-5,"_95":-5,"_96":26,"_97":98,"_99":100,"_101":-5,"_102":-5,"_103":104},"routes/_app.x.$handle.$name.search.$(branch)",{"_11":12,"_13":14,"_15":-5,"_16":17},"files",[],"project",{"_18":19,"_20":21,"_22":23,"_24":-5,"_25":26,"_27":28,"_29":28,"_30":31,"_32":-5,"_33":34,"_35":-5,"_36":26,"_37":-5,"_38":-5,"_39":40,"_41":42,"_43":-5,"_44":-5,"_45":-5,"_46":-5,"_47":48,"_49":48,"_50":51,"_52":51,"_53":51,"_54":48,"_55":48,"_56":57,"_58":59,"_60":61,"_62":26},"query","handle","mhussar3","id","5994aa15-9916-409e-a2cf-b02c797027e1","name","findCandidatesBackend","createdAt",["D",1781022809094],"deletedAt","legacyEnvVars",false,"privacy","public","httpPrivacy","description","","imageUrl","userId","52d79f98-f575-4133-b870-58d2d9bb24bf","pinnedFileId","pinPreview","pinMigrated","screenshotVersion","likeCount",0,"orgId","019ead36-eedf-7478-a0c1-de445d0092b1","tursoName","tursoHostname","tursoMeasuredAt","pinned","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm","user",{"_16":17,"_81":77},"org",{"_16":17,"_75":17,"_76":77,"_33":34,"_78":79,"_80":26},"branch",{"_63":64,"_20":65,"_18":66,"_67":19,"_68":-5,"_69":-5,"_70":-5,"_71":-5,"_72":-5,"_73":21,"_74":17},"isOwned","version",29,"main","f0d4749f-5f6f-4826-a8c1-a25df6fbd7f1","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","displayName","avatar","https://avatars.githubusercontent.com/u/188508645?v=4","tier","free","canRestrictVals","profileImageUrl","branchName","path","adoptOrgId",{"_18":19,"_20":21,"_22":140,"_24":-5,"_25":26,"_27":28,"_29":28,"_30":31,"_32":-5,"_33":34,"_35":-5,"_36":26,"_37":-5,"_38":-5,"_39":40,"_41":42,"_43":-5,"_44":-5,"_45":-5,"_46":-5,"_47":48,"_49":48,"_50":51,"_52":51,"_53":51,"_54":48,"_55":48,"_56":141,"_58":142,"_60":143,"_62":26},"tree",[135],[135],"counts",{"_123":40,"_124":125,"_126":40,"_127":128,"_129":130},"contents",[105],"file","upstreamProject","upstreamBranch","emptyEnvVars","flags",[],"hasHttpFiles",true,"grants","orgs","customDomains",{},{"_18":106,"_20":107,"_108":109,"_110":-5,"_111":66,"_112":64,"_113":100,"_22":114,"_63":115,"_116":117,"_118":119,"_120":26,"_121":-5,"_83":122},"a1b933fa-6fcd-4691-8e1f-1be519a38fca","main.ts","fileId","f240d034-6420-11f1-a269-1607ee4eb77e","parentId","branchId","branchVersion","latest",["D",1782159309063],28,"fileType","http","content","/** Find Candidates Backend - Val Town HTTP handler */\n\nimport { Hono } from \"npm:hono\";\nimport { cors } from \"npm:hono/cors\";\nimport { blob } from \"https://esm.town/v/std/blob\";\n\nconst app = new Hono();\n// The web app is served from a separate val now, so it calls this API cross-origin.\n// Allow it explicitly. (Preflight OPTIONS is handled here, before the auth gate.)\napp.use(\n \"*\",\n cors({\n origin: \"*\",\n allowMethods: [\"GET\", \"POST\", \"OPTIONS\"],\n allowHeaders: [\"Content-Type\", \"Authorization\"],\n }),\n);\n\n// Public - no auth\napp.get(\"/api/health\", (c) => c.json({ ok: true, version: \"0.11.0\" }));\n\n// Bearer-token gate for all /api/* routes registered below\napp.use(\"/api/*\", async (c, next) => {\n const token = Deno.env.get(\"ACCESS_TOKEN\");\n if (!token) return next();\n const auth = c.req.header(\"Authorization\") ?? \"\";\n if (auth !== `Bearer ${token}`) {\n return c.json({ error: \"Unauthorized\" }, 401);\n }\n return next();\n});\n\n// Types\n\ninterface Filters {\n title?: string; // single title from the structured-filters UI\n titles?: string[]; // all acceptable titles parsed from a brief\n title_role?: string; // PDL taxonomy function, e.g. \"finance\"\n title_levels?: string[]; // PDL levels, e.g. [\"cxo\", \"vp\"]\n company?: string;\n companies?: string[]; // current employer must be one of these (company-first mode)\n past_companies?: string[];\n seniority?: string;\n location?: string;\n industries?: string[];\n company_sizes?: string[];\n skills?: string[];\n}\n\ninterface Candidate {\n name: string;\n html_url: string;\n where: string;\n why: string;\n signals: string[];\n gaps: string[];\n tier: number;\n source: string;\n}\n\n// Claude helpers (raw HTTP - no SDK in Deno/Val Town)\n\nconst ANTHROPIC_URL = \"https://api.anthropic.com/v1/messages\";\n\n// Cost tracking\n// A Cost object is threaded through a single request so the response can report\n// exactly what was spent. Threading (vs a module global) keeps concurrent\n// requests from mixing totals. The param is optional everywhere and fail-safe:\n// a missed thread under-counts, it never crashes a search.\n\ninterface Cost {\n usd: number;\n pdlCredits: number;\n}\nfunction newCost(): Cost {\n return { usd: 0, pdlCredits: 0 };\n}\n\n// USD per 1M tokens (input / output), from the cached model table\nconst PRICE: Record = {\n \"claude-opus-4-8\": { in: 5, out: 25 },\n \"claude-sonnet-4-6\": { in: 3, out: 15 },\n \"claude-haiku-4-5\": { in: 1, out: 5 },\n};\n\n// deno-lint-ignore no-explicit-any\nfunction addUsage(cost: Cost | undefined, usage: any, model: string) {\n if (!cost || !usage) return;\n const p = PRICE[model] || PRICE[\"claude-opus-4-8\"];\n cost.usd += (\n (usage.input_tokens || 0) * p.in +\n (usage.output_tokens || 0) * p.out +\n (usage.cache_read_input_tokens || 0) * p.in * 0.1 +\n (usage.cache_creation_input_tokens || 0) * p.in * 1.25\n ) / 1e6;\n // Web search server tool: $10 / 1000 = $0.01 each\n cost.usd += ((usage.server_tool_use?.web_search_requests) || 0) * 0.01;\n}\n\n// Anthropic fetch with retry + friendly errors\n\nconst RETRYABLE = new Set([429, 500, 503, 529]);\nconst sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));\n\nfunction anthropicError(status: number, text: string): Error {\n let msg = text;\n try {\n msg = JSON.parse(text)?.error?.message || text;\n } catch { /* not JSON - keep raw */ }\n if (status === 400 && /credit balance/i.test(msg)) {\n return new Error(\n \"Anthropic credits exhausted - add credits at console.anthropic.com -> Plans & Billing, then retry.\",\n );\n }\n if (status === 401) {\n return new Error(\n \"Anthropic: invalid API key (401). Check ANTHROPIC_KEY on the backend.\",\n );\n }\n if (status === 429) {\n return new Error(\n \"Anthropic rate limit (429) after retries. Wait a moment and try again.\",\n );\n }\n if (status === 529) {\n return new Error(\n \"Anthropic is overloaded (529) after retries. Try again shortly.\",\n );\n }\n return new Error(`Anthropic error ${status}: ${msg}`);\n}\n\n// Single chokepoint for every Anthropic call: retries transient failures with\n// backoff (honoring Retry-After), maps known statuses to clean messages, and\n// aborts a hung socket so it fails cleanly instead of stalling the whole request.\nconst CALL_TIMEOUT_MS = 90000;\nasync function anthropicFetch(\n body: Record,\n apiKey: string,\n timeoutMs = CALL_TIMEOUT_MS,\n): Promise> {\n for (let attempt = 0;; attempt++) {\n const ctrl = new AbortController();\n const timer = setTimeout(() => ctrl.abort(), timeoutMs);\n let res: Response;\n try {\n res = await fetch(ANTHROPIC_URL, {\n method: \"POST\",\n headers: {\n \"Content-Type\": \"application/json\",\n \"x-api-key\": apiKey,\n \"anthropic-version\": \"2023-06-01\",\n },\n body: JSON.stringify(body),\n signal: ctrl.signal,\n });\n } catch (e) {\n if ((e as Error)?.name === \"AbortError\") {\n throw new Error(\n \"Anthropic request timed out. Try a narrower brief or fewer results.\",\n );\n }\n throw e;\n } finally {\n clearTimeout(timer);\n }\n\n if (res.ok) return await res.json() as Record;\n\n const text = await res.text();\n if (RETRYABLE.has(res.status) && attempt < 3) {\n const ra = parseInt(res.headers.get(\"retry-after\") || \"\");\n const waitMs = Math.min(\n Number.isFinite(ra) && ra > 0 ? ra * 1000 : 1000 * 2 ** attempt,\n 15000,\n );\n await sleep(waitMs);\n continue;\n }\n throw anthropicError(res.status, text);\n }\n}\n\n/** Call Claude with tool_choice to force structured JSON output. */\nasync function callClaude(\n apiKey: string,\n model: string,\n maxTokens: number,\n tool: Record,\n userMessage: string,\n cost?: Cost,\n timeoutMs?: number,\n): Promise> {\n const toolName = tool.name as string;\n\n const data = await anthropicFetch(\n {\n model,\n max_tokens: maxTokens,\n tool_choice: { type: \"tool\", name: toolName },\n tools: [tool],\n messages: [{ role: \"user\", content: userMessage }],\n },\n apiKey,\n timeoutMs,\n ) as {\n content: Array<\n { type: string; name: string; input: Record }\n >;\n usage?: Record;\n };\n addUsage(cost, data.usage, model);\n\n const block = data.content.find(\n (b) => b.type === \"tool_use\" && b.name === toolName,\n );\n if (!block) throw new Error(`Claude returned no ${toolName} call`);\n return block.input;\n}\n\n// Streaming variant of callClaude. Same forced-tool contract, but reads the response\n// incrementally over SSE instead of waiting for the whole buffered body. This prevents\n// the \"request appears to hang\" timeout on slow responses (Anthropic's recommended fix).\n// The abort timer covers BOTH the connect and the full stream read.\nasync function callClaudeStream(\n apiKey: string,\n model: string,\n maxTokens: number,\n tool: Record,\n userMessage: string,\n cost?: Cost,\n timeoutMs = CALL_TIMEOUT_MS,\n): Promise> {\n const toolName = tool.name as string;\n const ctrl = new AbortController();\n const timer = setTimeout(() => ctrl.abort(), timeoutMs);\n try {\n const res = await fetch(ANTHROPIC_URL, {\n method: \"POST\",\n headers: {\n \"Content-Type\": \"application/json\",\n \"x-api-key\": apiKey,\n \"anthropic-version\": \"2023-06-01\",\n },\n body: JSON.stringify({\n model,\n max_tokens: maxTokens,\n tool_choice: { type: \"tool\", name: toolName },\n tools: [tool],\n messages: [{ role: \"user\", content: userMessage }],\n stream: true,\n }),\n signal: ctrl.signal,\n });\n if (!res.ok || !res.body) {\n const t = await res.text().catch(() => \"\");\n throw anthropicError(res.status, t);\n }\n\n // Accumulate the forced tool's input JSON (streamed as input_json_delta chunks),\n // plus token usage for the cost meter.\n let jsonBuf = \"\";\n let uIn = 0, uOut = 0, uCacheRead = 0, uCacheCreate = 0;\n const reader = res.body.getReader();\n const decoder = new TextDecoder();\n let buf = \"\";\n while (true) {\n const { done, value } = await reader.read();\n if (done) break;\n buf += decoder.decode(value, { stream: true });\n let nl;\n while ((nl = buf.indexOf(\"\\n\\n\")) !== -1) { // SSE events are \\n\\n-separated\n const evtBlock = buf.slice(0, nl);\n buf = buf.slice(nl + 2);\n for (const line of evtBlock.split(\"\\n\")) {\n if (!line.startsWith(\"data:\")) continue;\n const payload = line.slice(5).trim();\n if (!payload || payload === \"[DONE]\") continue;\n let ev;\n try {\n ev = JSON.parse(payload);\n } catch {\n continue;\n }\n if (\n ev.type === \"content_block_delta\" &&\n ev.delta?.type === \"input_json_delta\"\n ) {\n jsonBuf += ev.delta.partial_json ?? \"\";\n } else if (ev.type === \"message_start\" && ev.message?.usage) {\n const u = ev.message.usage;\n uIn += u.input_tokens || 0;\n uCacheRead += u.cache_read_input_tokens || 0;\n uCacheCreate += u.cache_creation_input_tokens || 0;\n } else if (ev.type === \"message_delta\" && ev.usage) {\n uOut = ev.usage.output_tokens || uOut;\n } else if (ev.type === \"error\") {\n throw new Error(\n `Anthropic stream error: ${\n ev.error?.message || JSON.stringify(ev.error)\n }`,\n );\n }\n }\n }\n }\n addUsage(cost, {\n input_tokens: uIn,\n output_tokens: uOut,\n cache_read_input_tokens: uCacheRead,\n cache_creation_input_tokens: uCacheCreate,\n }, model);\n\n if (!jsonBuf) throw new Error(`Claude returned no ${toolName} call`);\n try {\n return JSON.parse(jsonBuf) as Record;\n } catch {\n throw new Error(`Claude returned malformed ${toolName} JSON`);\n }\n } catch (e) {\n if ((e as Error)?.name === \"AbortError\") {\n throw new Error(\n \"Anthropic request timed out. Try a narrower brief or fewer results.\",\n );\n }\n throw e;\n } finally {\n clearTimeout(timer);\n }\n}\n\n// Response cache (Val Town blob store)\n// Identical searches return the stored result instead of re-billing PDL credits\n// and tokens. All blob access is wrapped so a storage hiccup never breaks search.\n\nconst CACHE_TTL_MS = 7 * 24 * 3600 * 1000; // people data moves slowly; 7 days is safe\n\nasync function hashKey(obj: unknown): Promise {\n const json = JSON.stringify(obj);\n const buf = await crypto.subtle.digest(\n \"SHA-256\",\n new TextEncoder().encode(json),\n );\n const hex = [...new Uint8Array(buf)].map((b) =>\n b.toString(16).padStart(2, \"0\")\n ).join(\"\");\n return \"fc_cache_\" + hex.slice(0, 32);\n}\n\nasync function cacheGet(key: string): Promise | null> {\n try {\n const hit = await blob.getJSON(key) as {\n ts: number;\n payload: Record;\n } | undefined;\n if (hit && (Date.now() - hit.ts) < CACHE_TTL_MS) return hit.payload;\n } catch { /* treat any blob error as a miss */ }\n return null;\n}\n\nasync function cacheSet(\n key: string,\n payload: Record,\n): Promise {\n try {\n await blob.setJSON(key, { ts: Date.now(), payload });\n } catch { /* non-fatal - just skip caching */ }\n}\n\n// Step 1: parse brief -> structured filters\n\nasync function parseBriefToFilters(\n brief: string,\n apiKey: string,\n cost?: Cost,\n): Promise {\n const result = await callClaude(\n apiKey,\n \"claude-sonnet-4-6\", // simple extraction - sonnet is sufficient\n 512,\n {\n name: \"extract_filters\",\n description:\n \"Extract structured search filters from a natural-language recruiting brief.\",\n input_schema: {\n type: \"object\",\n properties: {\n titles: {\n type: \"array\",\n items: { type: \"string\" },\n description:\n \"ALL acceptable job titles, fully expanded. When the brief lists alternatives ('CFO or VP Finance'), include every one PLUS common wording variants, e.g. ['Chief Financial Officer', 'Senior Vice President of Finance', 'SVP Finance', 'Vice President of Finance', 'VP Finance', 'Head of Finance']. Titles are matched as exact phrases, so variants matter.\",\n },\n title_role: {\n type: \"string\",\n description:\n \"The job function in PDL taxonomy, lowercase - e.g. finance, sales, marketing, engineering, operations, human_resources, legal. Set whenever the function is clear; it catches title wordings the titles list can't enumerate.\",\n },\n title_levels: {\n type: \"array\",\n items: {\n type: \"string\",\n enum: [\n \"cxo\",\n \"owner\",\n \"partner\",\n \"vp\",\n \"director\",\n \"manager\",\n \"senior\",\n \"entry\",\n ],\n },\n description:\n \"Acceptable seniority levels, e.g. 'CFO or VP Finance' -> ['cxo', 'vp']. Combined with title_role as a fallback matcher.\",\n },\n company: {\n type: \"string\",\n description:\n \"Target company name if the brief asks to source from a specific company\",\n },\n seniority: {\n type: \"string\",\n description:\n \"Seniority level, one of: cxo, vp, director, manager, senior, partner, owner, entry\",\n },\n location: {\n type: \"string\",\n description:\n \"City or region - use the simple common form, e.g. 'New York', 'San Francisco' (not 'SF Bay Area')\",\n },\n past_companies: {\n type: \"array\",\n items: { type: \"string\" },\n description:\n \"Previous employers the person must have on their resume - only when the brief asks, e.g. 'ex-Stripe' -> ['Stripe'], 'Big 4 background' -> ['Deloitte', 'PwC', 'EY', 'KPMG']\",\n },\n industries: {\n type: \"array\",\n items: { type: \"string\" },\n description:\n \"Industries of the candidate's CURRENT company, lowercase LinkedIn/PDL taxonomy. Give 2-4 plausible variants so one wrong guess doesn't zero out the search, e.g. B2B SaaS -> ['computer software', 'information technology and services', 'internet']. ONLY when the brief requires the candidate to currently work in that industry ('CFO at a SaaS company'). If the brief asks for past EXPERIENCE in an industry ('with ecommerce experience'), leave this empty and put the keywords in skills - experience lives in work history, which the ranking step sees.\",\n },\n company_sizes: {\n type: \"array\",\n items: {\n type: \"string\",\n enum: [\n \"1-10\",\n \"11-50\",\n \"51-200\",\n \"201-500\",\n \"501-1000\",\n \"1001-5000\",\n \"5001-10000\",\n \"10001+\",\n ],\n },\n description:\n \"Employee-count buckets for the current company - only when the brief implies scale, e.g. 'startup' -> ['1-10', '11-50', '51-200']. Include adjacent buckets for recall.\",\n },\n skills: {\n type: \"array\",\n items: { type: \"string\" },\n description:\n \"Skills or keywords likely to appear in a professional skills list, e.g. ['private equity', 'financial modeling', 'fundraising']\",\n },\n },\n required: [],\n additionalProperties: false,\n },\n },\n `Extract search filters from this recruiting brief:\\n\\n${brief}`,\n cost,\n ) as Filters;\n\n // Strip empty / zero-length values so buildPDLQuery gets clean input\n if (!result.title) delete result.title;\n if (!result.titles?.length) delete result.titles;\n if (!result.title_role) delete result.title_role;\n if (!result.title_levels?.length) delete result.title_levels;\n if (!result.company) delete result.company;\n if (!result.past_companies?.length) delete result.past_companies;\n if (!result.seniority) delete result.seniority;\n if (!result.location) delete result.location;\n if (!result.industries?.length) delete result.industries;\n if (!result.company_sizes?.length) delete result.company_sizes;\n if (!result.skills?.length) delete result.skills;\n\n return result;\n}\n\n// Step 2: rank PDL results with Claude\n\ninterface RankEntry {\n index: number;\n tier: 1 | 2 | 3;\n why: string;\n gaps: string[];\n}\n\nasync function rankCandidates(\n candidates: Candidate[],\n dossiers: Record[],\n brief: string,\n apiKey: string,\n cost?: Cost,\n): Promise {\n if (candidates.length === 0) return [];\n\n // Full dossiers (work history, education, skills, company metadata) - the more\n // evidence the ranker sees, the less it has to guess\n const numbered = dossiers.map((d, i) => ({ index: i, ...d }));\n\n const result = await callClaude(\n apiKey,\n \"claude-opus-4-8\", // quality judgment - use Opus\n 4096, // room for up to 25 ranked entries without clipping\n {\n name: \"rank_candidates\",\n description:\n \"Rank every candidate by fit for a role. Return all with tier, why, and gaps. Sort tier 1 -> 2 -> 3.\",\n input_schema: {\n type: \"object\",\n properties: {\n ranked: {\n type: \"array\",\n items: {\n type: \"object\",\n properties: {\n index: {\n type: \"integer\",\n description: \"Original 0-based index from the input list\",\n },\n tier: {\n type: \"integer\",\n enum: [1, 2, 3],\n description:\n \"1 = strong fit 2 = potential fit 3 = weak fit\",\n },\n why: {\n type: \"string\",\n description: \"1-2 sentences on fit with the brief\",\n },\n gaps: {\n type: \"array\",\n items: { type: \"string\" },\n description:\n \"Up to 3 missing qualifications or open questions\",\n },\n },\n required: [\"index\", \"tier\", \"why\", \"gaps\"],\n additionalProperties: false,\n },\n },\n },\n required: [\"ranked\"],\n additionalProperties: false,\n },\n },\n `You are an executive recruiter at a PE-focused search firm.\\n\\nROLE BRIEF:\\n${brief}\\n\\nCANDIDATES (${candidates.length} total, real records from a people-data provider):\\n${\n JSON.stringify(numbered)\n }\\n\\nReturn all ${candidates.length} candidates ranked by fit. Use tier 1 (strong), 2 (potential), 3 (weak). Weigh work history and trajectory, not just the current title - each past employer's industry is listed, so a stint at a 'venture capital & private equity' firm or a sponsor-backed operating company is hard evidence for PE-related briefs. Prefer recently verified records (job_last_verified) when fit is otherwise equal. Use your own knowledge of the companies named (sector, scale, ownership, PE backing) to inform fit - but keep verified data separate from inference: anything the data doesn't confirm belongs in gaps, not in why. Sort best first.`,\n cost,\n ) as { ranked: RankEntry[] };\n\n // Merge Claude's scores back onto the original PDL records\n const merged = (result.ranked ?? [])\n .filter((r) => r.index >= 0 && r.index < candidates.length)\n .map((r) => ({\n ...candidates[r.index],\n tier: r.tier,\n why: r.why,\n gaps: r.gaps ?? [],\n }));\n\n // Safety sort in case Claude didn't fully order them\n merged.sort((a, b) => a.tier - b.tier);\n return merged;\n}\n\n// PDL adapter\n\n// PDL's job_title_levels vocabulary - map common recruiter phrasing onto it\nconst LEVEL_MAP: Record = {\n \"c-suite\": \"cxo\",\n \"c_suite\": \"cxo\",\n \"c-level\": \"cxo\",\n \"c level\": \"cxo\",\n \"csuite\": \"cxo\",\n \"chief\": \"cxo\",\n \"executive\": \"cxo\",\n \"exec\": \"cxo\",\n \"cxo\": \"cxo\",\n \"vice president\": \"vp\",\n \"vice-president\": \"vp\",\n \"vp\": \"vp\",\n \"junior\": \"entry\",\n};\nfunction normalizeSeniority(s: string): string {\n const k = s.trim().toLowerCase();\n return LEVEL_MAP[k] ?? k.replace(/[\\s-]+/g, \"_\");\n}\n\ntype QueryMode = \"strict\" | \"soft_industry\" | \"soft\";\n\nfunction buildPDLQuery(filters: Filters, mode: QueryMode = \"strict\") {\n const must: unknown[] = [];\n const should: unknown[] = [];\n // Staged relaxation when a search returns nothing (zero-result searches cost no credits):\n // strict - location AND industry/size are hard filters\n // soft_industry - industry/size demoted to ranking boosts; location stays hard\n // soft - location demoted too; only the title leg stays hard\n const locTarget = mode === \"soft\" ? should : must;\n const indTarget = mode === \"strict\" ? must : should;\n\n // Title: any of the parsed title phrases OR the role+levels taxonomy combo - the\n // taxonomy leg catches wordings no title list can enumerate (\"VP, Financial Planning\")\n const titleStrings = [\n ...(filters.titles ?? []),\n ...(filters.title ? [filters.title] : []),\n ].slice(0, 8);\n const titleLeg: unknown[] = titleStrings.map((t) => ({\n match_phrase: { job_title: t.toLowerCase() },\n }));\n if (filters.title_role && filters.title_levels?.length) {\n titleLeg.push({\n bool: {\n must: [\n { term: { job_title_role: filters.title_role.toLowerCase() } },\n {\n terms: {\n job_title_levels: filters.title_levels.map((l) =>\n l.toLowerCase()\n ),\n },\n },\n ],\n },\n });\n }\n if (titleLeg.length) must.push({ bool: { should: titleLeg } });\n\n if (filters.company) {\n must.push({ term: { job_company_name: filters.company.toLowerCase() } });\n }\n\n // Company-first mode: current employer must be ANY of the pre-screened companies\n if (filters.companies?.length) {\n must.push({\n bool: {\n should: filters.companies.map((co) => ({\n match_phrase: { job_company_name: co.toLowerCase() },\n })),\n },\n });\n }\n\n // Past employers - phrase match so \"Goldman Sachs\" doesn't loose-match \"Goldman Properties\"\n for (const pc of filters.past_companies ?? []) {\n must.push({\n match_phrase: { \"experience.company.name\": pc.toLowerCase() },\n });\n }\n\n // Location: match the person's own location OR their employer's. The free tier redacts\n // the person's home location in responses, but the company's location is fully visible -\n // that leg is the reliable one. (People mostly work near their employer; remote is the miss.)\n if (filters.location) {\n const loc = filters.location.toLowerCase();\n locTarget.push({\n bool: {\n should: [\n { match_phrase: { location_name: loc } },\n { term: { location_locality: loc } },\n { term: { location_region: loc } },\n { match_phrase: { job_company_location_name: loc } },\n { term: { job_company_location_locality: loc } },\n { term: { job_company_location_region: loc } },\n ],\n // NOTE: PDL rejects minimum_should_match - a bool with only `should` clauses\n // already requires at least one match by default\n },\n });\n }\n\n // terms = match ANY value in the list, so the parse step's 2-4 industry variants keep recall.\n // Checked against three fields: company industry (v1 + v2 taxonomies) and person industry.\n if (filters.industries?.length) {\n const inds = filters.industries.map((i) => i.toLowerCase());\n indTarget.push({\n bool: {\n should: [\n { terms: { job_company_industry: inds } },\n { terms: { job_company_industry_v2: inds } },\n { terms: { industry: inds } },\n ],\n },\n });\n }\n if (filters.company_sizes?.length) {\n indTarget.push({ terms: { job_company_size: filters.company_sizes } });\n }\n\n // Skip seniority when titles or levels are provided - they already imply it,\n // and stacking both over-constrains the query.\n if (\n filters.seniority && titleStrings.length === 0 &&\n !filters.title_levels?.length\n ) {\n must.push({\n term: { job_title_levels: normalizeSeniority(filters.seniority) },\n });\n }\n\n // Skills go in `should` (boost ranking) not `must` (hard filter) - PDL skill tags are\n // single words or short phrases; multi-word descriptors from Claude rarely match exactly.\n if (filters.skills?.length) {\n for (const s of filters.skills) {\n should.push({ term: { skills: s.toLowerCase() } });\n }\n }\n\n if (must.length === 0 && should.length === 0) return { match_all: {} };\n\n const boolQuery: Record = {};\n if (must.length) boolQuery.must = must;\n if (should.length) boolQuery.should = should;\n return { bool: boolQuery };\n}\n\n// PDL returns names lowercased - capitalize for display/CSV\nfunction titleCase(s: string): string {\n return s.replace(/\\b\\p{L}/gu, (ch) => ch.toUpperCase());\n}\n\n// Free-tier PDL redacts some fields by returning booleans - only accept real strings\nfunction str(v: unknown): string {\n return typeof v === \"string\" ? v : \"\";\n}\n\nfunction normalizePerson(p: Record): Candidate {\n const profiles = (p.profiles as Array<{ network: string; url: string }>) ??\n [];\n const github = profiles.find((x) => x.network === \"github\")?.url ?? \"\";\n const twitter = profiles.find((x) => x.network === \"twitter\")?.url ?? \"\";\n const indeed = profiles.find((x) => x.network === \"indeed\")?.url ?? \"\";\n\n const title = str(p.job_title);\n const company = str(p.job_company_name);\n const industry = str(p.job_company_industry);\n const size = str(p.job_company_size);\n const skills = ((p.skills as string[]) ?? []).filter((s) =>\n typeof s === \"string\"\n );\n\n const signals: string[] = [];\n if (title) signals.push(title);\n if (company) signals.push(`@ ${company}`);\n if (industry) signals.push(industry);\n if (size) signals.push(`${size} employees`);\n signals.push(...skills.slice(0, 3));\n\n const rawUrl = github || twitter || indeed || \"\"; // never surface LinkedIn\n\n // Person's home location is redacted on the free tier - fall back to the employer's\n // HQ (fully visible), labeled so it isn't mistaken for a confirmed home address\n const personLoc = str(p.location_name) ||\n [str(p.location_locality), str(p.location_region)].filter(Boolean).join(\n \", \",\n );\n const companyLoc = str(p.job_company_location_name).replace(\n /, united states$/,\n \"\",\n );\n const where = personLoc\n ? titleCase(personLoc)\n : companyLoc\n ? `${titleCase(companyLoc)} (company HQ)`\n : \"\";\n\n return {\n name: titleCase(str(p.full_name) || \"Unknown\"),\n html_url: rawUrl && !/^https?:\\/\\//i.test(rawUrl)\n ? `https://${rawUrl}`\n : rawUrl,\n where,\n why: `${title}${company ? ` at ${company}` : \"\"}`,\n signals,\n gaps: [],\n tier: 2, // overwritten by rankCandidates\n source: \"pdl\",\n };\n}\n\n// Everything potentially useful for ranking, pulled from the raw PDL record.\n// Redacted fields drop out automatically (str() returns \"\" -> undefined -> omitted by JSON).\n// Each past employer's industry/size/location is included - that's how the ranker can\n// spot PE/VC stints, startup-vs-enterprise patterns, and geography from work history.\nfunction buildDossier(p: Record): Record {\n const exp = ((p.experience as Array>) ?? [])\n .slice(0, 8)\n .map((e) => {\n const co = e.company as Record | undefined;\n const loc = co?.location as Record | undefined;\n return {\n title: str((e.title as Record | undefined)?.name),\n company: str(co?.name),\n industry: str(co?.industry) || undefined,\n size: str(co?.size) || undefined,\n location: str(loc?.name) || undefined,\n start: str(e.start_date) || undefined,\n end: str(e.end_date) || \"present\",\n };\n })\n .filter((e) => e.title || e.company);\n\n const seenSchools = new Set();\n const edu = ((p.education as Array>) ?? [])\n .map((e) => {\n const degrees = ((e.degrees as string[]) ?? []).filter((d) =>\n typeof d === \"string\"\n );\n const majors = ((e.majors as string[]) ?? []).filter((m) =>\n typeof m === \"string\"\n );\n return {\n school: str((e.school as Record | undefined)?.name),\n degrees: degrees.length ? degrees : undefined,\n majors: majors.length ? majors : undefined,\n };\n })\n // PDL often repeats a school with and without degree data - keep the first (richest) entry\n .filter((e) =>\n e.school && !seenSchools.has(e.school) &&\n (seenSchools.add(e.school), true)\n )\n .slice(0, 3);\n\n const skills = ((p.skills as string[]) ?? []).filter((s) =>\n typeof s === \"string\"\n ).slice(0, 25);\n\n return {\n name: titleCase(str(p.full_name) || \"Unknown\"),\n title: str(p.job_title) || undefined,\n company: str(p.job_company_name) || undefined,\n company_industry: str(p.job_company_industry) || undefined,\n company_size: str(p.job_company_size) || undefined,\n company_location: str(p.job_company_location_name) || undefined,\n company_founded: typeof p.job_company_founded === \"number\"\n ? p.job_company_founded\n : undefined,\n in_current_role_since: str(p.job_start_date) || undefined,\n job_last_verified: str(p.job_last_verified) || undefined,\n location: str(p.location_name) || undefined,\n country: str(p.location_country) || undefined,\n years_experience: typeof p.inferred_years_experience === \"number\"\n ? p.inferred_years_experience\n : undefined,\n summary: str(p.summary).slice(0, 400) || undefined,\n skills: skills.length ? skills : undefined,\n work_history: exp.length ? exp : undefined,\n education: edu.length ? edu : undefined,\n };\n}\n\ninterface SearchResult {\n candidates: Candidate[];\n dossiers: Record[];\n}\n\nasync function searchPDL(\n filters: Filters,\n size = 10,\n mode: QueryMode = \"strict\",\n cost?: Cost,\n): Promise {\n const apiKey = Deno.env.get(\"PDL_API_KEY\");\n if (!apiKey) throw new Error(\"PDL_API_KEY not configured\");\n\n const res = await fetch(\"https://api.peopledatalabs.com/v5/person/search\", {\n method: \"POST\",\n headers: { \"Content-Type\": \"application/json\", \"X-Api-Key\": apiKey },\n body: JSON.stringify({\n query: buildPDLQuery(filters, mode),\n size,\n dataset: \"all\",\n }),\n });\n\n // PDL returns 404 when no records match - not an error, and bills no credits\n if (res.status === 404) return { candidates: [], dossiers: [] };\n\n if (!res.ok) {\n const text = await res.text();\n throw new Error(`PDL ${res.status}: ${text}`);\n }\n\n const data = await res.json() as { data: Record[] };\n const people = data.data ?? [];\n // PDL bills one credit per record returned\n if (cost) cost.pdlCredits += people.length;\n return {\n candidates: people.map(normalizePerson),\n dossiers: people.map(buildDossier),\n };\n}\n\n// Web search (server-side, never LinkedIn)\n\nconst LINKEDIN_RE = /linkedin\\.com/i;\n\n// Belt-and-suspenders on top of the prompt rule: drop any LinkedIn URL that slips through\nfunction stripLinkedIn(url: string): string {\n return LINKEDIN_RE.test(url) ? \"\" : url;\n}\n\n// Run Claude with the web_search server tool, handling the pause_turn loop.\n// Returns the model's synthesized text. LinkedIn is forbidden in every web flow.\nasync function claudeWebSearch(\n apiKey: string,\n system: string,\n userText: string,\n maxUses = 3,\n cost?: Cost,\n): Promise {\n const webTool = {\n type: \"web_search_20260209\",\n name: \"web_search\",\n max_uses: maxUses,\n };\n const messages: Array> = [{\n role: \"user\",\n content: userText,\n }];\n let text = \"\";\n\n // Cap continuation rounds - each round is a full model turn, so fewer = faster\n // and far less likely to exceed the hosting platform's request timeout.\n for (let turn = 0; turn < 3; turn++) {\n // Sonnet (not Opus) for web search: ~2x faster, which keeps a multi-search call\n // inside the host's 60s request limit. Judgment-heavy steps (ranking,\n // normalization, verification) stay on Opus.\n const data = await anthropicFetch({\n model: \"claude-sonnet-4-6\",\n max_tokens: 3500,\n system,\n messages,\n tools: [webTool],\n }, apiKey) as {\n content: Array>;\n stop_reason: string;\n usage?: Record;\n };\n addUsage(cost, data.usage, \"claude-sonnet-4-6\");\n text = (data.content || [])\n .filter((b) => b.type === \"text\")\n .map((b) => b.text as string)\n .join(\"\\n\");\n // Long-running searches pause mid-turn - feed the partial assistant turn back and continue\n if (data.stop_reason === \"pause_turn\") {\n messages.push({ role: \"assistant\", content: data.content });\n continue;\n }\n break;\n }\n return text;\n}\n\n// Tavily web search - a dedicated search API. Much faster than claudeWebSearch\n// (~1-5s vs ~20-45s), so it keeps the web-search step well inside the 60s host limit.\n// Returns the SAME free-text \"notes\" shape claudeWebSearch produces, so the downstream\n// Claude extractor/normalizer is unchanged. LinkedIn excluded at the engine + as backstop.\nconst TAVILY_URL = \"https://api.tavily.com/search\";\nconst TAVILY_TIMEOUT_MS = 25000; // Tavily answers in seconds; generous, well under 60s\nconst TAVILY_BASIC_COST_USD = 0.008; // ~$8 / 1000 credits PAYG; $0 on the free 1000/mo tier\n\nasync function tavilySearch(\n apiKey: string,\n query: string,\n maxResults = 15,\n cost?: Cost,\n): Promise {\n const ctrl = new AbortController();\n const timer = setTimeout(() => ctrl.abort(), TAVILY_TIMEOUT_MS);\n let res: Response;\n try {\n res = await fetch(TAVILY_URL, {\n method: \"POST\",\n headers: {\n \"Content-Type\": \"application/json\",\n \"Authorization\": `Bearer ${apiKey}`,\n },\n body: JSON.stringify({\n query,\n search_depth: \"basic\", // 1 credit, fastest; \"advanced\" = 2 credits + deeper\n max_results: maxResults, // 0-20\n include_answer: false, // extraction/ranking happens in Claude, not Tavily\n include_raw_content: false, // snippets are enough and keep it fast\n exclude_domains: [\"linkedin.com\"], // engine-level no-LinkedIn (stripLinkedIn is backstop)\n }),\n signal: ctrl.signal,\n });\n } catch (e) {\n if ((e as Error)?.name === \"AbortError\") {\n throw new Error(\"Tavily request timed out. Try a narrower brief.\");\n }\n throw e;\n } finally {\n clearTimeout(timer);\n }\n\n if (cost) cost.usd += TAVILY_BASIC_COST_USD;\n\n if (!res.ok) {\n const text = await res.text();\n if (res.status === 401) {\n throw new Error(\n \"Tavily: invalid API key (401). Check TAVILY_API_KEY on the backend.\",\n );\n }\n if (res.status === 429) {\n throw new Error(\"Tavily quota/rate limit reached (429).\");\n }\n throw new Error(`Tavily error ${res.status}: ${text.slice(0, 200)}`);\n }\n\n const data = await res.json() as {\n results?: Array<{ title?: string; url?: string; content?: string }>;\n };\n // Drop any LinkedIn URL that slips past exclude_domains (subdomains etc.)\n const results = (data.results ?? []).filter((r) =>\n r.url && !LINKEDIN_RE.test(r.url)\n );\n\n // Empty results: return \"\" so callers can short-circuit and NOT spend on a downstream\n // Claude extraction over nothing.\n return results\n .map((r) =>\n `- ${r.title ?? \"\"}\\n URL: ${r.url}\\n ${\n (r.content ?? \"\").trim().slice(0, 300)\n }`\n )\n .join(\"\\n\");\n}\n\n// Pick the web-search engine for a request: Tavily by default, Claude if explicitly\n// chosen OR if no Tavily key is configured (so both engines stay usable).\nfunction resolveEngine(requested: string | undefined): \"tavily\" | \"claude\" {\n const wantTavily = (requested ?? \"tavily\") !== \"claude\";\n return (wantTavily && Deno.env.get(\"TAVILY_API_KEY\")) ? \"tavily\" : \"claude\";\n}\n\nconst WEB_SOURCE_SYS =\n `You are sourcing real, named people for an executive recruiter using web search. Craft high-yield queries targeting pages that list named individuals: company team/leadership/about pages, conference speaker rosters, \"top people in X\" lists, award pages, press releases announcing hires, podcast guest pages, Google Scholar. DO NOT use, cite, link to, or rely on LinkedIn in any way.\nExtract every specific individual you can (aim for 6-10) with: full name, current role + company, a public non-LinkedIn URL, and the concrete signal that matched the brief. Be honest if coverage is thin.`;\n\n// Normalize free-text web research into ranked candidates (shared candidate schema).\n// Sonnet (not Opus): this is mostly extraction + light tiering from web snippets, which\n// Sonnet handles well and ~2x faster — keeping it well inside the request timeout.\nasync function normalizeWebResults(\n notes: string,\n brief: string,\n apiKey: string,\n cost?: Cost,\n): Promise {\n const result = await callClaudeStream(\n apiKey,\n \"claude-sonnet-4-6\",\n 2000,\n {\n name: \"web_shortlist\",\n description: \"Turn web research notes into a ranked candidate shortlist.\",\n input_schema: {\n type: \"object\",\n properties: {\n candidates: {\n type: \"array\",\n items: {\n type: \"object\",\n properties: {\n name: { type: \"string\" },\n html_url: {\n type: \"string\",\n description:\n \"Public profile/source URL. NEVER a LinkedIn URL.\",\n },\n where: {\n type: \"string\",\n description: \"Role + company, plus location if known\",\n },\n tier: { type: \"integer\", enum: [1, 2, 3] },\n why: { type: \"string\" },\n signals: { type: \"array\", items: { type: \"string\" } },\n gaps: { type: \"array\", items: { type: \"string\" } },\n },\n required: [\n \"name\",\n \"html_url\",\n \"where\",\n \"tier\",\n \"why\",\n \"signals\",\n \"gaps\",\n ],\n additionalProperties: false,\n },\n },\n },\n required: [\"candidates\"],\n additionalProperties: false,\n },\n },\n `BRIEF:\\n${brief}\\n\\nWEB RESEARCH NOTES:\\n${notes}\\n\\nReturn only people actually found WITH a public non-LinkedIn URL. Never fabricate. Rank by fit: tier 1 strong, 2 potential, 3 weak.`,\n cost,\n 45000, // short timeout — web mode has been flaky; fail fast & clean rather than hang ~90s\n ) as { candidates: Array> };\n\n return (result.candidates ?? [])\n .map((c) => ({\n name: String(c.name ?? \"Unknown\"),\n html_url: stripLinkedIn(String(c.html_url ?? \"\")),\n where: String(c.where ?? \"\"),\n why: String(c.why ?? \"\"),\n signals: Array.isArray(c.signals) ? c.signals.map(String) : [],\n gaps: Array.isArray(c.gaps) ? c.gaps.map(String) : [],\n tier: typeof c.tier === \"number\" ? c.tier : 2,\n source: \"web\",\n }))\n .filter((c) => c.html_url); // drop anything that resolved to LinkedIn-only\n}\n\n// Company-first: web-find matching companies, then PDL by employer\n\nconst COMPANY_FIND_SYS =\n `You identify SPECIFIC, real companies that match a recruiter's brief, using web search. Focus on the company attributes in the brief (sector, location, funding stage, size). DO NOT use or cite LinkedIn. Prefer companies you can name with confidence from funding announcements, \"top companies\" lists, accelerator/VC portfolios, local business press, and company directories.`;\n\nasync function findCompanies(\n brief: string,\n apiKey: string,\n cost?: Cost,\n engine: \"tavily\" | \"claude\" = \"claude\",\n): Promise {\n let notes: string;\n if (engine === \"tavily\") {\n notes = await tavilySearch(\n Deno.env.get(\"TAVILY_API_KEY\")!,\n `Companies matching this recruiting brief (sector, location, funding stage, size). Name specific companies. Brief: ${brief}`,\n 15,\n cost,\n );\n } else {\n notes = await claudeWebSearch(\n apiKey,\n COMPANY_FIND_SYS,\n `Brief: ${brief}\\n\\nDo ONE focused web search, then list every specific matching company you can name (aim for 8-15). Don't run multiple searches — speed matters. No LinkedIn.`,\n 1,\n cost,\n );\n }\n if (!notes.trim()) return []; // no search hits — skip the extraction call entirely\n const result = await callClaude(\n apiKey,\n \"claude-sonnet-4-6\",\n 1024,\n {\n name: \"company_list\",\n description: \"Extract the specific company names from research notes.\",\n input_schema: {\n type: \"object\",\n properties: {\n companies: {\n type: \"array\",\n items: { type: \"string\" },\n description:\n \"Plain company names, no Inc/LLC suffixes unless part of the common name\",\n },\n },\n required: [\"companies\"],\n additionalProperties: false,\n },\n },\n `Extract every specific company named in these notes:\\n\\n${notes}`,\n cost,\n ) as { companies: string[] };\n return (result.companies ?? []).filter((co) =>\n typeof co === \"string\" && co.trim()\n ).slice(0, 40);\n}\n\n// GitHub adapter (ported from the static app, normalized to Candidate)\n\n// deno-lint-ignore no-explicit-any\nasync function ghFetch(url: string): Promise {\n const headers: Record = {\n \"Accept\": \"application/vnd.github+json\",\n };\n const token = Deno.env.get(\"GITHUB_TOKEN\");\n if (token) headers[\"Authorization\"] = \"Bearer \" + token;\n const res = await fetch(url, { headers });\n if (res.status === 403 || res.status === 429) {\n if (res.headers.get(\"x-ratelimit-remaining\") === \"0\") {\n throw new Error(\n \"GitHub rate limit hit. Add a GITHUB_TOKEN env var on the backend (60/hr -> 5000/hr).\",\n );\n }\n throw new Error(`GitHub blocked the request (${res.status}).`);\n }\n if (res.status === 404) {\n throw new Error(\"GitHub: not found (404). Check the repo/org name.\");\n }\n if (res.status === 422) {\n throw new Error(\"GitHub rejected the query (422). Try rephrasing.\");\n }\n if (!res.ok) throw new Error(`GitHub error ${res.status}.`);\n return res.json();\n}\n\nasync function parseGithubQuery(\n brief: string,\n apiKey: string,\n cost?: Cost,\n): Promise {\n const result = await callClaude(\n apiKey,\n \"claude-sonnet-4-6\",\n 256,\n {\n name: \"github_query\",\n description: \"Build a GitHub user-search query from a recruiting brief.\",\n input_schema: {\n type: \"object\",\n properties: {\n query: {\n type: \"string\",\n description:\n `GitHub user-search query. Qualifier-based, NOT semantic. Use qualifiers like location:\"City\", language:Lang, followers:>=N, repos:>=N, created: {\n if (!/\\btype:user\\b/.test(q)) q += \" type:user\";\n const d = await ghFetch(\n `https://api.github.com/search/users?q=${\n encodeURIComponent(q)\n }&sort=followers&order=desc&per_page=25`,\n );\n // deno-lint-ignore no-explicit-any\n return (d.items || []).map((i: any) => i.login);\n}\nasync function ghContributors(repo: string): Promise {\n const d = await ghFetch(\n `https://api.github.com/repos/${repo}/contributors?per_page=40`,\n );\n // deno-lint-ignore no-explicit-any\n return (d || []).map((u: any) => u.login);\n}\nasync function ghOrgMembers(org: string): Promise {\n const d = await ghFetch(\n `https://api.github.com/orgs/${\n encodeURIComponent(org)\n }/members?per_page=60`,\n );\n // deno-lint-ignore no-explicit-any\n return (d || []).map((u: any) => u.login);\n}\nasync function ghTopicOwners(topic: string, lang: string): Promise {\n const q = `topic:${topic}` + (lang ? ` language:${lang}` : \"\");\n const d = await ghFetch(\n `https://api.github.com/search/repositories?q=${\n encodeURIComponent(q)\n }&sort=stars&order=desc&per_page=40`,\n );\n const seen = new Set(), logins: string[] = [];\n // deno-lint-ignore no-explicit-any\n (d.items || []).forEach((r: any) => {\n if (r.owner && r.owner.type === \"User\" && !seen.has(r.owner.login)) {\n seen.add(r.owner.login);\n logins.push(r.owner.login);\n }\n });\n return logins;\n}\n\nasync function ghEnrich(login: string): Promise> {\n const u = await ghFetch(\n `https://api.github.com/users/${encodeURIComponent(login)}`,\n );\n const c: Record = {\n login: u.login,\n name: u.name || u.login,\n html_url: u.html_url,\n company: u.company || null,\n location: u.location || null,\n bio: u.bio || null,\n blog: u.blog || null,\n public_repos: u.public_repos,\n followers: u.followers,\n hireable: u.hireable,\n created_at: u.created_at,\n top_repos: [],\n };\n if (Deno.env.get(\"GITHUB_TOKEN\")) {\n try {\n const repos = await ghFetch(\n `https://api.github.com/users/${\n encodeURIComponent(login)\n }/repos?per_page=100&sort=pushed`,\n );\n // deno-lint-ignore no-explicit-any\n c.top_repos = (repos || []).filter((r: any) => !r.fork)\n // deno-lint-ignore no-explicit-any\n .sort((a: any, b: any) =>\n (b.stargazers_count || 0) - (a.stargazers_count || 0)\n )\n .slice(0, 5)\n // deno-lint-ignore no-explicit-any\n .map((r: any) => ({\n name: r.name,\n description: r.description,\n language: r.language,\n stars: r.stargazers_count,\n }));\n } catch { /* repo enrichment is best-effort */ }\n }\n return c;\n}\n\nfunction normalizeGithub(u: Record): Candidate {\n const company = (u.company as string) || \"\";\n const repos = (u.top_repos as Array>) ?? [];\n const langs = [\n ...new Set(repos.map((r) => r.language as string).filter(Boolean)),\n ].slice(0, 3);\n const signals: string[] = [];\n if (company) signals.push(company);\n if (typeof u.followers === \"number\") signals.push(`${u.followers} followers`);\n if (typeof u.public_repos === \"number\") {\n signals.push(`${u.public_repos} repos`);\n }\n signals.push(...langs);\n return {\n name: (u.name as string) || (u.login as string) || \"Unknown\",\n html_url: (u.html_url as string) || \"\",\n where: (u.location as string) || \"\",\n why: (u.bio as string) || company || \"GitHub developer\",\n signals,\n gaps: [],\n tier: 2,\n source: \"github\",\n };\n}\n\nasync function searchGithub(\n brief: string,\n apiKey: string | undefined,\n size: number,\n source: string,\n input: string,\n cost?: Cost,\n): Promise {\n let logins: string[] = [];\n if (source === \"repo\") {\n const repo = input.trim().replace(/^https?:\\/\\/github\\.com\\//, \"\");\n if (!/^[^/]+\\/[^/]+$/.test(repo)) {\n throw new Error(\"Enter the repo as owner/name, e.g. temporalio/temporal\");\n }\n logins = await ghContributors(repo);\n } else if (source === \"org\") {\n if (!input.trim()) throw new Error(\"Enter a GitHub org, e.g. stripe\");\n logins = await ghOrgMembers(input.trim());\n } else if (source === \"topic\") {\n const [topic, lang] = input.split(\"|\").map((s) => s.trim());\n if (!topic) throw new Error(\"Enter a topic, e.g. distributed-systems\");\n logins = await ghTopicOwners(topic, lang || \"\");\n } else {\n if (!brief) {\n throw new Error(\"Add a brief describing the developers you want\");\n }\n if (!apiKey) {\n throw new Error(\n \"ANTHROPIC_KEY needed to turn a brief into a GitHub query\",\n );\n }\n logins = await ghSearchUsers(await parseGithubQuery(brief, apiKey, cost));\n }\n\n const slice = logins.slice(0, size);\n const enriched: Record[] = [];\n for (const login of slice) {\n try {\n enriched.push(await ghEnrich(login));\n } catch (e) {\n if (String((e as Error).message).includes(\"rate limit\")) throw e; // hard stop on rate limit\n }\n }\n return { candidates: enriched.map(normalizeGithub), dossiers: enriched };\n}\n\n// Routes\n\n// Core search logic, split out so the route can wrap it with cache + cost tracking\n// Shared PDL tail: staged search (strict -> progressively softer) then Claude\n// ranking. Used by people mode and by company-first step 2.\nasync function pdlSearchAndRank(\n brief: string,\n effectiveFilters: Filters,\n size: number,\n anthropicKey: string | undefined,\n cost: Cost,\n): Promise<{ candidates: Candidate[]; relaxed: QueryMode | false }> {\n // Staged search: strict first, then progressively relax. Location is the filter\n // recruiters care most about, so it's the LAST thing to soften. Zero-result\n // searches cost no PDL credits, so failed attempts are free.\n let qmode: QueryMode = \"strict\";\n let { candidates: raw, dossiers } = await searchPDL(\n effectiveFilters,\n size,\n qmode,\n cost,\n );\n\n if (\n raw.length === 0 &&\n (effectiveFilters.industries?.length ||\n effectiveFilters.company_sizes?.length)\n ) {\n qmode = \"soft_industry\";\n ({ candidates: raw, dossiers } = await searchPDL(\n effectiveFilters,\n size,\n qmode,\n cost,\n ));\n }\n if (raw.length === 0 && effectiveFilters.location) {\n qmode = \"soft\";\n ({ candidates: raw, dossiers } = await searchPDL(\n effectiveFilters,\n size,\n qmode,\n cost,\n ));\n }\n const relaxed: QueryMode | false = qmode === \"strict\" ? false : qmode;\n\n if (brief && raw.length > 0 && anthropicKey) {\n const ranked = await rankCandidates(\n raw,\n dossiers,\n brief,\n anthropicKey,\n cost,\n );\n return { candidates: ranked, relaxed };\n }\n return { candidates: raw, relaxed };\n}\n\n// Brief -> structured PDL filters, with the keyword-title fallback\nasync function resolveFilters(\n brief: string,\n filters: Filters,\n hasFilters: boolean,\n anthropicKey: string | undefined,\n cost: Cost,\n): Promise {\n if (!hasFilters && brief && anthropicKey) {\n const parsed = await parseBriefToFilters(brief, anthropicKey, cost);\n const hasAny = Object.values(parsed).some(\n (v) => v !== undefined && v !== \"\" && (!Array.isArray(v) || v.length > 0),\n );\n return hasAny ? parsed : { title: brief };\n }\n return hasFilters ? filters : { title: brief };\n}\n\n// The two web-search modes run as TWO requests: a single Val Town free-tier\n// request is capped at 60s, and web search + PDL + ranking together exceed it.\n// /api/search does step 1 (the slow web search); /api/search/continue does the\n// PDL + ranking (company-first) or normalization (web). Each step fits in 60s.\nconst SPLIT_MODES = new Set([\"company-first\", \"web\"]);\n\napp.post(\"/api/search\", async (c) => {\n const body = await c.req.json().catch(() => ({})) as {\n brief?: string;\n filters?: Filters;\n size?: number;\n mode?: string; // people | company-first | github | web\n github_source?: string; // profile | repo | org | topic\n github_input?: string; // repo \"owner/name\", org name, or \"topic|lang\"\n nocache?: boolean; // skip the cache and force a fresh search\n engine?: string; // web-search engine for company-first/web: \"tavily\" | \"claude\"\n };\n\n const filters: Filters = body.filters ?? {};\n const brief = (body.brief ?? \"\").trim();\n const mode = body.mode || \"people\";\n const size = Math.max(1, Math.min(25, Number(body.size) || 10));\n const hasFilters = Object.values(filters).some((v) =>\n v !== undefined && v !== \"\"\n );\n const anthropicKey = Deno.env.get(\"ANTHROPIC_KEY\");\n const engine = resolveEngine(body.engine); // tavily by default, claude if chosen or no key\n\n // GitHub repo/org/topic searches don't need a brief; everything else does (or filters)\n const ghNeedsNoBrief = mode === \"github\" && body.github_source &&\n body.github_source !== \"profile\";\n if (!hasFilters && !brief && !ghNeedsNoBrief) {\n return c.json({ error: \"Provide a brief, or structured filters\" }, 400);\n }\n\n const githubSource = body.github_source || \"profile\";\n const githubInput = body.github_input || \"\";\n\n // Cache: an identical search returns the stored final result and spends nothing.\n // Include the engine so Tavily and Claude results cache separately (clean A/B).\n const cacheKey = await hashKey({\n mode,\n brief,\n filters,\n size,\n githubSource,\n githubInput,\n engine,\n });\n if (!body.nocache) {\n const hit = await cacheGet(cacheKey);\n if (hit) {\n return c.json({ ...hit, cached: true, cost: { usd: 0, pdlCredits: 0 } });\n }\n }\n\n const cost = newCost();\n try {\n // GitHub mode - single request (PDL-free, fits in 60s)\n if (mode === \"github\") {\n const { candidates, dossiers } = await searchGithub(\n brief,\n anthropicKey,\n size,\n githubSource,\n githubInput,\n cost,\n );\n let out: Candidate[] = candidates;\n if (brief && candidates.length && anthropicKey) {\n out = await rankCandidates(\n candidates,\n dossiers,\n brief,\n anthropicKey,\n cost,\n );\n }\n const payload = { candidates: out, mode, source: \"github\", cost };\n if (out.length) await cacheSet(cacheKey, payload);\n return c.json(payload);\n }\n\n // Company-first - STEP 1: discover matching companies on the web\n if (mode === \"company-first\") {\n const effectiveFilters = await resolveFilters(\n brief,\n filters,\n hasFilters,\n anthropicKey,\n cost,\n );\n let companiesFound: string[] | undefined;\n if (brief && anthropicKey) {\n // Companies already encode location/industry/stage, so drop those hard\n // filters to avoid double-constraining the PDL query in step 2.\n const companies = await findCompanies(\n brief,\n anthropicKey,\n cost,\n engine,\n );\n if (companies.length) {\n effectiveFilters.companies = companies;\n delete effectiveFilters.location;\n delete effectiveFilters.industries;\n delete effectiveFilters.company_sizes;\n companiesFound = companies;\n }\n }\n return c.json({\n stage: \"continue\",\n mode,\n effective_filters: effectiveFilters,\n companies_found: companiesFound,\n engine_used: engine,\n cost,\n });\n }\n\n // Web - STEP 1: search the public web for named people (Tavily or Claude)\n if (mode === \"web\") {\n if (!anthropicKey) throw new Error(\"ANTHROPIC_KEY not configured\"); // step 2 ranking needs it\n if (!brief) throw new Error(\"Web search needs a brief\");\n const notes = engine === \"tavily\"\n ? await tavilySearch(\n Deno.env.get(\"TAVILY_API_KEY\")!,\n `Named people (with current role and company) who fit this recruiting brief: ${brief}. Team pages, leadership bios, conference speakers, award lists, press releases.`,\n 10,\n cost,\n )\n : await claudeWebSearch(\n anthropicKey,\n WEB_SOURCE_SYS,\n `Brief: ${brief}\\nFind specific named people who fit. No LinkedIn.`,\n 2,\n cost,\n );\n // No web hits: short-circuit so step 2 doesn't spend an Opus call normalizing nothing\n if (!notes.trim()) {\n return c.json({\n candidates: [],\n mode,\n source: \"web\",\n engine_used: engine,\n cost,\n });\n }\n return c.json({\n stage: \"continue\",\n mode,\n notes,\n engine_used: engine,\n cost,\n });\n }\n\n // People mode - single request\n const effectiveFilters = await resolveFilters(\n brief,\n filters,\n hasFilters,\n anthropicKey,\n cost,\n );\n const { candidates, relaxed } = await pdlSearchAndRank(\n brief,\n effectiveFilters,\n size,\n anthropicKey,\n cost,\n );\n const payload = {\n candidates,\n filters_used: effectiveFilters,\n relaxed,\n mode,\n cost,\n };\n if (candidates.length) await cacheSet(cacheKey, payload);\n return c.json(payload);\n } catch (e) {\n return c.json({ error: e instanceof Error ? e.message : String(e) }, 500);\n }\n});\n\n// STEP 2 for the split web-search modes - finishes what /api/search started.\napp.post(\"/api/search/continue\", async (c) => {\n const body = await c.req.json().catch(() => ({})) as {\n brief?: string;\n filters?: Filters;\n size?: number;\n mode?: string;\n github_source?: string;\n github_input?: string;\n effective_filters?: Filters;\n companies_found?: string[];\n notes?: string;\n engine?: string;\n };\n const mode = body.mode || \"\";\n if (!SPLIT_MODES.has(mode)) {\n return c.json({ error: \"continue is only for company-first/web\" }, 400);\n }\n\n const brief = (body.brief ?? \"\").trim();\n const filters: Filters = body.filters ?? {};\n const size = Math.max(1, Math.min(25, Number(body.size) || 10));\n const anthropicKey = Deno.env.get(\"ANTHROPIC_KEY\");\n const githubSource = body.github_source || \"profile\";\n const githubInput = body.github_input || \"\";\n const engine = resolveEngine(body.engine);\n // Recompute the SAME cache key step 1 used (incl. engine) so the finished result gets cached\n const cacheKey = await hashKey({\n mode,\n brief,\n filters,\n size,\n githubSource,\n githubInput,\n engine,\n });\n\n const cost = newCost();\n try {\n let payload: Record;\n if (mode === \"company-first\") {\n const ef = body.effective_filters ?? {};\n const { candidates, relaxed } = await pdlSearchAndRank(\n brief,\n ef,\n size,\n anthropicKey,\n cost,\n );\n payload = {\n candidates,\n filters_used: ef,\n relaxed,\n mode,\n companies_found: body.companies_found,\n };\n } else {\n // web\n if (!anthropicKey) throw new Error(\"ANTHROPIC_KEY not configured\");\n const candidates = await normalizeWebResults(\n String(body.notes || \"\"),\n brief,\n anthropicKey,\n cost,\n );\n payload = { candidates, mode, source: \"web\" };\n }\n payload.cost = cost;\n if (\n Array.isArray(payload.candidates) &&\n (payload.candidates as unknown[]).length > 0\n ) {\n await cacheSet(cacheKey, payload);\n }\n return c.json(payload);\n } catch (e) {\n return c.json({ error: e instanceof Error ? e.message : String(e) }, 500);\n }\n});\n\n// POST /api/outreach - Claude-drafted first-touch message\napp.post(\"/api/outreach\", async (c) => {\n const body = await c.req.json().catch(() => ({})) as {\n candidate?: Candidate;\n brief?: string;\n };\n if (!body.candidate?.name) {\n return c.json({ error: \"candidate required\" }, 400);\n }\n const apiKey = Deno.env.get(\"ANTHROPIC_KEY\");\n if (!apiKey) return c.json({ error: \"ANTHROPIC_KEY not configured\" }, 500);\n\n const cost = newCost();\n try {\n const result = await callClaude(\n apiKey,\n \"claude-opus-4-8\",\n 1024,\n {\n name: \"draft_outreach\",\n description: \"Draft a first-touch recruiting email to a candidate.\",\n input_schema: {\n type: \"object\",\n properties: {\n subject: {\n type: \"string\",\n description: \"Short email subject line\",\n },\n message: {\n type: \"string\",\n description: \"The email body, 4-6 sentences, plain text\",\n },\n },\n required: [\"subject\", \"message\"],\n additionalProperties: false,\n },\n },\n `You are an executive recruiter writing a short, warm, honest first-touch message.\\n\\nROLE BRIEF:\\n${\n body.brief || \"(not provided)\"\n }\\n\\nCANDIDATE (real data - do not invent facts beyond it):\\n${\n JSON.stringify(body.candidate)\n }\\n\\nRules: reference ONE specific signal from the candidate's data; 4-6 sentences; no hype, no fake familiarity; be clear you're a recruiter; close with a low-pressure invitation to chat.`,\n cost,\n );\n return c.json({ ...result, cost });\n } catch (e) {\n return c.json({ error: e instanceof Error ? e.message : String(e) }, 500);\n }\n});\n\n// POST /api/verify - web-check one candidate's current role before outreach (never LinkedIn)\napp.post(\"/api/verify\", async (c) => {\n const body = await c.req.json().catch(() => ({})) as {\n candidate?: Candidate;\n };\n const cand = body.candidate;\n if (!cand?.name) return c.json({ error: \"candidate required\" }, 400);\n const apiKey = Deno.env.get(\"ANTHROPIC_KEY\");\n if (!apiKey) return c.json({ error: \"ANTHROPIC_KEY not configured\" }, 500);\n\n const cost = newCost();\n try {\n const notes = await claudeWebSearch(\n apiKey,\n `You verify a person's CURRENT role for a recruiter using web search. Confirm whether the stated role/company is still current, surface any newer role, and find one good public non-LinkedIn URL. DO NOT use or cite LinkedIn.`,\n `Person: ${cand.name}\\nStated role: ${cand.why}\\nLocation: ${cand.where}\\nFind their current role and a public source. No LinkedIn.`,\n 2,\n cost,\n );\n const result = await callClaude(\n apiKey,\n \"claude-opus-4-8\",\n 1024,\n {\n name: \"verification\",\n description: \"Structured verification of a candidate's current status.\",\n input_schema: {\n type: \"object\",\n properties: {\n status: {\n type: \"string\",\n enum: [\"confirmed\", \"changed\", \"unconfirmed\"],\n description:\n \"confirmed = stated role still current; changed = they moved; unconfirmed = web is silent\",\n },\n current_role: {\n type: \"string\",\n description: \"Best current role + company per the web, or empty\",\n },\n url: {\n type: \"string\",\n description: \"A public non-LinkedIn source URL, or empty\",\n },\n note: {\n type: \"string\",\n description: \"1-2 sentences on what the web shows\",\n },\n },\n required: [\"status\", \"current_role\", \"url\", \"note\"],\n additionalProperties: false,\n },\n },\n `CANDIDATE:\\n${\n JSON.stringify(cand)\n }\\n\\nWEB FINDINGS:\\n${notes}\\n\\nSummarize the verification honestly.`,\n cost,\n ) as Record;\n if (result.url) result.url = stripLinkedIn(String(result.url));\n return c.json({ ...result, cost });\n } catch (e) {\n return c.json({ error: e instanceof Error ? e.message : String(e) }, 500);\n }\n});\n\n// GET / - the web app now lives in its own val (see frontend.ts). This val is API-only.\napp.get(\n \"/\",\n (c) =>\n c.text(\n \"Find Candidates API. The web app runs in a separate val — open that val's URL and set THIS url as its Backend URL in Settings.\",\n ),\n);\n\nexport default app.fetch;","deleted","label",[107],"pulls","branches",1,"forks","envVars",{"_131":133,"_134":40},"connections",{"_131":40,"_132":40},"count","unfilledCount",4,"emptyCount",{"_18":106,"_20":107,"_108":109,"_110":-5,"_111":66,"_112":64,"_113":100,"_22":136,"_63":115,"_116":117,"_118":119,"_120":26,"_121":-5,"_137":138,"_83":139},["D",1782159309063],"children",[],[107],["D",1781022809094],{"_16":17,"_81":77},{"_16":17,"_75":17,"_76":77,"_33":34,"_78":79,"_80":26},{"_63":64,"_20":65,"_18":66,"_67":19,"_68":-5,"_69":-5,"_70":-5,"_71":-5,"_72":-5,"_73":21,"_74":17},"ctx",{"_56":-5,"_102":177,"_178":179,"_180":181,"_182":26,"_183":26,"_184":26,"_185":100,"_186":-5,"_187":-7,"_188":-7,"_189":40,"_190":26,"_191":26,"_192":-5,"_193":26,"_194":26,"_195":26,"_196":-5},"ENV",{"_148":149,"_150":151,"_152":65,"_153":154,"_155":156,"_157":158,"_159":160,"_161":162,"_163":164,"_165":166,"_167":168,"_169":170,"_171":172,"_173":174,"_175":176},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","RENDER_GIT_COMMIT","e87eb04e707cf64e7e532c8e8ec395f209e17f15","RENDER_GIT_BRANCH","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","CLOUDFLARE_TURNSTILE_SITE_KEY","0x4AAAAAACtaIZJH7s9rBMZ6","GOOGLE_CLIENT_ID","875989696899-jtsqkhlbdv5jrlsk8631p7ipjg3c6o62.apps.googleusercontent.com","STRIPE_PUBLISHABLE_KEY","pk_live_51N2zvWEpZTTLipIkVEwXrUG9AT0yeOOEYxszarZT1jpsZV58Ly6wlg3SltZpHN26CUalOBmUSY7adQRQiSkCZz2500qSXNkf8Y","API_URL","https://api.val.town",[],"preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","preferencesCloseBrackets","preferencesChatPanelState","preferencesDprint","preferencesDenofmt","notificationCount","flagDenols","isBusinessOrgMember","businessOrgHandle","isBusinessOrgAdmin","isHigherTownieTier","navCollapsed","currentOrgId"]