expect(compacted.payload?.key).toBe("agent:main:main");

expect(compacted.payload?.compacted).toBe(true);

expect(embeddedRunMock.compactEmbeddedPiSession).toHaveBeenCalledTimes(1);

const compactionCall = embeddedRunMock.compactEmbeddedPiSession.mock.calls[0]?.[0];

const compactionCall = embeddedRunMock.compactEmbeddedPiSession.mock.calls[0]?.[0] as

| {

agentHarnessId?: string;

allowGatewaySubagentBinding?: boolean;

bashElevated?: unknown;

config?: unknown;

model?: string;

provider?: string;

reasoningLevel?: string;

sessionFile?: string;

sessionId?: string;

sessionKey?: string;

thinkLevel?: string;

trigger?: string;

workspaceDir?: string;

}

| undefined;

if (!compactionCall) {

throw new Error("expected embedded compaction call");

}

};

expect(compactionCall.sessionId).toBe("sess-main");

expect(compactionCall.sessionKey).toBe("agent:main:main");

if (!compactionCall.sessionFile) {

throw new Error("expected embedded compaction session file");

}

expect(path.basename(compactionCall.sessionFile)).toBe("sess-main.jsonl");

expect(compactionCall.workspaceDir).toBe(path.join(os.tmpdir(), "openclaw-gateway-test"));

expect(callConfig.agents?.defaults?.model?.primary).toBe("anthropic/claude-opus-4-6");

await proxyFetch("https://api.example.com/v1/audio");

expect(proxyAgentSpy).toHaveBeenCalledWith(proxyUrl);

expect(undiciFetch).toHaveBeenCalledWith(

"https://api.example.com/v1/audio",

expect.objectContaining({ dispatcher: getLastAgent() }),

);

expect(undiciFetch).toHaveBeenCalledOnce();

const [input, init] = undiciFetch.mock.calls[0] ?? [];

expect(input).toBe("https://api.example.com/v1/audio");

expect(init?.dispatcher).toBe(getLastAgent());

});

it("reuses the same ProxyAgent across calls", async () => {

expect(envAgentSpy).toHaveBeenCalledWith({ httpsProxy: "http://proxy.test:8080" });

await fetchFn("https://api.example.com");

expect(undiciFetch).toHaveBeenCalledWith(

"https://api.example.com",

expect.objectContaining({ dispatcher: EnvHttpProxyAgent.lastCreated }),

);

expect(undiciFetch).toHaveBeenCalledOnce();

const [input, init] = undiciFetch.mock.calls[0] ?? [];

expect(input).toBe("https://api.example.com");

expect(init?.dispatcher).toBe(EnvHttpProxyAgent.lastCreated);

});

it("converts global FormData bodies when using proxy env fetch", async () => {

expect(setGlobalDispatcher).toHaveBeenCalledTimes(1);

const next = getCurrentDispatcher() as { options?: Record<string, unknown> };

expect(next).toBeInstanceOf(EnvHttpProxyAgent);

expect(next.options).toEqual(

expect.objectContaining({

httpProxy: "socks5://proxy.test:1080",

httpsProxy: "socks5://proxy.test:1080",

bodyTimeout: DEFAULT_UNDICI_STREAM_TIMEOUT_MS,

headersTimeout: DEFAULT_UNDICI_STREAM_TIMEOUT_MS,

}),

);

expect(next.options?.httpProxy).toBe("socks5://proxy.test:1080");

expect(next.options?.httpsProxy).toBe("socks5://proxy.test:1080");

expect(next.options?.bodyTimeout).toBe(DEFAULT_UNDICI_STREAM_TIMEOUT_MS);

expect(next.options?.headersTimeout).toBe(DEFAULT_UNDICI_STREAM_TIMEOUT_MS);

});

it("records timeout bridge but does not override unsupported custom proxy dispatcher types", () => {