@oh-my-pi/pi-coding-agent 16.0.4 → 16.0.6

package/src/tools/image-gen.ts

@@ -19,10 +19,10 @@ import {
 	Snowflake,
 	untilAborted,
 } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import packageJson from "../../package.json" with { type: "json" };
-
 import { isAuthenticated, type ModelRegistry } from "../config/model-registry";
+import { settings } from "../config/settings";
 import type { CustomTool } from "../extensibility/custom-tools/types";
 import { ohMyPiXAIUserAgent, resolveXAIHttpCredentials } from "../lib/xai-http";
 import imageGenDescription from "../prompts/tools/image-gen.md" with { type: "text" };
@@ -38,7 +38,8 @@ const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
 const OPENAI_IMAGE_OUTPUT_FORMAT = "webp";
 const OPENAI_IMAGE_MIME_TYPE = "image/webp";
 
-const ANTIGRAVITY_ENDPOINT = "https://daily-cloudcode-pa.sandbox.googleapis.com";
+const DEFAULT_ANTIGRAVITY_ENDPOINT_PROD = "https://daily-cloudcode-pa.googleapis.com";
+const DEFAULT_ANTIGRAVITY_ENDPOINT_SANDBOX = "https://daily-cloudcode-pa.sandbox.googleapis.com";
 const IMAGE_SYSTEM_INSTRUCTION =
 	"You are an AI image generator. Generate images based on user descriptions. Focus on creating high-quality, visually appealing images that match the user's request.";
 
@@ -57,37 +58,32 @@ const XAI_IMAGE_ASPECT_RATIOS = [...COMMON_IMAGE_ASPECT_RATIOS, "3:2", "2:3"] as
 const COMMON_IMAGE_ASPECT_RATIO_SET = new Set<string>(COMMON_IMAGE_ASPECT_RATIOS);
 const IMAGE_PROVIDER_PREFERENCES = new Set<string>(["auto", "antigravity", "gemini", "openai", "openrouter", "xai"]);
 
