@observyze/sdk 0.1.4 → 0.1.5

package/dist/index.mjs

@@ -4,7 +4,7 @@ import {
   SpanType,
   Trace,
   TraceStatus
-} from "./chunk-FQBYUOJB.mjs";
+} from "./chunk-53PSEBAD.mjs";
 
 // src/client.ts
 import debug3 from "debug";
@@ -12,8 +12,11 @@ import debug3 from "debug";
 // src/instrumentation/openai.ts
 import debug from "debug";
 var log = debug("observyze:sdk");
+var WRAPPED = /* @__PURE__ */ Symbol.for("observyze.openai.wrapped");
+var MAX_CAPTURED_STREAM_CHARS = 1e6;
 function wrapOpenAI(client, nwClient) {
   const anyClient = client;
+  if (anyClient[WRAPPED]) return client;
   if (nwClient.getConfig().enableProxyRedirect && anyClient.baseURL && anyClient.apiKey) {
     const isAlreadyRedirected = anyClient.baseURL.includes("/api/v1/proxy/openai");
     if (!isAlreadyRedirected) {
@@ -39,7 +42,7 @@ function wrapOpenAI(client, nwClient) {
       provider: "openai",
       model: params.model
     });
-    const span = trace.startSpan("chat.completions.create", SpanType.LLM);
+    const span = trace.startSpan("chat.completions.create", "llm" /* LLM */);
     span.setMetadata("model", params.model);
     span.setMetadata("provider", "openai");
     if (params.temperature !== void 0) span.setMetadata("temperature", params.temperature);
@@ -69,38 +72,64 @@ function wrapOpenAI(client, nwClient) {
           output: completionResponse.usage.completion_tokens,
           total: completionResponse.usage.total_tokens
         });
+        span.setMetadata("token_usage_source", "provider");
+      } else {
+        span.setMetadata("token_usage_source", "unavailable");
       }
       span.setMetadata("latency_ms", latency);
       span.end();
-      trace.end();
+      trace.end("success" /* SUCCESS */);
       return response;
     } catch (error) {
       const latency = Date.now() - startTime;
       span.setMetadata("latency_ms", latency);
       span.setError(error);
       span.end();
-      trace.end();
+      trace.end("error" /* ERROR */);
       throw error;
     }
   };
