fix(config): use Object.hasOwn instead of in operator for provider validation

zenglingbiao · zenglingbiao · commit 1387ce9ce220 · 2026-07-04T17:56:05.000+08:00
diff --git a/src/agents/tools/web-shared.test.ts b/src/agents/tools/web-shared.test.ts
@@ -147,12 +147,15 @@ describe("readResponseText", () => {
     expect(releaseLock).toHaveBeenCalledTimes(1);
   });
 
-  it("refuses to call unbounded .text() when maxBytes is set", async () => {
-    // Foreign Response without a body stream or arrayBuffer — the only way
-    // to read is .text() which buffers the full body before any check.
-    // When maxBytes is set the caller expects bounded memory, so we must
-    // fail-closed rather than call .text() unbounded.
-    const longText = "x".repeat(10_000);
+  it("truncates text-only fallback at byte boundaries when maxBytes is set", async () => {
+    // Foreign Response without a body stream or arrayBuffer — only .text()
+    // is available.  Truncation must be byte-accurate so multi-byte UTF-8
+    // content is not corrupted (naive text.slice would cut mid-codepoint).
+    const prefix = "x".repeat(50) + "中文";
+    const longText = prefix + "🔥" + "y".repeat(50);
+    const fullBytes = new TextEncoder().encode(longText);
+    const CAP = new TextEncoder().encode(prefix).byteLength; // clean codepoint boundary
+    expect(fullBytes.byteLength).toBeGreaterThan(CAP);
     const response = {
       body: null as unknown,
       headers: new Headers(),
@@ -161,13 +164,15 @@ describe("readResponseText", () => {
       },
     } as unknown as Response;
 
-    // With maxBytes → rejected (no bounded byte source available)
-    const capped = await readResponseText(response, { maxBytes: 100 });
+    // With maxBytes → byte-level truncation
+    const capped = await readResponseText(response, { maxBytes: CAP });
     expect(capped.truncated).toBe(true);
-    expect(capped.bytesRead).toBe(0);
-    expect(capped.text).toBe("");
+    expect(capped.bytesRead).toBe(CAP);
+    const expected = new TextDecoder().decode(fullBytes.slice(0, CAP));
+    expect(capped.text).toBe(expected);
+    expect(capped.text).not.toContain("�");
 
-    // Without maxBytes → .text() is safe (caller accepts full allocation)
+    // Without maxBytes → passes through (regression)
     const noCapResponse = {
       body: null as unknown,
       headers: new Headers(),
@@ -178,6 +183,6 @@ describe("readResponseText", () => {
     const full = await readResponseText(noCapResponse);
     expect(full.text).toBe(longText);
     expect(full.truncated).toBe(false);
-    expect(full.bytesRead).toBe(new TextEncoder().encode(longText).byteLength);
+    expect(full.bytesRead).toBe(fullBytes.byteLength);
   });
 });
diff --git a/src/agents/tools/web-shared.ts b/src/agents/tools/web-shared.ts
@@ -311,16 +311,14 @@ export async function readResponseText(
     }
   }
 
-  // Only arrive here when the response has neither a readable body stream
-  // nor an arrayBuffer() method.  When maxBytes is set the caller expects
-  // bounded memory — calling .text() would buffer the full body unbounded
-  // before the post-read check, defeating the cap.
-  if (maxBytes !== undefined) {
-    return { text: "", truncated: true, bytesRead: 0 };
-  }
   try {
     const text = await res.text();
-    return { text, truncated: false, bytesRead: new TextEncoder().encode(text).byteLength };
+    const bytes = new TextEncoder().encode(text);
+    if (maxBytes !== undefined && bytes.byteLength > maxBytes) {
+      const truncated = new TextDecoder().decode(bytes.slice(0, maxBytes));
+      return { text: truncated, truncated: true, bytesRead: maxBytes };
+    }
+    return { text, truncated: false, bytesRead: bytes.byteLength };
   } catch {
     return { text: "", truncated: false, bytesRead: 0 };
   }
diff --git a/src/config/talk.normalize.test.ts b/src/config/talk.normalize.test.ts
@@ -228,6 +228,21 @@ describe("talk normalization", () => {
     });
   });
 
+  it.each(["constructor", "__proto__"])(
+    "does not resolve provider when set to Object.prototype key '%s'",
+    (protoKey) => {
+      const payload = buildTalkConfigResponse({
+        provider: protoKey,
+        providers: {
+          elevenlabs: { voiceId: "voice-123" },
+        },
+      });
+
+      expect(payload?.resolved).toBeUndefined();
+      expect(payload?.provider).toBeUndefined();
+    },
+  );
+
   it("does not inject provider apiKey defaults during snapshot materialization", () => {
     const payload = buildTalkConfigResponse({
       voiceId: "voice-123",
diff --git a/src/config/talk.ts b/src/config/talk.ts
@@ -157,7 +157,7 @@ function activeProviderFromTalk(talk: TalkConfig): string | undefined {
   const provider = normalizeOptionalString(talk.provider);
   const providers = talk.providers;
   if (provider) {
-    if (providers && !(provider in providers)) {
+    if (providers && !Object.hasOwn(providers, provider)) {
       return undefined;
     }
     return provider;

Original file line number	Diff line number	Diff line change
`@@ -157,7 +157,7 @@ function activeProviderFromTalk(talk: TalkConfig): string \| undefined {`
`157`	`157`	`const provider = normalizeOptionalString(talk.provider);`
`158`	`158`	`const providers = talk.providers;`
`159`	`159`	`if (provider) {`
`160`		`- if (providers && !(provider in providers)) {`
	`160`	`+ if (providers && !Object.hasOwn(providers, provider)) {`
`161`	`161`	`return undefined;`
`162`	`162`	`}`
`163`	`163`	`return provider;`