@cloudbase/agent-observability 1.0.1-alpha.27 → 1.0.1-alpha.29

package/dist/chunk-PJ5HSKYS.mjs

@@ -0,0 +1,80 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/constants.ts
+import {
+  SemanticConventions,
+  OpenInferenceSpanKind
+} from "@arizeai/openinference-semantic-conventions";
+var OBSERVABILITY_TRACER_NAME, OBSERVABILITY_SDK_NAME, OBSERVABILITY_SDK_VERSION, OtelSpanAttributes;
+var init_constants = __esm({
+  "src/core/constants.ts"() {
+    "use strict";
+    OBSERVABILITY_TRACER_NAME = "agui-tracer";
+    OBSERVABILITY_SDK_NAME = "observability";
+    OBSERVABILITY_SDK_VERSION = "0.1.0";
+    OtelSpanAttributes = {
+      // OpenInference - re-export all standard conventions
+      ...SemanticConventions,
+      // Trace attributes (non-standard)
+      TRACE_NAME: "trace.name",
+      TRACE_TAGS: "trace.tags",
+      TRACE_PUBLIC: "trace.public",
+      TRACE_METADATA: "trace.metadata",
+      TRACE_INPUT: "trace.input",
+      TRACE_OUTPUT: "trace.output",
+      // Observation attributes (non-standard)
+      OBSERVATION_TYPE: "observation.type",
+      OBSERVATION_LEVEL: "observation.level",
+      OBSERVATION_STATUS_MESSAGE: "observation.status_message",
+      OBSERVATION_INPUT: "observation.input",
+      OBSERVATION_OUTPUT: "observation.output",
+      OBSERVATION_METADATA: "observation.metadata",
+      // LLM-specific (non-standard)
+      LLM_COMPLETION_START_TIME: "llm.completion_start_time",
+      LLM_MODEL_PARAMETERS: "llm.model_parameters",
+      LLM_USAGE_DETAILS: "llm.usage_details",
+      LLM_COST_DETAILS: "llm.cost_details",
+      // Retriever-specific (non-standard)
+      RETRIEVER_NAME: "retriever.name",
+      RETRIEVER_QUERY: "retriever.query",
+      RETRIEVER_INDEX_ID: "retriever.index_id",
+      RETRIEVER_TOP_K: "retriever.top_k",
+      // General (non-standard)
+      ENVIRONMENT: "environment",
+      RELEASE: "release",
+      VERSION: "version"
+    };
+  }
+});
+
+export {
+  __esm,
+  __export,
+  __toCommonJS,
+  OpenInferenceSpanKind,
+  OBSERVABILITY_TRACER_NAME,
+  OBSERVABILITY_SDK_NAME,
+  OBSERVABILITY_SDK_VERSION,
+  OtelSpanAttributes,
+  init_constants
+};
+//# sourceMappingURL=chunk-PJ5HSKYS.mjs.map

