"typescript/no-meaningless-void-operator": "error",

"typescript/no-misused-promises": "error",

"typescript/no-inferrable-types": "error",

"typescript/only-throw-error": "error",

"typescript/no-non-null-asserted-nullish-coalescing": "error",

"typescript/prefer-promise-reject-errors": "error",

"typescript/restrict-plus-operands": "error",

"typescript/no-unnecessary-qualifier": "error",

"typescript/no-unnecessary-type-assertion": "error",

"typescript/no-unnecessary-type-arguments": "error",

"typescript/require-array-sort-compare": "error",

"typescript/restrict-template-expressions": "error",

"typescript/triple-slash-reference": "error",

"typescript/unbound-method": "error",

"typescript/use-unknown-in-catch-callback-variable": "error",

"unicorn/consistent-date-clone": "error",

"unicorn/consistent-empty-array-spread": "error",

"unicorn/consistent-function-scoping": "off",

"unicorn/no-unnecessary-slice-end": "error",

"unicorn/no-useless-error-capture-stack-trace": "error",

"unicorn/no-useless-promise-resolve-reject": "error",

"unicorn/no-useless-switch-case": "error",

"unicorn/no-zero-fractions": "error",

"unicorn/prefer-date-now": "error",

"unicorn/prefer-dom-node-text-content": "error",

return item;

}

if (this.error) {

throw this.error;

throw toLintErrorObject(this.error, "Non-Error thrown");

}

if (this.closed) {

return null;

},

};

}

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}

})

.then(

() => ({ status: "resolved" as const }),

(error) => ({ status: "rejected" as const, error }),

(error: unknown) => ({ status: "rejected" as const, error }),

);

expect(outcome.status).toBe("rejected");

code: "ACP_SESSION_INIT_FAILED",

message: expect.stringContaining("deployment missing"),

});

expect(outcome.error.message).not.toContain("sk-testsecret1234567890");

const error = outcome.error;

expect(error).toBeInstanceOf(AcpRuntimeError);

if (!(error instanceof AcpRuntimeError)) {

throw new Error("expected AcpRuntimeError");

}

expect(error.message).not.toContain("sk-testsecret1234567890");

});

it("adds Codex wrapper stderr tail to generic first-turn failures", async () => {

};

const waitForAbort = async (abortSignal?: AbortSignal): Promise<never> => {

if (abortSignal?.aborted) {

throw (abortSignal.reason as unknown) ?? new Error("Operation aborted");

throw toLintErrorObject(

(abortSignal.reason as unknown) ?? new Error("Operation aborted"),

"Non-Error thrown",

);

}

return await new Promise<never>((_resolve, reject) => {

abortSignal?.addEventListener(

"abort",

() => {

reject((abortSignal.reason as unknown) ?? new Error("Operation aborted"));

reject(

toLintErrorObject(

(abortSignal.reason as unknown) ?? new Error("Operation aborted"),

"Non-Error rejection",

),

);

},

{ once: true },

);

expect(config.circuitBreakerCooldownMs).toBe(5000);

});

});

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}

"If relevant memory is mostly a stable user preference or recurring habit, lean toward returning it.",

"If the strongest match is only a one-off historical fact and not a recurring preference or habit, prefer NONE unless the latest user message clearly asks for that fact.",

];

case "balanced":

default:

return [

"Treat the latest user message as the primary query.",

(await Promise.race([

subagentPromise.then(

() => undefined,

(error) => readPartialTimeoutData(error),

(error: unknown) => readPartialTimeoutData(error),

),

timeoutPromise,

])) ?? {}

.then(() => {

logger.info(`bonjour: advertised ${serviceSummary(label, svc)}`);

})

.catch((err) => {

.catch((err: unknown) => {

handleAdvertiseFailure(label, svc, err, "failed");

});

} catch (err) {

)})`,

);

try {

void svc.advertise().catch((err) => {

void svc.advertise().catch((err: unknown) => {

logger.warn(

`bonjour: watchdog re-advertise failed (${serviceSummary(label, svc)}): ${formatBonjourError(err)}`,

);

await expect(

withCdpSocket(server.url, async (send) => {

await send("Test.ok");

const rejectRawString = () => Promise.reject("raw-string-from-callback");

const rejectRawString = () =>

Promise.reject(toLintErrorObject("raw-string-from-callback", "Non-Error rejection"));

return rejectRawString();

}),

).rejects.toThrow(/raw-string-from-callback/);

ws.close();

});

});

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}

}

}

if (lastError) {

throw lastError;

throw toLintErrorObject(lastError, "Non-Error thrown");

}

return null;

}

return;

}

await params.client.close().catch(() => {});

await terminateChromeMcpProcessTree(rootPid, descendantPids).catch((err) => {

await terminateChromeMcpProcessTree(rootPid, descendantPids).catch((err: unknown) => {

log.trace(

`Unable to fully terminate Chrome MCP subprocess tree for pid ${rootPid}: ${err instanceof Error ? err.message : String(err)}`,

);

if (signal) {

racers.push(

new Promise<never>((_, reject) => {

abortListener = () => reject(signal.reason ?? new Error("aborted"));

abortListener = () =>

reject(toLintErrorObject(signal.reason ?? new Error("aborted"), "Non-Error rejection"));

signal.addEventListener("abort", abortListener, { once: true });

}),

);

return await Promise.race([

pending,

new Promise<never>((_, reject) => {

abortListener = () => reject(signal.reason ?? new Error("aborted"));

abortListener = () =>

reject(toLintErrorObject(signal.reason ?? new Error("aborted"), "Non-Error rejection"));

signal.addEventListener("abort", abortListener, { once: true });

}),

]);

if (signal) {

racers.push(

new Promise<never>((_, reject) => {

abortListener = () => reject(signal.reason ?? new Error("aborted"));

abortListener = () =>

reject(toLintErrorObject(signal.reason ?? new Error("aborted"), "Non-Error rejection"));

signal.addEventListener("abort", abortListener, { once: true });

}),

);

await stopAllChromeMcpSessions();

chromeMcpProcessCleanupDepsForTest = null;

}

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}

let abortListener: (() => void) | undefined;

const abortPromise: Promise<never> = abortCtrl.signal.aborted

? Promise.reject(abortCtrl.signal.reason ?? new Error("aborted"))

? Promise.reject(

toLintErrorObject(abortCtrl.signal.reason ?? new Error("aborted"), "Non-Error rejection"),

)

: new Promise((_, reject) => {

abortListener = () => reject(abortCtrl.signal.reason ?? new Error("aborted"));

abortListener = () =>

reject(

toLintErrorObject(

abortCtrl.signal.reason ?? new Error("aborted"),

"Non-Error rejection",

),

);

abortCtrl.signal.addEventListener("abort", abortListener, { once: true });

});

withLoopbackBrowserAuth: withLoopbackBrowserAuthImpl,

};

export { testApi as __test };

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}

try {

const response = await opts.page.goto(opts.url, { timeout: opts.timeoutMs });

if (blockedError) {

throw blockedError;

throw toLintErrorObject(blockedError, "Non-Error thrown");

}

return response;

} catch (err) {

if (blockedError) {

throw blockedError;

throw toLintErrorObject(blockedError, "Non-Error thrown");

}

throw err;

} finally {

}

}

}

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}