fullstackgtm 0.50.1 → 0.52.0

package/src/index.ts

@@ -1,4 +1,17 @@
 export { auditSnapshot, defaultPolicy } from "./audit.ts";
+export {
+  DEFAULT_ICP_DERIVATION_MODEL,
+  OPENROUTER_API_BASE,
+  deriveWebsiteIcp,
+  normalizeCompanyWebsite,
+  websiteText,
+  icpReviewSegments,
+  type WebsiteIcpDerivation,
+  type WebsiteIcpEvidence,
+  type IcpReviewSegment,
+  type IcpDerivationProgress,
+} from "./icpDerive.ts";
+
 export {
   acquireCheckpointId,
   acquireCheckpointsDir,
@@ -55,6 +68,20 @@ export {
   type RulePackageTrust,
 } from "./config.ts";
 export { applyPatchPlan, type ApplyPatchPlanOptions } from "./connector.ts";
+export {
+  CONTACT_PROVIDER_CAPABILITIES,
+  runContactWaterfall,
+  validateContactWaterfall,
+  type ContactField,
+  type ContactInputShape,
+  type ContactProviderAdapter,
+  type ContactProviderBilling,
+  type ContactProviderCapability,
+  type ContactProviderExecution,
+  type ContactWaterfallAttempt,
+  type ContactWaterfallResult,
+  type ContactWaterfallStep,
+} from "./contactProviders.ts";
 export {
   APPLY_STAGES,
   BACKFILL_STRIPE_STAGES,
@@ -70,6 +97,17 @@ export {
   type ProgressSnapshot,
 } from "./progress.ts";
 export { createHubspotConnector, type HubspotConnectorOptions } from "./connectors/hubspot.ts";
+export {
+  CLAY_PUBLIC_API_BASE,
+  clayApiKey,
+  createClaySearch,
+  normalizeClayPerson,
+  runClayPeopleSearchPage,
+  validateClayApiKey,
+  type ClayPeopleSearchPage,
+  type ClaySearchSourceType,
+  type ClayKeyValidation,
+} from "./connectors/clay.ts";
 export {
   DEFAULT_LOOPBACK_PORT,
   DEFAULT_OAUTH_SCOPES,

package/src/init.ts

@@ -19,7 +19,7 @@ import { builtinAcquirePreset, ENRICH_CONFIG_FILE_NAME, type EnrichConfig } from
 import { DEFAULT_FIT_THRESHOLD, type Icp } from "./icp.ts";
 
 export type InitProvider = "hubspot" | "salesforce";
-export type InitSource = "pipe0" | "explorium" | "linkedin";
+export type InitSource = "pipe0" | "explorium" | "clay" | "linkedin";
 
 export type ScaffoldOptions = {
   /** discovery source the acquire preset + playbook are wired for. Default "pipe0". */
@@ -63,7 +63,7 @@ export function starterIcp(): Icp {
 export function starterEnrichConfig(source: InitSource): EnrichConfig {
   const preset = builtinAcquirePreset(source);
   if (!preset?.acquire) {
-    // builtinAcquirePreset covers pipe0/explorium/linkedin, so this is unreachable
+    // builtinAcquirePreset covers pipe0/explorium/clay/linkedin, so this is unreachable
     // for the typed InitSource set — guard anyway rather than emit a broken file.
     throw new Error(`init: no acquire preset for source "${source}"`);
   }

package/src/llm.ts

@@ -119,6 +119,10 @@ export type LlmCallOptions = {
    * endpoint). Origin → `/v1/chat/completions` appended; a base ending in
    * `/chat/completions` is used verbatim. Threaded from `OPENAI_API_BASE_URL`. */
   openaiBaseUrl?: string;
+  /** Optional OpenAI-compatible streaming telemetry. Raw reasoning text is
+   * deliberately not exposed; only provider-authored summaries and activity. */
+  onReasoningSummary?: (summary: string) => void;
+  onReasoningActivity?: (receivedCharacters: number) => void;
 };
 
 export type LlmExtractedInsight = ExtractedCallInsight & {
@@ -448,15 +452,19 @@ export async function forcedToolCall(
     return block.input;
   }
   const openaiUrl = resolveLlmUrl(options.openaiBaseUrl, OPENAI_URL, "/v1/chat/completions");
+  const requestBody = {
+    model,
+    messages: [{ role: "user", content: prompt }],
+    tools: [{ type: "function", function: { name: toolName, parameters: schema } }],
+    tool_choice: { type: "function", function: { name: toolName } },
+  };
+  if (options.onReasoningSummary || options.onReasoningActivity) {
+    return streamOpenAiToolCall(fetchImpl, openaiUrl, requestBody, options);
+  }
   const response = await llmFetch(fetchImpl, openaiUrl, {
     method: "POST",
     headers: { Authorization: `Bearer ${options.apiKey}`, "Content-Type": "application/json" },
-    body: JSON.stringify({
-      model,
-      messages: [{ role: "user", content: prompt }],
-      tools: [{ type: "function", function: { name: toolName, parameters: schema } }],
-      tool_choice: { type: "function", function: { name: toolName } },
-    }),
+    body: JSON.stringify(requestBody),
   });
   const call = (response as { choices?: Array<{ message?: { tool_calls?: Array<{ function?: { arguments?: string } }> } }> })
     .choices?.[0]?.message?.tool_calls?.[0];
@@ -464,6 +472,63 @@ export async function forcedToolCall(
   return JSON.parse(call.function.arguments);
 }
 
+async function streamOpenAiToolCall(
+  fetchImpl: typeof fetch,
+  url: string,
+  body: object,
+  options: LlmCallOptions,
+): Promise<unknown> {
+  let response: Response;
+  try {
+    response = await fetchImpl(url, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${options.apiKey}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ ...body, stream: true, reasoning: { enabled: true, exclude: false } }),
+    });
+  } catch (error) {
+    const cause = error instanceof Error && error.cause instanceof Error ? `: ${error.cause.message}` : "";
+    throw new Error(`Cannot reach ${new URL(url).hostname}${cause}. Check network access.`);
+  }
+  if (!response.ok) throw new Error(`LLM API error ${response.status} ${response.statusText} from ${new URL(url).hostname}. Check the API key and model name.`);
+  if (!response.body) throw new Error("LLM API returned no streaming response body.");
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let argumentsJson = "";
+  let reasoningCharacters = 0;
+  let lastActivityReport = 0;
+  const seenSummaries = new Set<string>();
+  while (true) {
+    const { value, done } = await reader.read();
+    buffer += decoder.decode(value, { stream: !done });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      if (!line.startsWith("data:")) continue;
+      const data = line.slice(5).trim();
+      if (!data || data === "[DONE]") continue;
+      let chunk: { choices?: Array<{ delta?: { reasoning?: string; reasoning_details?: Array<{ type?: string; summary?: string; text?: string }>; tool_calls?: Array<{ function?: { arguments?: string } }> } }> };
+      try { chunk = JSON.parse(data); } catch { continue; }
+      const delta = chunk.choices?.[0]?.delta;
+      argumentsJson += delta?.tool_calls?.[0]?.function?.arguments ?? "";
+      reasoningCharacters += delta?.reasoning?.length ?? 0;
+      for (const detail of delta?.reasoning_details ?? []) {
+        reasoningCharacters += detail.text?.length ?? detail.summary?.length ?? 0;
+        if (detail.type !== "reasoning.summary" || !detail.summary) continue;
+        const summary = detail.summary.replace(/\s+/g, " ").trim();
+        if (summary && !seenSummaries.has(summary)) { seenSummaries.add(summary); options.onReasoningSummary?.(summary); }
+      }
+      if (reasoningCharacters - lastActivityReport >= 800) {
+        lastActivityReport = reasoningCharacters;
+        options.onReasoningActivity?.(reasoningCharacters);
+      }
+    }
+    if (done) break;
+  }
+  if (!argumentsJson) throw new Error("OpenAI-compatible model returned no streamed tool call — try again or a different --model.");
+  return JSON.parse(argumentsJson);
+}
+
 async function llmFetch(fetchImpl: typeof fetch, url: string, init: RequestInit): Promise<unknown> {
   let response: Response;
   try {

package/src/publicHttp.ts

@@ -84,9 +84,15 @@ export type PublicRequestHop = (url: URL, addresses: PublicAddress[], headers: R
 
 const requestHop: PublicRequestHop = (url, addresses, headers, timeoutMs, maxBytes) => new Promise((resolve, reject) => {
   let cursor = 0;
-  const options: RequestOptions = {
+  const options: RequestOptions & { autoSelectFamily?: boolean } = {
     protocol: url.protocol, hostname: url.hostname, port: url.port || undefined,
     path: `${url.pathname}${url.search}`, method: "GET", headers,
+    // Node 20+ enables family autoselection by default and calls custom lookup
+    // functions with `{ all: true }`. This transport already resolved and
+    // validated every address, then pins one exact address per socket attempt;
+    // disable the second selection layer so the callback keeps the classic
+    // single-address contract and can never fall back to system DNS.
+    autoSelectFamily: false,
     lookup: (_hostname, options, callback) => {
       const requestedFamily = typeof options === "number" ? options : options?.family;
       const eligible = requestedFamily ? addresses.filter((a) => a.family === requestedFamily) : addresses;