-const responseModalitySchema = z.enum(["IMAGE", "TEXT"] as const);
-const aspectRatioSchema = z.enum(XAI_IMAGE_ASPECT_RATIOS).describe("aspect ratio");
-const imageSizeSchema = z.enum(["1024x1024", "1536x1024", "1024x1536"] as const).describe("image size");
-
-const inputImageSchema = z
-	.object({
-		path: z.string().describe("input image path").optional(),
-		data: z.string().describe("base64 image data").optional(),
-		mime_type: z.string().describe("mime type").optional(),
-	})
-	.strict();
-
-const baseImageSchema = z
-	.object({
-		subject: z.string().describe("main subject"),
-		action: z.string().describe("what subject is doing").optional(),
-		scene: z.string().describe("location or environment").optional(),
-		composition: z.string().describe("camera angle and framing").optional(),
-		lighting: z.string().describe("lighting setup").optional(),
-		style: z.string().describe("artistic style").optional(),
-		text: z.string().describe("text to render").optional(),
-		changes: z.array(z.string()).describe("edits to make").optional(),
-		aspect_ratio: aspectRatioSchema.optional(),
-		image_size: imageSizeSchema.optional(),
-		input: z.array(inputImageSchema).describe("input images").optional(),
-	})
-	.strict();
-
-export const imageGenSchema = baseImageSchema;
-export type ImageGenParams = z.infer<typeof imageGenSchema>;
-export type GeminiResponseModality = z.infer<typeof responseModalitySchema>;
+const responseModalitySchema = type('"IMAGE" | "TEXT"');
+
+const aspectRatioSchema = type.enumerated(...XAI_IMAGE_ASPECT_RATIOS).describe("aspect ratio");
+const imageSizeSchema = type('"1024x1024" | "1536x1024" | "1024x1536"').describe("image size");
+
+const inputImageSchema = type({
+	"path?": type("string").describe("input image path"),
+	"data?": type("string").describe("base64 image data"),
+	"mime_type?": type("string").describe("mime type"),
+});
+
+export const imageGenSchema = type({
+	subject: type("string").describe("main subject"),
+	"action?": type("string").describe("what subject is doing"),
+	"scene?": type("string").describe("location or environment"),
+	"composition?": type("string").describe("camera angle and framing"),
+	"lighting?": type("string").describe("lighting setup"),
+	"style?": type("string").describe("artistic style"),
+	"text?": type("string").describe("text to render"),
+	"changes?": type("string[]").describe("edits to make"),
+	"aspect_ratio?": aspectRatioSchema,
+	"image_size?": imageSizeSchema,
+	"input?": inputImageSchema.array().describe("input images"),
+});
+export type ImageGenParams = typeof imageGenSchema.infer;
+export type GeminiResponseModality = typeof responseModalitySchema.infer;
 
 /**
  * Assembles a structured prompt from the provided parameters.
@@ -1164,33 +1160,74 @@ export const imageGenTool: CustomTool<typeof imageGenSchema, ImageGenToolDetails
 							resolvedImages,
 						);
 
-						const resp = await fetchImpl(`${ANTIGRAVITY_ENDPOINT}/v1internal:streamGenerateContent?alt=sse`, {
-							method: "POST",
-							headers: {
-								Authorization: `Bearer ${bearer}`,
-								"Content-Type": "application/json",
-								Accept: "text/event-stream",
-								"User-Agent": getAntigravityUserAgent(),
-							},
-							body: JSON.stringify(requestBody),
-							signal: requestSignal,
-						});
+						let endpoints = [DEFAULT_ANTIGRAVITY_ENDPOINT_PROD, DEFAULT_ANTIGRAVITY_ENDPOINT_SANDBOX];
+						try {
+							const mode = settings.get("providers.antigravityEndpoint");
+							if (mode === "production") {
+								endpoints = [DEFAULT_ANTIGRAVITY_ENDPOINT_PROD];
+							} else if (mode === "sandbox") {
+								endpoints = [DEFAULT_ANTIGRAVITY_ENDPOINT_SANDBOX];
+							}
+						} catch {
+							// Ignored
+						}
 
-						if (!resp.ok) {
-							const errorText = await resp.text();
-							let message = errorText;
+						let resp: Response | undefined;
+						let lastError: Error | undefined;
+
+						for (let i = 0; i < endpoints.length; i++) {
+							const endpoint = endpoints[i];
+							const isLastEndpoint = i === endpoints.length - 1;
 							try {
-								const parsedErr = JSON.parse(errorText) as { error?: { message?: string } };
-								message = parsedErr.error?.message ?? message;
-							} catch {
-								// Keep raw text.
+								resp = await fetchImpl(`${endpoint}/v1internal:streamGenerateContent?alt=sse`, {
+									method: "POST",
+									headers: {
+										Authorization: `Bearer ${bearer}`,
+										"Content-Type": "application/json",
+										Accept: "text/event-stream",
+										"User-Agent": getAntigravityUserAgent(),
+									},
+									body: JSON.stringify(requestBody),
+									signal: requestSignal,
+								});
+
+								if (resp.ok) {
+									break;
+								}
+
+								const errorText = await resp.text();
+								let message = errorText;
+								try {
+									const parsedErr = JSON.parse(errorText) as { error?: { message?: string } };
+									message = parsedErr.error?.message ?? message;
+								} catch {
+									// Keep raw text.
+								}
+
+								lastError = new ProviderHttpError(
+									`Antigravity image request failed (${resp.status}): ${message}`,
+									resp.status,
+									{ headers: resp.headers },
+								);
+
+								if (resp.status === 429 || (resp.status >= 500 && resp.status < 600)) {
+									if (!isLastEndpoint) {
+										continue;
+									}
+								}
+								break;
+							} catch (error) {
+								lastError = error as Error;
+								if (isLastEndpoint) {
+									break;
+								}
 							}
-							throw new ProviderHttpError(
-								`Antigravity image request failed (${resp.status}): ${message}`,
-								resp.status,
-								{ headers: resp.headers },
-							);
 						}
+
+						if (!resp?.ok) {
+							throw lastError ?? new Error("Antigravity image generation failed");
+						}
+
 						return resp;
 					},
 					{ signal: requestSignal },

package/src/tools/inspect-image.ts

@@ -2,7 +2,7 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import { instrumentedCompleteSimple, resolveTelemetry } from "@oh-my-pi/pi-agent-core";
 import { type Api, completeSimple, type Model, type ToolExample } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import { extractTextContent } from "../commit/utils";
 
 import { expandRoleAlias, getModelMatchPreferences, resolveModelFromString } from "../config/model-resolver";
@@ -18,14 +18,13 @@ import {
 import type { ToolSession } from "./index";
 import { ToolError } from "./tool-errors";
 
-const inspectImageSchema = z
-	.object({
-		path: z.string().describe("image path"),
-		question: z.string().describe("question about image"),
-	})
-	.strict();
+const inspectImageSchema = type({
+	path: type("string").describe("image path"),
+	question: type("string").describe("question about image"),
+	"+": "reject",
+});
 
-export type InspectImageParams = z.infer<typeof inspectImageSchema>;
+export type InspectImageParams = typeof inspectImageSchema.infer;
 
 export interface InspectImageToolDetails {
 	model: string;
@@ -43,7 +42,7 @@ export class InspectImageTool implements AgentTool<typeof inspectImageSchema, In
 	readonly parameters = inspectImageSchema;
 	readonly strict = false;
 
-	readonly examples: readonly ToolExample<z.input<typeof inspectImageSchema>>[] = [
+	readonly examples: readonly ToolExample<typeof inspectImageSchema.infer>[] = [
 		{
 			caption: "OCR with strict formatting",
 			call: {

package/src/tools/irc.ts

@@ -13,7 +13,7 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { ToolExample } from "@oh-my-pi/pi-ai";
 import { type Component, Text } from "@oh-my-pi/pi-tui";
 import { formatAge, formatDuration, prompt } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import type { Settings } from "../config/settings";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { IrcBus, type IrcDeliveryReceipt, type IrcMessage } from "../irc/bus";
@@ -49,18 +49,18 @@ export function isIrcEnabled(settings: Settings, taskDepth: number): boolean {
 	return canSpawnAtDepth(maxDepth, taskDepth);
 }
 
-const ircSchema = z.object({
-	op: z.enum(["send", "wait", "inbox", "list"]).describe("irc operation"),
-	to: z.string().optional().describe('send: recipient agent id or "all"'),
-	message: z.string().optional().describe("send: message body"),
-	replyTo: z.string().optional().describe("send: message id being answered"),
-	await: z.boolean().optional().describe('send: wait for the recipient\'s reply (invalid with to:"all")'),
-	from: z.string().optional().describe("wait: only accept a message from this agent id"),
-	timeoutMs: z.number().optional().describe("wait: timeout in milliseconds (0 waits indefinitely)"),
-	peek: z.boolean().optional().describe("inbox: list messages without consuming them"),
+const ircSchema = type({
+	op: type("'send' | 'wait' | 'inbox' | 'list'").describe("irc operation"),
+	"to?": type("string").describe('send: recipient agent id or "all"'),
+	"message?": type("string").describe("send: message body"),
+	"replyTo?": type("string").describe("send: message id being answered"),
+	"await?": type("boolean").describe('send: wait for the recipient\'s reply (invalid with to:"all")'),
+	"from?": type("string").describe("wait: only accept a message from this agent id"),
+	"timeoutMs?": type("number").describe("wait: timeout in milliseconds (0 waits indefinitely)"),
+	"peek?": type("boolean").describe("inbox: list messages without consuming them"),
 });
 
-type IrcParams = z.infer<typeof ircSchema>;
+type IrcParams = typeof ircSchema.infer;
 
 interface IrcPeerInfo {
 	id: string;
@@ -98,7 +98,7 @@ export class IrcTool implements AgentTool<typeof ircSchema, IrcDetails> {
 	readonly parameters = ircSchema;
 	readonly strict = true;
 
-	readonly examples: readonly ToolExample<z.input<typeof ircSchema>>[] = [
+	readonly examples: readonly ToolExample<typeof ircSchema.infer>[] = [
 		{
 			caption: "List peers",
 			call: { op: "list" },

package/src/tools/job.ts

@@ -2,7 +2,7 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { prompt } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import type { AsyncJob, AsyncJobManager } from "../async";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { shimmerEnabled, shimmerText } from "../modes/theme/shimmer";
@@ -23,13 +23,13 @@ import {
 } from "./render-utils";
 import { ToolError } from "./tool-errors";
 
-const jobSchema = z.object({
-	poll: z.array(z.string()).optional().describe("job ids to wait for; omit to wait on all running jobs"),
-	cancel: z.array(z.string()).optional().describe("job ids to cancel"),
-	list: z.boolean().optional().describe("snapshot all jobs"),
+const jobSchema = type({
+	"poll?": type("string[]").describe("job ids to wait for; omit to wait on all running jobs"),
+	"cancel?": type("string[]").describe("job ids to cancel"),
+	"list?": type("boolean").describe("snapshot all jobs"),
 });
 
-type JobParams = z.infer<typeof jobSchema>;
+type JobParams = typeof jobSchema.infer;
 
 const WAIT_DURATION_MS: Record<string, number> = {
 	"5s": 5_000,

package/src/tools/learn.ts

@@ -1,26 +1,23 @@
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import { sanitizeSkillName, writeManagedSkill } from "../autolearn/managed-skills";
 import { isNameClaimedByAuthoredSkill } from "../extensibility/skills";
 import { localBackend } from "../memory-backend/local-backend";
 import learnDescription from "../prompts/tools/learn.md" with { type: "text" };
 import type { ToolSession } from ".";
 
-const learnSchema = z.object({
-	memory: z.string().describe("the durable, self-contained lesson to remember (what, when, why)"),
-	context: z.string().describe("optional source context for the lesson").optional(),
-	skill: z
-		.object({
-			action: z.enum(["create", "update"]),
-			name: z.string().describe("kebab-case skill name"),
-			description: z.string().describe("one-line description of when to use the skill"),
-			body: z.string().describe("the SKILL.md body in markdown (no frontmatter)"),
-		})
-		.describe("also create or enhance a managed skill in the same call")
-		.optional(),
+const learnSchema = type({
+	memory: type("string").describe("the durable, self-contained lesson to remember (what, when, why)"),
+	"context?": type("string").describe("optional source context for the lesson"),
+	"skill?": type({
+		action: "'create' | 'update'",
+		name: type("string").describe("kebab-case skill name"),
+		description: type("string").describe("one-line description of when to use the skill"),
+		body: type("string").describe("the SKILL.md body in markdown (no frontmatter)"),
+	}).describe("also create or enhance a managed skill in the same call"),
 });
 
-export type LearnParams = z.infer<typeof learnSchema>;
+export type LearnParams = typeof learnSchema.infer;
 
 /**
  * Orchestrating "learn" tool: persists a lesson to long-term memory and,

package/src/tools/manage-skill.ts

@@ -1,6 +1,6 @@
 import * as path from "node:path";
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import {
 	deleteManagedSkill,
 	getManagedSkillsDir,
@@ -11,29 +11,25 @@ import { isNameClaimedByAuthoredSkill } from "../extensibility/skills";
 import manageSkillDescription from "../prompts/tools/manage-skill.md" with { type: "text" };
 import type { ToolSession } from ".";
 
-const manageSkillSchema = z
-	.object({
-		action: z.enum(["create", "update", "delete"]),
-		name: z.string().describe("kebab-case skill name"),
-		description: z
-			.string()
-			.describe("one-line description of when to use the skill (required for create/update)")
-			.optional(),
-		body: z
-			.string()
-			.describe("the SKILL.md body in markdown, no frontmatter (required for create/update)")
-			.optional(),
-	})
-	// Enforce the action/field contract at validation time rather than only in
-	// execute. Kept as a cross-field refine (not a discriminated union) so the
-	// wire schema stays a single root object — strict structured-output mode and
-	// the Anthropic tool-schema builder both require that.
-	.refine(p => p.action === "delete" || (p.description !== undefined && p.body !== undefined), {
-		message: '"create" and "update" require both "description" and "body".',
-		path: ["description"],
-	});
+const manageSkillSchema = type({
+	action: "'create' | 'update' | 'delete'",
+	name: type("string").describe("kebab-case skill name"),
+	"description?": type("string").describe(
+		"one-line description of when to use the skill (required for create/update)",
+	),
+	"body?": type("string").describe("the SKILL.md body in markdown, no frontmatter (required for create/update)"),
+}).narrow(
+	(p, ctx) =>
+		p.action === "delete" ||
+		(p.description !== undefined && p.body !== undefined) ||
+		// Enforce the action/field contract at validation time rather than only in
+		// execute. Kept as a cross-field narrow (not a discriminated union) so the
+		// wire schema stays a single root object — strict structured-output mode and
+		// the Anthropic tool-schema builder both require that.
+		ctx.mustBe('used with both "description" and "body" for "create" and "update"'),
+);
 
-export type ManageSkillParams = z.infer<typeof manageSkillSchema>;
+export type ManageSkillParams = typeof manageSkillSchema.infer;
 
 /**
  * Direct create/update/delete of isolated managed skills. Gated behind

package/src/tools/memory-edit.ts

@@ -1,17 +1,17 @@
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import memoryEditDescription from "../prompts/tools/memory-edit.md" with { type: "text" };
 import type { ToolSession } from ".";
 
-const memoryEditSchema = z.object({
-	op: z.enum(["update", "forget", "invalidate"]).describe("memory edit operation"),
-	id: z.string().describe("memory id from recall output"),
-	content: z.string().optional().describe("replacement content for update"),
-	importance: z.number().optional().describe("replacement importance for update, clamped to [0, 1]"),
-	replacement_id: z.string().optional().describe("replacement memory id for invalidate"),
+const memoryEditSchema = type({
+	op: type("'update' | 'forget' | 'invalidate'").describe("memory edit operation"),
+	id: type("string").describe("memory id from recall output"),
+	"content?": type("string").describe("replacement content for update"),
+	"importance?": type("number").describe("replacement importance for update, clamped to [0, 1]"),
+	"replacement_id?": type("string").describe("replacement memory id for invalidate"),
 });
 
-export type MemoryEditParams = z.infer<typeof memoryEditSchema>;
+export type MemoryEditParams = typeof memoryEditSchema.infer;
 
 export class MemoryEditTool implements AgentTool<typeof memoryEditSchema> {
 	readonly name = "memory_edit";

package/src/tools/memory-recall.ts

@@ -1,15 +1,15 @@
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import { logger, untilAborted } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import { formatCurrentTime, formatMemories } from "../hindsight/content";
 import recallDescription from "../prompts/tools/recall.md" with { type: "text" };
 import type { ToolSession } from ".";
 
-const memoryRecallSchema = z.object({
-	query: z.string().describe("natural language search query"),
+const memoryRecallSchema = type({
+	query: type("string").describe("natural language search query"),
 });
 
-export type MemoryRecallParams = z.infer<typeof memoryRecallSchema>;
+export type MemoryRecallParams = typeof memoryRecallSchema.infer;
 
 export class MemoryRecallTool implements AgentTool<typeof memoryRecallSchema> {
 	readonly name = "recall";

package/src/tools/memory-reflect.ts

@@ -1,16 +1,16 @@
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import { logger, untilAborted } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import { ensureBankExists } from "../hindsight/bank";
 import reflectDescription from "../prompts/tools/reflect.md" with { type: "text" };
 import type { ToolSession } from ".";
 
-const memoryReflectSchema = z.object({
-	query: z.string().describe("question to answer"),
-	context: z.string().describe("optional context").optional(),
+const memoryReflectSchema = type({
+	query: type("string").describe("question to answer"),
+	"context?": type("string").describe("optional context"),
 });
 
-export type MemoryReflectParams = z.infer<typeof memoryReflectSchema>;
+export type MemoryReflectParams = typeof memoryReflectSchema.infer;
 
 export class MemoryReflectTool implements AgentTool<typeof memoryReflectSchema> {
 	readonly name = "reflect";

package/src/tools/memory-retain.ts

@@ -1,21 +1,19 @@
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import retainDescription from "../prompts/tools/retain.md" with { type: "text" };
 import type { ToolSession } from ".";
 
-const memoryRetainSchema = z.object({
-	items: z
-		.array(
-			z.object({
-				content: z.string().describe("information to remember"),
-				context: z.string().describe("source context").optional(),
-			}),
-		)
-		.min(1)
+const memoryRetainSchema = type({
+	items: type({
+		content: type("string").describe("information to remember"),
+		"context?": type("string").describe("source context"),
+	})
+		.array()
+		.atLeastLength(1)
 		.describe("memories to retain"),
 });
 
-export type MemoryRetainParams = z.infer<typeof memoryRetainSchema>;
+export type MemoryRetainParams = typeof memoryRetainSchema.infer;
 export class MemoryRetainTool implements AgentTool<typeof memoryRetainSchema> {
 	readonly name = "retain";
 	readonly approval = "read" as const;

package/src/tools/puppeteer/02_stealth_hairline.txt

@@ -6,6 +6,6 @@ Object_defineProperty(HTMLDivElement.prototype, "offsetHeight", {
   ...elementDescriptor,
   get: function () {
     if (this.id === "modernizr") return 1;
-    return elementDescriptor.get.apply(this);
+	    return Reflect_apply(elementDescriptor.get, this, []);
   },
 });

package/src/tools/puppeteer/04_stealth_iframe.txt

@@ -4,7 +4,7 @@ const addContentWindowProxy = (iframe) => {
 			if (key === "self") return this;
 			if (key === "frameElement") return iframe;
 			if (key === "0") return undefined;
-			return Reflect.get(target, key);
+			return Reflect_get(target, key);
 		},
 	};
 
@@ -24,7 +24,7 @@ const addContentWindowProxy = (iframe) => {
 };
 
 const handleIframeCreation = (target, thisArg, args) => {
-	const iframe = target.apply(thisArg, args);
+	const iframe = Reflect_apply(target, thisArg, args);
 	const originalIframe = iframe;
 	const originalSrcdoc = originalIframe.srcdoc;
 
@@ -53,12 +53,12 @@ const addIframeCreationSniffer = () => {
 		apply(target, thisArg, args) {
 			const isIframe = args && args.length && `${args[0]}`.toLowerCase() === "iframe";
 			if (!isIframe) {
-				return target.apply(thisArg, args);
+				return Reflect_apply(target, thisArg, args);
 			}
 			return handleIframeCreation(target, thisArg, args);
 		},
 		get(target, key) {
-			return Reflect.get(target, key);
+			return Reflect_get(target, key);
 		},
 	};
 

package/src/tools/puppeteer/05_stealth_webgl.txt

@@ -22,7 +22,7 @@ const getParameterProxyHandler = {
     if (param === 0x9245) return vendor;
     // UNMASKED_RENDERER_WEBGL = 0x9246
     if (param === 0x9246) return renderer;
-    return target.apply(thisArg, args);
+	    return Reflect_apply(target, thisArg, args);
   },
 };
 

package/src/tools/puppeteer/10_stealth_plugins.txt

@@ -113,11 +113,13 @@ const generateMagicArray = (dataArray, proto, itemProto, itemMainProp) => {
 		const blacklist = [...Object_keys(data), "length", "enabledPlugin"];
 		return new Window_Proxy(obj, {
 			ownKeys(target) {
-				return Reflect.ownKeys(target).filter(key => !blacklist.includes(key));
+				return [...Object_getOwnPropertyNames(target), ...Object.getOwnPropertySymbols(target)].filter(
+					key => !blacklist.includes(key),
+				);
 			},
 			getOwnPropertyDescriptor(target, prop) {
 				if (blacklist.includes(prop)) return undefined;
-				return Reflect.getOwnPropertyDescriptor(target, prop);
+				return Object_getOwnPropertyDescriptor(target, prop);
 			},
 		});
 	};
@@ -148,7 +150,7 @@ const generateMagicArray = (dataArray, proto, itemProto, itemMainProp) => {
 			if (key === "item") return functionMocks.item;
 			if (key === "namedItem") return functionMocks.namedItem;
 			if (proto === PluginArray.prototype && key === "refresh") return functionMocks.refresh;
-			return Reflect.get(target, key);
+			return Reflect_get(target, key);
 		},
 		ownKeys(target) {
 			const keys = [];
@@ -159,7 +161,7 @@ const generateMagicArray = (dataArray, proto, itemProto, itemMainProp) => {
 		},
 		getOwnPropertyDescriptor(target, prop) {
 			if (prop === "length") return undefined;
-			return Reflect.getOwnPropertyDescriptor(target, prop);
+			return Object_getOwnPropertyDescriptor(target, prop);
 		},
 	});
 };

package/src/tools/puppeteer/12_stealth_codecs.txt

@@ -19,7 +19,7 @@ Object_defineProperty(HTMLMediaElement.prototype, "canPlayType", {
 	value: new Window_Proxy(originalCanPlayType, {
 		apply(target, ctx, args) {
 			if (!args || !args.length) {
-				return target.apply(ctx, args);
+				return Reflect_apply(target, ctx, args);
 			}
 			const { mime, codecs } = parseInput(args[0]);
 			if (mime === "video/mp4" && codecs.includes("avc1.42E01E")) {
@@ -31,7 +31,7 @@ Object_defineProperty(HTMLMediaElement.prototype, "canPlayType", {
 			if (mime === "audio/aac" && !codecs.length) {
 				return "probably";
 			}
-			return target.apply(ctx, args);
+				return Reflect_apply(target, ctx, args);
 		},
 	}),
 	writable: true,

package/src/tools/puppeteer/13_stealth_worker.txt

@@ -50,7 +50,7 @@ const patchWorkerConstructor = (name, OriginalWorker) => {
 			}
 		},
 		apply(target, thisArg, args) {
-			return Reflect.apply(target, thisArg, args || []);
+			return Reflect_apply(target, thisArg, args || []);
 		},
 	};