package/dist/chunk-PJ5HSKYS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/constants.ts"],"sourcesContent":["/**\n * OTEL attribute constants for observability.\n *\n * Uses OpenInference semantic conventions where applicable:\n * https://github.com/Arize-ai/openinference/tree/main/spec\n *\n * Falls back to non-standard attributes where OpenInference\n * doesn't define a standard.\n *\n * @module\n */\n\nimport {\n  SemanticConventions,\n  OpenInferenceSpanKind,\n} from \"@arizeai/openinference-semantic-conventions\";\n\n// Re-export OpenInference types for convenience\nexport { OpenInferenceSpanKind };\n\n/**\n * SDK information\n */\n// Brandless defaults: avoid emitting project-specific identifiers into traces.\n// Users can still override service.name via OTEL_SERVICE_NAME.\nexport const OBSERVABILITY_TRACER_NAME = \"agui-tracer\";\nexport const OBSERVABILITY_SDK_NAME = \"observability\";\nexport const OBSERVABILITY_SDK_VERSION = \"0.1.0\";\n\n/**\n * Combined attribute namespace for internal use\n * Provides a single namespace for all OTEL attributes used internally.\n *\n * Combines OpenInference SemanticConventions with non-standard attributes\n */\nexport const OtelSpanAttributes = {\n  // OpenInference - re-export all standard conventions\n  ...SemanticConventions,\n\n  // Trace attributes (non-standard)\n  TRACE_NAME: \"trace.name\",\n  TRACE_TAGS: \"trace.tags\",\n  TRACE_PUBLIC: \"trace.public\",\n  TRACE_METADATA: \"trace.metadata\",\n  TRACE_INPUT: \"trace.input\",\n  TRACE_OUTPUT: \"trace.output\",\n\n  // Observation attributes (non-standard)\n  OBSERVATION_TYPE: \"observation.type\",\n  OBSERVATION_LEVEL: \"observation.level\",\n  OBSERVATION_STATUS_MESSAGE: \"observation.status_message\",\n  OBSERVATION_INPUT: \"observation.input\",\n  OBSERVATION_OUTPUT: \"observation.output\",\n  OBSERVATION_METADATA: \"observation.metadata\",\n\n  // LLM-specific (non-standard)\n  LLM_COMPLETION_START_TIME: \"llm.completion_start_time\",\n  LLM_MODEL_PARAMETERS: \"llm.model_parameters\",\n  LLM_USAGE_DETAILS: \"llm.usage_details\",\n  LLM_COST_DETAILS: \"llm.cost_details\",\n\n  // Retriever-specific (non-standard)\n  RETRIEVER_NAME: \"retriever.name\",\n  RETRIEVER_QUERY: \"retriever.query\",\n  RETRIEVER_INDEX_ID: \"retriever.index_id\",\n  RETRIEVER_TOP_K: \"retriever.top_k\",\n\n  // General (non-standard)\n  ENVIRONMENT: \"environment\",\n  RELEASE: \"release\",\n  VERSION: \"version\",\n} as const;\n\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAYA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAfP,IAyBa,2BACA,wBACA,2BAQA;AAnCb;AAAA;AAAA;AAyBO,IAAM,4BAA4B;AAClC,IAAM,yBAAyB;AAC/B,IAAM,4BAA4B;AAQlC,IAAM,qBAAqB;AAAA;AAAA,MAEhC,GAAG;AAAA;AAAA,MAGH,YAAY;AAAA,MACZ,YAAY;AAAA,MACZ,cAAc;AAAA,MACd,gBAAgB;AAAA,MAChB,aAAa;AAAA,MACb,cAAc;AAAA;AAAA,MAGd,kBAAkB;AAAA,MAClB,mBAAmB;AAAA,MACnB,4BAA4B;AAAA,MAC5B,mBAAmB;AAAA,MACnB,oBAAoB;AAAA,MACpB,sBAAsB;AAAA;AAAA,MAGtB,2BAA2B;AAAA,MAC3B,sBAAsB;AAAA,MACtB,mBAAmB;AAAA,MACnB,kBAAkB;AAAA;AAAA,MAGlB,gBAAgB;AAAA,MAChB,iBAAiB;AAAA,MACjB,oBAAoB;AAAA,MACpB,iBAAiB;AAAA;AAAA,MAGjB,aAAa;AAAA,MACb,SAAS;AAAA,MACT,SAAS;AAAA,IACX;AAAA;AAAA;","names":[]}

package/dist/{chunk-43GF2BGQ.mjs → chunk-Q5P7VQEQ.mjs}

