@arizeai/openinference-instrumentation-beeai 1.1.0 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arizeai/openinference-instrumentation-beeai",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "license": "Apache-2.0",
   "author": "gallas.milan@gmail.com",
   "description": "OpenInference Instrumentation for BeeAI framework",
@@ -36,12 +36,12 @@
     "@arizeai/openinference-semantic-conventions": "1.0.0"
   },
   "peerDependencies": {
-    "beeai-framework": "^0.1.8"
+    "beeai-framework": "^0.1.9"
   },
   "devDependencies": {
     "@types/jest": "^29.5.12",
     "@types/node": "^20.14.11",
-    "beeai-framework": "^0.1.8",
+    "beeai-framework": "^0.1.9",
     "import-in-the-middle": "^1.13.0",
     "@opentelemetry/exporter-trace-otlp-proto": "^0.50.0",
     "@opentelemetry/resources": "^1.30.1",

package/src/helpers/getSerializedObjectSafe.ts

@@ -15,7 +15,6 @@
  */
 
 import { Serializable } from "beeai-framework/internals/serializable";
-import { instrumentationLogger } from "beeai-framework/instrumentation/logger";
 import { getProp } from "beeai-framework/internals/helpers/object";
 import { EventMeta, InferCallbackValue } from "beeai-framework/emitter/types";
 import type { ReActAgentCallbacks } from "beeai-framework/agents/react/types";
@@ -52,6 +51,7 @@ import {
   SemanticConventions,
 } from "@arizeai/openinference-semantic-conventions";
 import { Tool, ToolEvents } from "beeai-framework/tools/base";
+import { diag } from "@opentelemetry/api";
 
 function parserLLMInputMessages(
   messages: readonly Message<MessageContentPart, string>[],
@@ -93,233 +93,242 @@ export function getSerializedObjectSafe(
   dataObject: unknown,
   meta: EventMeta<unknown>,
 ) {
-  // agent events
-  if (
-    [startEventName, successEventName, errorEventName, retryEventName].includes(
-      meta.name as keyof ReActAgentCallbacks,
-    ) &&
-    meta.creator instanceof BaseAgent
-  ) {
-    const { meta, tools, memory, error, data } =
-      dataObject as InferCallbackValue<
-        | ReActAgentCallbacks["start"]
-        | ReActAgentCallbacks["error"]
-        | ReActAgentCallbacks["success"]
-        | ReActAgentCallbacks["retry"]
-      >;
-    return {
-      [SemanticConventions.OPENINFERENCE_SPAN_KIND]:
-        OpenInferenceSpanKind.AGENT,
-      iteration: meta.iteration,
-      ...(tools?.length > 0 && {
-        [SemanticConventions.LLM_TOOLS]: tools.map((tool) => ({
-          [SemanticConventions.TOOL_NAME]: tool.name,
-          [SemanticConventions.TOOL_DESCRIPTION]: tool.description,
-          "tool.options": tool.options,
-        })),
-      }),
-      ...(memory.messages.length > 0 && {
-        [SemanticConventions.INPUT_MIME_TYPE]: MimeType.JSON,
-        [SemanticConventions.INPUT_VALUE]: JSON.stringify(memory.messages),
-      }),
-      ...(error && {
-        "exception.message": error.message,
-        "exception.stacktrace": error.stack,
-        "exception.type": error.name,
-      }),
-      ...(data && {
-        [SemanticConventions.OUTPUT_MIME_TYPE]: MimeType.JSON,
-        [SemanticConventions.OUTPUT_VALUE]: JSON.stringify(data),
-      }),
-    };
-  }
+  try {
+    // agent events
+    if (
+      [
+        startEventName,
+        successEventName,
+        errorEventName,
+        retryEventName,
+      ].includes(meta.name as keyof ReActAgentCallbacks) &&
+      meta.creator instanceof BaseAgent
+    ) {
+      const { meta, tools, memory, error, data } =
+        dataObject as InferCallbackValue<
+          | ReActAgentCallbacks["start"]
+          | ReActAgentCallbacks["error"]
+          | ReActAgentCallbacks["success"]
+          | ReActAgentCallbacks["retry"]
+        >;
+      return {
+        [SemanticConventions.OPENINFERENCE_SPAN_KIND]:
+          OpenInferenceSpanKind.AGENT,
+        iteration: meta.iteration,
+        ...(tools?.length > 0 && {
+          [SemanticConventions.LLM_TOOLS]: tools.map((tool) => ({
+            [SemanticConventions.TOOL_NAME]: tool.name,
+            [SemanticConventions.TOOL_DESCRIPTION]: tool.description,
+            "tool.options": tool.options,
+          })),
+        }),
+        ...(memory?.messages.length > 0 && {
+          [SemanticConventions.INPUT_MIME_TYPE]: MimeType.JSON,
+          [SemanticConventions.INPUT_VALUE]: JSON.stringify(memory.messages),
+        }),
+        ...(error && {
+          "exception.message": error.message,
+          "exception.stacktrace": error.stack,
+          "exception.type": error.name,
+        }),
+        ...(data && {
+          [SemanticConventions.OUTPUT_MIME_TYPE]: MimeType.JSON,
+          [SemanticConventions.OUTPUT_VALUE]: JSON.stringify(data),
+        }),
+      };
+    }
 
-  // update events
-  if (
-    [updateEventName, partialUpdateEventName].includes(
-      meta.name as keyof ReActAgentCallbacks,
-    )
-  ) {
-    const { data } = dataObject as InferCallbackValue<
-      ReActAgentCallbacks["partialUpdate"] | ReActAgentCallbacks["update"]
-    >;
+    // update events
+    if (
+      [updateEventName, partialUpdateEventName].includes(
+        meta.name as keyof ReActAgentCallbacks,
+      )
+    ) {
+      const { data } = dataObject as InferCallbackValue<
+        ReActAgentCallbacks["partialUpdate"] | ReActAgentCallbacks["update"]
+      >;
 
-    const output = data.final_answer || data.tool_output;
-    return {
-      [SemanticConventions.OPENINFERENCE_SPAN_KIND]:
-        OpenInferenceSpanKind.AGENT,
-      thought: data.thought,
-      ...(data.tool_name && {
-        [SemanticConventions.TOOL_NAME]: data.tool_name,
-      }),
-      ...(data.tool_input && {
-        [SemanticConventions.TOOL_PARAMETERS]: JSON.stringify(data.tool_input),
-      }),
-      ...(output && {
-        [SemanticConventions.OUTPUT_MIME_TYPE]: MimeType.JSON,
-        [SemanticConventions.OUTPUT_VALUE]: output,
-      }),
-    };
-  }
+      const output = data?.final_answer || data?.tool_output;
+      return {
+        [SemanticConventions.OPENINFERENCE_SPAN_KIND]:
+          OpenInferenceSpanKind.AGENT,
+        thought: data.thought,
+        ...(data?.tool_name && {
+          [SemanticConventions.TOOL_NAME]: data.tool_name,
+        }),
+        ...(data?.tool_input && {
+          [SemanticConventions.TOOL_PARAMETERS]: JSON.stringify(
+            data.tool_input,
+          ),
+        }),
+        ...(output && {
+          [SemanticConventions.OUTPUT_MIME_TYPE]: MimeType.JSON,
+          [SemanticConventions.OUTPUT_VALUE]: output,
+        }),
+      };
+    }
 
-  // tool events (from agent)
-  if (
-    [toolErrorEventName, toolStartEventName, toolSuccessEventName].includes(
-      meta.name as keyof ReActAgentCallbacks,
-    )
-  ) {
-    const { data } = dataObject as InferCallbackValue<
-      | ReActAgentCallbacks["toolError"]
-      | ReActAgentCallbacks["toolStart"]
-      | ReActAgentCallbacks["toolSuccess"]
-    >;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const output: any = data.result && data.result.createSnapshot();
+    // tool events (from agent)
+    if (
+      [toolErrorEventName, toolStartEventName, toolSuccessEventName].includes(
+        meta.name as keyof ReActAgentCallbacks,
+      )
+    ) {
+      const { data } = dataObject as InferCallbackValue<
+        | ReActAgentCallbacks["toolError"]
+        | ReActAgentCallbacks["toolStart"]
+        | ReActAgentCallbacks["toolSuccess"]
+      >;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const output: any = data?.result && data.result.createSnapshot();
 
-    return {
-      [SemanticConventions.OPENINFERENCE_SPAN_KIND]: OpenInferenceSpanKind.TOOL,
-      thought: data.iteration.thought,
-      ...(data.input
-        ? { [SemanticConventions.TOOL_PARAMETERS]: JSON.stringify(data.input) }
-        : {}),
-      ...(data.tool.description && {
-        [SemanticConventions.TOOL_DESCRIPTION]: data.tool.description,
-      }),
-      ...(data.tool.name && {
-        [SemanticConventions.TOOL_NAME]: data.tool.name,
-      }),
-      ...(data.error && {
-        "exception.message": data.error.message,
-        "exception.stacktrace": data.error.stack,
-        "exception.type": data.error.name,
-      }),
-      ...(output && {
-        [SemanticConventions.OUTPUT_VALUE]: JSON.stringify(output),
-      }),
-    };
-  }
-  // tool events native
-  if (
-    [
-      startToolEventName,
-      successToolEventName,
-      finishToolEventName,
-      errorToolEventName,
-      retryToolEventName,
-    ].includes(meta.name as keyof ToolEvents) &&
-    meta.creator instanceof Tool
-  ) {
-    if (!dataObject) {
       return {
         [SemanticConventions.OPENINFERENCE_SPAN_KIND]:
           OpenInferenceSpanKind.TOOL,
+        thought: data.iteration.thought,
+        ...(data?.input
+          ? {
+              [SemanticConventions.TOOL_PARAMETERS]: JSON.stringify(data.input),
+            }
+          : {}),
+        ...(data?.tool.description && {
+          [SemanticConventions.TOOL_DESCRIPTION]: data.tool.description,
+        }),
+        ...(data?.tool.name && {
+          [SemanticConventions.TOOL_NAME]: data.tool.name,
+        }),
+        ...(data?.error && {
+          "exception.message": data.error.message,
+          "exception.stacktrace": data.error.stack,
+          "exception.type": data.error.name,
+        }),
+        ...(output && {
+          [SemanticConventions.OUTPUT_VALUE]: JSON.stringify(output),
+        }),
       };
     }
-    const { input, output, error } = dataObject as InferCallbackValue<
-      | ToolEvents["start"]
-      | ToolEvents["success"]
-      | ToolEvents["retry"]
-      | ToolEvents["error"]
-    >;
+    // tool events native
+    if (
+      [
+        startToolEventName,
+        successToolEventName,
+        finishToolEventName,
+        errorToolEventName,
+        retryToolEventName,
+      ].includes(meta.name as keyof ToolEvents) &&
+      meta.creator instanceof Tool
+    ) {
+      if (!dataObject) {
+        return {
+          [SemanticConventions.OPENINFERENCE_SPAN_KIND]:
+            OpenInferenceSpanKind.TOOL,
+        };
+      }
+      const { input, output, error } = dataObject as InferCallbackValue<
+        | ToolEvents["start"]
+        | ToolEvents["success"]
+        | ToolEvents["retry"]
+        | ToolEvents["error"]
+      >;
 
-    return {
-      [SemanticConventions.OPENINFERENCE_SPAN_KIND]: OpenInferenceSpanKind.TOOL,
-      ...(input
-        ? { [SemanticConventions.TOOL_PARAMETERS]: JSON.stringify(input) }
-        : {}),
-      ...(output && {
-        [SemanticConventions.OUTPUT_VALUE]: JSON.stringify(output),
-      }),
-      ...(error && {
-        "exception.message": error.message,
-        "exception.stacktrace": error.stack,
-        "exception.type": error.name,
-      }),
-    };
-  }
+      return {
+        [SemanticConventions.OPENINFERENCE_SPAN_KIND]:
+          OpenInferenceSpanKind.TOOL,
+        ...(input
+          ? { [SemanticConventions.TOOL_PARAMETERS]: JSON.stringify(input) }
+          : {}),
+        ...(output && {
+          [SemanticConventions.OUTPUT_VALUE]: JSON.stringify(output),
+        }),
+        ...(error && {
+          "exception.message": error.message,
+          "exception.stacktrace": error.stack,
+          "exception.type": error.name,
+        }),
+      };
+    }
 
-  // llm events
-  if (
-    [
-      successLLMEventName,
-      startLLMEventName,
-      errorLLMEventName,
-      newTokenLLMEventName,
-    ].includes(meta.name as keyof ChatModelEvents) &&
-    meta.creator instanceof ChatModel
-  ) {
-    const { value, input, error } = dataObject as InferCallbackValue<
-      | ChatModelEvents["success"]
-      | ChatModelEvents["start"]
-      | ChatModelEvents["error"]
-      | ChatModelEvents["newToken"]
-    >;
+    // llm events
+    if (
+      [
+        successLLMEventName,
+        startLLMEventName,
+        errorLLMEventName,
+        newTokenLLMEventName,
+      ].includes(meta.name as keyof ChatModelEvents) &&
+      meta.creator instanceof ChatModel
+    ) {
+      const { value, input, error } = dataObject as InferCallbackValue<
+        | ChatModelEvents["success"]
+        | ChatModelEvents["start"]
+        | ChatModelEvents["error"]
+        | ChatModelEvents["newToken"]
+      >;
 
-    const creator = meta.creator.createSnapshot();
-    return {
-      [SemanticConventions.OPENINFERENCE_SPAN_KIND]: OpenInferenceSpanKind.LLM,
-      ...(value?.usage?.completionTokens && {
-        [SemanticConventions.LLM_TOKEN_COUNT_COMPLETION]:
-          value?.usage?.completionTokens,
-      }),
-      ...(value?.usage?.promptTokens && {
-        [SemanticConventions.LLM_TOKEN_COUNT_PROMPT]:
-          value?.usage?.promptTokens,
-      }),
-      ...(value?.usage?.totalTokens && {
-        [SemanticConventions.LLM_TOKEN_COUNT_TOTAL]: value?.usage?.totalTokens,
-      }),
-      ...(input?.messages.length > 0 && {
-        [SemanticConventions.INPUT_MIME_TYPE]: MimeType.JSON,
-        [SemanticConventions.INPUT_VALUE]: JSON.stringify(input.messages),
-        ...parserLLMInputMessages(input.messages),
-      }),
-      ...(value?.messages.length > 0 && {
-        [SemanticConventions.OUTPUT_MIME_TYPE]: MimeType.JSON,
-        [SemanticConventions.OUTPUT_VALUE]: JSON.stringify(value.messages),
-        ...parseLLMOutputMessages(value.messages),
-      }),
-      ...(error && {
-        "exception.message": error.message,
-        "exception.stacktrace": error.stack,
-        "exception.type": error.name,
-      }),
-      ...("providerId" in creator && {
-        [SemanticConventions.LLM_PROVIDER]: creator.providerId,
-        [`${SemanticAttributePrefixes.metadata}.${LLMAttributePostfixes.provider}`]:
-          creator.providerId,
-      }),
-      ...("modelId" in creator && {
-        [SemanticConventions.LLM_MODEL_NAME]: creator.modelId,
-        [`${SemanticAttributePrefixes.metadata}.${LLMAttributePostfixes.model_name}`]:
-          creator.modelId,
-      }),
-      ...(creator.parameters && {
-        [SemanticConventions.LLM_INVOCATION_PARAMETERS]: JSON.stringify(
-          creator.parameters,
-        ),
-      }),
-    };
-  }
-  if (meta.name === finishLLMEventName && meta.creator instanceof ChatModel) {
-    return {
-      [SemanticConventions.OPENINFERENCE_SPAN_KIND]: OpenInferenceSpanKind.LLM,
-    };
-  }
+      const creator = meta.creator.createSnapshot();
+      return {
+        [SemanticConventions.OPENINFERENCE_SPAN_KIND]:
+          OpenInferenceSpanKind.LLM,
+        ...(value?.usage?.completionTokens && {
+          [SemanticConventions.LLM_TOKEN_COUNT_COMPLETION]:
+            value?.usage?.completionTokens,
+        }),
+        ...(value?.usage?.promptTokens && {
+          [SemanticConventions.LLM_TOKEN_COUNT_PROMPT]:
+            value?.usage?.promptTokens,
+        }),
+        ...(value?.usage?.totalTokens && {
+          [SemanticConventions.LLM_TOKEN_COUNT_TOTAL]:
+            value?.usage?.totalTokens,
+        }),
+        ...(input?.messages.length > 0 && {
+          [SemanticConventions.INPUT_MIME_TYPE]: MimeType.JSON,
+          [SemanticConventions.INPUT_VALUE]: JSON.stringify(input.messages),
+          ...parserLLMInputMessages(input.messages),
+        }),
+        ...(value?.messages.length > 0 && {
+          [SemanticConventions.OUTPUT_MIME_TYPE]: MimeType.JSON,
+          [SemanticConventions.OUTPUT_VALUE]: JSON.stringify(value.messages),
+          ...parseLLMOutputMessages(value.messages),
+        }),
+        ...(error && {
+          "exception.message": error.message,
+          "exception.stacktrace": error.stack,
+          "exception.type": error.name,
+        }),
+        ...("providerId" in creator && {
+          [SemanticConventions.LLM_PROVIDER]: creator.providerId,
+          [`${SemanticAttributePrefixes.metadata}.${LLMAttributePostfixes.provider}`]:
+            creator.providerId,
+        }),
+        ...("modelId" in creator && {
+          [SemanticConventions.LLM_MODEL_NAME]: creator.modelId,
+          [`${SemanticAttributePrefixes.metadata}.${LLMAttributePostfixes.model_name}`]:
+            creator.modelId,
+        }),
+        ...(creator?.parameters && {
+          [SemanticConventions.LLM_INVOCATION_PARAMETERS]: JSON.stringify(
+            creator.parameters,
+          ),
+        }),
+      };
+    }
+    if (meta.name === finishLLMEventName && meta.creator instanceof ChatModel) {
+      return {
+        [SemanticConventions.OPENINFERENCE_SPAN_KIND]:
+          OpenInferenceSpanKind.LLM,
+      };
+    }
 
-  // other events
-  const data = getProp(dataObject, ["data"], dataObject);
-  if (data instanceof Serializable) {
-    try {
+    // other events
+    const data = getProp(dataObject, ["data"], dataObject);
+    if (data instanceof Serializable) {
       return { data: JSON.stringify(data.createSnapshot()), test: "hallo" };
-    } catch (e) {
-      instrumentationLogger.warn(
-        e,
-        "Invalid createSnapshot method in the Serializable class",
-      );
-      return null;
     }
-  }
 
-  return { data: JSON.stringify(data) };
+    return { data: JSON.stringify(data) };
+  } catch (e) {
+    diag.warn("Failed to parse event data", e);
+    return null;
+  }
 }