Skip to content

🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.

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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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(