@@ -1,57 +1,16 @@
 import {
+  OBSERVABILITY_SDK_NAME,
+  OBSERVABILITY_SDK_VERSION,
+  OpenInferenceSpanKind,
+  OtelSpanAttributes,
   __esm,
   __export,
-  __toCommonJS
-} from "./chunk-NFEGQTCC.mjs";
-
-// src/core/constants.ts
-import {
-  SemanticConventions,
-  OpenInferenceSpanKind
-} from "@arizeai/openinference-semantic-conventions";
-var OBSERVABILITY_SDK_NAME, OBSERVABILITY_SDK_VERSION, OtelSpanAttributes;
-var init_constants = __esm({
-  "src/core/constants.ts"() {
-    "use strict";
-    OBSERVABILITY_SDK_NAME = "observability";
-    OBSERVABILITY_SDK_VERSION = "0.1.0";
-    OtelSpanAttributes = {
-      // OpenInference - re-export all standard conventions
-      ...SemanticConventions,
-      // Trace attributes (non-standard)
-      TRACE_NAME: "trace.name",
-      TRACE_TAGS: "trace.tags",
-      TRACE_PUBLIC: "trace.public",
-      TRACE_METADATA: "trace.metadata",
-      TRACE_INPUT: "trace.input",
-      TRACE_OUTPUT: "trace.output",
-      // Observation attributes (non-standard)
-      OBSERVATION_TYPE: "observation.type",
-      OBSERVATION_LEVEL: "observation.level",
-      OBSERVATION_STATUS_MESSAGE: "observation.status_message",
-      OBSERVATION_INPUT: "observation.input",
-      OBSERVATION_OUTPUT: "observation.output",
-      OBSERVATION_METADATA: "observation.metadata",
-      // LLM-specific (non-standard)
-      LLM_COMPLETION_START_TIME: "llm.completion_start_time",
-      LLM_MODEL_PARAMETERS: "llm.model_parameters",
-      LLM_USAGE_DETAILS: "llm.usage_details",
-      LLM_COST_DETAILS: "llm.cost_details",
-      // Retriever-specific (non-standard)
-      RETRIEVER_NAME: "retriever.name",
-      RETRIEVER_QUERY: "retriever.query",
-      RETRIEVER_INDEX_ID: "retriever.index_id",
-      RETRIEVER_TOP_K: "retriever.top_k",
-      // General (non-standard)
-      ENVIRONMENT: "environment",
-      RELEASE: "release",
-      VERSION: "version"
-    };
-  }
-});
+  __toCommonJS,
+  init_constants
+} from "./chunk-PJ5HSKYS.mjs";
 
 // src/core/attributes.ts
