@crevanta/stelvara-sdk 0.1.0-alpha.1

package/dist/auto.js

@@ -0,0 +1,827 @@
+// src/buffer.ts
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var TraceBuffer = class {
+  queue = [];
+  timer = null;
+  flushing = false;
+  running = true;
+  config;
+  shutdownHook = null;
+  constructor(config) {
+    this.config = config;
+    this.start();
+  }
+  /**
+   * Add a trace to the buffer.
+   * Returns false if the buffer is shut down.
+   * Drops oldest trace if buffer is full.
+   */
+  enqueue(trace) {
+    if (!this.running) return false;
+    if (this.queue.length >= this.config.maxSize) {
+      this.queue.shift();
+    }
+    this.queue.push(trace);
+    return true;
+  }
+  /** Number of traces waiting to be flushed. */
+  get pendingCount() {
+    return this.queue.length;
+  }
+  /**
+   * Flush all pending traces to the API.
+   * Sends in batches of batchSize.
+   */
+  async flush() {
+    if (this.flushing || this.queue.length === 0) return;
+    this.flushing = true;
+    try {
+      while (this.queue.length > 0) {
+        const batch = this.queue.splice(0, this.config.batchSize);
+        await this.sendBatch(batch);
+      }
+    } finally {
+      this.flushing = false;
+    }
+  }
+  /**
+   * Flush remaining traces and stop the buffer.
+   * Resolves when done or after timeoutMs.
+   */
+  async shutdown(timeoutMs = 5e3) {
+    if (!this.running) return;
+    this.running = false;
+    if (this.timer !== null) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.removeShutdownHook();
+    const flushPromise = this.flush();
+    const timeoutPromise = delay(timeoutMs);
+    await Promise.race([flushPromise, timeoutPromise]);
+  }
+  /**
+   * Send a single batch to the ingestion API with retry logic.
+   */
+  async sendBatch(batch) {
+    const url = `${this.config.endpoint}/traces`;
+    const cleanBatch = batch.map(({ _localKey, ...clean }) => clean);
+    for (let attempt = 0; attempt < this.config.maxRetries; attempt++) {
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${this.config.apiKey}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(cleanBatch)
+        });
+        if (response.status === 201) {
+          const data = await response.json();
+          const traceIds = data.trace_ids ?? [];
+          this.config.onFlushSuccess?.(batch, traceIds);
+          return;
+        }
+        if (response.status === 429) {
+          const retryAfterHeader = response.headers.get("Retry-After");
+          const retryAfterSec = retryAfterHeader ? parseInt(retryAfterHeader, 10) : 2 ** attempt;
+          await delay(retryAfterSec * 1e3);
+          continue;
+        }
+        return;
+      } catch {
+        const backoffMs = 2 ** attempt * 1e3;
+        await delay(backoffMs);
+      }
+    }
+  }
+  start() {
+    this.timer = setInterval(() => {
+      void this.flush();
+    }, this.config.flushIntervalMs);
+    this.installShutdownHook();
+  }
+  installShutdownHook() {
+    const handler = () => {
+      void this.shutdown();
+    };
+    const g = globalThis;
+    if (typeof g.window !== "undefined" && typeof g.window.addEventListener === "function") {
+      const win = g.window;
+      win.addEventListener("beforeunload", handler);
+      this.shutdownHook = () => win.removeEventListener("beforeunload", handler);
+    } else if (typeof process !== "undefined" && typeof process.on === "function") {
+      process.on("beforeExit", handler);
+      this.shutdownHook = () => process.removeListener("beforeExit", handler);
+    }
+  }
+  removeShutdownHook() {
+    this.shutdownHook?.();
+    this.shutdownHook = null;
+  }
+};
+
+// src/client.ts
+var DEFAULT_ENDPOINT = "https://auinkdnurzlaitpwhknm.supabase.co/functions/v1";
+function resolveConfig(config) {
+  if (!config.apiKey) throw new Error("apiKey is required");
+  if (!config.agentId) throw new Error("agentId is required");
+  return {
+    apiKey: config.apiKey,
+    agentId: config.agentId,
+    endpoint: (config.endpoint ?? DEFAULT_ENDPOINT).replace(/\/+$/, ""),
+    bufferSize: config.bufferSize ?? 100,
+    batchSize: config.batchSize ?? 50,
+    flushIntervalMs: config.flushIntervalMs ?? 5e3,
+    maxRetries: config.maxRetries ?? 3,
+    enabled: config.enabled ?? true
+  };
+}
+var StelvaraClient = class {
+  config;
+  buffer;
+  traceIdMap = /* @__PURE__ */ new Map();
+  traceCounter = 0;
+  constructor(config) {
+    this.config = resolveConfig(config);
+    this.buffer = new TraceBuffer({
+      endpoint: this.config.endpoint,
+      apiKey: this.config.apiKey,
+      maxSize: this.config.bufferSize,
+      batchSize: this.config.batchSize,
+      flushIntervalMs: this.config.flushIntervalMs,
+      maxRetries: this.config.maxRetries,
+      onFlushSuccess: (batch, traceIds) => this.registerTraceIds(batch, traceIds)
+    });
+  }
+  /**
+   * Capture a trace payload and enqueue for delivery.
+   * Returns a local trace key for use with tagOutcome().
+   * Returns null if the client is disabled.
+   */
+  captureTrace(payload, options) {
+    if (!this.config.enabled) return null;
+    const localKey = `stv_local_${++this.traceCounter}`;
+    const envelope = {
+      agent_id: this.config.agentId,
+      payload,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      _localKey: localKey
+    };
+    if (options?.sessionId != null) {
+      envelope.session_id = options.sessionId;
+    }
+    if (options?.parentTraceId != null) {
+      envelope.parent_trace_id = options.parentTraceId;
+    }
+    if (options?.traceType != null) {
+      envelope.trace_type = options.traceType;
+    }
+    this.buffer.enqueue(envelope);
+    return localKey;
+  }
+  /**
+   * Tag a trace with business outcomes.
+   * Resolves local trace keys to server UUIDs automatically.
+   * Fire-and-forget — catches errors internally.
+   */
+  async tagOutcome(traceId, outcomes) {
+    if (!this.config.enabled) return;
+    let resolvedId = traceId;
+    if (traceId.startsWith("stv_local_")) {
+      const serverId = this.traceIdMap.get(traceId);
+      if (serverId) {
+        resolvedId = serverId;
+      } else {
+        console.warn(
+          `[stelvara] Trace ${traceId} not yet flushed \u2014 outcome may fail`
+        );
+      }
+    }
+    const url = `${this.config.endpoint}/outcomes`;
+    try {
+      await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.config.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ trace_id: resolvedId, outcomes })
+      });
+    } catch {
+      console.warn(`[stelvara] Failed to tag outcome for trace ${resolvedId}`);
+    }
+  }
+  /**
+   * Tag multiple traces with business outcomes in a single API call.
+   *
+   * @param entries - Array of { trace_id, outcomes } objects (max 100).
+   * @returns Response with inserted count, failed count, and per-entry results.
+   * @throws {Error} If entries is empty or exceeds 100 items.
+   *
+   * @example
+   * const result = await client.tagOutcomesBatch([
+   *   { trace_id: 'uuid-1', outcomes: { revenue_impact: 45 } },
+   *   { trace_id: 'uuid-2', outcomes: { customer_satisfied: 1 } },
+   * ]);
+   * console.log(`Tagged ${result.inserted} outcomes`);
+   */
+  async tagOutcomesBatch(entries) {
+    if (!this.config.enabled) return null;
+    if (entries.length === 0) {
+      throw new Error("entries must not be empty");
+    }
+    if (entries.length > 100) {
+      throw new Error("entries must not exceed 100 items");
+    }
+    const resolvedEntries = entries.map((entry) => {
+      let resolvedId = entry.trace_id;
+      if (entry.trace_id.startsWith("stv_local_")) {
+        const serverId = this.traceIdMap.get(entry.trace_id);
+        if (serverId) {
+          resolvedId = serverId;
+        } else {
+          console.warn(
+            `[stelvara] Trace ${entry.trace_id} not yet flushed \u2014 batch entry may fail`
+          );
+        }
+      }
+      return { trace_id: resolvedId, outcomes: entry.outcomes };
+    });
+    const url = `${this.config.endpoint}/outcomes-batch`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.config.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ entries: resolvedEntries })
+    });
+    return await response.json();
+  }
+  /**
+   * Tag all traces in a session with business outcomes.
+   * The server resolves trace IDs by session_id.
+   *
+   * @param sessionId - Session identifier.
+   * @param outcomes - Dict of outcome metrics applied to every trace in the session.
+   * @returns Response with traces_found, inserted count, and per-trace results.
+   *
+   * @example
+   * const result = await client.tagSessionOutcome('session-uuid', {
+   *   revenue_impact: 150,
+   *   customer_satisfied: 1,
+   * });
+   * console.log(`Tagged ${result.traces_found} traces`);
+   */
+  async tagSessionOutcome(sessionId, outcomes) {
+    if (!this.config.enabled) return null;
+    const url = `${this.config.endpoint}/outcomes-batch/session`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.config.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ session_id: sessionId, outcomes })
+    });
+    return await response.json();
+  }
+  /**
+   * Flush pending traces and shut down the client.
+   */
+  async shutdown(timeoutMs) {
+    await this.buffer.shutdown(timeoutMs);
+  }
+  /** Number of traces waiting to be flushed. */
+  get pendingCount() {
+    return this.buffer.pendingCount;
+  }
+  /**
+   * Map local trace keys to server-assigned trace IDs after flush.
+   */
+  registerTraceIds(batch, traceIds) {
+    for (let i = 0; i < batch.length; i++) {
+      const localKey = batch[i]._localKey;
+      if (localKey && traceIds[i]) {
+        this.traceIdMap.set(localKey, traceIds[i]);
+      }
+    }
+  }
+};
+
+// src/index.ts
+var _client = null;
+function init(config) {
+  if (_client !== null) {
+    void _client.shutdown();
+  }
+  _client = new StelvaraClient(config);
+}
+function captureTrace(payload, options) {
+  if (_client === null) {
+    throw new Error("Stelvara not initialized. Call init() first.");
+  }
+  return _client.captureTrace(payload, options);
+}
+function isInitialized() {
+  return _client !== null;
+}
+
+// src/auto.ts
+var ANTHROPIC_PATTERN = "api.anthropic.com/v1/messages";
+var OPENAI_PATTERN = "api.openai.com/v1/chat/completions";
+var _originalFetch = null;
+var _installed = false;
+var _sessionId = null;
+var _inFlight = false;
+function readEnvVar(name) {
+  const g = globalThis;
+  if (typeof g.Deno !== "undefined" && g.Deno.env?.get) {
+    return g.Deno.env.get(name);
+  }
+  if (typeof g.process !== "undefined" && g.process.env) {
+    return g.process.env[name];
+  }
+  return void 0;
+}
+function detectProvider(url) {
+  if (url.includes(ANTHROPIC_PATTERN)) return "anthropic";
+  if (url.includes(OPENAI_PATTERN)) return "openai";
+  return null;
+}
+function resolveUrl(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.href;
+  return input.url;
+}
+function parseBodySync(init2) {
+  if (!init2?.body || typeof init2.body !== "string") return null;
+  try {
+    return JSON.parse(init2.body);
+  } catch {
+    return null;
+  }
+}
+function extractLastUserMessage(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg?.role !== "user") continue;
+    const content = msg.content;
+    if (typeof content === "string") return content;
+    if (Array.isArray(content)) {
+      for (const block of content) {
+        const b = block;
+        if (b?.type === "text" && typeof b.text === "string") return b.text;
+      }
+    }
+  }
+  return "";
+}
+function extractAnthropicTrace(reqBody, resBody, durationMs) {
+  const messages = reqBody.messages ?? [];
+  const userMsg = extractLastUserMessage(messages);
+  const systemMsg = typeof reqBody.system === "string" ? reqBody.system : "";
+  const payload = {
+    input: { user_message: userMsg },
+    model: {
+      name: resBody.model ?? reqBody.model ?? "unknown",
+      provider: "anthropic"
+    },
+    performance: { duration_ms: durationMs }
+  };
+  const prompt = {};
+  if (systemMsg) prompt.system = systemMsg;
+  if (userMsg) prompt.user = userMsg;
+  if (prompt.system || prompt.user) payload.prompt = prompt;
+  const contentBlocks = resBody.content ?? [];
+  const toolCalls = [];
+  for (const block of contentBlocks) {
+    if (block.type === "text" && typeof block.text === "string" && !payload.response?.text) {
+      payload.response = { ...payload.response, text: block.text };
+    }
+    if (block.type === "tool_use") {
+      toolCalls.push({
+        name: block.name ?? "unknown",
+        arguments: block.input ?? void 0
+      });
+    }
+  }
+  if (toolCalls.length > 0) payload.tool_calls = toolCalls;
+  if (typeof resBody.stop_reason === "string") {
+    payload.response = { ...payload.response, finish_reason: resBody.stop_reason };
+  }
+  const usage = resBody.usage;
+  if (usage) {
+    const inputTokens = usage.input_tokens ?? 0;
+    const outputTokens = usage.output_tokens ?? 0;
+    const total = inputTokens + outputTokens;
+    if (total > 0) {
+      payload.response = { ...payload.response, tokens_used: total };
+    }
+    payload.performance = { duration_ms: durationMs };
+    if (inputTokens) payload.performance.tokens_input = inputTokens;
+    if (outputTokens) payload.performance.tokens_output = outputTokens;
+  }
+  return payload;
+}
+function extractOpenAITrace(reqBody, resBody, durationMs) {
+  const messages = reqBody.messages ?? [];
+  let systemMsg = "";
+  let userMsg = "";
+  for (const msg of messages) {
+    if (msg.role === "system" && typeof msg.content === "string") {
+      systemMsg = msg.content;
+    }
+  }
+  userMsg = extractLastUserMessage(messages);
+  const payload = {
+    input: { user_message: userMsg },
+    model: {
+      name: resBody.model ?? reqBody.model ?? "unknown",
+      provider: "openai"
+    },
+    performance: { duration_ms: durationMs }
+  };
+  const prompt = {};
+  if (systemMsg) prompt.system = systemMsg;
+  if (userMsg) prompt.user = userMsg;
+  if (prompt.system || prompt.user) payload.prompt = prompt;
+  const choices = resBody.choices ?? [];
+  if (choices.length > 0) {
+    const choice = choices[0];
+    const message = choice.message;
+    if (message) {
+      if (typeof message.content === "string") {
+        payload.response = { ...payload.response, text: message.content };
+      }
+      const rawToolCalls = message.tool_calls;
+      if (rawToolCalls && rawToolCalls.length > 0) {
+        payload.tool_calls = rawToolCalls.map((tc) => {
+          const fn = tc.function;
+          const entry = { name: fn?.name ?? "unknown" };
+          if (typeof fn?.arguments === "string") {
+            try {
+              entry.arguments = JSON.parse(fn.arguments);
+            } catch {
+              entry.arguments = { raw: fn.arguments };
+            }
+          }
+          return entry;
+        });
+      }
+    }
+    if (typeof choice.finish_reason === "string") {
+      payload.response = { ...payload.response, finish_reason: choice.finish_reason };
+    }
+  }
+  const usage = resBody.usage;
+  if (usage) {
+    const promptTokens = usage.prompt_tokens ?? 0;
+    const completionTokens = usage.completion_tokens ?? 0;
+    const total = usage.total_tokens ?? promptTokens + completionTokens;
+    if (total > 0) {
+      payload.response = { ...payload.response, tokens_used: total };
+    }
+    payload.performance = { duration_ms: durationMs };
+    if (promptTokens) payload.performance.tokens_input = promptTokens;
+    if (completionTokens) payload.performance.tokens_output = completionTokens;
+  }
+  return payload;
+}
+function makeAnthropicState() {
+  return {
+    model: "",
+    inputTokens: 0,
+    outputTokens: 0,
+    stopReason: "",
+    textContent: "",
+    toolCalls: [],
+    currentToolName: "",
+    currentToolArgs: "",
+    done: false
+  };
+}
+function makeOpenAIState() {
+  return {
+    model: "",
+    textContent: "",
+    toolCallMap: /* @__PURE__ */ new Map(),
+    finishReason: "",
+    done: false
+  };
+}
+function processAnthropicSSE(line, state) {
+  if (!line.startsWith("data: ")) return;
+  const json = line.slice(6);
+  try {
+    const event = JSON.parse(json);
+    switch (event.type) {
+      case "message_start": {
+        const msg = event.message;
+        if (msg) {
+          if (typeof msg.model === "string") state.model = msg.model;
+          const usage = msg.usage;
+          if (usage?.input_tokens) state.inputTokens = usage.input_tokens;
+        }
+        break;
+      }
+      case "content_block_start": {
+        const block = event.content_block;
+        if (block?.type === "tool_use") {
+          state.currentToolName = block.name ?? "unknown";
+          state.currentToolArgs = "";
+        }
+        break;
+      }
+      case "content_block_delta": {
+        const delta = event.delta;
+        if (delta?.type === "text_delta" && typeof delta.text === "string") {
+          state.textContent += delta.text;
+        }
+        if (delta?.type === "input_json_delta" && typeof delta.partial_json === "string") {
+          state.currentToolArgs += delta.partial_json;
+        }
+        break;
+      }
+      case "content_block_stop": {
+        if (state.currentToolName) {
+          const tc = { name: state.currentToolName };
+          if (state.currentToolArgs) {
+            try {
+              tc.arguments = JSON.parse(state.currentToolArgs);
+            } catch {
+              tc.arguments = { raw: state.currentToolArgs };
+            }
+          }
+          state.toolCalls.push(tc);
+          state.currentToolName = "";
+          state.currentToolArgs = "";
+        }
+        break;
+      }
+      case "message_delta": {
+        const delta = event.delta;
+        if (typeof delta?.stop_reason === "string") state.stopReason = delta.stop_reason;
+        const usage = event.usage;
+        if (usage?.output_tokens) state.outputTokens = usage.output_tokens;
+        break;
+      }
+      case "message_stop":
+        state.done = true;
+        break;
+    }
+  } catch {
+  }
+}
+function processOpenAISSE(line, state) {
+  if (!line.startsWith("data: ")) return;
+  const json = line.slice(6).trim();
+  if (json === "[DONE]") {
+    state.done = true;
+    return;
+  }
+  try {
+    const event = JSON.parse(json);
+    if (typeof event.model === "string" && !state.model) {
+      state.model = event.model;
+    }
+    const choices = event.choices ?? [];
+    if (choices.length > 0) {
+      const choice = choices[0];
+      const delta = choice.delta;
+      if (delta) {
+        if (typeof delta.content === "string") {
+          state.textContent += delta.content;
+        }
+        if (typeof choice.finish_reason === "string") {
+          state.finishReason = choice.finish_reason;
+        }
+        const toolCallDeltas = delta.tool_calls;
+        if (toolCallDeltas) {
+          for (const tcd of toolCallDeltas) {
+            const idx = tcd.index ?? 0;
+            const existing = state.toolCallMap.get(idx);
+            const fn = tcd.function;
+            if (!existing) {
+              state.toolCallMap.set(idx, {
+                name: fn?.name ?? "",
+                argumentsRaw: fn?.arguments ?? ""
+              });
+            } else {
+              if (fn?.name) existing.name += fn.name;
+              if (fn?.arguments) existing.argumentsRaw += fn.arguments;
+            }
+          }
+        }
+      }
+    }
+  } catch {
+  }
+}
+function buildAnthropicStreamTrace(reqBody, state, durationMs) {
+  const messages = reqBody.messages ?? [];
+  const userMsg = extractLastUserMessage(messages);
+  const systemMsg = typeof reqBody.system === "string" ? reqBody.system : "";
+  const total = state.inputTokens + state.outputTokens;
+  const payload = {
+    input: { user_message: userMsg },
+    model: { name: state.model || reqBody.model || "unknown", provider: "anthropic" },
+    response: {
+      text: state.textContent,
+      finish_reason: state.stopReason || void 0,
+      tokens_used: total > 0 ? total : void 0
+    },
+    performance: {
+      duration_ms: durationMs,
+      tokens_input: state.inputTokens || void 0,
+      tokens_output: state.outputTokens || void 0
+    }
+  };
+  const prompt = {};
+  if (systemMsg) prompt.system = systemMsg;
+  if (userMsg) prompt.user = userMsg;
+  if (prompt.system || prompt.user) payload.prompt = prompt;
+  if (state.toolCalls.length > 0) payload.tool_calls = state.toolCalls;
+  return payload;
+}
+function buildOpenAIStreamTrace(reqBody, state, durationMs) {
+  const messages = reqBody.messages ?? [];
+  let systemMsg = "";
+  for (const msg of messages) {
+    if (msg.role === "system" && typeof msg.content === "string") {
+      systemMsg = msg.content;
+      break;
+    }
+  }
+  const userMsg = extractLastUserMessage(messages);
+  const payload = {
+    input: { user_message: userMsg },
+    model: { name: state.model || reqBody.model || "unknown", provider: "openai" },
+    response: {
+      text: state.textContent || void 0,
+      finish_reason: state.finishReason || void 0
+    },
+    performance: { duration_ms: durationMs }
+  };
+  const prompt = {};
+  if (systemMsg) prompt.system = systemMsg;
+  if (userMsg) prompt.user = userMsg;
+  if (prompt.system || prompt.user) payload.prompt = prompt;
+  if (state.toolCallMap.size > 0) {
+    payload.tool_calls = Array.from(state.toolCallMap.values()).map((tc) => {
+      const entry = { name: tc.name };
+      if (tc.argumentsRaw) {
+        try {
+          entry.arguments = JSON.parse(tc.argumentsRaw);
+        } catch {
+          entry.arguments = { raw: tc.argumentsRaw };
+        }
+      }
+      return entry;
+    });
+  }
+  return payload;
+}
+function wrapStreamingResponse(response, provider, reqBody, startTime) {
+  const body = response.body;
+  if (!body) return response;
+  const decoder = new TextDecoder();
+  const state = provider === "anthropic" ? makeAnthropicState() : makeOpenAIState();
+  let buffer = "";
+  const transformedStream = new ReadableStream({
+    async start(controller) {
+      const reader = body.getReader();
+      try {
+        for (; ; ) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          controller.enqueue(value);
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed) continue;
+            if (provider === "anthropic") {
+              processAnthropicSSE(trimmed, state);
+            } else {
+              processOpenAISSE(trimmed, state);
+            }
+          }
+        }
+        if (buffer.trim()) {
+          if (provider === "anthropic") {
+            processAnthropicSSE(buffer.trim(), state);
+          } else {
+            processOpenAISSE(buffer.trim(), state);
+          }
+        }
+        state.done = true;
+        try {
+          const durationMs = Date.now() - startTime;
+          const tracePayload = provider === "anthropic" ? buildAnthropicStreamTrace(reqBody, state, durationMs) : buildOpenAIStreamTrace(reqBody, state, durationMs);
+          const hasToolCalls = (tracePayload.tool_calls?.length ?? 0) > 0;
+          const traceType = hasToolCalls ? "tool_use" : "chat";
+          if (isInitialized()) {
+            captureTrace(tracePayload, {
+              sessionId: _sessionId ?? void 0,
+              traceType
+            });
+          }
+        } catch {
+        }
+        controller.close();
+      } catch (err) {
+        controller.error(err);
+      } finally {
+        reader.releaseLock();
+      }
+    }
+  });
+  return new Response(transformedStream, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+async function patchedFetch(input, init2) {
+  if (_inFlight) {
+    return _originalFetch(input, init2);
+  }
+  const url = resolveUrl(input);
+  const provider = detectProvider(url);
+  if (!provider) {
+    return _originalFetch(input, init2);
+  }
+  _inFlight = true;
+  const startTime = Date.now();
+  let reqBody = null;
+  try {
+    reqBody = parseBodySync(init2);
+  } catch {
+  }
+  try {
+    const response = await _originalFetch(input, init2);
+    const isStreaming = reqBody?.stream === true;
+    if (isStreaming && reqBody) {
+      try {
+        return wrapStreamingResponse(response, provider, reqBody, startTime);
+      } catch {
+        return response;
+      }
+    }
+    if (reqBody) {
+      try {
+        const clone = response.clone();
+        const resBody = await clone.json();
+        const durationMs = Date.now() - startTime;
+        const tracePayload = provider === "anthropic" ? extractAnthropicTrace(reqBody, resBody, durationMs) : extractOpenAITrace(reqBody, resBody, durationMs);
+        const hasToolCalls = (tracePayload.tool_calls?.length ?? 0) > 0;
+        const traceType = hasToolCalls ? "tool_use" : "chat";
+        if (isInitialized()) {
+          captureTrace(tracePayload, {
+            sessionId: _sessionId ?? void 0,
+            traceType
+          });
+        }
+      } catch {
+      }
+    }
+    return response;
+  } finally {
+    _inFlight = false;
+  }
+}
+function install(options) {
+  if (_installed) return;
+  const apiKey = options?.apiKey ?? readEnvVar("STELVARA_API_KEY");
+  const agentId = options?.agentId ?? readEnvVar("STELVARA_AGENT_ID");
+  if (!isInitialized() && apiKey && agentId) {
+    init({ apiKey, agentId, endpoint: options?.endpoint });
+  }
+  _originalFetch = globalThis.fetch;
+  globalThis.fetch = patchedFetch;
+  _installed = true;
+}
+function uninstall() {
+  if (!_installed || !_originalFetch) return;
+  globalThis.fetch = _originalFetch;
+  _originalFetch = null;
+  _installed = false;
+}
+function setSessionId(id) {
+  _sessionId = id;
+}
+function _resetForTesting() {
+  if (_installed) uninstall();
+  _sessionId = null;
+}
+install();
+export {
+  _resetForTesting,
+  install,
+  setSessionId,
+  uninstall
+};
+//# sourceMappingURL=auto.js.map