chore(js): enforce safe type assertions (#3566)

Co-authored-by: Mikyo King <mikeldking@gmail.com>

Author: LarryHu0217

js/.changeset/safe-type-assertions.md

@@ -0,0 +1,18 @@
+---
+"@arizeai/openinference-core": patch
+"@arizeai/openinference-genai": patch
+"@arizeai/openinference-instrumentation-anthropic": patch
+"@arizeai/openinference-instrumentation-bedrock-agent-runtime": patch
+"@arizeai/openinference-instrumentation-bedrock": patch
+"@arizeai/openinference-instrumentation-beeai": patch
+"@arizeai/openinference-instrumentation-claude-agent-sdk": patch
+"@arizeai/openinference-instrumentation-langchain-v0": patch
+"@arizeai/openinference-instrumentation-langchain": patch
+"@arizeai/openinference-instrumentation-mcp": patch
+"@arizeai/openinference-instrumentation-openai-agents": patch
+"@arizeai/openinference-instrumentation-openai": patch
+"@arizeai/openinference-tanstack-ai": patch
+"@arizeai/openinference-vercel": patch
+---
+
+Replace unsafe type assertions with runtime type guards across packages (enforce `typescript/no-unsafe-type-assertion`)

js/.oxlintrc.json

@@ -24,7 +24,7 @@
       }
     ],
     "typescript/consistent-return": "warn",
-    "typescript/no-unsafe-type-assertion": "warn",
+    "typescript/no-unsafe-type-assertion": "error",
     "typescript/prefer-reduce-type-parameter": "warn",
     "typescript/no-floating-promises": "warn",
     "typescript/unbound-method": "warn",

js/packages/openinference-core/src/helpers/decorators.ts

@@ -48,14 +48,14 @@ export function observe<Fn extends AnyFn>(options: SpanTraceOptions = {}) {
     // Create a wrapper that preserves 'this' context for class methods
     const wrappedMethod = function (this: unknown, ...args: Parameters<Fn>) {
       // Bind the original method to the current 'this' context
-      const boundMethod = originalMethod.bind(this) as Fn;
+      const boundMethod = originalMethod.bind(this);
 
       // Use withSpan to wrap the bound method, ensuring consistent tracing behavior
       const tracedMethod = withSpan(boundMethod, traceOptions);
 
       return tracedMethod(...args);
-    } as Fn;
+    };
 
-    return wrappedMethod;
+    return Object.assign(wrappedMethod, originalMethod);
   };
 }

js/packages/openinference-core/src/helpers/withSpan.ts

