🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.
TypeScript analyticsautogenevaluationlangchainlarge-language-modelsllama-indexllmllm-evaluationllm-observabilityllmopsmonitoringobservabilityopen-sourceopenaiplaygroundprompt-engineeringprompt-managementself-hostedycombinator
fix(shared): keep metadata keys that collide with Object.prototype (#17686)
Ramanjot Singh21fb09d7910c
diff --git a/packages/shared/src/features/evals/observationForEval.ts b/packages/shared/src/features/evals/observationForEval.tsindex a993f5bb82..54b2fcd7cd 100644--- a/packages/shared/src/features/evals/observationForEval.ts+++ b/packages/shared/src/features/evals/observationForEval.ts@@ -139,6 +139,25 @@ export function zipObservationToolCalls(});}+/**+ * Zips parallel name/value arrays into a plain object, first occurrence wins.+ * Collects into a `Map` so that keys shared with `Object.prototype` (`toString`,+ * `constructor`, `__proto__`, ...) are treated as ordinary metadata keys.+ */+function zipFirstOccurrenceWins<T>(+ names: string[],+ values: T[],+): Record<string, T> {+ const entries = new Map<string, T>();+ names.forEach((name, i) => {+ if (!entries.has(name)) {+ entries.set(name, values[i]);+ }+ });++ return Object.fromEntries(entries);+}+export function convertEventRecordToObservationForEval(record: EventRecordBaseType,): ObservationForEval {@@ -148,14 +167,10 @@ export function convertEventRecordToObservationForEval();const experimentItemMetadata =record.experiment_item_metadata_names.length > 0- ? record.experiment_item_metadata_names.reduce<- Record<string, string | null | undefined>- >((acc, name, i) => {- if (!(name in acc)) {- acc[name] = record.experiment_item_metadata_values[i];- }- return acc;- }, {})+ ? zipFirstOccurrenceWins(+ record.experiment_item_metadata_names,+ record.experiment_item_metadata_values,+ ): undefined;const toolCallNames = record.tool_call_names ?? [];diff --git a/packages/shared/src/server/utils/metadata_conversion.ts b/packages/shared/src/server/utils/metadata_conversion.tsindex af9df1a0ad..c93d9abdec 100644--- a/packages/shared/src/server/utils/metadata_conversion.ts+++ b/packages/shared/src/server/utils/metadata_conversion.ts@@ -8,6 +8,10 @@ import { MetadataDomain } from "../../domain";** Returns `undefined` when the names array is empty so callers can distinguish* "no metadata" from "empty metadata object".+ *+ * Collects into a `Map` so that keys shared with `Object.prototype`+ * (`toString`, `constructor`, `__proto__`, ...) are treated as ordinary+ * metadata keys rather than as already-present ones.*/export function metadataArraysToRecord(names: string[],@@ -15,12 +19,14 @@ export function metadataArraysToRecord(): Record<string, string> | undefined {if (names.length === 0) return undefined;- return names.reduce<Record<string, string>>((acc, name, i) => {- if (!(name in acc)) {- acc[name] = values[i];+ const record = new Map<string, string>();+ names.forEach((name, i) => {+ if (!record.has(name)) {+ record.set(name, values[i]);}- return acc;- }, {});+ });++ return Object.fromEntries(record);}export function parseMetadataCHRecordToDomain(diff --git a/worker/src/queues/__tests__/metadata_conversion.test.ts b/worker/src/queues/__tests__/metadata_conversion.test.tsindex 4d5556f676..5c754d1ff9 100644--- a/worker/src/queues/__tests__/metadata_conversion.test.ts+++ b/worker/src/queues/__tests__/metadata_conversion.test.ts@@ -23,4 +23,28 @@ describe("metadataArraysToRecord", () => {const result = metadataArraysToRecord(["key"], ["value"]);expect(result).toEqual({ key: "value" });});++ it("should keep keys that collide with Object.prototype members", () => {+ const result = metadataArraysToRecord(+ ["toString", "constructor", "valueOf", "hasOwnProperty"],+ ["a", "b", "c", "d"],+ );+ expect(result).toEqual({+ toString: "a",+ constructor: "b",+ valueOf: "c",+ hasOwnProperty: "d",+ });+ });++ it("should keep a __proto__ key as an own property", () => {+ const result = metadataArraysToRecord(+ ["__proto__", "env"],+ ['{"polluted":true}', "prod"],+ );++ expect(Object.keys(result ?? {})).toEqual(["__proto__", "env"]);+ expect(Object.getPrototypeOf(result)).toBe(Object.prototype);+ expect(({} as Record<string, unknown>).polluted).toBeUndefined();+ });});diff --git a/worker/src/services/IngestionService/tests/convertRecordValuesToString.unit.test.ts b/worker/src/services/IngestionService/tests/convertRecordValuesToString.unit.test.tsnew file mode 100644index 0000000000..31147bfb92--- /dev/null+++ b/worker/src/services/IngestionService/tests/convertRecordValuesToString.unit.test.ts@@ -0,0 +1,29 @@+import { convertRecordValuesToString } from "../utils";+import { expect, describe, it } from "vitest";++describe("convertRecordValuesToString", () => {+ it("stringifies non-string values and passes strings through", () => {+ expect(+ convertRecordValuesToString({ a: "x", b: 2, c: { d: true } }),+ ).toEqual({+ a: "x",+ b: "2",+ c: '{"d":true}',+ });+ });++ it("keeps a __proto__ key as an own property instead of dropping it", () => {+ // JSON.parse (how ingested metadata actually arrives) creates __proto__+ // as an own property; an object literal with a `__proto__:` key would+ // instead set the prototype, which is a different, unrelated behavior.+ const input = JSON.parse('{"__proto__": "hello", "env": "prod"}');+ const result = convertRecordValuesToString(input);++ expect(Object.prototype.hasOwnProperty.call(result, "__proto__")).toBe(+ true,+ );+ expect(result.__proto__).toBe("hello");+ expect(result.env).toBe("prod");+ expect(({} as Record<string, unknown>).polluted).toBeUndefined();+ });+});diff --git a/worker/src/services/IngestionService/utils.ts b/worker/src/services/IngestionService/utils.tsindex 134e73de04..b6e35c036b 100644--- a/worker/src/services/IngestionService/utils.ts+++ b/worker/src/services/IngestionService/utils.ts@@ -50,12 +50,15 @@ export const convertPostgresJsonToMetadataRecord = (export const convertRecordValuesToString = (record: Record<string, unknown>,): Record<string, string> => {- const result: Record<string, string> = {};- for (const key in record) {- const value = record[key];- result[key] = typeof value === "string" ? value : JSON.stringify(value);- }- return result;+ // Built via Object.fromEntries rather than `result[key] = ...` so a key+ // named `__proto__` becomes an ordinary own property instead of invoking+ // Object.prototype's `__proto__` setter, which would silently drop it.+ return Object.fromEntries(+ Object.entries(record).map(([key, value]) => [+ key,+ typeof value === "string" ? value : JSON.stringify(value),+ ]),+ );};export function overwriteObject(