fullstackgtm 0.51.0 → 0.52.1

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 llmApiError(response, url);
+  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 {
@@ -474,11 +539,23 @@ async function llmFetch(fetchImpl: typeof fetch, url: string, init: RequestInit)
   }
   if (!response.ok) {
     // Status line only — provider error bodies can reflect request content.
-    throw new Error(`LLM API error ${response.status} ${response.statusText} from ${new URL(url).hostname}. Check the API key (\`fullstackgtm login anthropic|openai\`) and model name.`);
+    throw llmApiError(response, url);
   }
   return response.json();
 }
 
+function llmApiError(response: Response, url: string): Error {
+  const host = new URL(url).hostname;
+  const prefix = `LLM API error ${response.status} ${response.statusText} from ${host}.`;
+  if ((response.status === 401 || response.status === 403) && host === "openrouter.ai") {
+    return new Error(`${prefix} Replace the saved key with \`fullstackgtm login openrouter\`. If OPENROUTER_API_KEY is set, update or unset it first because environment credentials override saved login.`);
+  }
+  if (response.status === 401 || response.status === 403) {
+    return new Error(`${prefix} Replace the API key with \`fullstackgtm login anthropic|openai\` (choose one provider), then retry.`);
+  }
+  return new Error(`${prefix} Check the model name, provider availability, and account limits.`);
+}
+
 function truncateTranscript(transcript: string): string {
   if (transcript.length <= MAX_TRANSCRIPT_CHARS) return transcript;
   const half = MAX_TRANSCRIPT_CHARS / 2;

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;