@@ -1,3 +1,4 @@
+import type { Exception } from "@opentelemetry/api";
 import { SpanKind, SpanStatusCode } from "@opentelemetry/api";
 
 import {
@@ -13,6 +14,25 @@ import type { AnyFn, InputToAttributesFn, OutputToAttributesFn, SpanTraceOptions
 
 const { OPENINFERENCE_SPAN_KIND } = SemanticConventions;
 
+/**
+ * True when the thrown value is a valid OpenTelemetry {@link Exception} — a string or an
+ * object carrying at least one of message, name, or code — so it can be recorded on the
+ * span without losing its structured error details.
+ */
+function isException(error: unknown): error is Exception {
+  if (typeof error === "string") {
+    return true;
+  }
+  if (typeof error !== "object" || error == null) {
+    return false;
+  }
+  return (
+    ("message" in error && typeof error.message === "string") ||
+    ("name" in error && typeof error.name === "string") ||
+    ("code" in error && (typeof error.code === "string" || typeof error.code === "number"))
+  );
+}
+
 /**
  * Wraps a function with openinference tracing capabilities, creating spans for execution monitoring.
  *
@@ -94,7 +114,7 @@ export function withSpan<Fn extends AnyFn = AnyFn>(fn: Fn, options?: SpanTraceOp
     return String(error);
   };
   // TODO: infer the name from the target
-  const wrappedFn: Fn = function (this: ThisParameterType<Fn>, ...args: Parameters<Fn>) {
+  const wrappedFn = function (this: ThisParameterType<Fn>, ...args: Parameters<Fn>) {
     const tracer = configuredTracer ?? getTracer();
     return tracer.startActiveSpan(
       spanName,
@@ -108,16 +128,16 @@ export function withSpan<Fn extends AnyFn = AnyFn>(fn: Fn, options?: SpanTraceOp
       },
       (span) => {
         const recordError = (error: unknown) => {
-          span.recordException(error as Error);
+          span.recordException(isException(error) ? error : String(error));
           span.setStatus({
             code: SpanStatusCode.ERROR,
             message: getErrorMessage(error),
           });
         };
 
         try {
-          const result = fn.apply(this, args) as ReturnType<Fn>;
-          if (isPromise(result)) {
+          const result = fn.apply(this, args);
+          if (isPromise<Awaited<ReturnType<Fn>>>(result)) {
             // Execute the promise and return the promise chain
             return result
               .then((value: Awaited<ReturnType<Fn>>) => {
@@ -152,6 +172,6 @@ export function withSpan<Fn extends AnyFn = AnyFn>(fn: Fn, options?: SpanTraceOp
         }
       },
     );
-  } as Fn;
-  return wrappedFn;
+  };
+  return Object.assign(wrappedFn, fn);
 }

js/packages/openinference-core/src/trace/trace-config/OITracer.ts

@@ -19,7 +19,7 @@ function formatStartActiveSpanParams<F extends OpenInferenceActiveSpanCallback>(
 ) {
   let opts: SpanOptions | undefined;
   let ctx: Context | undefined;
-  let fn: F;
+  let fn: F | undefined;
 
   if (typeof arg2 === "function") {
     fn = arg2;
@@ -29,9 +29,11 @@ function formatStartActiveSpanParams<F extends OpenInferenceActiveSpanCallback>(
   } else {
     opts = arg2;
     ctx = arg3;
-    fn = arg4 as F;
+    fn = arg4;
   }
 
+  if (fn == null) return;
+
   opts = opts ?? {};
   ctx = ctx ?? apiContext.active();
 

js/packages/openinference-core/src/trace/trace-config/constants.ts

@@ -46,7 +46,7 @@ export const REDACTED_VALUE = "__REDACTED__";
  * The default, environment, and type information for each value on the TraceConfig
  * Used to generate a full TraceConfig object with the correct types and default values
  */
-export const traceConfigMetadata: Readonly<Record<TraceConfigKey, TraceConfigFlag>> = {
+export const traceConfigMetadata = {
   hideLLMTools: {
     default: DEFAULT_HIDE_LLM_TOOLS,
     envKey: OPENINFERENCE_HIDE_LLM_TOOLS,
@@ -102,7 +102,7 @@ export const traceConfigMetadata: Readonly<Record<TraceConfigKey, TraceConfigFla
     envKey: OPENINFERENCE_HIDE_PROMPTS,
     type: "boolean",
   },
-};
+} satisfies Readonly<Record<TraceConfigKey, TraceConfigFlag>>;
 
 export const DefaultTraceConfig: TraceConfig = {
   hideLLMTools: DEFAULT_HIDE_LLM_TOOLS,

js/packages/openinference-core/src/trace/trace-config/traceConfig.ts

@@ -1,10 +1,15 @@
 import { assertUnreachable, withSafety } from "../../utils";
 import { DefaultTraceConfig, traceConfigMetadata } from "./constants";
-import type { TraceConfig, TraceConfigKey, TraceConfigOptions } from "./types";
+import type {
+  BooleanTraceConfigFlag,
+  NumericTraceConfigFlag,
+  TraceConfig,
+  TraceConfigOptions,
+} from "./types";
 
 const safelyParseInt = withSafety({ fn: parseInt });
 
-type TraceConfigOptionMetadata = (typeof traceConfigMetadata)[TraceConfigKey];
+type TraceConfigOptionMetadata = BooleanTraceConfigFlag | NumericTraceConfigFlag;
 
 /**
  * Parses an option based on its type
@@ -13,6 +18,20 @@ type TraceConfigOptionMetadata = (typeof traceConfigMetadata)[TraceConfigKey];
  * @param optionMetadata - The {@link TraceConfigOptionMetadata} for the option which includes its type, default value, and environment variable key.
  *
  */
+function parseOption({
+  optionValue,
+  optionMetadata,
+}: {
+  optionValue?: boolean;
+  optionMetadata: BooleanTraceConfigFlag;
+}): boolean;
+function parseOption({
+  optionValue,
+  optionMetadata,
+}: {
+  optionValue?: number;
+  optionMetadata: NumericTraceConfigFlag;
+}): number;
 function parseOption({
   optionValue,
   optionMetadata,
@@ -52,14 +71,50 @@ export function generateTraceConfig(options?: TraceConfigOptions): TraceConfig {
   if (options == null) {
     return DefaultTraceConfig;
   }
-  return Object.entries(traceConfigMetadata).reduce((config, [key, optionMetadata]) => {
-    const TraceConfigKey = key as TraceConfigKey;
-    return {
-      ...config,
-      [TraceConfigKey]: parseOption({
-        optionValue: options[TraceConfigKey],
-        optionMetadata,
-      }),
-    };
-  }, {} as TraceConfig);
+  return {
+    hideLLMTools: parseOption({
+      optionValue: options.hideLLMTools,
+      optionMetadata: traceConfigMetadata.hideLLMTools,
+    }),
+    hideInputs: parseOption({
+      optionValue: options.hideInputs,
+      optionMetadata: traceConfigMetadata.hideInputs,
+    }),
+    hideOutputs: parseOption({
+      optionValue: options.hideOutputs,
+      optionMetadata: traceConfigMetadata.hideOutputs,
+    }),
+    hideInputMessages: parseOption({
+      optionValue: options.hideInputMessages,
+      optionMetadata: traceConfigMetadata.hideInputMessages,
+    }),
+    hideOutputMessages: parseOption({
+      optionValue: options.hideOutputMessages,
+      optionMetadata: traceConfigMetadata.hideOutputMessages,
+    }),
+    hideInputImages: parseOption({
+      optionValue: options.hideInputImages,
+      optionMetadata: traceConfigMetadata.hideInputImages,
+    }),
+    hideInputText: parseOption({
+      optionValue: options.hideInputText,
+      optionMetadata: traceConfigMetadata.hideInputText,
+    }),
+    hideOutputText: parseOption({
+      optionValue: options.hideOutputText,
+      optionMetadata: traceConfigMetadata.hideOutputText,
+    }),
+    hideEmbeddingVectors: parseOption({
+      optionValue: options.hideEmbeddingVectors,
+      optionMetadata: traceConfigMetadata.hideEmbeddingVectors,
+    }),
+    base64ImageMaxLength: parseOption({
+      optionValue: options.base64ImageMaxLength,
+      optionMetadata: traceConfigMetadata.base64ImageMaxLength,
+    }),
+    hidePrompts: parseOption({
+      optionValue: options.hidePrompts,
+      optionMetadata: traceConfigMetadata.hidePrompts,
+    }),
+  };
 }

js/packages/openinference-core/src/utils/typeUtils.ts

@@ -34,13 +34,7 @@ export function isObjectWithStringKeys(value: unknown): value is Record<string,
  * @returns true if it is a Promise
  */
 export function isPromise<T = unknown>(value: unknown): value is Promise<T> {
-  return (
-    !!value &&
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    typeof (value as any)?.then === "function" &&
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    typeof (value as any)?.catch === "function"
-  );
+  return isObject(value) && typeof value.then === "function" && typeof value.catch === "function";
 }
 
 /**

js/packages/openinference-genai/src/attributes.ts

@@ -155,16 +155,15 @@ const isGenAIChatMessage = (value: unknown): value is ChatMessage => {
  * @param toolDefinition - The tool definition to normalize
  * @returns The normalized tool definition, or the original value when it cannot be normalized
  */
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
 const normalizeToolDefinition = (toolDefinition: unknown): unknown => {
-  if (
-    typeof toolDefinition !== "object" ||
-    toolDefinition === null ||
-    Array.isArray(toolDefinition)
-  ) {
+  if (!isRecord(toolDefinition)) {
     return toolDefinition;
   }
 
-  const definition = toolDefinition as Record<string, unknown>;
+  const definition = toolDefinition;
   if (typeof definition.function === "object" && definition.function !== null) {
     return definition;
   }

js/packages/openinference-instrumentation-anthropic/src/instrumentation.ts

@@ -341,7 +341,7 @@ export class AnthropicInstrumentation extends InstrumentationBase<typeof Anthrop
  * True when create() returned an APIPromise we can transform with _thenUnwrap.
  */
 function hasThenUnwrap<T>(promise: PromiseLike<T>): promise is APIPromise<T> {
-  return typeof (promise as Partial<APIPromise<T>>)._thenUnwrap === "function";
+  return "_thenUnwrap" in promise && typeof promise._thenUnwrap === "function";
 }
 
 /**