@respan/cli 0.5.2 → 0.6.0

package/dist/hooks/gemini-cli.cjs

@@ -0,0 +1,825 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/hooks/gemini-cli.ts
+var fs2 = __toESM(require("node:fs"), 1);
+var os2 = __toESM(require("node:os"), 1);
+var path2 = __toESM(require("node:path"), 1);
+var import_node_child_process = require("node:child_process");
+
+// src/hooks/shared.ts
+var fs = __toESM(require("node:fs"), 1);
+var os = __toESM(require("node:os"), 1);
+var path = __toESM(require("node:path"), 1);
+function resolveTracesEndpoint(baseUrl) {
+  const DEFAULT = "https://api.respan.ai/api/v2/traces";
+  if (!baseUrl) return DEFAULT;
+  const normalized = baseUrl.replace(/\/+$/, "");
+  if (normalized.endsWith("/api")) return `${normalized}/v2/traces`;
+  return `${normalized}/api/v2/traces`;
+}
+var resolveTracingIngestEndpoint = resolveTracesEndpoint;
+var _logFile = null;
+var _debug = false;
+function initLogging(logFile, debug2) {
+  _logFile = logFile;
+  _debug = debug2;
+  const dir = path.dirname(logFile);
+  fs.mkdirSync(dir, { recursive: true });
+}
+function log(level, message) {
+  if (!_logFile) return;
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+  fs.appendFileSync(_logFile, `${ts} [${level}] ${message}
+`);
+}
+function debug(message) {
+  if (_debug) log("DEBUG", message);
+}
+var DEFAULT_BASE_URL = "https://api.respan.ai/api";
+function resolveCredentials() {
+  let apiKey = process.env.RESPAN_API_KEY ?? "";
+  let baseUrl = process.env.RESPAN_BASE_URL ?? DEFAULT_BASE_URL;
+  if (!apiKey) {
+    const credsFile = path.join(os.homedir(), ".respan", "credentials.json");
+    if (fs.existsSync(credsFile)) {
+      try {
+        const creds = JSON.parse(fs.readFileSync(credsFile, "utf-8"));
+        const configFile = path.join(os.homedir(), ".respan", "config.json");
+        let profile = "default";
+        if (fs.existsSync(configFile)) {
+          const cfg = JSON.parse(fs.readFileSync(configFile, "utf-8"));
+          profile = cfg.activeProfile ?? "default";
+        }
+        const cred = creds[profile] ?? {};
+        apiKey = cred.apiKey ?? cred.accessToken ?? "";
+        if (!baseUrl || baseUrl === DEFAULT_BASE_URL) {
+          baseUrl = cred.baseUrl ?? baseUrl;
+        }
+        if (baseUrl && !baseUrl.replace(/\/+$/, "").endsWith("/api")) {
+          baseUrl = baseUrl.replace(/\/+$/, "") + "/api";
+        }
+        if (apiKey) {
+          debug(`Using API key from credentials.json (profile: ${profile})`);
+        }
+      } catch (e) {
+        debug(`Failed to read credentials.json: ${e}`);
+      }
+    }
+  }
+  if (!apiKey) return null;
+  return { apiKey, baseUrl };
+}
+var KNOWN_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "customer_id",
+  "span_name",
+  "workflow_name",
+  "base_url",
+  "project_id"
+]);
+function loadRespanConfig(configPath) {
+  if (!fs.existsSync(configPath)) {
+    return { fields: {}, properties: {} };
+  }
+  try {
+    const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+      return { fields: {}, properties: {} };
+    }
+    const fields = {};
+    const properties = {};
+    for (const [k, v] of Object.entries(raw)) {
+      if (KNOWN_CONFIG_KEYS.has(k)) {
+        fields[k] = String(v);
+      } else {
+        properties[k] = String(v);
+      }
+    }
+    return { fields, properties };
+  } catch (e) {
+    debug(`Failed to load config from ${configPath}: ${e}`);
+    return { fields: {}, properties: {} };
+  }
+}
+function acquireLock(lockPath, timeoutMs = 5e3) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      fs.mkdirSync(lockPath);
+      return () => {
+        try {
+          fs.rmdirSync(lockPath);
+        } catch {
+        }
+      };
+    } catch {
+      const waitMs = Math.min(100, deadline - Date.now());
+      if (waitMs > 0) {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, waitMs);
+      }
+    }
+  }
+  debug("Could not acquire lock within timeout, proceeding without lock");
+  return () => {
+  };
+}
+function nowISO() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function parseTimestamp(ts) {
+  try {
+    const d = new Date(ts);
+    return isNaN(d.getTime()) ? null : d;
+  } catch {
+    return null;
+  }
+}
+function latencySeconds(start, end) {
+  const s = parseTimestamp(start);
+  const e = parseTimestamp(end);
+  if (s && e) return (e.getTime() - s.getTime()) / 1e3;
+  return void 0;
+}
+function truncate(text, maxChars = 4e3) {
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars) + "\n... (truncated)";
+}
+function addDefaultsToAll(spans) {
+  return spans;
+}
+function resolveSpanFields(config, defaults) {
+  const fields = config?.fields ?? {};
+  return {
+    workflowName: process.env.RESPAN_WORKFLOW_NAME ?? fields.workflow_name ?? defaults.workflowName,
+    spanName: process.env.RESPAN_SPAN_NAME ?? fields.span_name ?? defaults.spanName,
+    customerId: process.env.RESPAN_CUSTOMER_ID ?? fields.customer_id ?? ""
+  };
+}
+function buildMetadata(config, base = {}) {
+  const metadata = { ...base };
+  if (config?.properties) {
+    Object.assign(metadata, config.properties);
+  }
+  const envMetadata = process.env.RESPAN_METADATA;
+  if (envMetadata) {
+    try {
+      const extra = JSON.parse(envMetadata);
+      if (typeof extra === "object" && extra !== null) {
+        Object.assign(metadata, extra);
+      }
+    } catch {
+    }
+  }
+  return metadata;
+}
+function toOtlpValue(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string") return { stringValue: value };
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? { intValue: String(value) } : { doubleValue: value };
+  }
+  if (typeof value === "boolean") return { boolValue: value };
+  if (Array.isArray(value)) {
+    const values = value.map(toOtlpValue).filter(Boolean);
+    return { arrayValue: { values } };
+  }
+  if (typeof value === "object") {
+    const values = Object.entries(value).map(([k, v]) => {
+      const converted = toOtlpValue(v);
+      return converted ? { key: k, value: converted } : null;
+    }).filter(Boolean);
+    return { kvlistValue: { values } };
+  }
+  return { stringValue: String(value) };
+}
+function toOtlpAttributes(attrs) {
+  const result = [];
+  for (const [key, value] of Object.entries(attrs)) {
+    if (value === null || value === void 0) continue;
+    const converted = toOtlpValue(value);
+    if (converted) result.push({ key, value: converted });
+  }
+  return result;
+}
+function isoToNanos(iso) {
+  const d = new Date(iso);
+  if (isNaN(d.getTime())) return "0";
+  return String(BigInt(d.getTime()) * 1000000n);
+}
+function stringToTraceId(s) {
+  let hash = 0;
+  for (let i = 0; i < s.length; i++) {
+    hash = (hash << 5) - hash + s.charCodeAt(i) | 0;
+  }
+  let hash2 = 0;
+  for (let i = s.length - 1; i >= 0; i--) {
+    hash2 = (hash2 << 7) - hash2 + s.charCodeAt(i) | 0;
+  }
+  const hex1 = (hash >>> 0).toString(16).padStart(8, "0");
+  const hex2 = (hash2 >>> 0).toString(16).padStart(8, "0");
+  const hex3 = (s.length * 2654435761 >>> 0).toString(16).padStart(8, "0");
+  const hex4 = ((hash ^ hash2) >>> 0).toString(16).padStart(8, "0");
+  return (hex1 + hex2 + hex3 + hex4).slice(0, 32);
+}
+function stringToSpanId(s) {
+  let hash = 0;
+  for (let i = 0; i < s.length; i++) {
+    hash = (hash << 5) - hash + s.charCodeAt(i) | 0;
+  }
+  const hex1 = (hash >>> 0).toString(16).padStart(8, "0");
+  let hash2 = 0;
+  for (let i = s.length - 1; i >= 0; i--) {
+    hash2 = (hash2 << 3) - hash2 + s.charCodeAt(i) | 0;
+  }
+  const hex2 = (hash2 >>> 0).toString(16).padStart(8, "0");
+  return (hex1 + hex2).slice(0, 16);
+}
+function toOtlpPayload(spans) {
+  const otlpSpans = spans.map((span) => {
+    const attrs = {};
+    if (span.thread_identifier) attrs["respan.threads.thread_identifier"] = span.thread_identifier;
+    if (span.customer_identifier) attrs["respan.customer_params.customer_identifier"] = span.customer_identifier;
+    if (span.span_workflow_name) attrs["traceloop.workflow.name"] = span.span_workflow_name;
+    if (span.span_path) attrs["traceloop.entity.path"] = span.span_path;
+    const isRoot = !span.span_parent_id;
+    const isLlm = span.span_name.includes(".chat");
+    const isTool = span.span_name.startsWith("Tool:");
+    const isThinking = span.span_name.startsWith("Thinking") || span.span_name === "Reasoning";
+    if (isLlm) {
+      attrs["traceloop.span.kind"] = "task";
+      attrs["llm.request.type"] = "chat";
+    } else if (isTool) {
+      attrs["traceloop.span.kind"] = "tool";
+    } else if (isRoot) {
+      attrs["traceloop.span.kind"] = "workflow";
+    } else if (isThinking) {
+      attrs["traceloop.span.kind"] = "task";
+    }
+    if (span.model) attrs["gen_ai.request.model"] = span.model;
+    if (span.provider_id) attrs["gen_ai.system"] = span.provider_id;
+    if (span.prompt_tokens !== void 0) attrs["gen_ai.usage.prompt_tokens"] = span.prompt_tokens;
+    if (span.completion_tokens !== void 0) attrs["gen_ai.usage.completion_tokens"] = span.completion_tokens;
+    if (span.total_tokens !== void 0) attrs["llm.usage.total_tokens"] = span.total_tokens;
+    if (span.input) attrs["traceloop.entity.input"] = span.input;
+    if (span.output) attrs["traceloop.entity.output"] = span.output;
+    if (span.metadata && Object.keys(span.metadata).length > 0) {
+      attrs["respan.metadata"] = JSON.stringify(span.metadata);
+    }
+    attrs["respan.entity.log_method"] = "ts_tracing";
+    const startNanos = isoToNanos(span.start_time);
+    let endNanos = isoToNanos(span.timestamp);
+    if (startNanos === endNanos && span.latency && span.latency > 0) {
+      const startMs = new Date(span.start_time).getTime();
+      endNanos = String(BigInt(Math.round(startMs + span.latency * 1e3)) * 1000000n);
+    }
+    const otlpSpan = {
+      traceId: stringToTraceId(span.trace_unique_id),
+      spanId: stringToSpanId(span.span_unique_id),
+      name: span.span_name,
+      kind: isLlm ? 3 : 1,
+      // 3=CLIENT (LLM calls), 1=INTERNAL
+      startTimeUnixNano: startNanos,
+      endTimeUnixNano: endNanos,
+      attributes: toOtlpAttributes(attrs),
+      status: { code: 1 }
+      // STATUS_CODE_OK
+    };
+    if (span.span_parent_id) {
+      otlpSpan.parentSpanId = stringToSpanId(span.span_parent_id);
+    }
+    return otlpSpan;
+  });
+  return {
+    resourceSpans: [{
+      resource: {
+        attributes: toOtlpAttributes({
+          "service.name": "respan-cli-hooks"
+        })
+      },
+      scopeSpans: [{
+        scope: { name: "respan-cli-hooks", version: "0.5.3" },
+        spans: otlpSpans
+      }]
+    }]
+  };
+}
+
+// src/hooks/gemini-cli.ts
+var STATE_DIR = path2.join(os2.homedir(), ".gemini", "state");
+var LOG_FILE = path2.join(STATE_DIR, "respan_hook.log");
+var LOCK_PATH = path2.join(STATE_DIR, "respan_hook.lock");
+var DEBUG_MODE = (process.env.GEMINI_RESPAN_DEBUG ?? "").toLowerCase() === "true";
+var MAX_CHARS = parseInt(process.env.GEMINI_RESPAN_MAX_CHARS ?? "4000", 10) || 4e3;
+var SEND_DELAY = parseInt(process.env.GEMINI_RESPAN_SEND_DELAY ?? "10", 10) || 10;
+initLogging(LOG_FILE, DEBUG_MODE);
+var TOOL_DISPLAY_NAMES = {
+  read_file: "File Read",
+  read_many_files: "File Read",
+  write_file: "File Write",
+  list_directory: "Directory List",
+  run_shell_command: "Shell",
+  google_web_search: "Web Search",
+  web_fetch: "Web Fetch",
+  glob: "Find Files",
+  grep_search: "Search Text",
+  search_file_content: "Search Text",
+  replace: "File Edit",
+  save_memory: "Memory",
+  write_todos: "Todos",
+  get_internal_docs: "Docs"
+};
+function toolDisplayName(name) {
+  return TOOL_DISPLAY_NAMES[name] ?? (name || "Unknown");
+}
+function formatToolInput(toolName, args) {
+  if (!args) return "";
+  const a = args;
+  if (toolName === "run_shell_command" && typeof a === "object") {
+    const cmd = String(a.command ?? "");
+    const dir = String(a.dir_path ?? "");
+    return truncate(dir ? `[${dir}] Command: ${cmd}` : `Command: ${cmd}`, MAX_CHARS);
+  }
+  if (["read_file", "write_file"].includes(toolName) && typeof a === "object")
+    return truncate(String(a.file_path ?? JSON.stringify(a)), MAX_CHARS);
+  if (toolName === "read_many_files" && typeof a === "object")
+    return truncate(String(a.include ?? JSON.stringify(a)), MAX_CHARS);
+  if (toolName === "google_web_search" && typeof a === "object")
+    return truncate(`Query: ${a.query ?? String(a)}`, MAX_CHARS);
+  if (["glob", "grep_search", "search_file_content"].includes(toolName) && typeof a === "object")
+    return truncate(String(a.pattern ?? JSON.stringify(a)), MAX_CHARS);
+  if (toolName === "replace" && typeof a === "object") {
+    const fp = String(a.file_path ?? "");
+    const old = String(a.old_string ?? "");
+    if (fp && old) return truncate(`${fp}: ${JSON.stringify(old)} \u2192 ...`, MAX_CHARS);
+  }
+  try {
+    return truncate(JSON.stringify(args, null, 2), MAX_CHARS);
+  } catch {
+  }
+  return truncate(String(args), MAX_CHARS);
+}
+function statePath(sessionId) {
+  const safeId = sessionId.replace(/[/\\]/g, "_").slice(0, 64);
+  return path2.join(STATE_DIR, `respan_stream_${safeId}.json`);
+}
+function loadStreamState(sessionId) {
+  const p = statePath(sessionId);
+  if (fs2.existsSync(p)) {
+    try {
+      return JSON.parse(fs2.readFileSync(p, "utf-8"));
+    } catch {
+    }
+  }
+  return { accumulated_text: "", last_tokens: 0, first_chunk_time: "" };
+}
+function saveStreamState(sessionId, state) {
+  const p = statePath(sessionId);
+  fs2.mkdirSync(path2.dirname(p), { recursive: true });
+  const tmp = p + ".tmp." + process.pid;
+  try {
+    fs2.writeFileSync(tmp, JSON.stringify(state));
+    fs2.renameSync(tmp, p);
+  } catch {
+    try {
+      fs2.unlinkSync(tmp);
+    } catch {
+    }
+    fs2.writeFileSync(p, JSON.stringify(state));
+  }
+}
+function clearStreamState(sessionId) {
+  try {
+    fs2.unlinkSync(statePath(sessionId));
+  } catch {
+  }
+}
+function extractMessages(hookData) {
+  const llmReq = hookData.llm_request ?? {};
+  const messages = llmReq.messages ?? [];
+  return messages.map((msg) => ({
+    role: String(msg.role ?? "user") === "model" ? "assistant" : String(msg.role ?? "user"),
+    content: truncate(String(msg.content ?? ""), MAX_CHARS)
+  }));
+}
+function detectModel(hookData) {
+  const override = process.env.RESPAN_GEMINI_MODEL;
+  if (override) return override;
+  const llmReq = hookData.llm_request ?? {};
+  return String(llmReq.model ?? "") || "gemini-cli";
+}
+function buildSpans(hookData, outputText, tokens, config, startTimeIso, toolTurns, toolDetails, thoughtsTokens) {
+  const spans = [];
+  const sessionId = String(hookData.session_id ?? "");
+  const model = detectModel(hookData);
+  const now = nowISO();
+  const endTime = String(hookData.timestamp ?? "") || now;
+  const beginTime = startTimeIso || endTime;
+  const lat = latencySeconds(beginTime, endTime);
+  const promptMessages = extractMessages(hookData);
+  const completionMessage = { role: "assistant", content: truncate(outputText, MAX_CHARS) };
+  const { workflowName, spanName, customerId } = resolveSpanFields(config, {
+    workflowName: "gemini-cli",
+    spanName: "gemini-cli"
+  });
+  const safeId = sessionId.replace(/[/\\]/g, "_").slice(0, 50);
+  const traceUniqueId = `gcli_${safeId}`;
+  const rootSpanId = `gcli_${safeId}_root`;
+  const threadId = `gcli_${sessionId}`;
+  const llmReq = hookData.llm_request ?? {};
+  const reqConfig = llmReq.config ?? {};
+  const baseMeta = { source: "gemini-cli" };
+  if (toolTurns > 0) baseMeta.tool_turns = toolTurns;
+  if (thoughtsTokens > 0) baseMeta.reasoning_tokens = thoughtsTokens;
+  const metadata = buildMetadata(config, baseMeta);
+  spans.push({
+    trace_unique_id: traceUniqueId,
+    thread_identifier: threadId,
+    customer_identifier: customerId,
+    span_unique_id: rootSpanId,
+    span_name: spanName,
+    span_workflow_name: workflowName,
+    model,
+    provider_id: "",
+    span_path: "",
+    input: promptMessages.length ? JSON.stringify(promptMessages) : "",
+    output: JSON.stringify(completionMessage),
+    timestamp: endTime,
+    start_time: beginTime,
+    metadata,
+    ...lat !== void 0 ? { latency: lat } : {}
+  });
+  const genSpan = {
+    trace_unique_id: traceUniqueId,
+    span_unique_id: `gcli_${safeId}_gen`,
+    span_parent_id: rootSpanId,
+    span_name: "gemini.chat",
+    span_workflow_name: workflowName,
+    span_path: "gemini_chat",
+    model,
+    provider_id: "google",
+    metadata: {},
+    input: promptMessages.length ? JSON.stringify(promptMessages) : "",
+    output: JSON.stringify(completionMessage),
+    timestamp: endTime,
+    start_time: beginTime,
+    prompt_tokens: tokens.prompt_tokens,
+    completion_tokens: tokens.completion_tokens,
+    total_tokens: tokens.total_tokens,
+    ...lat !== void 0 ? { latency: lat } : {}
+  };
+  if (reqConfig.temperature != null) genSpan.temperature = reqConfig.temperature;
+  if (reqConfig.maxOutputTokens != null) genSpan.max_tokens = reqConfig.maxOutputTokens;
+  spans.push(genSpan);
+  if (thoughtsTokens > 0) {
+    spans.push({
+      trace_unique_id: traceUniqueId,
+      span_unique_id: `gcli_${safeId}_reasoning`,
+      span_parent_id: rootSpanId,
+      span_name: "Reasoning",
+      span_workflow_name: workflowName,
+      span_path: "reasoning",
+      provider_id: "",
+      metadata: { reasoning_tokens: thoughtsTokens },
+      input: "",
+      output: `[Reasoning: ${thoughtsTokens} tokens]`,
+      timestamp: endTime,
+      start_time: beginTime
+    });
+  }
+  for (let i = 0; i < toolTurns; i++) {
+    const detail = toolDetails[i] ?? null;
+    const toolName = detail?.name ?? "";
+    const toolArgs = detail?.args ?? detail?.input ?? {};
+    const toolOutput = detail?.output ?? "";
+    const displayName = toolName ? toolDisplayName(toolName) : `Call ${i + 1}`;
+    const toolInputStr = toolName ? formatToolInput(toolName, toolArgs) : "";
+    const toolMeta = {};
+    if (toolName) toolMeta.tool_name = toolName;
+    if (detail?.error) toolMeta.error = detail.error;
+    const toolStart = detail?.start_time ?? beginTime;
+    const toolEnd = detail?.end_time ?? endTime;
+    const toolLat = latencySeconds(toolStart, toolEnd);
+    spans.push({
+      trace_unique_id: traceUniqueId,
+      span_unique_id: `gcli_${safeId}_tool_${i + 1}`,
+      span_parent_id: rootSpanId,
+      span_name: `Tool: ${displayName}`,
+      span_workflow_name: workflowName,
+      span_path: toolName ? `tool_${toolName}` : "tool_call",
+      provider_id: "",
+      metadata: toolMeta,
+      input: toolInputStr,
+      output: truncate(toolOutput, MAX_CHARS),
+      timestamp: toolEnd,
+      start_time: toolStart,
+      ...toolLat !== void 0 ? { latency: toolLat } : {}
+    });
+  }
+  return addDefaultsToAll(spans);
+}
+function sendSpansDetached(spans, apiKey, baseUrl) {
+  const url = resolveTracingIngestEndpoint(baseUrl);
+  debug(`Sending ${spans.length} span(s) to ${url}: ${spans.map((s) => s.span_name).join(", ")}`);
+  if (DEBUG_MODE) {
+    const debugFile = path2.join(STATE_DIR, "respan_last_payload.json");
+    fs2.writeFileSync(debugFile, JSON.stringify(spans, null, 2));
+  }
+  const payloadFile = path2.join(STATE_DIR, `respan_send_${process.pid}.json`);
+  fs2.writeFileSync(payloadFile, JSON.stringify(toOtlpPayload(spans)));
+  const senderScript = `
+const fs = require('fs');
+const pf = ${JSON.stringify(payloadFile)};
+try {
+  const data = fs.readFileSync(pf);
+  (async () => {
+    for (let i = 0; i < 3; i++) {
+      try {
+        const r = await fetch(${JSON.stringify(url)}, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'X-Respan-Dogfood': '1',
+            'Authorization': 'Bearer ' + process.env.RESPAN_API_KEY,
+          },
+          body: data,
+          signal: AbortSignal.timeout(30000),
+        });
+        if (r.status < 500) break;
+        if (i < 2) await new Promise(r => setTimeout(r, 1000));
+      } catch(e) {
+        if (i < 2) await new Promise(r => setTimeout(r, 1000));
+      }
+    }
+  })().finally(() => { try { fs.unlinkSync(pf); } catch {} });
+} catch(e) { try { fs.unlinkSync(pf); } catch {} }
+`;
+  const env = { ...process.env, RESPAN_API_KEY: apiKey };
+  try {
+    const child = (0, import_node_child_process.execFile)("node", ["-e", senderScript], {
+      env,
+      stdio: "ignore",
+      detached: true
+    });
+    child.unref();
+    debug("Launched sender subprocess");
+  } catch (e) {
+    log("ERROR", `Failed to launch sender: ${e}`);
+    try {
+      fs2.unlinkSync(payloadFile);
+    } catch {
+    }
+  }
+}
+function launchDelayedSend(sessionId, sendVersion, spans, apiKey, baseUrl) {
+  const payloadFile = path2.join(STATE_DIR, `respan_delayed_${process.pid}.json`);
+  fs2.writeFileSync(payloadFile, JSON.stringify(toOtlpPayload(spans)));
+  const stateFile = statePath(sessionId);
+  const url = resolveTracingIngestEndpoint(baseUrl);
+  const script = `
+const fs = require('fs');
+setTimeout(async () => {
+  const sf = ${JSON.stringify(stateFile)};
+  const pf = ${JSON.stringify(payloadFile)};
+  try {
+    if (!fs.existsSync(sf)) { fs.unlinkSync(pf); process.exit(0); }
+    const state = JSON.parse(fs.readFileSync(sf, 'utf-8'));
+    if (state.send_version !== ${sendVersion}) { fs.unlinkSync(pf); process.exit(0); }
+    const data = fs.readFileSync(pf);
+    for (let i = 0; i < 3; i++) {
+      try {
+        const r = await fetch(${JSON.stringify(url)}, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'X-Respan-Dogfood': '1',
+            'Authorization': 'Bearer ' + process.env.RESPAN_API_KEY,
+          },
+          body: data,
+          signal: AbortSignal.timeout(30000),
+        });
+        if (r.status < 500) break;
+        if (i < 2) await new Promise(r => setTimeout(r, 1000));
+      } catch(e) { if (i < 2) await new Promise(r => setTimeout(r, 1000)); }
+    }
+    try { fs.unlinkSync(sf); } catch {}
+    try { fs.unlinkSync(pf); } catch {}
+  } catch(e) { try { fs.unlinkSync(pf); } catch {} }
+}, ${SEND_DELAY * 1e3});
+`;
+  const env = { ...process.env, RESPAN_API_KEY: apiKey };
+  try {
+    const child = (0, import_node_child_process.execFile)("node", ["-e", script], {
+      env,
+      stdio: "ignore",
+      detached: true
+    });
+    child.unref();
+    debug(`Launched delayed sender (version=${sendVersion}, delay=${SEND_DELAY}s)`);
+  } catch (e) {
+    log("ERROR", `Failed to launch delayed sender: ${e}`);
+    try {
+      fs2.unlinkSync(payloadFile);
+    } catch {
+    }
+  }
+}
+function processBeforeTool(hookData) {
+  const sessionId = String(hookData.session_id ?? "unknown");
+  const toolName = String(hookData.tool_name ?? "");
+  const toolInput = hookData.tool_input ?? {};
+  debug(`BeforeTool: ${toolName}`);
+  const state = loadStreamState(sessionId);
+  const pending = state.pending_tools ?? [];
+  pending.push({ name: toolName, input: toolInput, start_time: nowISO() });
+  state.pending_tools = pending;
+  saveStreamState(sessionId, state);
+  process.stdout.write("{}\n");
+}
+function processAfterTool(hookData) {
+  const sessionId = String(hookData.session_id ?? "unknown");
+  const toolName = String(hookData.tool_name ?? "");
+  const toolResponse = hookData.tool_response ?? {};
+  const output = String(toolResponse.llmContent ?? "");
+  const error = toolResponse.error ? String(toolResponse.error) : void 0;
+  debug(`AfterTool: ${toolName}, output_len=${output.length}, error=${error}`);
+  const state = loadStreamState(sessionId);
+  const pending = state.pending_tools ?? [];
+  const completed = state.tool_details ?? [];
+  for (let i = pending.length - 1; i >= 0; i--) {
+    if (pending[i].name === toolName) {
+      const detail = pending.splice(i, 1)[0];
+      detail.output = output;
+      detail.end_time = nowISO();
+      if (error) detail.error = error;
+      completed.push(detail);
+      break;
+    }
+  }
+  state.pending_tools = pending;
+  state.tool_details = completed;
+  saveStreamState(sessionId, state);
+  process.stdout.write("{}\n");
+}
+function processChunk(hookData) {
+  const sessionId = String(hookData.session_id ?? "unknown");
+  const llmResp = hookData.llm_response ?? {};
+  const chunkText = String(llmResp.text ?? "") || "";
+  const usage = llmResp.usageMetadata ?? {};
+  const completionTokens = Number(usage.candidatesTokenCount ?? 0);
+  const thoughtsTokens = Number(usage.thoughtsTokenCount ?? 0);
+  const candidates = llmResp.candidates ?? [];
+  let finishReason = "";
+  let hasToolCall = false;
+  const chunkToolDetails = [];
+  if (candidates.length > 0 && typeof candidates[0] === "object") {
+    finishReason = String(candidates[0].finishReason ?? "");
+    const content = candidates[0].content ?? {};
+    if (typeof content === "object") {
+      for (const part of content.parts ?? []) {
+        if (typeof part !== "object") continue;
+        const fc = part.functionCall ?? part.toolCall;
+        if (fc) {
+          hasToolCall = true;
+          if (typeof fc === "object") {
+            chunkToolDetails.push({
+              name: String(fc.name ?? ""),
+              args: fc.args ?? {}
+            });
+          }
+        }
+      }
+    }
+  }
+  const messages = hookData.llm_request?.messages ?? [];
+  const currentMsgCount = messages.length;
+  let state = loadStreamState(sessionId);
+  const isFinished = ["STOP", "MAX_TOKENS", "SAFETY"].includes(finishReason);
+  const savedMsgCount = state.msg_count ?? 0;
+  let toolCallDetected = false;
+  if (savedMsgCount > 0 && currentMsgCount > savedMsgCount) {
+    const newMsgs = messages.slice(savedMsgCount);
+    const hasNewUserMsg = newMsgs.some((m) => m.role === "user");
+    if (hasNewUserMsg) {
+      debug(`New user message detected (msgs ${savedMsgCount} \u2192 ${currentMsgCount}), starting fresh turn`);
+      clearStreamState(sessionId);
+      state = { accumulated_text: "", last_tokens: 0, first_chunk_time: "" };
+    } else {
+      state.tool_turns = (state.tool_turns ?? 0) + 1;
+      state.send_version = (state.send_version ?? 0) + 1;
+      toolCallDetected = true;
+      debug(`Tool call detected via msg_count (${savedMsgCount} \u2192 ${currentMsgCount}), tool_turns=${state.tool_turns}`);
+    }
+  }
+  state.msg_count = currentMsgCount;
+  if (chunkText) {
+    if (!state.first_chunk_time) state.first_chunk_time = nowISO();
+    state.accumulated_text += chunkText;
+    state.last_tokens = completionTokens || state.last_tokens;
+    if (thoughtsTokens > 0) state.thoughts_tokens = thoughtsTokens;
+    saveStreamState(sessionId, state);
+    debug(`Accumulated chunk: +${chunkText.length} chars, total=${state.accumulated_text.length}`);
+  }
+  const isToolTurn = hasToolCall || ["TOOL_CALLS", "FUNCTION_CALL", "TOOL_USE"].includes(finishReason);
+  if (isToolTurn) {
+    state.tool_turns = (state.tool_turns ?? 0) + 1;
+    state.send_version = (state.send_version ?? 0) + 1;
+    if (chunkToolDetails.length) {
+      state.tool_details = [...state.tool_details ?? [], ...chunkToolDetails];
+    }
+    saveStreamState(sessionId, state);
+    debug(`Tool call via response parts (finish=${finishReason}), tool_turns=${state.tool_turns}`);
+    process.stdout.write("{}\n");
+    return;
+  }
+  const hasNewText = state.accumulated_text.length > (state.last_send_text_len ?? 0);
+  const shouldSend = (!toolCallDetected || isFinished) && hasNewText && state.accumulated_text && (!chunkText || isFinished);
+  process.stdout.write("{}\n");
+  if (!shouldSend) {
+    if (toolCallDetected) saveStreamState(sessionId, state);
+    return;
+  }
+  const creds = resolveCredentials();
+  if (!creds) {
+    log("ERROR", "No API key found. Run: respan auth login");
+    clearStreamState(sessionId);
+    return;
+  }
+  const finalPrompt = Number(usage.promptTokenCount ?? 0);
+  const finalCompletion = completionTokens || state.last_tokens;
+  const finalTotal = Number(usage.totalTokenCount ?? 0) || finalPrompt + finalCompletion;
+  const tok = { prompt_tokens: finalPrompt, completion_tokens: finalCompletion, total_tokens: finalTotal };
+  const config = loadRespanConfig(path2.join(os2.homedir(), ".gemini", "respan.json"));
+  const spans = buildSpans(
+    hookData,
+    state.accumulated_text,
+    tok,
+    config,
+    state.first_chunk_time || void 0,
+    state.tool_turns ?? 0,
+    state.tool_details ?? [],
+    state.thoughts_tokens ?? 0
+  );
+  if (isFinished && chunkText) {
+    debug(`Immediate send (text+STOP, tool_turns=${state.tool_turns ?? 0}), ${state.accumulated_text.length} chars`);
+    sendSpansDetached(spans, creds.apiKey, creds.baseUrl);
+    clearStreamState(sessionId);
+    return;
+  }
+  state.send_version = (state.send_version ?? 0) + 1;
+  state.last_send_text_len = state.accumulated_text.length;
+  saveStreamState(sessionId, state);
+  debug(`Delayed send (version=${state.send_version}, delay=${SEND_DELAY}s), ${state.accumulated_text.length} chars`);
+  launchDelayedSend(sessionId, state.send_version, spans, creds.apiKey, creds.baseUrl);
+}
+function main() {
+  try {
+    const raw = fs2.readFileSync(0, "utf-8");
+    if (!raw.trim()) {
+      process.stdout.write("{}\n");
+      return;
+    }
+    const hookData = JSON.parse(raw);
+    const event = String(hookData.hook_event_name ?? "");
+    const unlock = acquireLock(LOCK_PATH);
+    try {
+      if (event === "BeforeTool") {
+        processBeforeTool(hookData);
+      } else if (event === "AfterTool") {
+        processAfterTool(hookData);
+      } else {
+        processChunk(hookData);
+      }
+    } finally {
+      unlock?.();
+    }
+  } catch (e) {
+    if (e instanceof SyntaxError) {
+      log("ERROR", `Invalid JSON from stdin: ${e}`);
+    } else {
+      log("ERROR", `Hook error: ${e}`);
+    }
+    process.stdout.write("{}\n");
+  }
+}
+main();