@cloudbase/agent-observability 1.0.1-alpha.16 → 1.0.1-alpha.18

package/dist/langchain.js

@@ -125,6 +125,18 @@ function createObservationAttributes(type, attributes) {
     if (model) {
       otelAttributes[import_openinference_semantic_conventions2.SemanticConventions.LLM_MODEL_NAME] = model;
     }
+    const system = attributes?.system;
+    const provider = attributes?.provider;
+    const inputMessages = attributes?.inputMessages;
+    const outputMessages = attributes?.outputMessages;
+    const inputMimeType = attributes?.inputMimeType;
+    const outputMimeType = attributes?.outputMimeType;
+    if (system !== void 0) {
+      otelAttributes[import_openinference_semantic_conventions2.SemanticConventions.LLM_SYSTEM] = String(system);
+    }
+    if (provider !== void 0) {
+      otelAttributes[import_openinference_semantic_conventions2.SemanticConventions.LLM_PROVIDER] = String(provider);
+    }
     if (modelParameters) {
       otelAttributes[import_openinference_semantic_conventions2.SemanticConventions.LLM_INVOCATION_PARAMETERS] = _serialize(modelParameters);
       otelAttributes[OtelSpanAttributes.LLM_MODEL_PARAMETERS] = _serialize(modelParameters);
@@ -147,6 +159,20 @@ function createObservationAttributes(type, attributes) {
     if (completionStartTime) {
       otelAttributes[OtelSpanAttributes.LLM_COMPLETION_START_TIME] = _serialize(completionStartTime);
     }
+    if (inputMessages !== void 0 && Array.isArray(inputMessages)) {
+      const messageAttrs = _flattenLLMMessages(inputMessages, "llm.input_messages");
+      Object.assign(otelAttributes, messageAttrs);
+    }
+    if (outputMessages !== void 0 && Array.isArray(outputMessages)) {
+      const messageAttrs = _flattenLLMMessages(outputMessages, "llm.output_messages");
+      Object.assign(otelAttributes, messageAttrs);
+    }
+    if (inputMimeType !== void 0) {
+      otelAttributes[import_openinference_semantic_conventions2.SemanticConventions.INPUT_MIME_TYPE] = String(inputMimeType);
+    }
+    if (outputMimeType !== void 0) {
+      otelAttributes[import_openinference_semantic_conventions2.SemanticConventions.OUTPUT_MIME_TYPE] = String(outputMimeType);
+    }
   }
   if (type === "embedding") {
     if (model) {
@@ -156,6 +182,42 @@ function createObservationAttributes(type, attributes) {
       otelAttributes[import_openinference_semantic_conventions2.SemanticConventions.LLM_INVOCATION_PARAMETERS] = _serialize(modelParameters);
     }
   }
+  if (type === "tool") {
+    const toolName = attributes?.toolName ?? attributes?.tool_name;
+    const toolDescription = attributes?.toolDescription;
+    const toolParameters = attributes?.toolParameters;
+    const toolCall = attributes?.toolCall;
+    if (toolName !== void 0) {
+      otelAttributes[import_openinference_semantic_conventions2.SemanticConventions.TOOL_NAME] = String(toolName);
+    }
+    if (toolDescription !== void 0) {
+      otelAttributes[import_openinference_semantic_conventions2.SemanticConventions.TOOL_DESCRIPTION] = String(toolDescription);
+    }
+    if (toolParameters !== void 0) {
+      otelAttributes[import_openinference_semantic_conventions2.SemanticConventions.TOOL_PARAMETERS] = _serialize(toolParameters);
+    }
+    if (toolCall !== void 0 && typeof toolCall === "object") {
+      const toolCallAttrs = _flattenToolCall(toolCall);
+      Object.assign(otelAttributes, toolCallAttrs);
+    }
+  }
+  if (type === "agent") {
+    const agentName = attributes?.agentName;
+    if (agentName !== void 0) {
+      otelAttributes[import_openinference_semantic_conventions2.SemanticConventions.AGENT_NAME] = String(agentName);
+    }
+  }
+  if (type === "retriever") {
+    const documents = attributes?.documents;
+    const query = attributes?.query;
+    if (documents !== void 0 && Array.isArray(documents)) {
+      const docAttrs = _flattenDocuments(documents);
+      Object.assign(otelAttributes, docAttrs);
+    }
+    if (query !== void 0) {
+      otelAttributes["retriever.query"] = String(query);
+    }
+  }
   const metadataAttrs = _flattenAndSerializeMetadata(
     metadata,
     import_openinference_semantic_conventions2.SemanticConventions.METADATA
@@ -166,6 +228,11 @@ function createObservationAttributes(type, attributes) {
     OtelSpanAttributes.OBSERVATION_METADATA
   );
   Object.assign(otelAttributes, obsetvabilityMetadataAttrs);
+  for (const [key, value] of Object.entries(attributes)) {
+    if (!(key in otelAttributes) && value !== void 0 && value !== null) {
+      otelAttributes[key] = typeof value === "string" ? value : _serialize(value);
+    }
+  }
   return Object.fromEntries(
     Object.entries(otelAttributes).filter(([_, v]) => v != null)
   );
@@ -199,6 +266,96 @@ function _flattenAndSerializeMetadata(metadata, prefix) {
   }
   return metadataAttributes;
 }
+function _flattenLLMMessages(messages, prefix) {
+  const attributes = {};
+  if (!messages || !Array.isArray(messages)) {
+    return attributes;
+  }
+  try {
+    messages.forEach((msg, index) => {
+      if (!msg || typeof msg !== "object") return;
+      const baseKey = `${prefix}.${index}.message`;
+      if (msg.role !== void 0) {
+        attributes[`${baseKey}.role`] = String(msg.role);
+      }
+      if (msg.content !== void 0) {
+        attributes[`${baseKey}.content`] = String(msg.content);
+      }
+      if (msg.toolCallId !== void 0) {
+        attributes[`${baseKey}.tool_call_id`] = String(msg.toolCallId);
+      }
+      if (msg.toolCalls && Array.isArray(msg.toolCalls)) {
+        msg.toolCalls.forEach((toolCall, tcIndex) => {
+          if (!toolCall || typeof toolCall !== "object") return;
+          const tcKey = `${baseKey}.tool_calls.${tcIndex}`;
+          if (toolCall.id !== void 0) {
+            attributes[`${tcKey}.id`] = String(toolCall.id);
+          }
+          if (toolCall.function !== void 0) {
+            if (toolCall.function.name !== void 0) {
+              attributes[`${tcKey}.function.name`] = String(toolCall.function.name);
+            }
+            if (toolCall.function.arguments !== void 0) {
+              attributes[`${tcKey}.function.arguments`] = String(toolCall.function.arguments);
+            }
+          }
+        });
+      }
+    });
+  } catch (e) {
+  }
+  return attributes;
+}
+function _flattenDocuments(documents) {
+  const attributes = {};
+  if (!documents || !Array.isArray(documents)) {
+    return attributes;
+  }
+  try {
+    documents.forEach((doc, index) => {
+      if (!doc || typeof doc !== "object") return;
+      const baseKey = `retrieval.documents.${index}.document`;
+      if (doc.id !== void 0) {
+        attributes[`${baseKey}.id`] = String(doc.id);
+      }
+      if (doc.content !== void 0) {
+        attributes[`${baseKey}.content`] = String(doc.content);
+      }
+      if (doc.score !== void 0) {
+        attributes[`${baseKey}.score`] = String(doc.score);
+      }
+      if (doc.metadata !== void 0 && typeof doc.metadata === "object") {
+        const metadataSerialized = _serialize(doc.metadata);
+        if (metadataSerialized) {
+          attributes[`${baseKey}.metadata`] = metadataSerialized;
+        }
+      }
+    });
+  } catch (e) {
+  }
+  return attributes;
+}
+function _flattenToolCall(toolCall) {
+  const attributes = {};
+  if (!toolCall || typeof toolCall !== "object") {
+    return attributes;
+  }
+  try {
+    if (toolCall.id !== void 0) {
+      attributes["tool_call.id"] = String(toolCall.id);
+    }
+    if (toolCall.function !== void 0) {
+      if (toolCall.function.name !== void 0) {
+        attributes["tool_call.function.name"] = String(toolCall.function.name);
+      }
+      if (toolCall.function.arguments !== void 0) {
+        attributes["tool_call.function.arguments"] = String(toolCall.function.arguments);
+      }
+    }
+  } catch (e) {
+  }
+  return attributes;
+}
 var import_openinference_semantic_conventions2;
 var init_attributes = __esm({
   "src/core/attributes.ts"() {
@@ -727,6 +884,8 @@ var CallbackHandler = class extends import_base.BaseCallbackHandler {
   last_trace_id = null;
   // External parent context from AG-UI.Server span
   externalParentSpanContext;
+  // External metadata from AG-UI.Server (e.g., threadId, runId)
+  externalMetadata;
   // Adapter name for ROOT span prefix
   adapterName;
   // Logger for debug output (defaults to noopLogger for silent operation)
@@ -748,10 +907,12 @@ var CallbackHandler = class extends import_base.BaseCallbackHandler {
    * to the server-level span, creating a unified trace hierarchy.
    *
    * @param spanContext - SpanContext from the AG-UI.Server span
+   * @param metadata - Optional metadata from server (e.g., threadId, runId)
    * @public
    */
-  setExternalParentContext(spanContext) {
+  setExternalParentContext(spanContext, metadata) {
     this.externalParentSpanContext = spanContext;
+    this.externalMetadata = metadata;
   }
   async handleLLMNewToken(token, _idx, runId, _parentRunId, _tags, _fields) {
     if (runId && !(runId in this.completionStartTimes)) {
@@ -781,7 +942,7 @@ var CallbackHandler = class extends import_base.BaseCallbackHandler {
         parentRunId,
         runId,
         tags,
-        metadata,
+        metadata: this.joinTagsAndMetaData(tags, metadata),
         attributes: {
           input: finalInput
         },
@@ -862,10 +1023,15 @@ var CallbackHandler = class extends import_base.BaseCallbackHandler {
       }
     }
     let extractedModelName;
+    let extractedSystem;
+    let extractedProvider;
     if (extraParams) {
       const invocationParamsModelName = extraParams.invocation_params.model;
       const metadataModelName = metadata && "ls_model_name" in metadata ? metadata["ls_model_name"] : void 0;
       extractedModelName = invocationParamsModelName ?? metadataModelName;
+      if (metadata && "ls_provider" in metadata) {
+        extractedProvider = metadata["ls_provider"];
+      }
     }
     const registeredPrompt = this.promptToParentRunMap.get(
       parentRunId ?? "root"
@@ -958,7 +1124,7 @@ var CallbackHandler = class extends import_base.BaseCallbackHandler {
         attributes: {
           input
         },
-        metadata,
+        metadata: this.joinTagsAndMetaData(tags, metadata),
         tags,
         asType: "tool"
       });
@@ -977,7 +1143,7 @@ var CallbackHandler = class extends import_base.BaseCallbackHandler {
           input: query
         },
         tags,
-        metadata,
+        metadata: this.joinTagsAndMetaData(tags, metadata),
         asType: "span"
       });
     } catch (e) {
@@ -1123,12 +1289,14 @@ var CallbackHandler = class extends import_base.BaseCallbackHandler {
     if (!parentRunId && this.adapterName) {
       finalRunName = `Adapter.${this.adapterName}`;
     }
+    const serverMetadata = this.externalMetadata ? { "agui.thread_id": this.externalMetadata.threadId, "agui.run_id": this.externalMetadata.runId } : {};
     const observation = startObservation(
       finalRunName,
       {
         version: this.version,
         metadata: this.joinTagsAndMetaData(tags, metadata),
-        ...attributes
+        ...attributes,
+        ...serverMetadata
       },
       {
         asType: asType ?? "span",
@@ -1145,6 +1313,19 @@ var CallbackHandler = class extends import_base.BaseCallbackHandler {
       this.logger.warn?.("Observation not found in runMap. Skipping operation.");
       return;
     }
+    const level = attributes.level;
+    const statusMessage = attributes.statusMessage;
+    if (level === "ERROR") {
+      try {
+        const { SpanStatusCode: SpanStatusCode2 } = require("@opentelemetry/api");
+        observation.otelSpan.setStatus({
+          code: SpanStatusCode2.ERROR,
+          message: statusMessage || "Unknown error"
+        });
+      } catch (e) {
+        this.logger.debug?.("Failed to set span error status:", e);
+      }
+    }
     observation.update(attributes).end();
     this.last_trace_id = observation.traceId;
     this.runMap.delete(runId);
@@ -1166,7 +1347,7 @@ var CallbackHandler = class extends import_base.BaseCallbackHandler {
     if (!metadata) {
       return;
     }
-    const reservedKeys = ["promptInfo", "userId", "sessionId"];
+    const reservedKeys = ["promptInfo", "userId", "sessionId", "thread_id", "runId", "run_id"];
     return Object.fromEntries(
       Object.entries(metadata).filter(([key, _]) => !reservedKeys.includes(key))
     );