+  Object.defineProperty(anyClient, WRAPPED, { value: true, enumerable: false });
   return client;
 }
 function wrapOpenAIStream(stream, span, trace, startTime) {
   const bufferedChunks = [];
   let streamId = "";
   let streamModel = "";
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let outputTruncated = false;
+  let capturedChars = 0;
   return {
     [Symbol.asyncIterator]: async function* () {
+      let completed = false;
+      let failure;
       try {
         for await (const chunk of stream) {
           if (chunk.id) streamId = chunk.id;
           if (chunk.model) streamModel = chunk.model;
           const delta = chunk.choices[0]?.delta;
           if (delta?.content) {
-            bufferedChunks.push(delta.content);
+            if (capturedChars < MAX_CAPTURED_STREAM_CHARS) {
+              const captured = delta.content.slice(0, MAX_CAPTURED_STREAM_CHARS - capturedChars);
+              bufferedChunks.push(captured);
+              capturedChars += captured.length;
+              if (captured.length < delta.content.length) outputTruncated = true;
+            } else {
+              outputTruncated = true;
+            }
+          }
+          if (chunk.usage) {
+            inputTokens = Math.max(inputTokens, chunk.usage.prompt_tokens || 0);
+            outputTokens = Math.max(outputTokens, chunk.usage.completion_tokens || 0);
           }
           yield chunk;
         }
+        completed = true;
+      } catch (error) {
+        failure = error;
+        throw error;
+      } finally {
         const latency = Date.now() - startTime;
         const completeOutput = bufferedChunks.join("");
         span.setOutput({
@@ -110,15 +139,21 @@ function wrapOpenAIStream(stream, span, trace, startTime) {
         });
         span.setMetadata("latency_ms", latency);
         span.setMetadata("streaming", true);
+        span.setMetadata("stream_completed", completed);
+        span.setMetadata("output_truncated", outputTruncated);
+        if (inputTokens > 0 || outputTokens > 0) {
+          span.setTokens({ input: inputTokens, output: outputTokens, total: inputTokens + outputTokens });
+          span.setMetadata("token_usage_source", "provider");
+        } else {
+          span.setMetadata("token_usage_source", "unavailable");
+        }
+        if (failure) {
+          span.setError(failure);
+        } else if (!completed) {
+          span.setError(new Error("Stream consumption ended before provider completion"));
+        }
         span.end();
-        trace.end();
-      } catch (error) {
-        const latency = Date.now() - startTime;
-        span.setMetadata("latency_ms", latency);
-        span.setError(error);
-        span.end();
-        trace.end();
-        throw error;
+        trace.end(completed && !failure ? "success" /* SUCCESS */ : "error" /* ERROR */);
       }
     }
   };
@@ -127,8 +162,11 @@ function wrapOpenAIStream(stream, span, trace, startTime) {
 // src/instrumentation/anthropic.ts
 import debug2 from "debug";
 var log2 = debug2("observyze:sdk");
+var WRAPPED2 = /* @__PURE__ */ Symbol.for("observyze.anthropic.wrapped");
+var MAX_CAPTURED_STREAM_CHARS2 = 1e6;
 function wrapAnthropic(client, nwClient) {
   const anyClient = client;
+  if (anyClient[WRAPPED2]) return client;
   if (nwClient.getConfig().enableProxyRedirect && anyClient.baseURL && anyClient.apiKey) {
     const isAlreadyRedirected = anyClient.baseURL.includes("/api/v1/proxy/anthropic");
     if (!isAlreadyRedirected) {
@@ -154,7 +192,7 @@ function wrapAnthropic(client, nwClient) {
       provider: "anthropic",
       model: params.model
     });
-    const span = trace.startSpan("messages.create", SpanType.LLM);
+    const span = trace.startSpan("messages.create", "llm" /* LLM */);
     span.setMetadata("model", params.model);
     span.setMetadata("provider", "anthropic");
     if (params.temperature !== void 0) span.setMetadata("temperature", params.temperature);
@@ -188,20 +226,24 @@ function wrapAnthropic(client, nwClient) {
           output: messageResponse.usage.output_tokens,
           total: messageResponse.usage.input_tokens + messageResponse.usage.output_tokens
         });
+        span.setMetadata("token_usage_source", "provider");
+      } else {
+        span.setMetadata("token_usage_source", "unavailable");
       }
       span.setMetadata("latency_ms", latency);
       span.end();
-      trace.end();
+      trace.end("success" /* SUCCESS */);
       return response;
     } catch (error) {
       const latency = Date.now() - startTime;
       span.setMetadata("latency_ms", latency);
       span.setError(error);
       span.end();
-      trace.end();
+      trace.end("error" /* ERROR */);
       throw error;
     }
   };
+  Object.defineProperty(anyClient, WRAPPED2, { value: true, enumerable: false });
   return client;
 }
 function wrapAnthropicStream(stream, span, trace, startTime) {
@@ -211,8 +253,12 @@ function wrapAnthropicStream(stream, span, trace, startTime) {
   let stopReason = null;
   let inputTokens = 0;
   let outputTokens = 0;
+  let capturedChars = 0;
+  let outputTruncated = false;
   return {
     [Symbol.asyncIterator]: async function* () {
+      let completed = false;
+      let failure;
       try {
         for await (const event of stream) {
           if (event.type === "message_start" && event.message) {
@@ -223,7 +269,14 @@ function wrapAnthropicStream(stream, span, trace, startTime) {
             }
           }
           if (event.type === "content_block_delta" && event.delta?.text) {
-            bufferedChunks.push(event.delta.text);
+            if (capturedChars < MAX_CAPTURED_STREAM_CHARS2) {
+              const captured = event.delta.text.slice(0, MAX_CAPTURED_STREAM_CHARS2 - capturedChars);
+              bufferedChunks.push(captured);
+              capturedChars += captured.length;
+              if (captured.length < event.delta.text.length) outputTruncated = true;
+            } else {
+              outputTruncated = true;
+            }
           }
           if (event.type === "message_delta" && event.delta) {
             if (event.delta.stop_reason) {
@@ -235,6 +288,11 @@ function wrapAnthropicStream(stream, span, trace, startTime) {
           }
           yield event;
         }
+        completed = true;
+      } catch (error) {
+        failure = error;
+        throw error;
+      } finally {
         const latency = Date.now() - startTime;
         const completeOutput = bufferedChunks.join("");
         span.setOutput({
@@ -249,52 +307,747 @@ function wrapAnthropicStream(stream, span, trace, startTime) {
             output: outputTokens,
             total: inputTokens + outputTokens
           });
+          span.setMetadata("token_usage_source", "provider");
+        } else {
+          span.setMetadata("token_usage_source", "unavailable");
         }
         span.setMetadata("latency_ms", latency);
         span.setMetadata("streaming", true);
+        span.setMetadata("stream_completed", completed);
+        span.setMetadata("output_truncated", outputTruncated);
+        if (failure) {
+          span.setError(failure);
+        } else if (!completed) {
+          span.setError(new Error("Stream consumption ended before provider completion"));
+        }
         span.end();
-        trace.end();
+        trace.end(completed && !failure ? "success" /* SUCCESS */ : "error" /* ERROR */);
+      }
+    }
+  };
+}
+
+// src/instrumentation/langchain.ts
+import { AsyncLocalStorage } from "async_hooks";
+var WRAPPED3 = /* @__PURE__ */ Symbol.for("observyze.langchain.wrapped");
+var nestedInstrumentation = new AsyncLocalStorage();
+var MAX_CAPTURED_STREAM_CHARS3 = 1e6;
+function runnableName(runnable) {
+  return String(
+    runnable.name || runnable.lc_namespace?.join(".") || runnable.constructor?.name || "Runnable"
+  );
+}
+function extractUsage(output) {
+  const usage2 = output?.usage_metadata || output?.response_metadata?.tokenUsage || output?.usage;
+  if (!usage2) return null;
+  const input = Number(usage2.input_tokens ?? usage2.promptTokens ?? usage2.prompt_tokens ?? 0);
+  const outputTokens = Number(usage2.output_tokens ?? usage2.completionTokens ?? usage2.completion_tokens ?? 0);
+  const total = Number(usage2.total_tokens ?? usage2.totalTokens ?? input + outputTokens);
+  return input > 0 || outputTokens > 0 || total > 0 ? { input, output: outputTokens, total } : null;
+}
+function chunkText(chunk) {
+  if (typeof chunk === "string") return chunk;
+  if (typeof chunk?.content === "string") return chunk.content;
+  if (typeof chunk?.text === "string") return chunk.text;
+  return "";
+}
+function wrapLangChain(runnable, nwClient) {
+  const target = runnable;
+  if (target[WRAPPED3]) return runnable;
+  const name = runnableName(runnable);
+  const originalInvoke = runnable.invoke.bind(runnable);
+  target.invoke = async (input, config) => {
+    if (nestedInstrumentation.getStore()) return originalInvoke(input, config);
+    const trace = nwClient.startTrace(`langchain.${name}.invoke`, { provider: "langchain", runnable: name });
+    const span = trace.startSpan(`${name}.invoke`, "chain" /* CHAIN */);
+    span.setInput(input);
+    try {
+      const output = await nestedInstrumentation.run(true, () => originalInvoke(input, config));
+      span.setOutput(output);
+      const usage2 = extractUsage(output);
+      if (usage2) {
+        span.setTokens(usage2);
+        span.setMetadata("token_usage_source", "provider");
+      } else {
+        span.setMetadata("token_usage_source", "unavailable");
+      }
+      span.end();
+      trace.end("success" /* SUCCESS */);
+      return output;
+    } catch (error) {
+      span.setError(error);
+      span.end();
+      trace.end("error" /* ERROR */);
+      throw error;
+    }
+  };
+  if (typeof runnable.stream === "function") {
+    const originalStream = runnable.stream.bind(runnable);
+    target.stream = async (input, config) => {
+      if (nestedInstrumentation.getStore()) return originalStream(input, config);
+      const trace = nwClient.startTrace(`langchain.${name}.stream`, { provider: "langchain", runnable: name });
+      const span = trace.startSpan(`${name}.stream`, "chain" /* CHAIN */);
+      span.setInput(input);
+      let source;
+      try {
+        source = await nestedInstrumentation.run(true, () => originalStream(input, config));
       } catch (error) {
-        const latency = Date.now() - startTime;
-        span.setMetadata("latency_ms", latency);
         span.setError(error);
         span.end();
-        trace.end();
+        trace.end("error" /* ERROR */);
+        throw error;
+      }
+      return {
+        [Symbol.asyncIterator]: async function* () {
+          let output = "";
+          let completed = false;
+          let truncated = false;
+          let failure;
+          try {
+            for await (const chunk of source) {
+              const text = chunkText(chunk);
+              if (output.length < MAX_CAPTURED_STREAM_CHARS3) {
+                const captured = text.slice(0, MAX_CAPTURED_STREAM_CHARS3 - output.length);
+                output += captured;
+                if (captured.length < text.length) truncated = true;
+              } else if (text) {
+                truncated = true;
+              }
+              yield chunk;
+            }
+            completed = true;
+          } catch (error) {
+            failure = error;
+            throw error;
+          } finally {
+            span.setOutput({ content: output });
+            span.setMetadata("streaming", true);
+            span.setMetadata("stream_completed", completed);
+            span.setMetadata("output_truncated", truncated);
+            span.setMetadata("token_usage_source", "unavailable");
+            if (failure) span.setError(failure);
+            else if (!completed) span.setError(new Error("Stream consumption ended before runnable completion"));
+            span.end();
+            trace.end(completed && !failure ? "success" /* SUCCESS */ : "error" /* ERROR */);
+          }
+        }
+      };
+    };
+  }
+  Object.defineProperty(target, WRAPPED3, { value: true, enumerable: false });
+  return runnable;
+}
+
+// src/instrumentation/gemini.ts
+var WRAPPED4 = /* @__PURE__ */ Symbol.for("observyze.gemini.wrapped");
+var MAX_CAPTURED_STREAM_CHARS4 = 1e6;
+function modelName(target, request) {
+  return String(request?.model || target?.model || target?.modelName || "unknown");
+}
+function responseText(response) {
+  try {
+    if (typeof response?.text === "function") return String(response.text());
+    if (typeof response?.text === "string") return response.text;
+    const parts = response?.candidates?.[0]?.content?.parts;
+    return Array.isArray(parts) ? parts.map((part) => part?.text || "").join("") : "";
+  } catch {
+    return "";
+  }
+}
+function usage(response) {
+  const value = response?.usageMetadata || response?.usage_metadata || response?.usage;
+  if (!value) return null;
+  const input = Number(value.promptTokenCount ?? value.inputTokens ?? value.input_tokens ?? 0);
+  const output = Number(value.candidatesTokenCount ?? value.outputTokens ?? value.output_tokens ?? 0);
+  const total = Number(value.totalTokenCount ?? value.totalTokens ?? value.total_tokens ?? input + output);
+  return input > 0 || output > 0 || total > 0 ? { input, output, total } : null;
+}
+function instrumentMethod(target, method, nwClient) {
+  if (typeof target?.[method] !== "function") return;
+  const original = target[method].bind(target);
+  target[method] = async (...args) => {
+    const request = args[0];
+    const model = modelName(target, request);
+    const trace = nwClient.startTrace(`gemini.${method}`, { provider: "google", model });
+    const span = trace.startSpan(method, "llm" /* LLM */);
+    span.setMetadata("provider", "google");
+    span.setMetadata("model", model);
+    span.setInput(request);
+    try {
+      const result = await original(...args);
+      const stream = result?.stream || (result?.[Symbol.asyncIterator] ? result : null);
+      if (stream?.[Symbol.asyncIterator]) {
+        const wrappedStream = wrapGeminiStream(stream, result?.response, span, trace, model);
+        if (result?.stream) {
+          return new Proxy(result, {
+            get(target2, property, receiver) {
+              return property === "stream" ? wrappedStream : Reflect.get(target2, property, receiver);
+            }
+          });
+        }
+        return wrappedStream;
+      }
+      const resolved = result?.response ? await result.response : result;
+      span.setOutput({
+        text: responseText(resolved),
+        finish_reason: resolved?.candidates?.[0]?.finishReason
+      });
+      const tokenUsage = usage(resolved);
+      if (tokenUsage) {
+        span.setTokens(tokenUsage);
+        span.setMetadata("token_usage_source", "provider");
+      } else {
+        span.setMetadata("token_usage_source", "unavailable");
+      }
+      span.end();
+      trace.end("success" /* SUCCESS */);
+      return result;
+    } catch (error) {
+      span.setError(error);
+      span.end();
+      trace.end("error" /* ERROR */);
+      throw error;
+    }
+  };
+}
+function wrapGeminiStream(stream, finalResponse, span, trace, model) {
+  return {
+    [Symbol.asyncIterator]: async function* () {
+      let text = "";
+      let completed = false;
+      let truncated = false;
+      let failure;
+      let latestUsage = null;
+      try {
+        for await (const chunk of stream) {
+          const chunkText2 = responseText(chunk);
+          if (text.length < MAX_CAPTURED_STREAM_CHARS4) {
+            const captured = chunkText2.slice(0, MAX_CAPTURED_STREAM_CHARS4 - text.length);
+            text += captured;
+            if (captured.length < chunkText2.length) truncated = true;
+          } else if (chunkText2) {
+            truncated = true;
+          }
+          latestUsage = usage(chunk) || latestUsage;
+          yield chunk;
+        }
+        completed = true;
+      } catch (error) {
+        failure = error;
         throw error;
+      } finally {
+        if (completed && finalResponse) {
+          try {
+            const resolved = await finalResponse;
+            latestUsage = usage(resolved) || latestUsage;
+            if (!text) text = responseText(resolved).slice(0, MAX_CAPTURED_STREAM_CHARS4);
+          } catch (error) {
+            failure = error;
+          }
+        }
+        span.setOutput({ model, text });
+        span.setMetadata("streaming", true);
+        span.setMetadata("stream_completed", completed);
+        span.setMetadata("output_truncated", truncated);
+        if (latestUsage) {
+          span.setTokens(latestUsage);
+          span.setMetadata("token_usage_source", "provider");
+        } else {
+          span.setMetadata("token_usage_source", "unavailable");
+        }
+        if (failure) span.setError(failure);
+        else if (!completed) span.setError(new Error("Stream consumption ended before Gemini completed"));
+        span.end();
+        trace.end(completed && !failure ? "success" /* SUCCESS */ : "error" /* ERROR */);
       }
     }
   };
 }
+function wrapGemini(client, nwClient) {
+  const target = client.models || client;
+  if (target[WRAPPED4]) return client;
+  instrumentMethod(target, "generateContent", nwClient);
+  instrumentMethod(target, "generateContentStream", nwClient);
+  Object.defineProperty(target, WRAPPED4, { value: true, enumerable: false });
+  return client;
+}
+
+// src/instrumentation/vercel-ai.ts
+var MAX_CAPTURED_STREAM_CHARS5 = 1e6;
+function modelName2(request, response) {
+  let requestModelId;
+  try {
+    requestModelId = typeof request?.model?.modelId === "function" ? request.model.modelId() : request?.model?.modelId;
+  } catch {
+    requestModelId = void 0;
+  }
+  return String(
+    response?.response?.modelId || requestModelId || request?.model || "unknown"
+  );
+}
+async function resolveUsage(value) {
+  const usage2 = await Promise.resolve(value?.usage).catch(() => null);
+  if (!usage2) return null;
+  const input = Number(usage2.inputTokens ?? usage2.promptTokens ?? usage2.input_tokens ?? 0);
+  const output = Number(usage2.outputTokens ?? usage2.completionTokens ?? usage2.output_tokens ?? 0);
+  const total = Number(usage2.totalTokens ?? usage2.total_tokens ?? input + output);
+  return input > 0 || output > 0 || total > 0 ? { input, output, total } : null;
+}
+function wrapVercelAI(sdk, nwClient) {
+  const wrapped = { ...sdk };
+  const generateText = sdk.generateText;
+  const streamText = sdk.streamText;
+  if (typeof generateText === "function") {
+    wrapped.generateText = async (...args) => {
+      const request = args[0];
+      const trace = nwClient.startTrace("vercel-ai.generateText", { provider: "vercel-ai", model: modelName2(request) });
+      const span = trace.startSpan("generateText", "llm" /* LLM */);
+      span.setMetadata("provider", "vercel-ai");
+      span.setMetadata("model", modelName2(request));
+      span.setInput(request);
+      try {
+        const result = await generateText.apply(sdk, args);
+        span.setOutput({ text: result?.text, finish_reason: result?.finishReason });
+        const tokens = await resolveUsage(result);
+        if (tokens) {
+          span.setTokens(tokens);
+          span.setMetadata("token_usage_source", "provider");
+        } else span.setMetadata("token_usage_source", "unavailable");
+        span.end();
+        trace.end("success" /* SUCCESS */);
+        return result;
+      } catch (error) {
+        span.setError(error);
+        span.end();
+        trace.end("error" /* ERROR */);
+        throw error;
+      }
+    };
+  }
+  if (typeof streamText === "function") {
+    wrapped.streamText = (...args) => {
+      const request = args[0];
+      const trace = nwClient.startTrace("vercel-ai.streamText", { provider: "vercel-ai", model: modelName2(request) });
+      const span = trace.startSpan("streamText", "llm" /* LLM */);
+      span.setMetadata("provider", "vercel-ai");
+      span.setMetadata("model", modelName2(request));
+      span.setInput(request);
+      let result;
+      try {
+        result = streamText.apply(sdk, args);
+      } catch (error) {
+        span.setError(error);
+        span.end();
+        trace.end("error" /* ERROR */);
+        throw error;
+      }
+      if (!result?.textStream?.[Symbol.asyncIterator]) {
+        span.setError(new Error("Vercel AI streamText returned no textStream"));
+        span.end();
+        trace.end("error" /* ERROR */);
+        return result;
+      }
+      const source = result.textStream;
+      const textStream = {
+        [Symbol.asyncIterator]: async function* () {
+          let text = "";
+          let completed = false;
+          let truncated = false;
+          let failure;
+          try {
+            for await (const chunk of source) {
+              if (text.length < MAX_CAPTURED_STREAM_CHARS5) {
+                const captured = String(chunk).slice(0, MAX_CAPTURED_STREAM_CHARS5 - text.length);
+                text += captured;
+                if (captured.length < String(chunk).length) truncated = true;
+              } else if (chunk) truncated = true;
+              yield chunk;
+            }
+            completed = true;
+          } catch (error) {
+            failure = error;
+            throw error;
+          } finally {
+            span.setOutput({ text });
+            span.setMetadata("streaming", true);
+            span.setMetadata("stream_completed", completed);
+            span.setMetadata("output_truncated", truncated);
+            const tokens = completed ? await resolveUsage(result) : null;
+            if (tokens) {
+              span.setTokens(tokens);
+              span.setMetadata("token_usage_source", "provider");
+            } else span.setMetadata("token_usage_source", "unavailable");
+            if (failure) span.setError(failure);
+            else if (!completed) span.setError(new Error("Stream consumption ended before Vercel AI completed"));
+            span.end();
+            trace.end(completed && !failure ? "success" /* SUCCESS */ : "error" /* ERROR */);
+          }
+        }
+      };
+      return new Proxy(result, {
+        get(target, property, receiver) {
+          return property === "textStream" ? textStream : Reflect.get(target, property, receiver);
+        }
+      });
+    };
+  }
+  return wrapped;
+}
+
+// src/instrumentation/llamaindex.ts
+var WRAPPED5 = /* @__PURE__ */ Symbol.for("observyze.llamaindex.wrapped");
+function outputValue(response) {
+  if (typeof response?.response === "string") return { text: response.response };
+  if (typeof response?.message?.content === "string") return { text: response.message.content };
+  if (typeof response === "string") return { text: response };
+  if (typeof response?.toString === "function" && response.toString !== Object.prototype.toString) {
+    try {
+      return { text: String(response.toString()) };
+    } catch {
+      return { response_type: response?.constructor?.name || typeof response };
+    }
+  }
+  return { response_type: response?.constructor?.name || typeof response };
+}
+function extractUsage2(response) {
+  const usage2 = response?.usage || response?.raw?.usage || response?.message?.additionalKwargs?.usage;
+  if (!usage2) return null;
+  const input = Number(usage2.prompt_tokens ?? usage2.input_tokens ?? usage2.inputTokens ?? 0);
+  const output = Number(usage2.completion_tokens ?? usage2.output_tokens ?? usage2.outputTokens ?? 0);
+  const total = Number(usage2.total_tokens ?? usage2.totalTokens ?? input + output);
+  return input > 0 || output > 0 || total > 0 ? { input, output, total } : null;
+}
+function instrument(target, method, nwClient) {
+  if (typeof target?.[method] !== "function") return;
+  const original = target[method].bind(target);
+  target[method] = async (...args) => {
+    const trace = nwClient.startTrace(`llamaindex.${method}`, { provider: "llamaindex" });
+    const span = trace.startSpan(method, method === "query" ? "retrieval" /* RETRIEVAL */ : "llm" /* LLM */);
+    span.setMetadata("provider", "llamaindex");
+    span.setInput(args[0]);
+    try {
+      const result = await original(...args);
+      span.setOutput(outputValue(result));
+      const tokens = extractUsage2(result);
+      if (tokens) {
+        span.setTokens(tokens);
+        span.setMetadata("token_usage_source", "provider");
+      } else span.setMetadata("token_usage_source", "unavailable");
+      span.end();
+      trace.end("success" /* SUCCESS */);
+      return result;
+    } catch (error) {
+      span.setError(error);
+      span.end();
+      trace.end("error" /* ERROR */);
+      throw error;
+    }
+  };
+}
+function wrapLlamaIndex(engine, nwClient) {
+  const target = engine;
+  if (target[WRAPPED5]) return engine;
+  instrument(target, "query", nwClient);
+  instrument(target, "chat", nwClient);
+  Object.defineProperty(target, WRAPPED5, { value: true, enumerable: false });
+  return engine;
+}
 
 // src/instrumentation/index.ts
 function wrap(client, nwClient) {
-  if ("chat" in client && client.chat && "completions" in client.chat) {
+  const candidate = client;
+  if (candidate?.chat?.completions && typeof candidate.chat.completions.create === "function") {
     return wrapOpenAI(client, nwClient);
   }
-  if ("messages" in client && client.messages && "create" in client.messages) {
+  if (candidate?.messages && typeof candidate.messages.create === "function") {
     return wrapAnthropic(client, nwClient);
   }
+  if (typeof candidate?.generateContent === "function" || typeof candidate?.generateContentStream === "function" || typeof candidate?.models?.generateContent === "function" || typeof candidate?.models?.generateContentStream === "function") {
+    return wrapGemini(client, nwClient);
+  }
+  if (typeof candidate?.generateText === "function" || typeof candidate?.streamText === "function") {
+    return wrapVercelAI(client, nwClient);
+  }
+  if (typeof candidate?.invoke === "function") {
+    return wrapLangChain(client, nwClient);
+  }
+  if (typeof candidate?.query === "function" || typeof candidate?.chat === "function") {
+    return wrapLlamaIndex(client, nwClient);
+  }
   throw new Error(
-    "Observyze SDK: Unsupported client type. Supported clients: OpenAI, Anthropic"
+    "Observyze SDK: Unsupported client type. Supported clients: OpenAI, Anthropic, Gemini, Vercel AI SDK, LangChain, and LlamaIndex"
   );
 }
 
+// src/execution-budget.ts
+var ExecutionBudgetExceededError = class extends Error {
+  constructor(dimension, message) {
+    super(message);
+    this.dimension = dimension;
+    this.name = "ExecutionBudgetExceededError";
+  }
+  dimension;
+  code = "OBSERVYZE_EXECUTION_BUDGET_EXCEEDED";
+};
+var ExecutionBudget = class {
+  constructor(options) {
+    this.options = options;
+    if (!Number.isInteger(options.maxCalls) || options.maxCalls < 1 || options.maxCalls > 1e5) {
+      throw new Error("ExecutionBudget maxCalls must be an integer between 1 and 100000");
+    }
+    if (!Number.isInteger(options.timeoutMs) || options.timeoutMs < 100 || options.timeoutMs > 864e5) {
+      throw new Error("ExecutionBudget timeoutMs must be an integer between 100 and 86400000");
+    }
+    if (options.maxTokens !== void 0 && (!Number.isInteger(options.maxTokens) || options.maxTokens < 1 || options.maxTokens > 1e10)) {
+      throw new Error("ExecutionBudget maxTokens must be an integer between 1 and 10000000000");
+    }
+  }
+  options;
+  startedAt = Date.now();
+  controller = new AbortController();
+  callsUsed = 0;
+  tokensUsed = 0;
+  get signal() {
+    return this.controller.signal;
+  }
+  get stats() {
+    const elapsedMs = Date.now() - this.startedAt;
+    return {
+      callsUsed: this.callsUsed,
+      tokensUsed: this.tokensUsed,
+      elapsedMs,
+      remainingCalls: Math.max(0, this.options.maxCalls - this.callsUsed),
+      remainingTokens: this.options.maxTokens === void 0 ? null : Math.max(0, this.options.maxTokens - this.tokensUsed),
+      remainingMs: Math.max(0, this.options.timeoutMs - elapsedMs),
+      aborted: this.controller.signal.aborted
+    };
+  }
+  abort(reason = "Execution budget aborted by the application") {
+    if (!this.controller.signal.aborted) this.controller.abort(new Error(reason));
+  }
+  consumeTokens(tokens) {
+    if (!Number.isInteger(tokens) || tokens < 0) {
+      throw new Error("ExecutionBudget token usage must be a non-negative integer");
+    }
+    this.assertTime();
+    if (this.options.maxTokens !== void 0 && this.tokensUsed + tokens > this.options.maxTokens) {
+      this.abort("Execution token budget exceeded");
+      throw new ExecutionBudgetExceededError(
+        "tokens",
+        `Execution token budget exceeded (${this.tokensUsed + tokens}/${this.options.maxTokens})`
+      );
+    }
+    this.tokensUsed += tokens;
+  }
+  async run(operation, reservedTokens = 0) {
+    this.assertTime();
+    if (this.controller.signal.aborted) {
+      throw new ExecutionBudgetExceededError("time", "Execution budget is already aborted");
+    }
+    if (this.callsUsed >= this.options.maxCalls) {
+      this.abort("Execution call budget exceeded");
+      throw new ExecutionBudgetExceededError(
+        "calls",
+        `Execution call budget exceeded (${this.callsUsed}/${this.options.maxCalls})`
+      );
+    }
+    this.consumeTokens(reservedTokens);
+    this.callsUsed += 1;
+    const remainingMs = this.options.timeoutMs - (Date.now() - this.startedAt);
+    if (remainingMs <= 0) this.assertTime();
+    let timeout;
+    const deadline = new Promise((_resolve, reject) => {
+      timeout = setTimeout(() => {
+        this.abort("Execution time budget exceeded");
+        reject(new ExecutionBudgetExceededError(
+          "time",
+          `Execution time budget exceeded (${this.options.timeoutMs}ms)`
+        ));
+      }, remainingMs);
+    });
+    try {
+      return await Promise.race([operation(this.controller.signal), deadline]);
+    } finally {
+      if (timeout) clearTimeout(timeout);
+    }
+  }
+  assertTime() {
+    if (Date.now() - this.startedAt >= this.options.timeoutMs) {
+      this.abort("Execution time budget exceeded");
+      throw new ExecutionBudgetExceededError(
+        "time",
+        `Execution time budget exceeded (${this.options.timeoutMs}ms)`
+      );
+    }
+  }
+};
+
 // src/client.ts
 import fs from "fs";
 import path from "path";
 var log3 = debug3("observyze:sdk");
+var MAX_HISTORY_FILE_BYTES = 50 * 1024 * 1024;
+var MAX_HISTORY_TRACES = 1e4;
+var MAX_GUARDRAIL_REQUEST_BYTES = 1024 * 1024;
+var ALLOWED_EVALUATION_SOURCES = /* @__PURE__ */ new Set(["live", "consensus", "nli_fast_path", "error", "disabled", "fallback"]);
+var SAFE_IMPORTED_METADATA = /* @__PURE__ */ new Set([
+  "provider",
+  "model",
+  "temperature",
+  "max_tokens",
+  "max_completion_tokens",
+  "max_output_tokens",
+  "latency_ms",
+  "streaming",
+  "stream_completed",
+  "output_truncated",
+  "token_usage_source",
+  "cost_source",
+  "known_pricing",
+  "source",
+  "lifecycle",
+  "invocation_type"
+]);
+function luhnValid(candidate) {
+  const digits = candidate.replace(/[^0-9]/g, "");
+  if (digits.length < 13 || digits.length > 19 || /^(\d)\1+$/.test(digits)) return false;
+  let sum = 0;
+  let shouldDouble = false;
+  for (let index = digits.length - 1; index >= 0; index -= 1) {
+    let digit = Number(digits[index]);
+    if (shouldDouble) {
+      digit *= 2;
+      if (digit > 9) digit -= 9;
+    }
+    sum += digit;
+    shouldDouble = !shouldDouble;
+  }
+  return sum % 10 === 0;
+}
+var PII_PATTERNS = [
+  { name: "email", pattern: /\b[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}\b/g, replacement: "[EMAIL_REDACTED]" },
+  { name: "jwt", pattern: /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g, replacement: "[JWT_REDACTED]" },
+  { name: "authorization", pattern: /\b(?:Bearer|Token|Basic)\s+[A-Za-z0-9\-._~+/]+=*/gi, replacement: "[AUTH_TOKEN_REDACTED]" },
+  { name: "aws_access_key", pattern: /\b(?:AKIA|ASIA|AROA|ANPA|ANVA|AIDA)[A-Z0-9]{16}\b/g, replacement: "[AWS_KEY_REDACTED]" },
+  { name: "api_key", pattern: /(?<![A-Za-z0-9_])(?:(?:sk|pk)-[A-Za-z0-9-]{20,}|ob_[A-Za-z0-9]{20,}|claude-[A-Za-z0-9-]{20,})(?![A-Za-z0-9_])/g, replacement: "[API_KEY_REDACTED]" },
+  { name: "github_token", pattern: /\b(?:ghp|gho|ghu|ghs|github_pat)_[A-Za-z0-9_]{20,}\b/g, replacement: "[API_KEY_REDACTED]" },
+  { name: "ssn", pattern: /\b\d{3}-\d{2}-\d{4}\b/g, replacement: "[SSN_REDACTED]" },
+  { name: "credit_card_luhn", pattern: /\b(?:\d[ -]?){12,18}\d\b/g, replacement: (match) => luhnValid(match) ? "[CC_REDACTED]" : match },
+  { name: "phone_us", pattern: /(?<!\d)(?:\+?1[-.\\s]?)?\(?\d{3}\)?[-.\\s]?\d{3}[-.\\s]?\d{4}(?!\d)/g, replacement: "[PHONE_REDACTED]" },
+  { name: "phone_international", pattern: /(?<!\d)\+(?:[0-9][().\s-]?){7,15}[0-9](?!\d)/g, replacement: "[PHONE_REDACTED]" },
+  { name: "zip_context", pattern: /(?:zip\s*(?:code)?[\s:]*)\b\d{5}(?:-\d{4})?\b/gi, replacement: "zip: [ZIP_REDACTED]" },
+  { name: "ipv4", pattern: /\b(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\b/g, replacement: "[IP_REDACTED]" },
+  { name: "ipv6", pattern: /\b(?:[0-9a-fA-F]{1,4}:){2,7}[0-9a-fA-F]{1,4}\b/g, replacement: "[IP_REDACTED]" }
+];
+var SENSITIVE_KEY_SEGMENTS = /* @__PURE__ */ new Set([
+  "password",
+  "passwd",
+  "secret",
+  "token",
+  "apikey",
+  "key",
+  "authorization",
+  "credential",
+  "private",
+  "ssn",
+  "social",
+  "dob",
+  "birth",
+  "passport",
+  "credit",
+  "card",
+  "cvv",
+  "cvc",
+  "pin",
+  "bank",
+  "routing",
+  "account"
+]);
+function isSensitiveKey(key) {
+  const normalized = key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().replace(/-/g, "_");
+  if (SENSITIVE_KEY_SEGMENTS.has(normalized)) return true;
+  if (/^(?:first|last|given|family|full|person)_?name$/.test(normalized)) return true;
+  return normalized.split("_").some((segment) => SENSITIVE_KEY_SEGMENTS.has(segment)) && /(?:password|passwd|secret|token|api_?key|authorization|credential|private_?key|ssn|social_?security|credit_?card|card_?number|cvv|cvc|bank_?account|routing_?number|passport|date_?of_?birth)/.test(normalized);
+}
+function redactValue(value, depth = 0) {
+  if (depth > 16) return "[MAX_DEPTH_EXCEEDED]";
+  if (typeof value === "string") {
+    let redacted = value;
+    for (const { pattern, replacement } of PII_PATTERNS) {
+      pattern.lastIndex = 0;
+      redacted = typeof replacement === "string" ? redacted.replace(pattern, replacement) : redacted.replace(pattern, replacement);
+    }
+    return redacted;
+  }
+  if (Array.isArray(value)) return value.map((item) => redactValue(item, depth + 1));
+  if (value instanceof Date) return value;
+  if (value instanceof Map) return redactValue(Object.fromEntries(value.entries()), depth + 1);
+  if (value !== null && typeof value === "object") {
+    const redacted = {};
+    for (const [key, nested] of Object.entries(value)) {
+      redacted[key] = isSensitiveKey(key) ? "[REDACTED]" : redactValue(nested, depth + 1);
+    }
+    return redacted;
+  }
+  return value;
+}
+function operationalMetadata(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return Object.fromEntries(Object.entries(value).filter(
+    ([key, item]) => SAFE_IMPORTED_METADATA.has(key) && (item === null || ["string", "number", "boolean"].includes(typeof item))
+  ));
+}
+function metadataOnlyImportedTrace(trace) {
+  return {
+    trace_id: trace?.trace_id,
+    organization_id: trace?.organization_id,
+    project_id: trace?.project_id,
+    name: "[CONTENT_CAPTURE_DISABLED]",
+    status: trace?.status,
+    start_time: trace?.start_time,
+    end_time: trace?.end_time,
+    duration_ms: trace?.duration_ms,
+    metadata: operationalMetadata(trace?.metadata),
+    spans: Array.isArray(trace?.spans) ? trace.spans.map((span) => ({
+      span_id: span?.span_id,
+      parent_span_id: span?.parent_span_id,
+      name: "[CONTENT_CAPTURE_DISABLED]",
+      type: span?.type,
+      start_time: span?.start_time,
+      end_time: span?.end_time,
+      duration_ms: span?.duration_ms,
+      input: null,
+      output: null,
+      ...span?.error ? { error: { message: "Error details omitted because content capture is disabled" } } : {},
+      metadata: operationalMetadata(span?.metadata),
+      tokens: span?.tokens || span?.tokens_used
+    })) : [],
+    tags: [],
+    cost: trace?.cost
+  };
+}
+var IngestionRequestError = class extends Error {
+  constructor(message, retryable, retryAfterMs) {
+    super(message);
+    this.retryable = retryable;
+    this.retryAfterMs = retryAfterMs;
+    this.name = "IngestionRequestError";
+  }
+  retryable;
+  retryAfterMs;
+};
 var DEFAULT_CONFIG = {
-  endpoint: "http://localhost:3001",
+  endpoint: "https://api.observyze.com",
   batchSize: 100,
   flushInterval: 5e3,
-  enableAutoInstrumentation: true,
+  requestTimeoutMs: 1e4,
   debug: false,
   dryRun: false,
   enablePiiRedaction: true,
+  captureContent: true,
   hallucinationThreshold: 0.8,
   safetyThreshold: 0.9,
   confidenceThreshold: 0.4,
-  evalEndpoint: process.env.EVAL_ENDPOINT || (process.env.NODE_ENV === "production" ? "https://api.observyze.com" : "http://localhost:3001"),
   enableCircuitBreaker: true,
   failClosed: true,
   enableProxyRedirect: true
@@ -306,10 +1059,46 @@ var ObservyzeClient = class _ObservyzeClient {
   isShuttingDown = false;
   MAX_QUEUE_SIZE = 1e3;
   RETRY_DELAYS = [1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
-  /**
-   * Parse a JSON API error response and extract trace_id, error code, and message.
-   * The api-gateway error handler includes these fields in every error response.
-   */
+  static async readBoundedResponse(response, maxBytes = 64 * 1024) {
+    if (!response.body) {
+      if (typeof response.text === "function") return String(await response.text()).slice(0, maxBytes);
+      if (typeof response.json === "function") return JSON.stringify(await response.json()).slice(0, maxBytes);
+      return "";
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const remaining = maxBytes - size;
+      if (remaining <= 0) {
+        await reader.cancel();
+        break;
+      }
+      chunks.push(value.byteLength > remaining ? value.slice(0, remaining) : value);
+      size += Math.min(value.byteLength, remaining);
+      if (value.byteLength > remaining) {
+        await reader.cancel();
+        break;
+      }
+    }
+    const merged = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+      merged.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return new TextDecoder().decode(merged);
+  }
+  static retryAfterMs(response) {
+    const value = response.headers?.get?.("retry-after");
+    if (!value) return void 0;
+    const seconds = Number(value);
+    if (Number.isFinite(seconds)) return Math.min(6e4, Math.max(0, seconds * 1e3));
+    const date = Date.parse(value);
+    return Number.isFinite(date) ? Math.min(6e4, Math.max(0, date - Date.now())) : void 0;
+  }
   static parseApiError(_response, body) {
     try {
       const parsed = JSON.parse(body);
@@ -320,18 +1109,9 @@ var ObservyzeClient = class _ObservyzeClient {
         message: error.message || body.slice(0, 200)
       };
     } catch {
-      return {
-        traceId: "unknown",
-        code: "UNKNOWN_ERROR",
-        message: body.slice(0, 200)
-      };
+      return { traceId: "unknown", code: "UNKNOWN_ERROR", message: body.slice(0, 200) };
     }
   }
-  /**
-   * Format an API error into a user-friendly message with trace_id for correlation.
-   * Example output:
-   *   "Observyze API error (401 [ref: err_a1b2c3d4]): MISSING_PROVIDER_KEY — No API key configured..."
-   */
   static formatApiError(response, body) {
     const { traceId, code, message } = _ObservyzeClient.parseApiError(response, body);
     const prefix = traceId !== "unknown" ? ` [ref: ${traceId}]` : "";
@@ -341,11 +1121,27 @@ var ObservyzeClient = class _ObservyzeClient {
     if (!config.apiKey) {
       throw new Error("Observyze SDK: apiKey is required");
     }
+    if (config.batchSize !== void 0 && (!Number.isInteger(config.batchSize) || config.batchSize < 1 || config.batchSize > 100)) {
+      throw new Error("Observyze SDK: batchSize must be an integer between 1 and 100");
+    }
+    if (config.flushInterval !== void 0 && (!Number.isFinite(config.flushInterval) || config.flushInterval < 100 || config.flushInterval > 36e5)) {
+      throw new Error("Observyze SDK: flushInterval must be between 100 and 3600000 milliseconds");
+    }
+    if (config.requestTimeoutMs !== void 0 && (!Number.isFinite(config.requestTimeoutMs) || config.requestTimeoutMs < 100 || config.requestTimeoutMs > 12e4)) {
+      throw new Error("Observyze SDK: requestTimeoutMs must be between 100 and 120000 milliseconds");
+    }
+    try {
+      const endpoint = new URL(config.endpoint || String(DEFAULT_CONFIG.endpoint));
+      if (!["http:", "https:"].includes(endpoint.protocol)) throw new Error("invalid protocol");
+    } catch {
+      throw new Error("Observyze SDK: endpoint must be a valid HTTP(S) URL");
+    }
     this.config = {
       ...DEFAULT_CONFIG,
       ...config,
       organizationId: config.organizationId || "",
-      projectId: config.projectId || ""
+      projectId: config.projectId || "",
+      evalEndpoint: config.evalEndpoint || config.endpoint || String(DEFAULT_CONFIG.endpoint)
     };
     this.startFlushTimer();
     if (this.config.debug) {
@@ -364,13 +1160,14 @@ var ObservyzeClient = class _ObservyzeClient {
     const trace = new Trace(
       name,
       this.config.organizationId,
-      this.config.projectId
+      this.config.projectId,
+      this.config.captureContent
     );
     if (metadata) {
       trace.setMetadataAll(metadata);
     }
     const originalEnd = trace.end.bind(trace);
-    trace.end = (status = TraceStatus.SUCCESS) => {
+    trace.end = (status = "success" /* SUCCESS */) => {
       originalEnd(status);
       this.bufferTrace(trace);
     };
@@ -421,7 +1218,7 @@ var ObservyzeClient = class _ObservyzeClient {
     }
   }
   /**
-   * Flush all buffered traces to the Ingestion Service
+   * Flush all buffered traces to Observyze
    */
   async flush() {
     if (this.traceBuffer.length === 0) {
@@ -464,37 +1261,52 @@ var ObservyzeClient = class _ObservyzeClient {
     let lastError = null;
     for (let attempt = 0; attempt < this.RETRY_DELAYS.length + 1; attempt++) {
       try {
-        const response = await fetch(`${this.config.endpoint}/api/v1/ingest/batch`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            "Authorization": `Bearer ${this.config.apiKey}`
-          },
-          body: JSON.stringify({
-            traces: traces.map((trace) => {
-              const json = trace.toJSON();
-              if (this.config.enablePiiRedaction) {
-                json.spans = this.sanitizePII(json.spans);
-              }
-              return json;
-            })
-          })
-        });
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.config.requestTimeoutMs);
+        let response;
+        try {
+          response = await fetch(`${this.config.endpoint}/api/v1/ingest/batch`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Authorization": `Bearer ${this.config.apiKey}`,
+              "x-api-key": this.config.apiKey
+            },
+            body: JSON.stringify({
+              traces: traces.map((trace) => {
+                const json = trace.toJSON();
+                return this.config.enablePiiRedaction ? this.sanitizePII(json) : json;
+              })
+            }),
+            signal: controller.signal
+          });
+        } finally {
+          clearTimeout(timeout);
+        }
         if (!response.ok) {
-          const errorBody = await response.text();
+          const errorBody = await _ObservyzeClient.readBoundedResponse(response);
           const formatted = _ObservyzeClient.formatApiError(response, errorBody);
-          throw new Error(`[Observyze SDK] Trace ingestion failed. ${formatted}`);
+          const retryable = [408, 425, 429].includes(response.status) || response.status >= 500;
+          throw new IngestionRequestError(
+            `[Observyze SDK] Trace ingestion failed. ${formatted}`,
+            retryable,
+            _ObservyzeClient.retryAfterMs(response)
+          );
         }
         if (this.config.debug) {
           log3(`[Observyze SDK] Successfully sent ${traces.length} traces${attempt > 0 ? ` (after ${attempt} retries)` : ""}`);
         }
+        if (response.body) await response.body.cancel().catch(() => void 0);
         return;
       } catch (error) {
         lastError = error;
-        if (attempt >= this.RETRY_DELAYS.length) {
+        const retryable = !(error instanceof IngestionRequestError) || error.retryable;
+        if (!retryable || attempt >= this.RETRY_DELAYS.length) {
           break;
         }
-        const delay = this.RETRY_DELAYS[attempt];
+        const configuredDelay = error instanceof IngestionRequestError ? error.retryAfterMs : void 0;
+        const baseDelay = configuredDelay ?? this.RETRY_DELAYS[attempt];
+        const delay = Math.min(6e4, Math.round(baseDelay * (0.8 + Math.random() * 0.4)));
         if (this.config.debug) {
           log3.extend("warn")(`[Observyze SDK] Attempt ${attempt + 1} failed, retrying in ${delay}ms...`, error);
         }
@@ -540,22 +1352,21 @@ var ObservyzeClient = class _ObservyzeClient {
     return { ...this.config };
   }
   /**
-   * Wrap an LLM client (OpenAI, Anthropic) to enable auto-instrumentation
-   * 
+   * Wrap a supported LLM client or framework boundary to enable auto-instrumentation.
+   *
+   * Supports: OpenAI, Anthropic, Google Gemini, Vercel AI SDK, LangChain, LlamaIndex.
+   *
    * @example
    * ```typescript
    * import OpenAI from 'openai'
    * import { ObservyzeClient } from '@observyze/sdk'
-   * 
+   *
    * const nw = new ObservyzeClient({ apiKey: 'your-api-key' })
-   * const openai = new OpenAI({ apiKey: 'openai-key' })
-   * 
-   * // Wrap the client to enable auto-instrumentation
-   * nw.wrap(openai)
-   * 
+   * const openai = nw.wrap(new OpenAI({ apiKey: 'openai-key' }))
+   *
    * // All calls are now automatically traced
    * const response = await openai.chat.completions.create({
-   *   model: 'gpt-4',
+   *   model: 'gpt-4o',
    *   messages: [{ role: 'user', content: 'Hello!' }]
    * })
    * ```
@@ -563,27 +1374,19 @@ var ObservyzeClient = class _ObservyzeClient {
   wrap(client) {
     return wrap(client, this);
   }
+  /** Create an active call/token/time budget for one agent execution. */
+  createExecutionBudget(options) {
+    return new ExecutionBudget(options);
+  }
   /**
    * Verify that the SDK can reach Observyze and send traces end-to-end.
    *
-   * This is the definitive "is my integration working?" test for SDK users.
-   * It sends a real test trace through the EXACT same pipeline used by
-   * `flush()` / the wrapped LLM clients (same endpoint, apiKey, retry logic),
-   * so a successful call proves the whole chain works from your code:
-   *   - apiKey is valid and authorized
-   *   - endpoint is reachable from your environment
-   *   - organization / project resolution works
-   *   - the ingest pipeline accepts and stores traces
-   *
    * @example
    * ```typescript
    * const nw = new ObservyzeClient({ apiKey: process.env.OBSERVYZE_API_KEY })
    * const result = await nw.testConnection()
-   * // { ok: true, traceId: 'nw_xxx', message: 'Connection successful...' }
+   * // { ok: true, traceId: '...', message: 'Connection successful...' }
    * ```
-   *
-   * The returned traceId can be searched in the Observyze dashboard (Traces →
-   * search the trace name "Observyze Connection Test") to confirm it landed.
    */
   async testConnection() {
     if (this.config.dryRun) {
@@ -595,9 +1398,10 @@ var ObservyzeClient = class _ObservyzeClient {
     const trace = new Trace(
       "Observyze Connection Test",
       this.config.organizationId,
-      this.config.projectId
+      this.config.projectId,
+      this.config.captureContent
     );
-    const span = trace.startSpan("connection-test", SpanType.LLM);
+    const span = trace.startSpan("connection-test", "llm" /* LLM */);
     span.setInput({ prompt: "Observyze SDK connection test" });
     span.setOutput({ response: "Connection successful" });
     span.setTokens({ input: 5, output: 4, total: 9 });
@@ -605,7 +1409,7 @@ var ObservyzeClient = class _ObservyzeClient {
     span.end();
     trace.setMetadata("source", "sdk-test-connection");
     trace.addTag("setup-test");
-    trace.end(TraceStatus.SUCCESS);
+    trace.end("success" /* SUCCESS */);
     try {
       await this.sendWithRetry([trace]);
       return {
@@ -617,8 +1421,7 @@ var ObservyzeClient = class _ObservyzeClient {
       const rawMessage = error?.message || String(error);
       const statusMatch = rawMessage.match(/\((\d{3})/);
       const isNetworkFailure = !statusMatch && /fetch|network|ENOTFOUND|ECONNREFUSED|ETIMEDOUT/i.test(rawMessage);
-      const defaultEndpoint = "http://localhost:3001";
-      const hint = isNetworkFailure && this.config.endpoint === defaultEndpoint ? ` You are using the default endpoint (${defaultEndpoint}). For production, set endpoint: "https://api.observyze.com" in the ObservyzeClient config, then re-run.` : isNetworkFailure ? " Check that your endpoint is reachable from this environment (firewalls, proxies, DNS) and that you are not using a local endpoint in production." : "";
+      const hint = isNetworkFailure ? " Check that your endpoint is reachable from this environment (firewalls, proxies, DNS)." : "";
       return {
         ok: false,
         ...statusMatch ? { status: parseInt(statusMatch[1], 10) } : {},
@@ -627,8 +1430,8 @@ var ObservyzeClient = class _ObservyzeClient {
     }
   }
   /**
-   * Sync local agent .history file to Observyze cloud
-   * Parses JSON/NDJSON agent history and sends to ingestion endpoint.
+   * Sync a local agent .history file to Observyze cloud.
+   * Parses JSON/NDJSON agent history and sends to the ingestion endpoint.
    */
   async syncLocalHistory(filePath) {
     try {
@@ -639,6 +1442,11 @@ var ObservyzeClient = class _ObservyzeClient {
       if (!fs.existsSync(fullPath)) {
         throw new Error(`History file not found: ${fullPath}`);
       }
+      const fileStats = fs.statSync(fullPath);
+      if (!fileStats.isFile()) throw new Error("History path must reference a regular file");
+      if (fileStats.size > MAX_HISTORY_FILE_BYTES) {
+        throw new Error(`History file exceeds the ${MAX_HISTORY_FILE_BYTES} byte limit`);
+      }
       const content = fs.readFileSync(fullPath, "utf-8");
       let items = [];
       try {
@@ -649,21 +1457,36 @@ var ObservyzeClient = class _ObservyzeClient {
       if (!Array.isArray(items)) {
         items = [items];
       }
+      if (items.length > MAX_HISTORY_TRACES) {
+        throw new Error(`History import exceeds the ${MAX_HISTORY_TRACES} trace limit`);
+      }
       if (this.config.debug) {
         log3(`[Observyze SDK] Syncing ${items.length} traces from ${filePath}`);
       }
       for (let i = 0; i < items.length; i += this.config.batchSize) {
         const batch = items.slice(i, i + this.config.batchSize);
-        const response = await fetch(`${this.config.endpoint}/api/v1/ingest/batch`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            "Authorization": `Bearer ${this.config.apiKey}`
-          },
-          body: JSON.stringify({ traces: batch })
-        });
+        const privacyBoundBatch = this.config.captureContent ? batch : batch.map(metadataOnlyImportedTrace);
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.config.requestTimeoutMs);
+        let response;
+        try {
+          response = await fetch(`${this.config.endpoint}/api/v1/ingest/batch`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Authorization": `Bearer ${this.config.apiKey}`,
+              "x-api-key": this.config.apiKey
+            },
+            body: JSON.stringify({
+              traces: this.config.enablePiiRedaction ? this.sanitizePII(privacyBoundBatch) : privacyBoundBatch
+            }),
+            signal: controller.signal
+          });
+        } finally {
+          clearTimeout(timeout);
+        }
         if (!response.ok) {
-          const errorBody = await response.text();
+          const errorBody = await _ObservyzeClient.readBoundedResponse(response);
           const formatted = _ObservyzeClient.formatApiError(response, errorBody);
           throw new Error(`[Observyze SDK] Local history sync failed. ${formatted}`);
         }
@@ -677,219 +1500,106 @@ var ObservyzeClient = class _ObservyzeClient {
     }
   }
   /**
-   * Industry-grade PII Redaction (Compliance & RBAC)
-   *
-   * Recursively scrubs PII from trace data before transmission to the cloud.
-   * Coverage: emails, JWTs, bearer tokens, AWS/API keys, SSNs, credit cards,
-   * phone numbers (US + E.164), IPv4/IPv6, passport numbers, ZIP codes, plus
-   * key-based redaction for sensitive JSON fields (password, token, api_key, etc.).
-   *
-   * Design:
-   *  - Pure function, never mutates the original object
-   *  - Depth-limited to 16 levels to prevent stack overflow on deep agent outputs
-   *  - Key-aware: sensitive key names are fully redacted regardless of value format
+   * Industry-grade PII redaction.
+   * Recursively scrubs PII from trace data before transmission.
    */
-  static PII_PATTERNS = [
-    { pattern: /\b[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}\b/gi, label: "[EMAIL_REDACTED]" },
-    { pattern: /\beyJ[A-Za-z0-9_\-]+\.eyJ[A-Za-z0-9_\-]+\.[A-Za-z0-9_\-]+\b/g, label: "[JWT_REDACTED]" },
-    { pattern: /\b(Bearer|Token|Basic)\s+[A-Za-z0-9\-.~+\/]+=*\b/gi, label: "[AUTH_TOKEN_REDACTED]" },
-    { pattern: /\b(AKIA|ASIA|AROA|ANPA|ANVA|AIDA)[A-Z0-9]{16}\b/g, label: "[AWS_KEY_REDACTED]" },
-    { pattern: /\b(sk-[A-Za-z0-9\-]{20,}|pk-[A-Za-z0-9\-]{20,}|ob_[A-Za-z0-9]{20,}|ghp_[A-Za-z0-9]{36,}|gho_[A-Za-z0-9]{36,})\b/g, label: "[API_KEY_REDACTED]" },
-    { pattern: /\b\d{3}-\d{2}-\d{4}\b/g, label: "[SSN_REDACTED]" },
-    { pattern: /\b(?:\d[ \-]?){13,18}\d\b/g, label: "[CC_REDACTED]" },
-    { pattern: /(?:\+1[\s.\-]?)?\(?\d{3}\)?[\s.\-]?\d{3}[\s.\-]?\d{4}\b/g, label: "[PHONE_REDACTED]" },
-    { pattern: /\+\d{1,3}[\s.\-]?\(?\d{1,4}\)?[\s.\-]?\d{1,4}[\s.\-]?\d{1,9}/g, label: "[PHONE_REDACTED]" },
-    { pattern: /\b(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\b/g, label: "[IP_REDACTED]" },
-    { pattern: /\b(?:[0-9a-fA-F]{1,4}:){2,7}[0-9a-fA-F]{1,4}\b/g, label: "[IP_REDACTED]" }
-  ];
-  static SENSITIVE_KEYS = /* @__PURE__ */ new Set([
-    "password",
-    "passwd",
-    "secret",
-    "token",
-    "apikey",
-    "api_key",
-    "accesstoken",
-    "access_token",
-    "refreshtoken",
-    "refresh_token",
-    "authorization",
-    "auth",
-    "credential",
-    "credentials",
-    "private_key",
-    "privatekey",
-    "client_secret",
-    "clientsecret",
-    "ssn",
-    "social_security",
-    "dob",
-    "date_of_birth",
-    "dateofbirth",
-    "passport",
-    "passport_number",
-    "credit_card",
-    "creditcard",
-    "card_number",
-    "cardnumber",
-    "cvv",
-    "cvc",
-    "pin",
-    "bank_account",
-    "routing_number"
-  ]);
-  static isSensitiveKey(key) {
-    const normalized = key.toLowerCase().replace(/-/g, "_");
-    if (_ObservyzeClient.SENSITIVE_KEYS.has(normalized)) return true;
-    const segments = normalized.split("_");
-    for (const segment of segments) {
-      if (_ObservyzeClient.SENSITIVE_KEYS.has(segment)) return true;
-    }
-    return false;
-  }
   sanitizePII(data, depth = 0) {
-    if (depth > 16) return "[MAX_DEPTH_EXCEEDED]";
-    if (data === null || data === void 0) return data;
-    if (typeof data === "string") {
-      let result = data;
-      for (const { pattern, label } of _ObservyzeClient.PII_PATTERNS) {
-        pattern.lastIndex = 0;
-        result = result.replace(pattern, label);
-      }
-      return result;
-    }
-    if (typeof data === "number" || typeof data === "boolean") return data;
-    if (Array.isArray(data)) return data.map((item) => this.sanitizePII(item, depth + 1));
-    if (typeof data === "object") {
-      const sanitized = {};
-      for (const [k, v] of Object.entries(data)) {
-        sanitized[k] = _ObservyzeClient.isSensitiveKey(k) ? "[REDACTED]" : this.sanitizePII(v, depth + 1);
-      }
-      return sanitized;
-    }
-    return data;
+    return redactValue(data, depth);
   }
   /**
-   * Phase 4: Autonomous Circuit Breakers (Requirement 4.1)
-   * Evaluate a trace or text for hallucination in real-time.
-   * If hallucination score > hallucinationThreshold, the SDK blocks execution.
-   * 
+   * Explicitly evaluate content before an application action.
+   * Requires an active Observyze subscription with guardrails enabled.
+   *
    * Returns GuardrailResult with score: null when evaluation couldn't be performed.
-   * In failClosed mode, null scores result in blocked execution.
-   * In failOpen mode, null scores allow execution through.
+   * In failClosed mode (default), null scores block execution.
+   *
+   * @example
+   * ```typescript
+   * const result = await nw.checkGuardrails(llmOutput)
+   * if (!result.pass) {
+   *   throw new Error('Guardrail blocked: ' + result.reason)
+   * }
+   * ```
    */
   async checkGuardrails(content) {
     if (!this.config.enableCircuitBreaker) {
       return { pass: true, score: 0, safetyScore: 0, evaluationSource: "disabled" };
     }
+    if (!this.config.captureContent) {
+      const reason = "Guardrail content dispatch is disabled because captureContent is false";
+      return this.config.failClosed ? { pass: false, score: null, confidence: null, safetyScore: null, evaluationSource: "disabled", fallbackReason: reason, reason } : { pass: true, score: null, confidence: null, safetyScore: null, evaluationSource: "disabled", fallbackReason: reason };
+    }
     try {
       if (this.config.debug) {
-        log3(`[Observyze Guardrail] Analyzing payload for hallucination anomalies...`);
+        log3(`[Observyze Guardrail] Analyzing payload...`);
       }
       const evalEndpoint = this.config.evalEndpoint;
-      const payload = typeof content === "string" ? { text: content, organization_id: this.config.organizationId } : { trace: content, organization_id: this.config.organizationId };
-      const controller = new AbortController();
-      const timeout = setTimeout(() => controller.abort(), 5e3);
-      let evalResult = null;
-      try {
-        const response = await fetch(`${evalEndpoint}/api/v1/evaluate/hallucination`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            "Authorization": `Bearer ${this.config.apiKey}`
-          },
-          body: JSON.stringify(payload),
-          signal: controller.signal
-        });
-        clearTimeout(timeout);
-        if (response.ok) {
-          evalResult = await response.json();
-        } else {
-          const errorBody = await response.text();
+      const protectedContent = this.config.enablePiiRedaction ? this.sanitizePII(content) : content;
+      const payload = typeof protectedContent === "string" ? { text: protectedContent, organization_id: this.config.organizationId } : { trace: protectedContent, organization_id: this.config.organizationId };
+      const serializedPayload = JSON.stringify(payload);
+      if (Buffer.byteLength(serializedPayload, "utf8") > MAX_GUARDRAIL_REQUEST_BYTES) {
+        throw new Error(`Guardrail payload exceeds the ${MAX_GUARDRAIL_REQUEST_BYTES} byte limit`);
+      }
+      const evaluate = async (type) => {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.config.requestTimeoutMs);
+        try {
+          const response = await fetch(`${evalEndpoint}/api/v1/evaluate/${type}`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Authorization": `Bearer ${this.config.apiKey}`,
+              "x-api-key": this.config.apiKey
+            },
+            body: serializedPayload,
+            signal: controller.signal
+          });
+          if (response.ok) {
+            const text = await _ObservyzeClient.readBoundedResponse(response);
+            const parsed = JSON.parse(text);
+            return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+          }
+          const errorBody = await _ObservyzeClient.readBoundedResponse(response);
           const { traceId, code, message } = _ObservyzeClient.parseApiError(response, errorBody);
           if (this.config.debug) {
-            log3.extend("warn")(`[Observyze Guardrail] Eval returned ${response.status} [${code}] (ref: ${traceId}): ${message}`);
+            log3.extend("warn")(`[Observyze Guardrail] ${type} eval returned ${response.status} [${code}] (ref: ${traceId}): ${message}`);
           }
-        }
-      } catch (fetchError) {
-        clearTimeout(timeout);
-        if (fetchError.name === "AbortError") {
+          return null;
+        } catch (fetchError) {
           if (this.config.debug) {
-            log3.extend("warn")("[Observyze Guardrail] Evaluation timed out after 5s");
+            const reason = fetchError?.name === "AbortError" ? `timed out after ${this.config.requestTimeoutMs}ms` : `failed: ${fetchError?.message || "unknown error"}`;
+            log3.extend("warn")(`[Observyze Guardrail] ${type} evaluation ${reason}`);
           }
-        } else if (this.config.debug) {
-          log3.extend("warn")("[Observyze Guardrail] Evaluation request failed:", fetchError.message);
+          return null;
+        } finally {
+          clearTimeout(timeout);
         }
+      };
+      const [hallucinationResult, safetyResult] = await Promise.all([
+        evaluate("hallucination"),
+        evaluate("safety")
+      ]);
+      const unavailableReason = "One or more required guardrail evaluations were unavailable";
+      if (!hallucinationResult || !safetyResult) {
+        return this.config.failClosed ? { pass: false, score: null, confidence: null, safetyScore: null, evaluationSource: "error", fallbackReason: unavailableReason, reason: `${unavailableReason}. Fail-closed: execution blocked.` } : { pass: true, score: null, confidence: null, safetyScore: null, evaluationSource: "error", fallbackReason: unavailableReason };
       }
-      let hallucinationScore = 0;
-      let safetyScore = 0;
-      let evaluationSource = "live";
-      let confidence = null;
-      if (evalResult) {
-        hallucinationScore = evalResult.score ?? evalResult.hallucination_score ?? null;
-        safetyScore = evalResult.safety_score ?? 0;
-        evaluationSource = evalResult.evaluation_source ?? "live";
-        confidence = evalResult.confidence ?? null;
-        if (hallucinationScore === null) {
-          if (this.config.failClosed) {
-            if (this.config.debug) {
-              log3.extend("warn")("[Observyze Guardrail] Eval returned null score \u2014 failing closed (blocking)");
-            }
-            return {
-              pass: false,
-              score: null,
-              confidence: null,
-              safetyScore: null,
-              evaluationSource: "error",
-              fallbackReason: evalResult.message || "Evaluation failed to produce a score",
-              reason: "Evaluation service failed to produce a score. Fail-closed: execution blocked."
-            };
-          }
-          if (this.config.debug) {
-            log3("[Observyze Guardrail] Eval returned null score \u2014 allowing (fail-open)");
-          }
-          return {
-            pass: true,
-            score: null,
-            confidence: null,
-            safetyScore: null,
-            evaluationSource: "error",
-            fallbackReason: evalResult.message || "Evaluation failed to produce a score"
-          };
-        }
-      } else if (this.config.failClosed) {
-        if (this.config.debug) {
-          log3.extend("warn")("[Observyze Guardrail] Eval unavailable \u2014 failing closed (blocking)");
-        }
-        return {
-          pass: false,
-          score: null,
-          confidence: null,
-          safetyScore: null,
-          evaluationSource: "error",
-          fallbackReason: "Evaluation service unreachable",
-          reason: "Evaluation service unreachable. Fail-closed: execution blocked."
-        };
-      } else {
-        if (this.config.debug) {
-          log3("[Observyze Guardrail] Eval unavailable \u2014 allowing (fail-open)");
-        }
-        return {
-          pass: true,
-          score: null,
-          confidence: null,
-          safetyScore: null,
-          evaluationSource: "error",
-          fallbackReason: "Evaluation service unreachable"
-        };
+      const validScore = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1 ? value : null;
+      const hallucinationScore = validScore(hallucinationResult.score ?? hallucinationResult.hallucination_score);
+      const safetyScore = validScore(safetyResult.score ?? safetyResult.safety_score);
+      const rawSource = hallucinationResult.evaluation_source ?? safetyResult.evaluation_source ?? "live";
+      const evaluationSource = ALLOWED_EVALUATION_SOURCES.has(rawSource) ? rawSource : "live";
+      const confidence = validScore(hallucinationResult.confidence ?? safetyResult.confidence);
+      if (hallucinationScore === null || safetyScore === null) {
+        const reason = hallucinationResult.message || safetyResult.message || "Evaluation failed to produce a score";
+        return this.config.failClosed ? { pass: false, score: null, confidence: null, safetyScore: null, evaluationSource: "error", fallbackReason: reason, reason: `${reason}. Fail-closed: execution blocked.` } : { pass: true, score: null, confidence: null, safetyScore: null, evaluationSource: "error", fallbackReason: reason };
       }
       const hallThreshold = this.config.hallucinationThreshold;
       const safeThreshold = this.config.safetyThreshold;
       const confThreshold = this.config.confidenceThreshold;
       if (confidence !== null && confidence < confThreshold) {
-        if (hallucinationScore >= hallThreshold) {
+        if (hallucinationScore >= hallThreshold || safetyScore >= safeThreshold) {
           if (this.config.debug) {
-            log3.extend("warn")(`[Observyze Guardrail] High score (${hallucinationScore.toFixed(2)}) but low confidence (${confidence.toFixed(2)}). Alerting only.`);
+            log3.extend("warn")(`[Observyze Guardrail] High score but low confidence (${confidence.toFixed(2)}). Alerting only.`);
           }
           return {
             pass: true,
@@ -897,7 +1607,7 @@ var ObservyzeClient = class _ObservyzeClient {
             confidence,
             safetyScore,
             evaluationSource,
-            reason: `Score ${hallucinationScore.toFixed(2)} but confidence ${confidence.toFixed(2)} is low. Execution allowed with alert.`
+            reason: `Risk score exceeded a threshold but confidence ${confidence.toFixed(2)} is below ${confThreshold.toFixed(2)}. Execution allowed with alert.`
           };
         }
       }
@@ -937,9 +1647,8 @@ var ObservyzeClient = class _ObservyzeClient {
     }
   }
   /**
-   * Phase 4: Autonomous Circuit Breakers
-   * Execute an agent action wrapped with the Circuit Breaker.
-   * Pauses execution if hallucination score >= hallucinationThreshold and requests human review.
+   * Execute an application action only after an explicit pre-execution
+   * guardrail check passes.
    * @throws Error when execution is blocked by circuit breaker
    */
   async executeWithCircuitBreaker(agentExecution, traceContext) {
@@ -948,7 +1657,9 @@ var ObservyzeClient = class _ObservyzeClient {
     }
     const guardResult = await this.checkGuardrails(traceContext || "execution context");
     if (!guardResult.pass) {
-      const error = new Error(`[Observyze] Execution Blocked by Autonomous Circuit Breaker. Hallucination: ${guardResult.score?.toFixed(2) ?? "N/A"}, Safety: ${(guardResult.safetyScore ?? 0)?.toFixed(2) ?? "N/A"}. Reason: ${guardResult.reason}. Human approval required before agent can continue.`);
+      const error = new Error(
+        `[Observyze] Execution Blocked by Autonomous Circuit Breaker. Hallucination: ${guardResult.score?.toFixed(2) ?? "N/A"}, Safety: ${(guardResult.safetyScore ?? 0)?.toFixed(2) ?? "N/A"}. Reason: ${guardResult.reason}. Human approval required before agent can continue.`
+      );
       if (this.config.debug) {
         log3.extend("error")("[Observyze CircuitBreaker] Execution blocked:", error.message);
       }
@@ -959,34 +1670,10 @@ var ObservyzeClient = class _ObservyzeClient {
     }
     return await agentExecution();
   }
-  /**
-   * Phase 4: Bug Bounty Protocol (Automated) (Requirement 4.2)
-   * Automatically shard persistent failure cases to external security researcher endpoints (e.g. HackerOne wrapper)
-   */
-  async reportBugBounty(traceId, securityEndpoint, failureContext) {
-    try {
-      if (this.config.debug) {
-        log3(`[Observyze SDK] Sharding persistent failure case ${traceId} to Bug Bounty Protocol endpoint...`);
-      }
-      await fetch(securityEndpoint, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          alert: "persistent_failure_sharded",
-          trace_id: traceId,
-          context: failureContext,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        })
-      });
-      if (this.config.debug) {
-        log3(`[Observyze SDK] Bug Bounty payload successfully transmitted.`);
-      }
-    } catch (err) {
-      log3.extend("error")("[Observyze Bug Bounty] Failed to shard failure case:", err);
-    }
-  }
 };
 export {
+  ExecutionBudget,
+  ExecutionBudgetExceededError,
   ObservyzeClient,
   ObservyzeSpanExporter,
   Span,
@@ -995,5 +1682,9 @@ export {
   TraceStatus,
   wrap,
   wrapAnthropic,
-  wrapOpenAI
+  wrapGemini,
+  wrapLangChain,
+  wrapLlamaIndex,
+  wrapOpenAI,
+  wrapVercelAI
 };