-import { SemanticConventions as SemanticConventions2 } from "@arizeai/openinference-semantic-conventions";
+import { SemanticConventions } from "@arizeai/openinference-semantic-conventions";
 function createTraceAttributes({
   name,
   userId,
@@ -98,23 +57,23 @@ function createObservationAttributes(type, attributes) {
   } = attributes;
   const spanKind = OpenInferenceSpanKind[type.toUpperCase()] || "CHAIN";
   const otelAttributes = {
-    [SemanticConventions2.OPENINFERENCE_SPAN_KIND]: spanKind,
+    [SemanticConventions.OPENINFERENCE_SPAN_KIND]: spanKind,
     [OtelSpanAttributes.OBSERVATION_TYPE]: type,
     [OtelSpanAttributes.OBSERVATION_LEVEL]: level,
     [OtelSpanAttributes.OBSERVATION_STATUS_MESSAGE]: statusMessage,
     [OtelSpanAttributes.VERSION]: version,
     // Use OpenInference input.value convention
-    [SemanticConventions2.INPUT_VALUE]: _serialize(input),
+    [SemanticConventions.INPUT_VALUE]: _serialize(input),
     // Also set observation.input for compatibility
     [OtelSpanAttributes.OBSERVATION_INPUT]: _serialize(input),
     // Use OpenInference output.value convention
-    [SemanticConventions2.OUTPUT_VALUE]: _serialize(output),
+    [SemanticConventions.OUTPUT_VALUE]: _serialize(output),
     // Also set observation.output for compatibility
     [OtelSpanAttributes.OBSERVATION_OUTPUT]: _serialize(output)
   };
   if (type === "llm") {
     if (model) {
-      otelAttributes[SemanticConventions2.LLM_MODEL_NAME] = model;
+      otelAttributes[SemanticConventions.LLM_MODEL_NAME] = model;
     }
     const system = attributes?.system;
     const provider = attributes?.provider;
@@ -123,26 +82,26 @@ function createObservationAttributes(type, attributes) {
     const inputMimeType = attributes?.inputMimeType;
     const outputMimeType = attributes?.outputMimeType;
     if (system !== void 0) {
-      otelAttributes[SemanticConventions2.LLM_SYSTEM] = String(system);
+      otelAttributes[SemanticConventions.LLM_SYSTEM] = String(system);
     }
     if (provider !== void 0) {
-      otelAttributes[SemanticConventions2.LLM_PROVIDER] = String(provider);
+      otelAttributes[SemanticConventions.LLM_PROVIDER] = String(provider);
     }
     if (modelParameters) {
-      otelAttributes[SemanticConventions2.LLM_INVOCATION_PARAMETERS] = _serialize(modelParameters);
+      otelAttributes[SemanticConventions.LLM_INVOCATION_PARAMETERS] = _serialize(modelParameters);
       otelAttributes[OtelSpanAttributes.LLM_MODEL_PARAMETERS] = _serialize(modelParameters);
     }
     if (usageDetails) {
       if (typeof usageDetails === "object") {
         const usage = usageDetails;
         if (usage.promptTokens !== void 0) {
-          otelAttributes[SemanticConventions2.LLM_TOKEN_COUNT_PROMPT] = usage.promptTokens;
+          otelAttributes[SemanticConventions.LLM_TOKEN_COUNT_PROMPT] = usage.promptTokens;
         }
         if (usage.completionTokens !== void 0) {
-          otelAttributes[SemanticConventions2.LLM_TOKEN_COUNT_COMPLETION] = usage.completionTokens;
+          otelAttributes[SemanticConventions.LLM_TOKEN_COUNT_COMPLETION] = usage.completionTokens;
         }
         if (usage.totalTokens !== void 0) {
-          otelAttributes[SemanticConventions2.LLM_TOKEN_COUNT_TOTAL] = usage.totalTokens;
+          otelAttributes[SemanticConventions.LLM_TOKEN_COUNT_TOTAL] = usage.totalTokens;
         }
       }
       otelAttributes[OtelSpanAttributes.LLM_USAGE_DETAILS] = _serialize(usageDetails);
@@ -159,18 +118,18 @@ function createObservationAttributes(type, attributes) {
       Object.assign(otelAttributes, messageAttrs);
     }
     if (inputMimeType !== void 0) {
-      otelAttributes[SemanticConventions2.INPUT_MIME_TYPE] = String(inputMimeType);
+      otelAttributes[SemanticConventions.INPUT_MIME_TYPE] = String(inputMimeType);
     }
     if (outputMimeType !== void 0) {
-      otelAttributes[SemanticConventions2.OUTPUT_MIME_TYPE] = String(outputMimeType);
+      otelAttributes[SemanticConventions.OUTPUT_MIME_TYPE] = String(outputMimeType);
     }
   }
   if (type === "embedding") {
     if (model) {
-      otelAttributes[SemanticConventions2.EMBEDDING_MODEL_NAME] = model;
+      otelAttributes[SemanticConventions.EMBEDDING_MODEL_NAME] = model;
     }
     if (modelParameters) {
-      otelAttributes[SemanticConventions2.LLM_INVOCATION_PARAMETERS] = _serialize(modelParameters);
+      otelAttributes[SemanticConventions.LLM_INVOCATION_PARAMETERS] = _serialize(modelParameters);
     }
   }
   if (type === "tool") {
@@ -179,13 +138,13 @@ function createObservationAttributes(type, attributes) {
     const toolParameters = attributes?.toolParameters;
     const toolCall = attributes?.toolCall;
     if (toolName !== void 0) {
-      otelAttributes[SemanticConventions2.TOOL_NAME] = String(toolName);
+      otelAttributes[SemanticConventions.TOOL_NAME] = String(toolName);
     }
     if (toolDescription !== void 0) {
-      otelAttributes[SemanticConventions2.TOOL_DESCRIPTION] = String(toolDescription);
+      otelAttributes[SemanticConventions.TOOL_DESCRIPTION] = String(toolDescription);
     }
     if (toolParameters !== void 0) {
-      otelAttributes[SemanticConventions2.TOOL_PARAMETERS] = _serialize(toolParameters);
+      otelAttributes[SemanticConventions.TOOL_PARAMETERS] = _serialize(toolParameters);
     }
     if (toolCall !== void 0 && typeof toolCall === "object") {
       const toolCallAttrs = _flattenToolCall(toolCall);
@@ -195,7 +154,7 @@ function createObservationAttributes(type, attributes) {
   if (type === "agent") {
     const agentName = attributes?.agentName;
     if (agentName !== void 0) {
-      otelAttributes[SemanticConventions2.AGENT_NAME] = String(agentName);
+      otelAttributes[SemanticConventions.AGENT_NAME] = String(agentName);
     }
   }
   if (type === "retriever") {
@@ -211,7 +170,7 @@ function createObservationAttributes(type, attributes) {
   }
   const metadataAttrs = _flattenAndSerializeMetadata(
     metadata,
-    SemanticConventions2.METADATA
+    SemanticConventions.METADATA
   );
   Object.assign(otelAttributes, metadataAttrs);
   const obsetvabilityMetadataAttrs = _flattenAndSerializeMetadata(
@@ -780,7 +739,7 @@ __export(src_exports, {
   validateTraceContext: () => validateTraceContext,
   validateTraceId: () => validateTraceId
 });
-import { trace as trace2, context as context2, SpanStatusCode as SpanStatusCode2 } from "@opentelemetry/api";
+import { trace as trace2, context as context2, SpanStatusCode as SpanStatusCode2, INVALID_SPAN_CONTEXT } from "@opentelemetry/api";
 function createOtelSpan(params) {
   return getTracer().startSpan(
     params.name,
@@ -795,63 +754,98 @@ function createParentContext(parentSpanContext) {
   if (!parentSpanContext) return;
   return trace2.setSpanContext(context2.active(), parentSpanContext);
 }
-function startObservation(name, attributes, options) {
-  const { asType = "chain", ...observationOptions } = options || {};
-  const otelSpan = createOtelSpan({
-    name,
-    ...observationOptions
-  });
+function createNoopSpan() {
+  return trace2.wrapSpanContext(INVALID_SPAN_CONTEXT);
+}
+function createNoopObservation(asType = "chain") {
+  const otelSpan = createNoopSpan();
   switch (asType) {
     case "llm":
-      return new ObservationLLM({
-        otelSpan,
-        attributes
-      });
+      return new ObservationLLM({ otelSpan });
     case "embedding":
-      return new ObservationEmbedding({
-        otelSpan,
-        attributes
-      });
+      return new ObservationEmbedding({ otelSpan });
     case "agent":
-      return new ObservationAgent({
-        otelSpan,
-        attributes
-      });
+      return new ObservationAgent({ otelSpan });
     case "tool":
-      return new ObservationTool({
-        otelSpan,
-        attributes
-      });
-    case "chain":
-      return new ObservationChain({
-        otelSpan,
-        attributes
-      });
+      return new ObservationTool({ otelSpan });
     case "retriever":
-      return new ObservationRetriever({
-        otelSpan,
-        attributes
-      });
+      return new ObservationRetriever({ otelSpan });
     case "reranker":
-      return new ObservationReranker({
-        otelSpan,
-        attributes
-      });
+      return new ObservationReranker({ otelSpan });
     case "evaluator":
-      return new ObservationEvaluator({
-        otelSpan,
-        attributes
-      });
+      return new ObservationEvaluator({ otelSpan });
     case "guardrail":
-      return new ObservationGuardrail({
-        otelSpan,
-        attributes
-      });
+      return new ObservationGuardrail({ otelSpan });
+    case "chain":
     default:
-      return new ObservationChain({
-        otelSpan,
-        attributes
-      });
+      return new ObservationChain({ otelSpan });
+  }
+}
+function startObservation(name, attributes, options) {
+  const { asType = "chain", ...observationOptions } = options || {};
+  try {
+    const otelSpan = createOtelSpan({
+      name,
+      ...observationOptions
+    });
+    switch (asType) {
+      case "llm":
+        return new ObservationLLM({
+          otelSpan,
+          attributes
+        });
+      case "embedding":
+        return new ObservationEmbedding({
+          otelSpan,
+          attributes
+        });
+      case "agent":
+        return new ObservationAgent({
+          otelSpan,
+          attributes
+        });
+      case "tool":
+        return new ObservationTool({
+          otelSpan,
+          attributes
+        });
+      case "chain":
+        return new ObservationChain({
+          otelSpan,
+          attributes
+        });
+      case "retriever":
+        return new ObservationRetriever({
+          otelSpan,
+          attributes
+        });
+      case "reranker":
+        return new ObservationReranker({
+          otelSpan,
+          attributes
+        });
+      case "evaluator":
+        return new ObservationEvaluator({
+          otelSpan,
+          attributes
+        });
+      case "guardrail":
+        return new ObservationGuardrail({
+          otelSpan,
+          attributes
+        });
+      default:
+        return new ObservationChain({
+          otelSpan,
+          attributes
+        });
+    }
+  } catch (err) {
+    console.warn(
+      `[Observability] Failed to create observation "${name}":`,
+      err instanceof Error ? err.message : err
+    );
+    return createNoopObservation(asType);
   }
 }
 function updateActiveTrace(attributes) {
@@ -892,67 +886,81 @@ function wrapPromise(promise, span, endOnExit) {
 }
 function startActiveObservation(name, fn, options) {
   const { asType = "chain", endOnExit, ...observationOptions } = options || {};
-  return getTracer().startActiveSpan(
-    name,
-    { startTime: observationOptions?.startTime },
-    createParentContext(observationOptions?.parentSpanContext) ?? context2.active(),
-    (span) => {
-      try {
-        let observation;
-        switch (asType) {
-          case "llm":
-            observation = new ObservationLLM({ otelSpan: span });
-            break;
-          case "embedding":
-            observation = new ObservationEmbedding({ otelSpan: span });
-            break;
-          case "agent":
-            observation = new ObservationAgent({ otelSpan: span });
-            break;
-          case "tool":
-            observation = new ObservationTool({ otelSpan: span });
-            break;
-          case "retriever":
-            observation = new ObservationRetriever({ otelSpan: span });
-            break;
-          case "reranker":
-            observation = new ObservationReranker({ otelSpan: span });
-            break;
-          case "evaluator":
-            observation = new ObservationEvaluator({ otelSpan: span });
-            break;
-          case "guardrail":
-            observation = new ObservationGuardrail({ otelSpan: span });
-            break;
-          case "chain":
-          default:
-            observation = new ObservationChain({ otelSpan: span });
-        }
-        const result = fn(observation);
-        if (result instanceof Promise) {
-          return wrapPromise(
-            result,
-            span,
-            endOnExit
-          );
-        } else {
+  let fnCalled = false;
+  try {
+    return getTracer().startActiveSpan(
+      name,
+      { startTime: observationOptions?.startTime },
+      createParentContext(observationOptions?.parentSpanContext) ?? context2.active(),
+      (span) => {
+        try {
+          let observation;
+          switch (asType) {
+            case "llm":
+              observation = new ObservationLLM({ otelSpan: span });
+              break;
+            case "embedding":
+              observation = new ObservationEmbedding({ otelSpan: span });
+              break;
+            case "agent":
+              observation = new ObservationAgent({ otelSpan: span });
+              break;
+            case "tool":
+              observation = new ObservationTool({ otelSpan: span });
+              break;
+            case "retriever":
+              observation = new ObservationRetriever({ otelSpan: span });
+              break;
+            case "reranker":
+              observation = new ObservationReranker({ otelSpan: span });
+              break;
+            case "evaluator":
+              observation = new ObservationEvaluator({ otelSpan: span });
+              break;
+            case "guardrail":
+              observation = new ObservationGuardrail({ otelSpan: span });
+              break;
+            case "chain":
+            default:
+              observation = new ObservationChain({ otelSpan: span });
+          }
+          fnCalled = true;
+          const result = fn(observation);
+          if (result instanceof Promise) {
+            return wrapPromise(
+              result,
+              span,
+              endOnExit
+            );
+          } else {
+            if (endOnExit !== false) {
+              span.end();
+            }
+            return result;
+          }
+        } catch (err) {
+          span.setStatus({
+            code: SpanStatusCode2.ERROR,
+            message: err instanceof Error ? err.message : "Unknown error"
+          });
           if (endOnExit !== false) {
             span.end();
           }
-          return result;
-        }
-      } catch (err) {
-        span.setStatus({
-          code: SpanStatusCode2.ERROR,
-          message: err instanceof Error ? err.message : "Unknown error"
-        });
-        if (endOnExit !== false) {
-          span.end();
+          throw err;
         }
-        throw err;
       }
+    );
+  } catch (err) {
+    if (fnCalled) {
+      throw err;
     }
-  );
+    console.warn(
+      `[Observability] startActiveObservation "${name}" failed, falling back to no-op:`,
+      err instanceof Error ? err.message : err
+    );
+    const noopObservation = createNoopObservation(asType);
+    return fn(noopObservation);
+  }
 }
 function updateActiveObservation(attributes) {
   const span = trace2.getActiveSpan();
@@ -978,41 +986,59 @@ function observe(fn, options = {}) {
   } = options;
   const wrappedFunction = function(...args) {
     const name = fn.name || "anonymous-function";
-    const inputData = captureInput ? _captureArguments(args) : void 0;
-    const observation = startObservation(
-      name,
-      inputData ? { input: inputData } : {},
-      {
-        ...observationOptions,
-        asType
-      }
-    );
-    const activeContext = trace2.setSpan(context2.active(), observation.otelSpan);
-    const result = context2.with(activeContext, () => fn.apply(this, args));
-    if (result instanceof Promise) {
-      return result.then(
-        (value) => {
-          if (captureOutput) {
-            observation.update({ output: value });
-          }
-          observation.end();
-          return value;
-        },
-        (err) => {
-          observation.update({
-            level: "ERROR",
-            statusMessage: err instanceof Error ? err.message : "Unknown error"
-          });
-          observation.end();
-          throw err;
+    let observation;
+    let fnCalled = false;
+    try {
+      const inputData = captureInput ? _captureArguments(args) : void 0;
+      observation = startObservation(
+        name,
+        inputData ? { input: inputData } : {},
+        {
+          ...observationOptions,
+          asType
         }
       );
+      const activeContext = trace2.setSpan(context2.active(), observation.otelSpan);
+      fnCalled = true;
+      const result = context2.with(activeContext, () => fn.apply(this, args));
+      if (result instanceof Promise) {
+        return result.then(
+          (value) => {
+            if (captureOutput) {
+              observation.update({ output: value });
+            }
+            observation.end();
+            return value;
+          },
+          (err) => {
+            observation.update({
+              level: "ERROR",
+              statusMessage: err instanceof Error ? err.message : "Unknown error"
+            });
+            observation.end();
+            throw err;
+          }
+        );
+      }
+      if (captureOutput) {
+        observation.update({ output: result });
+      }
+      observation.end();
+      return result;
+    } catch (err) {
+      if (fnCalled) {
+        throw err;
+      }
+      console.warn(
+        `[Observability] observe "${name}" failed, falling back to direct call:`,
+        err instanceof Error ? err.message : err
+      );
+      try {
+        observation?.end();
+      } catch {
+      }
+      return fn.apply(this, args);
     }
-    if (captureOutput) {
-      observation.update({ output: result });
-    }
-    observation.end();
-    return result;
   };
   Object.defineProperty(wrappedFunction, "name", { value: fn.name });
   Object.defineProperty(wrappedFunction, "length", { value: fn.length });
@@ -1059,4 +1085,4 @@ export {
   observe,
   init_src
 };
-//# sourceMappingURL=chunk-43GF2BGQ.mjs.map
+//# sourceMappingURL=chunk-Q5P7VQEQ.mjs.map