Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
import { createServer, type IncomingMessage, type Server, type ServerResponse } from 'node:http';
import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process';
import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import path from 'node:path';
import { fileURLToPath } from 'node:url';
import { gzipSync } from 'node:zlib';
import { EventEmitter } from 'node:events';
import { Transform } from 'node:stream';
import { afterEach, describe, expect, it, vi } from 'vitest';
import {
createAnthropicCompatProxy,
isFetchBlockedPort,
listenOnFetchSafeLoopbackPort,
} from './server.js';
import {
createActiveStripTransform,
createDuplicateToolUseIdRecoveryRule,
createEmptyAssistantMessageRecoveryRule,
createEmptyThinkingRecoveryRule,
createAnthropicContextManagementRecoveryRule,
createEncryptedContentRecoveryRule,
createImageGenerationIdRecoveryRule,
createToolExchangeAdjacencyRecoveryRule,
createToolUseProviderSpecificFieldsRecoveryRule,
createVllmResponsesCompatibilityRule,
dedupeDuplicateToolUseIds,
repairToolExchangeAdjacency,
stripEncryptedContentFromBody,
} from './transform.js';
import { createXaiModelInputRecoveryRule } from './xai-model-input.js';
import { createAnthropicEffortCompatibilityRule } from './anthropic-effort-compatibility.js';
import { listenOnAvailableLoopbackPort } from './test-loopback-server.js';
import { createThreadStripController } from './thread-strip-controller.js';
import type { ProxyHandle, RequestTransform } from './types.js';
const TEST_REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../..');
const TEST_PI_BINARY = path.join(
TEST_REPO_ROOT,
'apps',
'pi-bin',
`${process.platform}-${process.arch}`,
process.platform === 'win32' ? 'pi.exe' : 'pi',
);
function startFakeUpstream(
handler: (reqIndex: number, body: string, res: ServerResponse) => void,
): Promise<{ url: string; bodies: string[]; rawBodies: Buffer[]; headers: Array<Record<string, string>>; paths: string[]; close: () => Promise<void> }> {
const bodies: string[] = [];
const rawBodies: Buffer[] = [];
const headers: Array<Record<string, string>> = [];
const paths: string[] = [];
const server: Server = createServer((req: IncomingMessage, res: ServerResponse) => {
const chunks: Buffer[] = [];
req.on('data', (c: Buffer) => chunks.push(c));
req.on('end', () => {
const rawBody = Buffer.concat(chunks);
const body = rawBody.toString('utf8');
const idx = bodies.length;
bodies.push(body);
rawBodies.push(rawBody);
const flat: Record<string, string> = {};
for (const [k, v] of Object.entries(req.headers)) flat[k.toLowerCase()] = Array.isArray(v) ? v.join(', ') : String(v ?? '');
headers.push(flat);
paths.push(req.url ?? '');
handler(idx, body, res);
});
});
return listenOnAvailableLoopbackPort(server).then((port) => ({
url: `http://127.0.0.1:${port}`,
bodies,
rawBodies,
headers,
paths,
close: () => new Promise<void>((r) => server.close(() => r())),
}));
}
const ENC_ERROR_BODY = JSON.stringify({
error: { message: 'Encrypted content gAAA... could not be decrypted or parsed.', code: 'invalid_encrypted_content' },
});
const XAI_ENC_ERROR_BODY = JSON.stringify({
code: 'invalid-argument',
error: 'Could not decrypt the provided encrypted_content. Ensure the value is the unmodified encrypted_content from a previous response.',
});
const IMAGE_GENERATION_ID_ERROR_BODY = JSON.stringify({
error: {
message: 'Image generation items without `id` are not supported for this request.',
type: 'invalid_request_error',
param: 'input',
code: null,
},
});
const TOOL_USE_PROVIDER_SPECIFIC_FIELDS_ERROR_BODY = JSON.stringify({
error: {
message: 'messages.2.content.0.tool_use.provider_specific_fields: Extra inputs are not permitted',
type: 'invalid_request_error',
},
});
let proxy: ProxyHandle | null = null;
let upstreamClose: (() => Promise<void>) | null = null;
afterEach(async () => {
if (proxy) { await proxy.dispose(); proxy = null; }
if (upstreamClose) { await upstreamClose(); upstreamClose = null; }
});
async function post(url: string, body: unknown): Promise<{ status: number; text: string }> {
const res = await fetch(`${url}/v1/responses`, {
method: 'POST',
headers: { 'content-type': 'application/json', 'thread-id': 'thread-a' },
body: JSON.stringify(body),
});
return { status: res.status, text: await res.text() };
}
describe('anthropic-compat-proxy loopback port guard', () => {
it('tracks Fetch standard bad ports used by HTTP clients', () => {
expect(isFetchBlockedPort(6000)).toBe(true);
expect(isFetchBlockedPort(6001)).toBe(false);
expect(isFetchBlockedPort(6063)).toBe(false);
expect(isFetchBlockedPort(6566)).toBe(true);
expect(isFetchBlockedPort(6667)).toBe(true);
expect(isFetchBlockedPort(6679)).toBe(true);
expect(isFetchBlockedPort(10080)).toBe(true);
expect(isFetchBlockedPort(49152)).toBe(false);
});
it('returns a proxy URL that fetch can request directly', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true }));
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
});
const port = Number(new URL(proxy.url).port);
expect(isFetchBlockedPort(port)).toBe(false);
const result = await post(proxy.url, { model: 'test-model' });
expect(result).toEqual({ status: 200, text: JSON.stringify({ ok: true }) });
});
it('reports a refused loopback upstream as "nothing is listening" with a stable code (#4100)', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end('{}');
});
const port = Number(new URL(upstream.url).port);
// 上游先关掉:自定义供应商指向的本地代理 / SSH 隧道没起来,端口无监听。
await upstream.close();
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
});
const result = await post(proxy.url, { model: 'test-model' });
expect(result.status).toBe(502);
const json = JSON.parse(result.text) as { error: { type: string; code?: string; message: string } };
expect(json.error.type).toBe('proxy_error');
expect(json.error.code).toBe('upstream_loopback_refused');
expect(json.error.message).toMatch(new RegExp(`connect ECONNREFUSED 127\\.0\\.0\\.1:${port}`));
expect(json.error.message).toMatch(/nothing is listening on that local port/);
expect(json.error.message).toMatch(/local proxy or an SSH tunnel/);
});
it('pipes successful response bodies through a request-scoped transform', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
const payload = '{"source":"upstream"}';
res.writeHead(200, {
'content-type': 'application/json', 'content-length': String(payload.length),
}).end(payload);
});
upstreamClose = upstream.close;
let requestBody = '';
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [(body) => ({ ...(body as object), routed: true })],
transformResponse: (ctx) => {
requestBody = ctx.requestBody.toString('utf8');
return new Transform({
transform(chunk, _encoding, callback) {
callback(null, String(chunk).replace('upstream', 'adapted-provider'));
},
});
},
});
const response = await fetch(`${proxy.url}/v1/responses`, {
method: 'POST',
headers: { 'content-type': 'application/json' }, body: '{"model":"test-model"}',
});
expect(await response.json()).toEqual({ source: 'adapted-provider' });
expect(response.headers.get('content-length')).toBeNull();
expect(JSON.parse(requestBody)).toEqual({ model: 'test-model', routed: true });
});
it.each([false, true])('creates the stream adapter with verified MIME (upstream header: %s)', async (withMime) => {
const sse = 'data: {"type":"response.created"}\n\n';
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, {
...(withMime ? { 'content-type': 'text/event-stream' } : {}),
'content-length': Buffer.byteLength(sse),
});
res.write(sse.slice(0, 3));
setImmediate(() => res.end(sse.slice(3)));
});
upstreamClose = upstream.close;
const transformResponse = vi.fn((ctx) => {
if (ctx.responseHeaders['content-type'] !== 'text/event-stream') {
throw new Error(`unsupported content type '${ctx.responseHeaders['content-type'] ?? ''}'`);
}
return new Transform({
transform(chunk, _encoding, callback) {
callback(null, chunk);
},
flush(callback) {
callback(null, ': adapted\n\n');
},
});
});
proxy = await createAnthropicCompatProxy({ upstream: upstream.url, transformResponse });
const response = await fetch(`${proxy.url}/responses`, {
method: 'POST', headers: { 'content-type': 'application/json' },
body: JSON.stringify({ model: 'test-model', stream: true }),
});
expect(response.status).toBe(200);
expect(response.headers.get('content-type')).toBe('text/event-stream');
expect(response.headers.get('content-length')).toBeNull();
expect(await response.text()).toBe(`${sse}: adapted\n\n`);
expect(transformResponse).toHaveBeenCalledOnce();
});
it('returns 502 before committing inferred SSE if adapter construction fails', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200).end('data: {"type":"response.created"}\n\n');
});
upstreamClose = upstream.close;
const transformResponse = vi.fn(() => { throw new Error('adapter unavailable'); });
proxy = await createAnthropicCompatProxy({ upstream: upstream.url, transformResponse });
const result = await post(proxy.url, { model: 'test-model', stream: true });
expect(result.status).toBe(502);
expect(JSON.parse(result.text).error.code).toBe('response_transform_unavailable');
expect(transformResponse).toHaveBeenCalledOnce();
});
it.each(['reject', 'oversize', 'stale'])('does not forward a route body rewrite that is %s', async (mode) => {
const upstream = await startFakeUpstream((_idx, _body, res) => res.end('{}'));
upstreamClose = upstream.close;
let current = true;
const rewrite = vi.fn(async () => {
if (mode === 'reject') throw new Error('Invalid request');
if (mode === 'stale') current = false;
return { body: Buffer.from('x'.repeat(mode === 'oversize' ? 200 : 2)) };
});
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
maxRequestBodyBytes: 100,
bypassRequestTransforms: () => true,
routingTransform: () => ({ transformRequestBody: rewrite, dispatchGenerationValid: () => current }),
});
const result = await post(proxy.url, { model: 'test' });
expect(result.status).toBe(mode === 'reject' ? 502 : mode === 'oversize' ? 413 : 503);
expect(rewrite).toHaveBeenCalledOnce();
expect(upstream.bodies).toEqual([]);
});
it('can preserve an image request body without changing normal response transforms', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end('{}');
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [(body) => ({ ...(body as object), transformed: true })],
bypassRequestTransforms: (_body, ctx) => ctx.url.endsWith('/images/generations'),
});
await fetch(`${proxy.url}/v1/images/generations`, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: '{"model":"gpt-image-2","prompt":"draw"}',
});
await fetch(`${proxy.url}/v1/responses`, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: '{"model":"chat-model"}',
});
expect(upstream.bodies).toEqual([
'{"model":"gpt-image-2","prompt":"draw"}',
'{"model":"chat-model","transformed":true}',
]);
});
it('routes selected multipart requests while preserving their original bytes and headers', async () => {
const defaultUpstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(500).end();
});
const routedUpstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, { 'content-type': 'application/json' }).end('{}');
});
upstreamClose = async () => {
await Promise.all([defaultUpstream.close(), routedUpstream.close()]);
};
const boundary = 'cindy-image-boundary';
const body = Buffer.concat([
Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="prompt"\r\n\r\ndraw\r\n`),
Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="image"; filename="raw.bin"\r\nContent-Type: application/octet-stream\r\n\r\n`),
Buffer.from([0, 255, 13, 10, 128, 42]),
Buffer.from(`\r\n--${boundary}--\r\n`),
]);
proxy = await createAnthropicCompatProxy({
upstream: defaultUpstream.url,
transformRequest: [() => ({ should: 'never run' })],
routeOpaqueRequestBody: (ctx) => ctx.url === '/_cindy/custom-provider/route/images/edits',
bypassRequestTransforms: (_body, ctx) =>
ctx.url === '/_cindy/custom-provider/route/images/edits',
routingTransform: (parsed, ctx) => {
expect(parsed).toBeUndefined();
expect(ctx.headers['content-type']).toBe(`multipart/form-data; boundary=${boundary}`);
return {
upstreamOverride: routedUpstream.url,
pathOverride: '/images/edits',
headerOverride: { authorization: 'Bearer routed-key' },
};
},
});
const response = await fetch(`${proxy.url}/_cindy/custom-provider/route/images/edits`, {
method: 'POST',
headers: {
'content-type': `multipart/form-data; boundary=${boundary}`,
'content-length': String(body.length),
authorization: 'Bearer loopback-placeholder',
},
body,
});
expect(response.status).toBe(200);
expect(defaultUpstream.rawBodies).toHaveLength(0);
expect(routedUpstream.paths).toEqual(['/images/edits']);
expect(routedUpstream.rawBodies[0]).toEqual(body);
expect(routedUpstream.headers[0]?.['content-type']).toBe(
`multipart/form-data; boundary=${boundary}`,
);
expect(routedUpstream.headers[0]?.['content-length']).toBe(String(body.length));
expect(routedUpstream.headers[0]?.authorization).toBe('Bearer routed-key');
});
it('reports content-free lifecycle events at real JSON, multipart, and transport terminal points', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(201, { 'content-type': 'application/json' }).end('{"private":"response"}');
});
upstreamClose = upstream.close;
const events: Array<Record<string, unknown>> = [];
const prefix = '/_cindy/custom-provider/0123456789abcdefabcd';
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
routeOpaqueRequestBody: (ctx) => ctx.url === `${prefix}/images/edits`,
routingTransform: (_body, ctx) => ({
pathOverride: ctx.url.endsWith('/images/edits')
? '/images/edits'
: ctx.url.endsWith('/images/generations')
? '/images/generations'
: ctx.url,
...(ctx.url.startsWith(`${prefix}/images/`)
? { forwardLifecycle: {
onStart: () => events.push({ type: 'start' }),
onComplete: (status) => events.push({ type: 'complete', status }),
onFailure: (failure, status) => events.push({
type: 'transport-error',
failure,
...(status === undefined ? {} : { status }),
}),
} }
: {}),
}),
});
const generation = await fetch(`${proxy.url}${prefix}/images/generations`, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: '{"prompt":"private prompt"}',
});
expect(generation.status).toBe(201);
const multipart = Buffer.from('private multipart bytes');
const edit = await fetch(`${proxy.url}${prefix}/images/edits`, {
method: 'POST',
headers: { 'content-type': 'multipart/form-data; boundary=private-boundary' },
body: multipart,
});
expect(edit.status).toBe(201);
await fetch(`${proxy.url}/responses`, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: '{}',
});
await fetch(`${proxy.url}/images/generations`, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: '{}',
});
expect(events).toEqual([
{ type: 'start' },
{ type: 'complete', status: 201 },
{ type: 'start' },
{ type: 'complete', status: 201 },
]);
await upstream.close();
upstreamClose = async () => undefined;
const unavailable = await fetch(`${proxy.url}${prefix}/images/generations`, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: '{"prompt":"must not reach lifecycle callbacks"}',
});
expect(unavailable.status).toBe(502);
expect(events.slice(4)).toEqual([
{ type: 'start' },
{ type: 'transport-error', failure: 'request-error' },
]);
expect(JSON.stringify(events)).not.toMatch(
/private prompt|multipart|boundary|response|127\.0\.0\.1|ECONNREFUSED/,
);
});
it('emits one terminal lifecycle event for HTTP errors, aborted responses, and successful retry', async () => {
const retryAttempts = new Map<string, number>();
const upstream = await startFakeUpstream((_idx, body, res) => {
const request = JSON.parse(body) as { mode?: string };
if (request.mode === 'http-error') {
res.writeHead(503, { 'content-type': 'application/json' }).end('{"private":"failure"}');
return;
}
if (request.mode === 'aborted-response') {
res.writeHead(200, { 'content-type': 'application/json' });
res.write('{"private":"partial"');
setImmediate(() => res.destroy());
return;
}
const attempts = (retryAttempts.get(request.mode ?? '') ?? 0) + 1;
retryAttempts.set(request.mode ?? '', attempts);
if (request.mode === 'retry-success' && attempts === 1) {
res.writeHead(400, { 'content-type': 'application/json' }).end(ENC_ERROR_BODY);
return;
}
res.writeHead(200, { 'content-type': 'application/json' }).end('{}');
});
upstreamClose = upstream.close;
const events: Array<Record<string, unknown>> = [];
let requestId = 0;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createEncryptedContentRecoveryRule({ enabled: () => true })],
routingTransform: () => {
const id = ++requestId;
return {
forwardLifecycle: {
onStart: () => events.push({ id, type: 'start' }),
onComplete: (status) => events.push({ id, type: 'complete', status }),
onFailure: (failure, status) => events.push({
id,
type: 'failure',
failure,
...(status === undefined ? {} : { status }),
}),
},
};
},
});
expect((await post(proxy.url, { mode: 'http-error' })).status).toBe(503);
await fetch(`${proxy.url}/v1/responses`, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ mode: 'aborted-response' }),
}).then((response) => response.text()).catch(() => undefined);
expect((await post(proxy.url, {
mode: 'retry-success',
input: [{ type: 'reasoning', encrypted_content: 'gAAA-private' }],
})).status).toBe(200);
expect(upstream.bodies).toHaveLength(4);
expect(events.filter((event) => event.id === 1)).toEqual([
{ id: 1, type: 'start' },
{ id: 1, type: 'complete', status: 503 },
]);
expect(events.filter((event) => event.id === 2)).toEqual([
{ id: 2, type: 'start' },
{
id: 2,
type: 'failure',
failure: expect.stringMatching(/^response-(error|aborted|closed)$/),
status: 200,
},
]);
expect(events.filter((event) => event.id === 3)).toEqual([
{ id: 3, type: 'start' },
{ id: 3, type: 'complete', status: 200 },
]);
});
it('settles retry rejection and retry hook failure without a second upstream attempt', async () => {
let mode: 'idle' | 'reject' | 'throw' = 'idle';
const upstream = await startFakeUpstream((_idx, body, res) => {
mode = (JSON.parse(body) as { mode: 'reject' | 'throw' }).mode;
res.writeHead(400, { 'content-type': 'application/json' }).end(ENC_ERROR_BODY);
});
upstreamClose = upstream.close;
const events: Array<Record<string, unknown>> = [];
let requestId = 0;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createEncryptedContentRecoveryRule({ enabled: () => true })],
routingTransform: () => {
const id = ++requestId;
return {
forwardLifecycle: {
onStart: () => events.push({ id, type: 'start' }),
onComplete: (status) => events.push({ id, type: 'complete', status }),
onFailure: (failure) => events.push({ id, type: 'failure', failure }),
},
};
},
revalidateBeforeDispatch: () => {
if (mode === 'throw') throw new Error('private retry hook error');
if (mode === 'reject') {
return {
localHandler: async ({ res }) => {
res.writeHead(503, { 'content-type': 'application/json' }).end('{}');
},
};
}
return null;
},
});
expect((await post(proxy.url, {
mode: 'reject',
input: [{ type: 'reasoning', encrypted_content: 'gAAA-private' }],
})).status).toBe(503);
mode = 'idle';
expect((await post(proxy.url, {
mode: 'throw',
input: [{ type: 'reasoning', encrypted_content: 'gAAA-private' }],
})).status).toBe(503);
expect(upstream.bodies).toHaveLength(2);
expect(events).toEqual([
{ id: 1, type: 'start' },
{ id: 1, type: 'failure', failure: 'retry-rejected' },
{ id: 2, type: 'start' },
{ id: 2, type: 'failure', failure: 'retry-error' },
]);
expect(JSON.stringify(events)).not.toContain('private retry hook error');
});
it('rejects a transparent retry when its routed credential generation changes', async () => {
let generationValid = true;
const upstream = await startFakeUpstream((_idx, _body, res) => {
generationValid = false;
res.writeHead(400, { 'content-type': 'application/json' }).end(ENC_ERROR_BODY);
});
upstreamClose = upstream.close;
const events: Array<Record<string, unknown>> = [];
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createEncryptedContentRecoveryRule({ enabled: () => true })],
routingTransform: () => ({
headerOverride: { authorization: 'Bearer old-generation-fixture' },
dispatchGenerationValid: () => generationValid,
forwardLifecycle: {
onStart: () => events.push({ type: 'start' }),
onComplete: (status) => events.push({ type: 'complete', status }),
onFailure: (failure) => events.push({ type: 'failure', failure }),
},
}),
});
expect((await post(proxy.url, {
input: [{ type: 'reasoning', encrypted_content: 'gAAA-private' }],
})).status).toBe(503);
expect(upstream.bodies).toHaveLength(1);
expect(upstream.headers).toHaveLength(1);
expect(upstream.headers[0]?.authorization).toBe('Bearer old-generation-fixture');
expect(events).toEqual([
{ type: 'start' },
{ type: 'failure', failure: 'retry-rejected' },
]);
});
it('rejects an already-stale routed decision before its first upstream dispatch', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, { 'content-type': 'application/json' }).end('{}');
});
upstreamClose = upstream.close;
const events: Array<Record<string, unknown>> = [];
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
routingTransform: () => ({
dispatchGenerationValid: () => false,
forwardLifecycle: {
onStart: () => events.push({ type: 'start' }),
onComplete: (status) => events.push({ type: 'complete', status }),
onFailure: (failure) => events.push({ type: 'failure', failure }),
},
}),
});
expect((await post(proxy.url, { input: [] })).status).toBe(503);
expect(upstream.bodies).toHaveLength(0);
expect(upstream.headers).toHaveLength(0);
expect(events).toEqual([]);
});
it('settles a client cancellation while waiting for retry revalidation', async () => {
let releaseGate!: () => void;
let markGateEntered!: () => void;
const gateEntered = new Promise<void>((resolve) => { markGateEntered = resolve; });
const gateReleased = new Promise<void>((resolve) => { releaseGate = resolve; });
let retryPending = false;
const upstream = await startFakeUpstream((_idx, _body, res) => {
retryPending = true;
res.writeHead(400, { 'content-type': 'application/json' }).end(ENC_ERROR_BODY);
});
upstreamClose = upstream.close;
const events: Array<Record<string, unknown>> = [];
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createEncryptedContentRecoveryRule({ enabled: () => true })],
routingTransform: () => ({
forwardLifecycle: {
onStart: () => events.push({ type: 'start' }),
onComplete: (status) => events.push({ type: 'complete', status }),
onFailure: (failure) => events.push({ type: 'failure', failure }),
},
}),
revalidateBeforeDispatch: () => retryPending
? {
localHandler: async () => {
markGateEntered();
await gateReleased;
},
}
: null,
});
const controller = new AbortController();
const request = fetch(`${proxy.url}/v1/responses`, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({
input: [{ type: 'reasoning', encrypted_content: 'gAAA-private' }],
}),
signal: controller.signal,
}).catch(() => null);
await gateEntered;
controller.abort();
await request;
await vi.waitFor(() => expect(events).toEqual([
{ type: 'start' },
{ type: 'failure', failure: 'client-aborted' },
]));
releaseGate();
await new Promise((resolve) => setImmediate(resolve));
expect(upstream.bodies).toHaveLength(1);
expect(events).toEqual([
{ type: 'start' },
{ type: 'failure', failure: 'client-aborted' },
]);
});
it('settles request-scoped transform state after a non-2xx response', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(503, { 'content-type': 'application/json' });
res.end(JSON.stringify({ error: { type: 'provider_unavailable' } }));
});
upstreamClose = upstream.close;
const onRequestSettled = vi.fn();
const requestTransform: RequestTransform = (body) => body;
requestTransform.onRequestSettled = onRequestSettled;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [requestTransform],
});
const response = await post(proxy.url, { model: 'test-model' });
expect(response.status).toBe(503);
expect(onRequestSettled).toHaveBeenCalledOnce();
expect(onRequestSettled).toHaveBeenCalledWith(1);
});
it('settles request-scoped transform state when the client closes during an async transform', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, { 'content-type': 'application/json' }).end('{}');
});
upstreamClose = upstream.close;
let resolveTransform!: () => void;
let markTransformStarted!: () => void;
const transformStarted = new Promise<void>((resolve) => {
markTransformStarted = resolve;
});
const transformReleased = new Promise<void>((resolve) => {
resolveTransform = resolve;
});
const onRequestSettled = vi.fn();
const requestTransform: RequestTransform = async (body) => {
markTransformStarted();
await transformReleased;
return body;
};
requestTransform.onRequestSettled = onRequestSettled;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [requestTransform],
});
const controller = new AbortController();
const response = fetch(`${proxy.url}/v1/responses`, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: '{"model":"test-model"}',
signal: controller.signal,
}).catch(() => null);
await transformStarted;
controller.abort();
await response;
expect(onRequestSettled).not.toHaveBeenCalled();
resolveTransform();
await vi.waitFor(() => expect(onRequestSettled).toHaveBeenCalledOnce());
expect(onRequestSettled).toHaveBeenCalledWith(1);
});
it('fails the client when a response transform rejects during async flush', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end('{"ok":true}');
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
transformResponse: () => new Transform({
transform(chunk, _encoding, callback) {
callback(null, chunk);
},
flush(callback) {
setImmediate(() => callback(new Error('response transform flush failed')));
},
}),
});
const controller = new AbortController();
const resultPromise = fetch(`${proxy.url}/v1/responses`, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: '{"model":"test-model"}',
signal: controller.signal,
}).then(async (response) => {
await response.text();
return 'resolved' as const;
}).catch(() => 'rejected' as const);
const result = await Promise.race([
resultPromise,
// real-wait: bound the proxy request while the upstream cancellation path is under test.
new Promise<'timeout'>((resolve) => setTimeout(() => resolve('timeout'), 1_000)),
]);
controller.abort();
expect(result).toBe('rejected');
});
it('jumps out of a Windows excluded-port range after EACCES and cleans listeners', async () => {
const attemptedPorts: number[] = [];
let boundPort = 0;
const fakeServer = new EventEmitter() as EventEmitter & {
address: () => { address: string; family: string; port: number } | null;
listen: (port: number) => void;
};
fakeServer.address = () => boundPort === 0
? null
: { address: '127.0.0.1', family: 'IPv4', port: boundPort };
fakeServer.listen = (port: number) => {
attemptedPorts.push(port);
queueMicrotask(() => {
if (attemptedPorts.length === 1) {
fakeServer.emit(
'error',
Object.assign(new Error('permission denied'), { code: 'EACCES' }),
);
return;
}
boundPort = port;
fakeServer.emit('listening');
});
};
const random = vi.spyOn(Math, 'random')
.mockReturnValueOnce(0.05)
.mockReturnValueOnce(0.75);
try {
const port = await listenOnFetchSafeLoopbackPort(
fakeServer as unknown as Server,
'127.0.0.1',
{},
);
expect(port).toBe(61440);
expect(attemptedPorts).toEqual([49971, 61440]);
expect(fakeServer.listenerCount('error')).toBe(0);
expect(fakeServer.listenerCount('listening')).toBe(0);
} finally {
random.mockRestore();
}
});
it('closes a listening proxy server before rejecting an invalid address', async () => {
let closed = false;
const fakeServer = new EventEmitter() as EventEmitter & {
address: () => null;
close: (callback: () => void) => void;
listen: () => void;
};
fakeServer.address = () => null;
fakeServer.close = (callback) => {
closed = true;
queueMicrotask(callback);
};
fakeServer.listen = () => queueMicrotask(() => fakeServer.emit('listening'));
await expect(listenOnFetchSafeLoopbackPort(
fakeServer as unknown as Server,
'127.0.0.1',
{},
)).rejects.toThrow('anthropic-compat-proxy: failed to bind loopback port');
expect(closed).toBe(true);
expect(fakeServer.listenerCount('error')).toBe(0);
expect(fakeServer.listenerCount('listening')).toBe(0);
});
it('closes a listening test server before rejecting an invalid address', async () => {
let closed = false;
const fakeServer = new EventEmitter() as EventEmitter & {
address: () => null;
close: (callback: () => void) => void;
listen: () => void;
};
fakeServer.address = () => null;
fakeServer.close = (callback) => {
closed = true;
queueMicrotask(callback);
};
fakeServer.listen = () => queueMicrotask(() => fakeServer.emit('listening'));
await expect(
listenOnAvailableLoopbackPort(fakeServer as unknown as Server),
).rejects.toThrow('test loopback server failed to resolve its listening port');
expect(closed).toBe(true);
expect(fakeServer.listenerCount('error')).toBe(0);
expect(fakeServer.listenerCount('listening')).toBe(0);
});
it('reports a stable Error after exhausting test-server bind retries', async () => {
const fakeServer = new EventEmitter() as EventEmitter & {
address: () => null;
listen: () => void;
};
fakeServer.address = () => null;
fakeServer.listen = () => queueMicrotask(() => {
fakeServer.emit(
'error',
Object.assign(new Error('permission denied'), { code: 'EACCES' }),
);
});
await expect(
listenOnAvailableLoopbackPort(fakeServer as unknown as Server),
).rejects.toThrow(
'test loopback server failed to bind after 32 attempts; last error permission denied',
);
expect(fakeServer.listenerCount('error')).toBe(0);
expect(fakeServer.listenerCount('listening')).toBe(0);
});
});
describe('anthropic-compat-proxy tool_use provider field compatibility', () => {
const bodyWithProviderSpecificFields = {
model: 'claude-fable-5',
messages: [
{
role: 'assistant',
content: [
{
type: 'tool_use',
id: 'toolu_1',
name: 'Bash',
input: { command: 'Get-ChildItem' },
provider_specific_fields: null,
},
],
},
{ role: 'user', content: [{ type: 'tool_result', tool_use_id: 'toolu_1', content: 'ok' }] },
],
};
it('strips tool_use.provider_specific_fields before forwarding by default', async () => {
const upstream = await startFakeUpstream((_idx, body, res) => {
expect(body).not.toContain('provider_specific_fields');
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true }));
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({ upstream: upstream.url });
const r = await post(proxy.url, bodyWithProviderSpecificFields);
expect(r.status).toBe(200);
expect(upstream.bodies).toHaveLength(1);
});
it('strips and retries once when LiteLLM rejects the provider field', async () => {
const upstream = await startFakeUpstream((idx, body, res) => {
if (idx === 0) {
expect(body).toContain('provider_specific_fields');
res.writeHead(400, { 'content-type': 'application/json' });
res.end(TOOL_USE_PROVIDER_SPECIFIC_FIELDS_ERROR_BODY);
return;
}
expect(body).not.toContain('provider_specific_fields');
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true }));
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createToolUseProviderSpecificFieldsRecoveryRule()],
});
const r = await post(proxy.url, bodyWithProviderSpecificFields);
expect(r.status).toBe(200);
expect(upstream.bodies).toHaveLength(2);
});
});
describe('Anthropic context management rejection (#7041)', () => {
const request = {
model: 'claude-opus-test', max_tokens: 128,
context_management: { edits: [{ type: 'clear_tool_uses_20250919' }] },
messages: [{ role: 'user', content: 'hello' }],
};
it.each([
[400, 'ValidationException: context_management: Extra inputs are not permitted', 200, 2],
[400, 'ValidationException: context_management: Extra inputs are not permitted', 400, 2],
[200, '{}', 200, 1],
[400, 'ValidationException: unrelated_field: Extra inputs are not permitted', 400, 1],
] as const)('only retries an explicit context_management rejection (%s, %s)', async (status, error, expectedStatus, count) => {
const upstream = await startFakeUpstream((index, _body, res) => {
res.writeHead(index === 0 ? status : expectedStatus, { 'content-type': 'application/json' });
res.end(index === 0 ? JSON.stringify({ error: { message: error } }) : '{}');
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url, transformRequest: [],
recoveryRules: [createAnthropicContextManagementRecoveryRule()],
});
const response = await post(proxy.url, request);
expect(response.status).toBe(expectedStatus);
expect(upstream.bodies).toHaveLength(count);
expect(JSON.parse(upstream.bodies[0]!)).toEqual(request);
if (count === 2) {
expect(JSON.parse(upstream.bodies[1]!)).toEqual({
model: request.model, max_tokens: request.max_tokens, messages: request.messages,
});
}
});
});
describe('anthropic-compat-proxy encrypted content retry', () => {
it('normalizes and retries the vLLM Qwen Responses incompatibility once', async () => {
const upstream = await startFakeUpstream((idx, body, res) => {
if (idx === 0) {
expect(JSON.parse(body)).toMatchObject({
instructions: 'base instructions',
reasoning: { effort: 'high' },
input: [
{ type: 'message', role: 'developer', content: 'permissions' },
{ type: 'message', role: 'user', content: 'hello' },
],
});
res.writeHead(400, { 'content-type': 'application/json' });
res.end(JSON.stringify({
error: {
message: 'Unexpected reasoning effort high. Supported types are xhigh (default), medium, and low.',
type: 'BadRequestError',
},
}));
return;
}
expect(JSON.parse(body)).toEqual({
model: 'qwen3.8-27b-fp8',
reasoning: { effort: 'xhigh' },
input: [
{ type: 'message', role: 'system', content: 'base instructions' },
{ type: 'message', role: 'system', content: 'permissions' },
{ type: 'message', role: 'user', content: 'hello' },
],
});
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true }));
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createVllmResponsesCompatibilityRule()],
});
const result = await post(proxy.url, {
model: 'qwen3.8-27b-fp8',
instructions: 'base instructions',
reasoning: { effort: 'high' },
input: [
{ type: 'message', role: 'developer', content: 'permissions' },
{ type: 'message', role: 'user', content: 'hello' },
],
});
expect(result.status).toBe(200);
expect(upstream.bodies).toHaveLength(2);
});
it('omits output_config.effort and retries once when a custom Anthropic gateway rejects the effort (#5032)', async () => {
const upstream = await startFakeUpstream((idx, rawBody, res) => {
const body = JSON.parse(rawBody) as { output_config?: { effort?: string } };
if (idx === 0) {
expect(body.output_config?.effort).toBe('high');
res.writeHead(400, { 'content-type': 'application/json' });
res.end(JSON.stringify({
type: 'error',
error: { type: 'invalid_request_error', message: 'Unexpected reasoning effort high. Supported types are xhigh (default), medium, and low.' },
}));
return;
}
expect(body).not.toHaveProperty('output_config');
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true }));
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createAnthropicEffortCompatibilityRule()],
});
const result = await post(proxy.url, {
model: 'Qwen3.8-Flash-Next',
max_tokens: 1024,
output_config: { effort: 'high' },
messages: [{ role: 'user', content: 'hello' }],
});
expect(result.status).toBe(200);
expect(upstream.bodies).toHaveLength(2);
});
it('surfaces the gateway effort rejection as-is when the rule is not registered (#5032 baseline)', async () => {
const upstream = await startFakeUpstream((_idx, _rawBody, res) => {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(JSON.stringify({ type: 'error', error: { type: 'invalid_request_error', message: 'Unexpected reasoning effort high. Supported types are xhigh (default), medium, and low.' } }));
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({ upstream: upstream.url, transformRequest: [], recoveryRules: [] });
const result = await post(proxy.url, {
model: 'Qwen3.8-Flash-Next',
output_config: { effort: 'high' },
messages: [{ role: 'user', content: 'hello' }],
});
expect(result.status).toBe(400);
expect(upstream.bodies).toHaveLength(1);
});
it('does not retry an unrelated 400 through the effort rule (#5032)', async () => {
const upstream = await startFakeUpstream((_idx, _rawBody, res) => {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(JSON.stringify({ type: 'error', error: { type: 'invalid_request_error', message: 'messages: at least one message is required' } }));
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createAnthropicEffortCompatibilityRule()],
});
const result = await post(proxy.url, {
model: 'Qwen3.8-Flash-Next',
output_config: { effort: 'high' },
messages: [],
});
expect(result.status).toBe(400);
expect(upstream.bodies).toHaveLength(1);
});
it('preserves readable agent progress when foreign reasoning ciphertext triggers recovery', async () => {
const upstream = await startFakeUpstream((_idx, rawBody, res) => {
const body = JSON.parse(rawBody) as {
input?: Array<{ type?: string; content?: unknown[]; encrypted_content?: unknown }>;
};
const encryptedParts = (body.input ?? [])
.filter((item) => item.type === 'agent_message' && Array.isArray(item.content))
.flatMap((item) => item.content ?? [])
.filter((part): part is Record<string, unknown> => (
typeof part === 'object'
&& part !== null
&& 'type' in part
&& part.type === 'encrypted_content'
));
const foreignReasoning = (body.input ?? []).some((item) => (
item.type === 'reasoning'
&& item.encrypted_content === 'gAAAAA-foreign-reasoning'
));
if (encryptedParts.some((part) => typeof part.encrypted_content !== 'string')) {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(JSON.stringify({
error: {
message: "Missing required parameter: 'input[2].content[1].encrypted_content'.",
code: 'missing_required_parameter',
},
}));
} else if (foreignReasoning) {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(ENC_ERROR_BODY);
} else {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true }));
}
});
upstreamClose = upstream.close;
const controller = createThreadStripController();
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [createActiveStripTransform({
controller,
enabled: () => true,
strip: stripEncryptedContentFromBody,
})],
recoveryRules: [createEncryptedContentRecoveryRule({
enabled: () => true,
onRetry: (threadId, model) => controller.markActive(threadId, model),
})],
});
const request = {
model: 'gpt-5.6-sol',
input: [
{ type: 'message', role: 'user', content: 'go' },
{
type: 'reasoning',
id: 'foreign-reasoning',
summary: [],
encrypted_content: 'gAAAAA-foreign-reasoning',
},
{
type: 'agent_message',
author: '/root/progress_test',
recipient: '/root',
content: [
{ type: 'input_text', text: 'progress' },
{ type: 'encrypted_content', encrypted_content: 'gAAAAA-progress' },
],
internal_chat_message_metadata_passthrough: { source: 'send_message' },
},
{
type: 'agent_message',
author: '/root/progress_test',
recipient: '/root',
content: [{ type: 'input_text', text: 'complete' }],
},
{
type: 'agent_message',
author: '/root/opaque',
content: [{ type: 'encrypted_content', encrypted_content: 'gAAAAA-only' }],
},
],
};
expect((await post(proxy.url, request)).status).toBe(200);
expect(upstream.bodies).toHaveLength(2);
expect(JSON.parse(upstream.bodies[1]).input).toEqual([
{ type: 'message', role: 'user', content: 'go' },
{
type: 'agent_message',
author: '/root/progress_test',
recipient: '/root',
content: [{ type: 'input_text', text: 'progress' }],
internal_chat_message_metadata_passthrough: { source: 'send_message' },
},
{
type: 'agent_message',
author: '/root/progress_test',
recipient: '/root',
content: [{ type: 'input_text', text: 'complete' }],
},
]);
expect((await post(proxy.url, request)).status).toBe(200);
expect(upstream.bodies).toHaveLength(3);
expect(upstream.bodies[2]).toBe(upstream.bodies[1]);
});
it.each([false, true])('classifies rejected compaction after safe reasoning retry (reasoning=%s)', async (reasoning) => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(400, { 'content-type': 'application/json', 'content-encoding': 'gzip' });
res.end(gzipSync(ENC_ERROR_BODY));
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createEncryptedContentRecoveryRule({ enabled: () => true })],
});
const compaction = { type: 'compaction', encrypted_content: 'opaque-prior-state' };
const message = { role: 'user', content: 'keep the original fact' };
const result = await post(proxy.url, { model: 'gpt-6-astra', input: [
message, compaction,
...(reasoning ? [{ type: 'reasoning', encrypted_content: 'old-credentials' }] : []),
] });
expect(result.status).toBe(400);
expect(JSON.parse(result.text).error.code).toBe('CINDY_ENCRYPTED_COMPACTION_INCOMPATIBLE');
expect(upstream.bodies).toHaveLength(reasoning ? 2 : 1);
const final = JSON.parse(upstream.bodies.at(-1)!);
expect(final.input).toContainEqual(compaction);
expect(final.input).toContainEqual(message);
expect(final.input.some((item: { type?: string }) => item.type === 'reasoning')).toBe(false);
});
it('preserves a compatible compaction without retry or classification', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true }));
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({ upstream: upstream.url, transformRequest: [],
recoveryRules: [createEncryptedContentRecoveryRule({ enabled: () => true })] });
const input = [{ type: 'compaction', encrypted_content: 'still-compatible' }];
const result = await post(proxy.url, { model: 'gpt-6-astra', input });
expect(result.status).toBe(200);
expect(upstream.bodies).toHaveLength(1);
expect(JSON.parse(upstream.bodies[0]).input).toEqual(input);
});
it('leaves compaction errors unchanged when encrypted recovery is disabled', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(ENC_ERROR_BODY);
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({ upstream: upstream.url, transformRequest: [],
recoveryRules: [createEncryptedContentRecoveryRule({ enabled: () => false })] });
const result = await post(proxy.url, { model: 'gpt-6-astra', input: [
{ type: 'compaction', encrypted_content: 'opaque-prior-state' },
] });
expect(result.text).toBe(ENC_ERROR_BODY);
expect(upstream.bodies).toHaveLength(1);
});
it('retries invalid_encrypted_content once when enabled and marks the thread active', async () => {
const upstream = await startFakeUpstream((idx, _body, res) => {
if (idx === 0) {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(ENC_ERROR_BODY);
} else {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true, attempt: idx }));
}
});
upstreamClose = upstream.close;
let marked: { threadId: string; model: string } | null = null;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createEncryptedContentRecoveryRule({
enabled: () => true,
onRetry: (threadId, model) => { marked = { threadId, model }; },
})],
});
const r = await post(proxy.url, { model: 'gpt-5.5', input: [{ type: 'reasoning', encrypted_content: 'gAAAsecret' }] });
expect(r.status).toBe(200);
expect(JSON.parse(r.text)).toMatchObject({ ok: true });
expect(upstream.bodies).toHaveLength(2);
expect(upstream.bodies[0]).toContain('encrypted_content');
expect(upstream.bodies[1]).not.toContain('encrypted_content');
expect(marked).toEqual({ threadId: 'thread-a', model: 'gpt-5.5' });
});
it('retries xAI encrypted_content decrypt failures on 422', async () => {
const upstream = await startFakeUpstream((idx, _body, res) => {
if (idx === 0) {
res.writeHead(422, { 'content-type': 'application/json' });
res.end(XAI_ENC_ERROR_BODY);
} else {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true, attempt: idx }));
}
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createEncryptedContentRecoveryRule({ enabled: () => true })],
});
const r = await post(proxy.url, { model: 'grok-4.5', input: [{ type: 'reasoning', encrypted_content: 'gAAAsecret' }] });
expect(r.status).toBe(200);
expect(JSON.parse(r.text)).toMatchObject({ ok: true });
expect(upstream.bodies).toHaveLength(2);
expect(upstream.bodies[0]).toContain('encrypted_content');
expect(upstream.bodies[1]).not.toContain('encrypted_content');
});
it('retries LiteLLM-wrapped xAI ModelInput 422 after sanitizing input', async () => {
const upstream = await startFakeUpstream((idx, _body, res) => {
if (idx === 0) {
res.writeHead(422, { 'content-type': 'application/json' });
res.end(JSON.stringify({
error: 'litellm.BadRequestError: XaiException - {"error":"Failed to deserialize the JSON body into the target type: data did not match any variant of untagged enum ModelInput"}',
}));
} else {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true, attempt: idx }));
}
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createXaiModelInputRecoveryRule()],
});
const r = await post(proxy.url, {
model: 'my-custom-grok',
input: [
{ type: 'message', role: 'user', content: 'hi' },
{ type: 'agent_message', author: 'bot', content: 'done' },
],
});
expect(r.status).toBe(200);
expect(JSON.parse(r.text)).toMatchObject({ ok: true });
expect(upstream.bodies).toHaveLength(2);
expect(upstream.bodies[0]).toContain('agent_message');
expect(upstream.bodies[1]).not.toContain('agent_message');
expect(JSON.parse(upstream.bodies[1]).input).toEqual([
{ type: 'message', role: 'user', content: 'hi' },
{
type: 'message',
role: 'assistant',
content: [{ type: 'output_text', text: '[collab bot]\ndone' }],
},
]);
});
it('does not rewrite OpenAI collab history when another recovery rule retries', async () => {
const upstream = await startFakeUpstream((idx, _body, res) => {
if (idx === 0) {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(ENC_ERROR_BODY);
} else {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true, attempt: idx }));
}
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [
createEncryptedContentRecoveryRule({ enabled: () => true }),
createXaiModelInputRecoveryRule(),
],
});
const r = await post(proxy.url, {
model: 'gpt-5.5',
input: [
{ type: 'reasoning', encrypted_content: 'gAAAsecret' },
{ type: 'agent_message', author: 'bot', content: 'keep me' },
],
});
expect(r.status).toBe(200);
expect(upstream.bodies).toHaveLength(2);
expect(JSON.parse(upstream.bodies[1]).input).toEqual([
{ type: 'agent_message', author: 'bot', content: 'keep me' },
]);
});
it('does not stack encrypted-content strip onto a ModelInput 422 retry', async () => {
const upstream = await startFakeUpstream((idx, _body, res) => {
if (idx === 0) {
res.writeHead(422, { 'content-type': 'application/json' });
res.end(JSON.stringify({
error: 'litellm.BadRequestError: XaiException - {"error":"data did not match any variant of untagged enum ModelInput"}',
}));
} else {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true, attempt: idx }));
}
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [
createEncryptedContentRecoveryRule({ enabled: () => true }),
createXaiModelInputRecoveryRule(),
],
});
const r = await post(proxy.url, {
model: 'grok-4.5',
input: [
{ type: 'reasoning', id: 'rs_1', summary: [], encrypted_content: 'gAAAkeep' },
{ type: 'agent_message', author: 'bot', content: 'done' },
],
});
expect(r.status).toBe(200);
expect(JSON.parse(upstream.bodies[1]).input).toEqual([
{ type: 'reasoning', id: 'rs_1', summary: [], encrypted_content: 'gAAAkeep' },
{
type: 'message',
role: 'assistant',
content: [{ type: 'output_text', text: '[collab bot]\ndone' }],
},
]);
});
it('keeps proactive stripping active when a provider transform rewrites the model id', async () => {
const upstream = await startFakeUpstream((_idx, body, res) => {
if (body.includes('encrypted_content')) {
res.writeHead(422, { 'content-type': 'application/json' });
res.end(XAI_ENC_ERROR_BODY);
} else {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true }));
}
});
upstreamClose = upstream.close;
const controller = createThreadStripController();
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [
createActiveStripTransform({
controller,
enabled: () => true,
strip: stripEncryptedContentFromBody,
}),
(body) => {
const request = body as { model?: unknown };
if (typeof request.model !== 'string' || !request.model.startsWith('xai/')) return null;
return { ...request, model: request.model.slice('xai/'.length) };
},
],
recoveryRules: [createEncryptedContentRecoveryRule({
enabled: () => true,
onRetry: (threadId, model) => controller.markActive(threadId, model),
})],
});
const body = {
model: 'xai/grok-4.5',
input: [{ type: 'reasoning', encrypted_content: 'gAAAsecret' }],
};
expect((await post(proxy.url, body)).status).toBe(200);
expect(upstream.bodies).toHaveLength(2);
expect((await post(proxy.url, body)).status).toBe(200);
// 第二轮应在发上游前主动剥离,只新增一次请求;若 marker 错记成改写后的
// grok-4.5,会被入站 xai/grok-4.5 reconcile 清掉,再次产生 422 + retry。
expect(upstream.bodies).toHaveLength(3);
expect(upstream.bodies[2]).not.toContain('encrypted_content');
expect(upstream.bodies.map((requestBody) => JSON.parse(requestBody).model)).toEqual([
'grok-4.5',
'grok-4.5',
'grok-4.5',
]);
});
it('returns invalid_encrypted_content 400 without retry when disabled', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(ENC_ERROR_BODY);
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createEncryptedContentRecoveryRule({ enabled: () => false })],
});
const r = await post(proxy.url, { model: 'gpt-5.5', input: [{ encrypted_content: 'gAAA' }] });
expect(r.status).toBe(400);
expect(upstream.bodies).toHaveLength(1);
});
it('passes through ordinary 400 responses without retry', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(JSON.stringify({ error: { message: "Unknown parameter: 'foo'", code: 'invalid_request_error' } }));
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createEncryptedContentRecoveryRule({ enabled: () => true })],
});
const r = await post(proxy.url, { model: 'gpt-5.5', input: [{ encrypted_content: 'gAAA' }] });
expect(r.status).toBe(400);
expect(r.text).toContain('Unknown parameter');
expect(upstream.bodies).toHaveLength(1);
});
it('returns original 400 when the request has no encrypted_content to strip', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(ENC_ERROR_BODY);
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createEncryptedContentRecoveryRule({ enabled: () => true })],
});
const r = await post(proxy.url, { model: 'gpt-5.5', input: [{ role: 'user', content: 'hi' }] });
expect(r.status).toBe(400);
expect(upstream.bodies).toHaveLength(1);
});
it('passes through 2xx requests without proactive stripping', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true }));
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({ upstream: upstream.url, transformRequest: [] });
const r = await post(proxy.url, { model: 'gpt-5.5', input: [{ encrypted_content: 'gAAA' }] });
expect(r.status).toBe(200);
expect(upstream.bodies).toHaveLength(1);
expect(upstream.bodies[0]).toContain('encrypted_content');
});
it('does not retry a second time after retry still returns invalid_encrypted_content', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(ENC_ERROR_BODY);
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createEncryptedContentRecoveryRule({ enabled: () => true })],
});
const r = await post(proxy.url, { model: 'gpt-5.5', input: [{ encrypted_content: 'gAAA' }] });
expect(r.status).toBe(400);
expect(upstream.bodies).toHaveLength(2);
expect(upstream.bodies[1]).not.toContain('encrypted_content');
});
});
describe('anthropic-compat-proxy image generation id retry', () => {
it('applies other safe recovery strippers before the single retry', async () => {
const upstream = await startFakeUpstream((idx, _body, res) => {
if (idx === 0) {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(ENC_ERROR_BODY);
} else {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true, attempt: idx }));
}
});
upstreamClose = upstream.close;
const marked: string[] = [];
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [
createEncryptedContentRecoveryRule({
enabled: () => true,
onRetry: (threadId, model) => { marked.push(`encrypted:${threadId}:${model}`); },
}),
createImageGenerationIdRecoveryRule({
onRetry: (threadId, model) => { marked.push(`image:${threadId}:${model}`); },
}),
],
});
const r = await post(proxy.url, {
model: 'gpt-5.5',
tools: [{ type: 'image_generation' }],
input: [
{ type: 'reasoning', encrypted_content: 'gAAA' },
{ type: 'image_generation_end', call_id: 'ig_1', result: 'data:image/png;base64,xxx' },
{ type: 'image_generation_call', id: 'ig_1', result: 'data:image/png;base64,xxx' },
],
});
expect(r.status).toBe(200);
expect(upstream.bodies).toHaveLength(2);
expect(upstream.bodies[1]).not.toContain('encrypted_content');
expect(upstream.bodies[1]).not.toContain('image_generation_end');
expect(upstream.bodies[1]).toContain('image_generation_call');
expect(upstream.bodies[1]).toContain('"tools":[{"type":"image_generation"}]');
expect(marked).toEqual(['encrypted:thread-a:gpt-5.5', 'image:thread-a:gpt-5.5']);
});
it('retries once after removing image generation history items without id', async () => {
const upstream = await startFakeUpstream((idx, _body, res) => {
if (idx === 0) {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(IMAGE_GENERATION_ID_ERROR_BODY);
} else {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true, attempt: idx }));
}
});
upstreamClose = upstream.close;
let marked: { threadId: string; model: string } | null = null;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createImageGenerationIdRecoveryRule({
onRetry: (threadId, model) => { marked = { threadId, model }; },
})],
});
const r = await post(proxy.url, {
model: 'gpt-5.5',
input: [
{ type: 'image_generation_end', call_id: 'ig_1', result: 'data:image/png;base64,xxx' },
{ type: 'image_generation_call', id: 'ig_1', result: 'data:image/png;base64,xxx' },
],
});
expect(r.status).toBe(200);
expect(JSON.parse(r.text)).toMatchObject({ ok: true });
expect(upstream.bodies).toHaveLength(2);
expect(upstream.bodies[0]).toContain('image_generation_end');
expect(upstream.bodies[1]).not.toContain('image_generation_end');
expect(upstream.bodies[1]).toContain('image_generation_call');
expect(marked).toEqual({ threadId: 'thread-a', model: 'gpt-5.5' });
});
});
async function postWithAuth(url: string, body: unknown, authorization: string): Promise<{ status: number; text: string }> {
const res = await fetch(`${url}/v1/responses`, {
method: 'POST',
headers: { 'content-type': 'application/json', 'thread-id': 'thread-a', authorization },
body: JSON.stringify(body),
});
return { status: res.status, text: await res.text() };
}
describe('anthropic-compat-proxy routingTransform', () => {
it('routes an explicit upstream override without resolving an unavailable default upstream', async () => {
const custom = await startFakeUpstream((_i, _b, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ from: 'custom' }));
});
upstreamClose = custom.close;
proxy = await createAnthropicCompatProxy({
upstream: () => '',
transformRequest: [],
routingTransform: () => ({ upstreamOverride: custom.url }),
});
const result = await post(proxy.url, { model: 'custom-model' });
expect(result).toEqual({ status: 200, text: JSON.stringify({ from: 'custom' }) });
expect(custom.bodies).toHaveLength(1);
});
it('forwards to an exact same-origin path override instead of appending the client path', async () => {
const custom = await startFakeUpstream((_i, _b, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end('{}');
});
upstreamClose = custom.close;
proxy = await createAnthropicCompatProxy({
upstream: `${custom.url}/base`,
transformRequest: [],
routingTransform: () => ({ pathOverride: '/tenant/acme/infer?stream=1' }),
});
await post(proxy.url, { model: 'custom-model' });
expect(custom.paths).toEqual(['/base/tenant/acme/infer?stream=1']);
});
it('accepts a root override when the upstream base already names the endpoint', async () => {
const custom = await startFakeUpstream((_i, _b, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end('{}');
});
upstreamClose = custom.close;
proxy = await createAnthropicCompatProxy({
upstream: `${custom.url}/inference-endpoint`,
transformRequest: [],
routingTransform: () => ({ pathOverride: '/' }),
});
await post(proxy.url, { model: 'custom-model' });
expect(custom.paths).toEqual(['/inference-endpoint/']);
});
it('preserves the upstream base query when applying a path override', async () => {
const custom = await startFakeUpstream((_i, _b, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end('{}');
});
upstreamClose = custom.close;
proxy = await createAnthropicCompatProxy({
upstream: `${custom.url}/base?tenant=acme`,
transformRequest: [],
routingTransform: () => ({ pathOverride: '/infer?stream=1&next=%2fadmin' }),
});
await post(proxy.url, { model: 'custom-model' });
expect(custom.paths).toEqual(['/base/infer?tenant=acme&stream=1&next=%2fadmin']);
});
it.each([
'//evil.example/infer',
'/infer#fragment',
'/infer\r\nx-injected: yes',
'/my path',
'/infer\tmode',
'/infer\u0000mode',
'/infer\u007fmode',
'/infer\u0085mode',
'/café',
'/../admin',
'/.%2e/admin',
'/%2e%2e%2fadmin',
'/safe%5Cpart',
'/a<b',
'/infer%2',
'/%ZZ',
'/模型',
'/v1\\messages',
`/${'a'.repeat(2_048)}`,
])('rejects an unsafe path override before contacting the upstream: %j', async (pathOverride) => {
const custom = await startFakeUpstream((_i, _b, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end('{}');
});
upstreamClose = custom.close;
proxy = await createAnthropicCompatProxy({
upstream: `${custom.url}/base`,
transformRequest: [],
routingTransform: () => ({ pathOverride }),
});
const result = await post(proxy.url, { model: 'custom-model' });
expect(result.status).toBe(502);
expect(JSON.parse(result.text)).toEqual({
error: { type: 'proxy_error', message: 'selected request path invalid' },
});
expect(custom.paths).toHaveLength(0);
});
it('revalidateBeforeDispatch can divert a localHandler after routingTransform', async () => {
let innerRan = false;
proxy = await createAnthropicCompatProxy({
upstream: () => '',
transformRequest: [],
routingTransform: () => ({
localHandler: async ({ res }) => {
innerRan = true;
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ from: 'inner' }));
},
}),
revalidateBeforeDispatch: () => ({
localHandler: async ({ res }) => {
res.writeHead(503, {
'content-type': 'application/json',
'retry-after': '1',
});
res.end(JSON.stringify({
error: { type: 'owner_boundary_pending', code: 'owner_boundary_pending' },
}));
},
}),
});
const result = await post(proxy.url, { model: 'subscription-direct-model' });
expect(result.status).toBe(503);
expect(JSON.parse(result.text)).toEqual({
error: { type: 'owner_boundary_pending', code: 'owner_boundary_pending' },
});
expect(innerRan).toBe(false);
});
it('revalidates after async request transforms and does not forward', async () => {
const custom = await startFakeUpstream((_i, _b, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end('{}');
});
upstreamClose = custom.close;
let pending = false;
proxy = await createAnthropicCompatProxy({
upstream: custom.url,
transformRequest: [async () => {
pending = true;
return null;
}],
routingTransform: () => ({ headerOverride: { authorization: 'Bearer previous-owner' } }),
revalidateBeforeDispatch: () => (pending
? {
localHandler: async ({ res }) => {
res.writeHead(503, {
'content-type': 'application/json',
'retry-after': '1',
});
res.end(JSON.stringify({
error: { type: 'owner_boundary_pending', code: 'owner_boundary_pending' },
}));
},
}
: null),
});
const result = await post(proxy.url, { model: 'claude-haiku-4-5-20251001' });
expect(result.status).toBe(503);
expect(JSON.parse(result.text)).toEqual({
error: { type: 'owner_boundary_pending', code: 'owner_boundary_pending' },
});
expect(custom.bodies).toHaveLength(0);
});
it('revalidates when owner scope changes during async transforms even if pending stays false', async () => {
const custom = await startFakeUpstream((_i, _b, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end('{}');
});
upstreamClose = custom.close;
let ownerScope = 'cloud:owner-a:1';
const ownerScopeByCtx = new WeakMap<object, string>();
proxy = await createAnthropicCompatProxy({
upstream: custom.url,
transformRequest: [async () => {
ownerScope = 'cloud:owner-b:2';
return null;
}],
routingTransform: (_body, ctx) => {
ownerScopeByCtx.set(ctx, ownerScope);
return { headerOverride: { authorization: 'Bearer previous-owner' } };
},
revalidateBeforeDispatch: (_decision, ctx) => {
const start = ctx ? ownerScopeByCtx.get(ctx) : undefined;
if (start !== undefined && start !== ownerScope) {
return {
localHandler: async ({ res }) => {
res.writeHead(503, {
'content-type': 'application/json',
'retry-after': '1',
});
res.end(JSON.stringify({
error: { type: 'owner_boundary_pending', code: 'owner_boundary_pending' },
}));
},
};
}
return null;
},
});
const result = await post(proxy.url, { model: 'claude-haiku-4-5-20251001' });
expect(result.status).toBe(503);
expect(JSON.parse(result.text)).toEqual({
error: { type: 'owner_boundary_pending', code: 'owner_boundary_pending' },
});
expect(custom.bodies).toHaveLength(0);
});
it('stamps owner scope before collecting the body so a switch during upload cannot re-baseline', async () => {
const custom = await startFakeUpstream((_i, _b, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end('{}');
});
upstreamClose = custom.close;
let ownerScope = 'cloud:owner-a:1';
const ownerScopeByCtx = new WeakMap<object, string>();
proxy = await createAnthropicCompatProxy({
upstream: custom.url,
transformRequest: [],
routingTransform: () => {
// collectRequestBody 已经结束;若盖章拖到这里,会把 B 当成起始 scope。
ownerScope = 'cloud:owner-b:2';
return { headerOverride: { authorization: 'Bearer previous-owner' } };
},
revalidateBeforeDispatch: (_decision, ctx) => {
if (ctx && !ownerScopeByCtx.has(ctx)) ownerScopeByCtx.set(ctx, ownerScope);
const start = ctx ? ownerScopeByCtx.get(ctx) : undefined;
if (start !== undefined && start !== ownerScope) {
return {
localHandler: async ({ res }) => {
res.writeHead(503, {
'content-type': 'application/json',
'retry-after': '1',
});
res.end(JSON.stringify({
error: { type: 'owner_boundary_pending', code: 'owner_boundary_pending' },
}));
},
};
}
return null;
},
});
const result = await post(proxy.url, { model: 'claude-haiku-4-5-20251001' });
expect(result.status).toBe(503);
expect(JSON.parse(result.text)).toEqual({
error: { type: 'owner_boundary_pending', code: 'owner_boundary_pending' },
});
expect(custom.bodies).toHaveLength(0);
expect(custom.headers).toHaveLength(0);
});
it('revalidates owner scope before a transparent recovery retry', async () => {
let ownerScope = 'cloud:owner-a:1';
const ownerScopeByCtx = new WeakMap<object, string>();
const custom = await startFakeUpstream((idx, _body, res) => {
ownerScope = 'cloud:owner-b:2';
if (idx === 0) {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(ENC_ERROR_BODY);
return;
}
res.writeHead(200, { 'content-type': 'application/json' });
res.end('{}');
});
upstreamClose = custom.close;
proxy = await createAnthropicCompatProxy({
upstream: custom.url,
transformRequest: [],
routingTransform: () => ({ headerOverride: { authorization: 'Bearer previous-owner' } }),
recoveryRules: [createEncryptedContentRecoveryRule({ enabled: () => true })],
revalidateBeforeDispatch: (_decision, ctx) => {
if (ctx && !ownerScopeByCtx.has(ctx)) ownerScopeByCtx.set(ctx, ownerScope);
const start = ctx ? ownerScopeByCtx.get(ctx) : undefined;
if (start !== undefined && start !== ownerScope) {
return {
localHandler: async ({ res }) => {
res.writeHead(503, {
'content-type': 'application/json',
'retry-after': '1',
});
res.end(JSON.stringify({
error: { type: 'owner_boundary_pending', code: 'owner_boundary_pending' },
}));
},
};
}
return null;
},
});
const r = await post(proxy.url, {
model: 'gpt-5.5',
input: [{ type: 'reasoning', encrypted_content: 'gAAAsecret' }],
});
expect(r.status).toBe(503);
expect(JSON.parse(r.text)).toEqual({
error: { type: 'owner_boundary_pending', code: 'owner_boundary_pending' },
});
expect(custom.bodies).toHaveLength(1);
expect(custom.headers[0]?.authorization).toBe('Bearer previous-owner');
});
it('runs a local handler without resolving an unavailable default upstream', async () => {
proxy = await createAnthropicCompatProxy({
upstream: () => '',
transformRequest: [],
routingTransform: () => ({
localHandler: async ({ res }) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ from: 'local-handler' }));
},
}),
});
const result = await post(proxy.url, { model: 'subscription-direct-model' });
expect(result).toEqual({ status: 200, text: JSON.stringify({ from: 'local-handler' }) });
});
it('returns a controlled 503 only when the request actually needs an unavailable default upstream', async () => {
proxy = await createAnthropicCompatProxy({
upstream: () => '',
transformRequest: [],
routingTransform: () => ({ headerOverride: { authorization: 'Bearer gateway-key' } }),
});
const result = await post(proxy.url, { model: 'gateway-model' });
expect(result.status).toBe(503);
expect(JSON.parse(result.text)).toEqual({
error: { type: 'proxy_error', message: 'default upstream unavailable' },
});
});
it('awaits async routingTransform decisions before forwarding', async () => {
const gateway = await startFakeUpstream((_i, _b, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ from: 'gateway' }));
});
const xai = await startFakeUpstream((_i, _b, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ from: 'xai' }));
});
upstreamClose = async () => { await gateway.close(); await xai.close(); };
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
routingTransform: async () => ({
upstreamOverride: xai.url,
headerOverride: { authorization: 'Bearer xai-token' },
}),
});
const r = await postWithAuth(proxy.url, { model: 'xai/grok-4.3', input: [] }, 'Bearer openai-token');
expect(JSON.parse(r.text)).toMatchObject({ from: 'xai' });
expect(xai.headers.at(-1)?.authorization).toBe('Bearer xai-token');
expect(gateway.bodies).toHaveLength(0);
});
it('overrides upstream and authorization header per request', async () => {
const gateway = await startFakeUpstream((_i, _b, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ from: 'gateway' }));
});
const chatgpt = await startFakeUpstream((_i, _b, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ from: 'chatgpt' }));
});
upstreamClose = async () => { await gateway.close(); await chatgpt.close(); };
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
routingTransform: (body) => {
const model = (body as { model?: string }).model ?? '';
// 折扣: 默认 upstream(gateway) + 换 gateway key; 普通: override 到 chatgpt + 透传原 auth
if (model.startsWith('codex/')) return { headerOverride: { authorization: 'Bearer gw-key' } };
return { upstreamOverride: chatgpt.url };
},
});
const r1 = await postWithAuth(proxy.url, { model: 'codex/gpt-5.5', input: [] }, 'Bearer oauth-token');
expect(JSON.parse(r1.text)).toMatchObject({ from: 'gateway' });
expect(gateway.headers.at(-1)?.authorization).toBe('Bearer gw-key');
const r2 = await postWithAuth(proxy.url, { model: 'gpt-5.5', input: [] }, 'Bearer oauth-token');
expect(JSON.parse(r2.text)).toMatchObject({ from: 'chatgpt' });
expect(chatgpt.headers.at(-1)?.authorization).toBe('Bearer oauth-token');
});
it('deletes headers after merging headerOverride (e.g. strip the OAuth beta for gateway models)', async () => {
const gateway = await startFakeUpstream((_i, _b, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ from: 'gateway' }));
});
upstreamClose = gateway.close;
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
// 模拟 OAuth 模式: provider 路由模型换 gateway key 并抹掉 OAuth 专用 beta header。
// claude-* 透传(不动 header, 保留 oauth beta)。
routingTransform: (body) => {
const model = (body as { model?: string }).model ?? '';
if (model.startsWith('claude-')) return null;
return { headerOverride: { authorization: 'Bearer gw-key' }, headerDelete: ['anthropic-beta'] };
},
});
// provider 路由模型: 客户端带 oauth bearer + oauth beta → 上游应收到 gateway key 且无 beta。
const provider = await fetch(`${proxy.url}/v1/messages`, {
method: 'POST',
headers: {
'content-type': 'application/json',
'thread-id': 'thread-a',
authorization: 'Bearer oauth-token',
'anthropic-beta': 'oauth-2025-04-20',
},
body: JSON.stringify({ model: 'gpt-5.5', messages: [] }),
});
expect(JSON.parse(await provider.text())).toMatchObject({ from: 'gateway' });
expect(gateway.headers.at(-1)?.authorization).toBe('Bearer gw-key');
expect(gateway.headers.at(-1)?.['anthropic-beta']).toBeUndefined();
// claude-* 透传: header 原样保留(decision=null)。
const anthropic = await fetch(`${proxy.url}/v1/messages`, {
method: 'POST',
headers: {
'content-type': 'application/json',
'thread-id': 'thread-a',
authorization: 'Bearer oauth-token',
'anthropic-beta': 'oauth-2025-04-20',
},
body: JSON.stringify({ model: 'claude-opus-4-8', messages: [] }),
});
await anthropic.text();
expect(gateway.headers.at(-1)?.authorization).toBe('Bearer oauth-token');
expect(gateway.headers.at(-1)?.['anthropic-beta']).toBe('oauth-2025-04-20');
});
it('routes by the ORIGINAL body even when a transform rewrites model', async () => {
const gateway = await startFakeUpstream((_i, _b, res) => { res.writeHead(200, { 'content-type': 'application/json' }); res.end('{}'); });
const chatgpt = await startFakeUpstream((_i, _b, res) => { res.writeHead(200, { 'content-type': 'application/json' }); res.end('{}'); });
upstreamClose = async () => { await gateway.close(); await chatgpt.close(); };
proxy = await createAnthropicCompatProxy({
upstream: chatgpt.url,
// transform 去掉 codex/ 前缀(发上游的 body.model 变 gpt-5.5)
transformRequest: [(body) => {
const b = body as { model?: string };
if (typeof b.model === 'string' && b.model.startsWith('codex/')) return { ...b, model: b.model.slice('codex/'.length) };
return null;
}],
// routing 看原始 body, 仍能识别 codex/ 前缀 → 落 gateway
routingTransform: (body) => {
const model = (body as { model?: string }).model ?? '';
return model.startsWith('codex/') ? { upstreamOverride: gateway.url } : null;
},
});
await post(proxy.url, { model: 'codex/gpt-5.5', input: [] });
expect(gateway.bodies).toHaveLength(1);
expect(chatgpt.bodies).toHaveLength(0);
expect(JSON.parse(gateway.bodies[0]).model).toBe('gpt-5.5'); // 发上游已去前缀
});
it('without routingTransform, always uses default upstream (backward compat)', async () => {
const gateway = await startFakeUpstream((_i, _b, res) => { res.writeHead(200, { 'content-type': 'application/json' }); res.end('{}'); });
upstreamClose = gateway.close;
proxy = await createAnthropicCompatProxy({ upstream: gateway.url, transformRequest: [] });
await post(proxy.url, { model: 'gpt-5.5', input: [] });
expect(gateway.bodies).toHaveLength(1);
});
it('runs routingTransform for body-less GET (e.g. /models poll) with undefined body and applies upstreamOverride', async () => {
const gateway = await startFakeUpstream((_i, _b, res) => { res.writeHead(200, { 'content-type': 'application/json' }); res.end(JSON.stringify({ from: 'gateway' })); });
// 模拟"凭证原生后端"(codex 的 /models 在 oauth 态应被 override 到这里)。
const official = await startFakeUpstream((_i, _b, res) => { res.writeHead(200, { 'content-type': 'application/json' }); res.end(JSON.stringify({ from: 'official' })); });
upstreamClose = async () => { await gateway.close(); await official.close(); };
let bodyForGet: unknown = 'untouched';
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
routingTransform: (body, ctx) => {
// GET 没有 body → routingTransform 现在也会被调用,body 为 undefined,可据 url 路由控制面请求。
if (ctx.method === 'GET' && ctx.url.startsWith('/models')) {
bodyForGet = body;
return { upstreamOverride: official.url };
}
return null;
},
});
const res = await fetch(`${proxy.url}/models?client_version=0.135.0`, { method: 'GET' });
expect(JSON.parse(await res.text())).toMatchObject({ from: 'official' });
expect(bodyForGet).toBeUndefined(); // GET 以 undefined body 调 transform
expect(official.paths.at(-1)).toContain('/models');
expect(gateway.bodies).toHaveLength(0); // 没掉默认上游
});
it('GET with a null-returning routingTransform still uses default upstream (backward compat)', async () => {
const gateway = await startFakeUpstream((_i, _b, res) => { res.writeHead(200, { 'content-type': 'application/json' }); res.end(JSON.stringify({ from: 'gateway' })); });
upstreamClose = gateway.close;
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
routingTransform: () => null, // 任何请求都不 override
});
const res = await fetch(`${proxy.url}/models`, { method: 'GET' });
expect(JSON.parse(await res.text())).toMatchObject({ from: 'gateway' });
expect(gateway.paths.at(-1)).toContain('/models');
});
it('▶ inbound 日志的 upstreamBase 显示本请求**最终**发往的 upstream(override / 默认)', async () => {
const gateway = await startFakeUpstream((_i, _b, res) => { res.writeHead(200, { 'content-type': 'application/json' }); res.end('{}'); });
// 模拟"订阅直连"上游(per-session 选 Anthropic 时 routingTransform 会 override 到它)。
const direct = await startFakeUpstream((_i, _b, res) => { res.writeHead(200, { 'content-type': 'application/json' }); res.end('{}'); });
upstreamClose = async () => { await gateway.close(); await direct.close(); };
const debugs: Array<{ msg: string; ctx?: Record<string, unknown> }> = [];
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
// gpt-* → override 到 direct(订阅直连);其余 → null(走默认 gateway upstream)。
routingTransform: (body) => {
const model = (body as { model?: string }).model ?? '';
return model.startsWith('gpt-') ? { upstreamOverride: direct.url } : null;
},
logger: { isDebugEnabled: () => true, debug: (msg, ctx) => debugs.push({ msg, ctx }) },
});
// override 命中 → inbound 日志的 upstreamBase 是最终落点(direct),不是默认 gateway。
await post(proxy.url, { model: 'gpt-5.5', input: [] });
expect(debugs.find((d) => d.msg.includes('inbound request'))?.ctx?.upstreamBase).toBe(direct.url);
// 无 override(decision=null)→ inbound 日志回落默认上游 gateway。
debugs.length = 0;
await post(proxy.url, { model: 'claude-opus-4-8', input: [] });
expect(debugs.find((d) => d.msg.includes('inbound request'))?.ctx?.upstreamBase).toBe(gateway.url);
});
it('decodes a gzip-encoded non-2xx error body for errorType + debug dump', async () => {
const errorJson = JSON.stringify({
error: { message: 'Rate limit reached for gpt-5.5', type: 'rate_limit_error', code: 'rate_limit_exceeded' },
});
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(429, { 'content-type': 'application/json', 'content-encoding': 'gzip' });
res.end(gzipSync(Buffer.from(errorJson, 'utf8')));
});
upstreamClose = upstream.close;
const warns: Array<{ msg: string; ctx?: Record<string, unknown> }> = [];
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
logger: { isDebugEnabled: () => true, warn: (msg, ctx) => warns.push({ msg, ctx }) },
});
const r = await post(proxy.url, { model: 'codex/gpt-5.5', input: [] });
// 客户端侧: pipe + content-encoding 透传, undici 自动解压 → 拿到可读 JSON, 功能不受影响。
expect(r.status).toBe(429);
expect(JSON.parse(r.text)).toMatchObject({ error: { type: 'rate_limit_error' } });
// 日志侧: 解压后才能抽出 errorType, dump 出的 body 是可读 JSON 而不是 gzip 乱码。
const warn = warns.find((w) => w.msg.includes('non-2xx'));
expect(warn?.ctx?.errorType).toBe('rate_limit_error');
expect(String(warn?.ctx?.body)).toContain('Rate limit reached');
expect(String(warn?.ctx?.body)).not.toContain('�'); // 无 replacement char(乱码标志)
});
it('detects gzip-encoded invalid_encrypted_content and still triggers transparent retry', async () => {
const upstream = await startFakeUpstream((idx, _body, res) => {
if (idx === 0) {
res.writeHead(400, { 'content-type': 'application/json', 'content-encoding': 'gzip' });
res.end(gzipSync(Buffer.from(ENC_ERROR_BODY, 'utf8')));
} else {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true }));
}
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createEncryptedContentRecoveryRule({ enabled: () => true })],
});
const r = await post(proxy.url, { model: 'gpt-5.5', input: [{ encrypted_content: 'gAAA' }] });
// gzip 压缩的 400 错误体也能被识别 → 剥离 encrypted_content 重试一次 → 第二次 200。
expect(r.status).toBe(200);
expect(upstream.bodies).toHaveLength(2);
expect(upstream.bodies[1]).not.toContain('encrypted_content');
});
it('encrypted retry after override still hits the override upstream', async () => {
const gateway = await startFakeUpstream((_i, _b, res) => { res.writeHead(200, { 'content-type': 'application/json' }); res.end('{}'); });
const chatgpt = await startFakeUpstream((idx, _b, res) => {
if (idx === 0) { res.writeHead(400, { 'content-type': 'application/json' }); res.end(ENC_ERROR_BODY); }
else { res.writeHead(200, { 'content-type': 'application/json' }); res.end(JSON.stringify({ ok: true })); }
});
upstreamClose = async () => { await gateway.close(); await chatgpt.close(); };
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
routingTransform: () => ({ upstreamOverride: chatgpt.url }),
recoveryRules: [createEncryptedContentRecoveryRule({ enabled: () => true })],
});
const r = await post(proxy.url, { model: 'gpt-5.5', input: [{ encrypted_content: 'gAAA' }] });
expect(r.status).toBe(200);
expect(chatgpt.bodies).toHaveLength(2); // 首次 400 + 重试都落 override upstream
expect(gateway.bodies).toHaveLength(0);
});
it('tees successful responses to responseObserver without changing the response', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ id: 'resp_123', service_tier: 'priority' }));
});
upstreamClose = upstream.close;
const chunks: string[] = [];
let observedEnd = false;
let transformedReqId: number | null = null;
let observedCtx: { reqId: number; url: string; status: number; upstreamBase: string } | null = null;
const upstreamWithQuery = `${upstream.url}/tenant/acme?region=us`;
proxy = await createAnthropicCompatProxy({
upstream: upstreamWithQuery,
transformRequest: [(_body, ctx) => {
transformedReqId = ctx.reqId;
return null;
}],
responseObserver: (ctx) => {
observedCtx = {
reqId: ctx.reqId,
url: ctx.url,
status: ctx.status,
upstreamBase: ctx.upstreamBase,
};
return {
onData: (chunk) => chunks.push(chunk.toString('utf8')),
onEnd: () => { observedEnd = true; },
};
},
});
const r = await post(proxy.url, { model: 'gpt-5.5', input: [] });
expect(r.status).toBe(200);
expect(JSON.parse(r.text)).toEqual({ id: 'resp_123', service_tier: 'priority' });
expect(transformedReqId).toBeTypeOf('number');
expect(observedCtx).toEqual({
reqId: transformedReqId,
url: '/v1/responses',
status: 200,
upstreamBase: upstreamWithQuery,
});
expect(chunks.join('')).toBe(r.text);
expect(observedEnd).toBe(true);
});
it('feeds observer on 400 buffered by recovery branch when no rule matches', async () => {
// 回归:有 enabled recovery rule 时 400 走缓冲分支,规则不命中的回落路径也必须喂观察器,
// 否则自定义供应商的普通 400(如 model_not_found)静默绕过上游错误分类 toast。
const errBody = JSON.stringify({ error: { type: 'invalid_request_error', message: 'model x not found' } });
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(errBody);
});
upstreamClose = upstream.close;
const chunks: string[] = [];
let observedStatus = -1;
let observedEnd = false;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createEncryptedContentRecoveryRule({ enabled: () => true })], // 不会命中该错误体
responseObserver: (ctx) => {
observedStatus = ctx.status;
return {
onData: (chunk) => chunks.push(chunk.toString('utf8')),
onEnd: () => { observedEnd = true; },
};
},
});
const r = await post(proxy.url, { model: 'gpt-5.5', input: [] });
expect(r.status).toBe(400);
expect(upstream.bodies).toHaveLength(1); // 无命中 → 不重试
expect(observedStatus).toBe(400);
expect(chunks.join('')).toBe(errBody);
expect(observedEnd).toBe(true);
});
it('exposes the final routed headers to the observer, not the client-sent ones', async () => {
// 回归:供应商 OAuth 是路由期经 headerOverride 注入的。观察器若只拿得到 requestHeaders,
// 就只能看到 agent 子进程自带的那把 bearer —— 任何「这次请求用了哪把凭证」的判断
// (如 xAI 凭证失效收口的等值关联)都会永远对不上,整条链路的收口静默失效。
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(403, { 'content-type': 'application/json' });
res.end(JSON.stringify({ code: 'unauthenticated:bad-credentials' }));
});
upstreamClose = upstream.close;
let observedRequestAuth: string | undefined;
let observedOutboundAuth: string | undefined;
let observedOutboundBeta: string | undefined;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
routingTransform: () => ({
headerOverride: { authorization: 'Bearer routed-xai-token' },
headerDelete: ['anthropic-beta'],
}),
responseObserver: (ctx) => {
observedRequestAuth = ctx.requestHeaders.authorization;
observedOutboundAuth = ctx.outboundHeaders?.authorization;
observedOutboundBeta = ctx.outboundHeaders?.['anthropic-beta'];
return null;
},
});
const r = await fetch(`${proxy.url}/v1/responses`, {
method: 'POST',
headers: {
'content-type': 'application/json',
'thread-id': 'thread-a',
authorization: 'Bearer client-subprocess-token',
'anthropic-beta': 'oauth-2025-04-20',
},
body: JSON.stringify({ model: 'gpt-5.5', input: [] }),
});
expect(r.status).toBe(403);
// 客户端原始头保持原样(反解 thread-id 等会话归属仍靠它)。
expect(observedRequestAuth).toBe('Bearer client-subprocess-token');
// 实际发往上游的是路由注入后的凭证,且 headerDelete 已生效。
expect(observedOutboundAuth).toBe('Bearer routed-xai-token');
expect(observedOutboundBeta).toBeUndefined();
});
});
const THINKING_ERROR_BODY = JSON.stringify({
error: {
type: 'invalid_request_error',
message: 'messages.7.content.0.thinking: each thinking block must contain thinking',
},
});
// 混合 sync + async transform:锁定 runTransforms 的串行 await 语义(顺序保持、
// async 被 await、null 透传、失败回退)。防止后续改动误并行化破坏链式顺序依赖。
describe('anthropic-compat-proxy mixed sync+async transform chain', () => {
it('awaits async transforms in order and keeps sync passthrough', async () => {
const order: string[] = [];
const custom = await startFakeUpstream((_i, body, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ echoed: JSON.parse(body) }));
});
upstreamClose = custom.close;
proxy = await createAnthropicCompatProxy({
upstream: custom.url,
transformRequest: [
// 第一个:sync transform 透传(返回 null),不改 body。
() => {
order.push('sync-passthrough');
return null;
},
// 第二个:async transform,模拟视觉桥(延迟后改写 body)。
async (body) => {
order.push('async-begin');
await new Promise((r) => setTimeout(r, 20));
order.push('async-end');
return { ...(body as Record<string, unknown>), model: 'rewritten-by-async' };
},
// 第三个:sync transform,在 async 结果上再改。
(body) => {
order.push('sync-after-async');
return { ...(body as Record<string, unknown>), extra: true };
},
],
});
await post(proxy.url, { model: 'original', messages: [{ role: 'user', content: 'x' }] });
// 顺序:sync 透传 → async 开始 → async 结束 → sync 尾改(严格串行,无并行交错)。
expect(order).toEqual(['sync-passthrough', 'async-begin', 'async-end', 'sync-after-async']);
// async 的结果被下游消费:final body 同时含 async 与 sync 的改写。
expect(custom.bodies).toHaveLength(1);
const sent = JSON.parse(custom.bodies[0]);
expect(sent.model).toBe('rewritten-by-async');
expect(sent.extra).toBe(true);
});
it('recovers from a throwing async transform by skipping it (passthrough)', async () => {
const custom = await startFakeUpstream((_i, body, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ echoed: JSON.parse(body) }));
});
upstreamClose = custom.close;
proxy = await createAnthropicCompatProxy({
upstream: custom.url,
transformRequest: [
async () => {
throw new Error('boom');
},
(body) => ({ ...(body as Record<string, unknown>), survived: true }),
],
});
await post(proxy.url, { model: 'original', messages: [] });
expect(custom.bodies).toHaveLength(1);
// 抛错的 async transform 被跳过,后续 sync transform 照常执行。
expect(JSON.parse(custom.bodies[0]).survived).toBe(true);
});
it('rejects locally when a fail-closed request transform throws', async () => {
const custom = await startFakeUpstream((_i, _body, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end('{}');
});
upstreamClose = custom.close;
const rejectingTransform: RequestTransform = () => {
throw new Error('request cannot be adapted safely');
};
rejectingTransform.errorMode = 'reject-request';
proxy = await createAnthropicCompatProxy({
upstream: custom.url,
transformRequest: [rejectingTransform],
});
const response = await post(proxy.url, { model: 'original', input: [] });
expect(response.status).toBe(502);
expect(JSON.parse(response.text)).toMatchObject({ error: { type: 'proxy_error' } });
expect(custom.bodies).toHaveLength(0);
});
});
// 跨厂商切回 Anthropic 模型: 历史里 gpt 留下的空壳 thinking 块 + 后面一句 text。
function anthropicBodyWithEmptyThinking(): unknown {
return {
model: 'claude-sonnet-4-6',
messages: [
{ role: 'user', content: 'hi' },
{
role: 'assistant',
content: [
{ type: 'thinking', thinking: '', signature: '' },
{ type: 'text', text: 'ok' },
],
},
],
};
}
describe('anthropic-compat-proxy empty-thinking recovery', () => {
it('strips empty thinking blocks and retries once on the thinking 400', async () => {
const upstream = await startFakeUpstream((idx, _body, res) => {
if (idx === 0) {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(THINKING_ERROR_BODY);
} else {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true }));
}
});
upstreamClose = upstream.close;
let marked: { threadId: string; model: string } | null = null;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createEmptyThinkingRecoveryRule({
enabled: () => true,
onRetry: (threadId, model) => { marked = { threadId, model }; },
})],
});
const r = await post(proxy.url, anthropicBodyWithEmptyThinking());
expect(r.status).toBe(200);
expect(upstream.bodies).toHaveLength(2);
expect(upstream.bodies[0]).toContain('"thinking":""');
expect(upstream.bodies[1]).not.toContain('"thinking":""');
expect(marked).toEqual({ threadId: 'thread-a', model: 'claude-sonnet-4-6' });
});
it('does not retry when there is no empty thinking block to strip (content-bearing block survives)', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(THINKING_ERROR_BODY);
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createEmptyThinkingRecoveryRule({ enabled: () => true })],
});
const r = await post(proxy.url, {
model: 'claude-sonnet-4-6',
messages: [{ role: 'assistant', content: [{ type: 'thinking', thinking: 'real reasoning', signature: '' }] }],
});
expect(r.status).toBe(400);
expect(upstream.bodies).toHaveLength(1);
});
it('does not retry a second time after the retry still returns the thinking 400', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(THINKING_ERROR_BODY);
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createEmptyThinkingRecoveryRule({ enabled: () => true })],
});
const r = await post(proxy.url, anthropicBodyWithEmptyThinking());
expect(r.status).toBe(400);
expect(upstream.bodies).toHaveLength(2);
});
it('dispatches the right rule when encrypted + thinking rules coexist', async () => {
const upstream = await startFakeUpstream((idx, _body, res) => {
if (idx === 0) {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(THINKING_ERROR_BODY);
} else {
res.writeHead(200, { 'content-type': 'application/json' });
res.end('{}');
}
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [
createEncryptedContentRecoveryRule({ enabled: () => true }),
createEmptyThinkingRecoveryRule({ enabled: () => true }),
],
});
const r = await post(proxy.url, anthropicBodyWithEmptyThinking());
expect(r.status).toBe(200);
expect(upstream.bodies).toHaveLength(2);
expect(upstream.bodies[1]).not.toContain('"thinking":""');
});
it('decodes a gzip-encoded thinking 400 and still triggers the retry', async () => {
const upstream = await startFakeUpstream((idx, _body, res) => {
if (idx === 0) {
res.writeHead(400, { 'content-type': 'application/json', 'content-encoding': 'gzip' });
res.end(gzipSync(Buffer.from(THINKING_ERROR_BODY, 'utf8')));
} else {
res.writeHead(200, { 'content-type': 'application/json' });
res.end('{}');
}
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createEmptyThinkingRecoveryRule({ enabled: () => true })],
});
const r = await post(proxy.url, anthropicBodyWithEmptyThinking());
expect(r.status).toBe(200);
expect(upstream.bodies).toHaveLength(2);
expect(upstream.bodies[1]).not.toContain('"thinking":""');
});
it('passes through a clean 2xx Anthropic request byte-identical (cache safe)', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true }));
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createEmptyThinkingRecoveryRule({ enabled: () => true })],
});
const clean = {
model: 'claude-sonnet-4-6',
messages: [{ role: 'assistant', content: [{ type: 'thinking', thinking: 'deep', signature: 'sig' }, { type: 'text', text: 'a' }] }],
};
const r = await post(proxy.url, clean);
expect(r.status).toBe(200);
expect(upstream.bodies).toHaveLength(1);
expect(upstream.bodies[0]).toBe(JSON.stringify(clean));
});
});
// moonshot 线上 400 原文(2026-07-28,经 LiteLLM passthrough;request_id 取自真实捕获)。
const MOONSHOT_EMPTY_ASSISTANT_ERROR_BODY = JSON.stringify({
error: {
type: 'invalid_request_error',
message: "Invalid request: the message at position 395 with role 'assistant' must not be empty",
},
request_id: 'f1b34454-8a63-11f1-bf3c-9ac780b5488d',
type: 'error',
});
// moonshot/kimi-k3 线上污染会话形态(2026-07-28): 完整 tool_use/tool_result 上下文里
// 夹着一条 thinking-only 空 assistant(流中断后客户端持久化的未完成占位 block)。
function kimiBodyWithEmptyAssistant(): unknown {
return {
model: 'moonshot/kimi-k3',
messages: [
{ role: 'user', content: 'run ls' },
{ role: 'assistant', content: [{ type: 'tool_use', id: 'toolu_01', name: 'Bash', input: { command: 'ls' } }] },
{ role: 'user', content: [{ type: 'tool_result', tool_use_id: 'toolu_01', content: 'ok' }] },
{ role: 'assistant', content: [{ type: 'thinking', thinking: '', signature: '' }] },
{ role: 'user', content: 'continue' },
],
};
}
// ───────────────────────────────────────────────────────────────────────────
// 重复 tool_use id(moonshot/kimi 序号 id 跨 turn 复用,2026-07 两个会话实测
// `Edit_306` / `Bash_256` 各复用 20+ 次致安静瘫痪)的全链路防御实测。
// ───────────────────────────────────────────────────────────────────────────
// kimi-k3 事故会话形态: 同一序号 id 的两对完整 tool 交换跨 turn 出现。
function kimiBodyWithDuplicatedToolUseIds(): Record<string, unknown> {
return {
model: 'moonshot/kimi-k3',
messages: [
{ role: 'user', content: '把 race-2 修掉' },
{ role: 'assistant', content: [{ type: 'tool_use', id: 'Edit_306', name: 'Edit', input: { file: 'a.ts', old: 'x', new: 'y' } }] },
{ role: 'user', content: [{ type: 'tool_result', tool_use_id: 'Edit_306', content: 'has been updated successfully' }] },
{ role: 'assistant', content: [{ type: 'text', text: '继续修复计划' }, { type: 'tool_use', id: 'Edit_306', name: 'Edit', input: { file: 'a.ts', old: 'x', new: 'y' } }] },
{ role: 'user', content: [{ type: 'tool_result', tool_use_id: 'Edit_306', content: 'String to replace not found' }] },
],
};
}
// Anthropic 文案的重复 id 400(LiteLLM 版本差 / 真 Anthropic 上游可见)。
const DUPLICATE_TOOL_USE_ID_ERROR_BODY = JSON.stringify({
error: { type: 'invalid_request_error', message: 'messages: `tool_use` ids must be unique' },
});
// moonshot chatcmpl 校验透出的孤儿 result 400(原文双空格,kimi kosong 注释同款)。
const MOONSHOT_TOOL_CALL_ID_NOT_FOUND_BODY = JSON.stringify({
error: { type: 'invalid_request_error', message: 'Invalid request: tool_call_id is not found' },
});
describe('anthropic-compat-proxy duplicate tool_use id (kimi/moonshot 序号 id 复用)', () => {
it('proactively rewrites duplicated ids before forwarding — no 400 needed', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true }));
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [repairToolExchangeAdjacency, dedupeDuplicateToolUseIds], // host 同序: repair 先于 dedupe
recoveryRules: [],
});
const r = await post(proxy.url, kimiBodyWithDuplicatedToolUseIds());
expect(r.status).toBe(200);
// 只发一次:主动 transform 在转发前修好,不等上游报错。
expect(upstream.bodies).toHaveLength(1);
const sent = JSON.parse(upstream.bodies[0]);
// 第二对 Edit_306 被唯一化,首对与配对关系保持完整。
expect(sent.messages[1].content[0].id).toBe('Edit_306');
expect(sent.messages[2].content[0].tool_use_id).toBe('Edit_306');
expect(sent.messages[3].content[1].id).toBe('Edit_306_2');
expect(sent.messages[4].content[0].tool_use_id).toBe('Edit_306_2');
// text 块与业务 input 原样保留。
expect(sent.messages[3].content[0]).toEqual({ type: 'text', text: '继续修复计划' });
expect(sent.messages[3].content[1].input).toEqual({ file: 'a.ts', old: 'x', new: 'y' });
});
it('passes a clean paired history through byte-identical (zero interference)', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true }));
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [repairToolExchangeAdjacency, dedupeDuplicateToolUseIds], // host 同序: repair 先于 dedupe
recoveryRules: [],
});
const cleanBody = {
model: 'moonshot/kimi-k3',
messages: [
{ role: 'user', content: 'run ls' },
{ role: 'assistant', content: [{ type: 'tool_use', id: 'Bash_256', name: 'Bash', input: { command: 'ls' } }] },
{ role: 'user', content: [{ type: 'tool_result', tool_use_id: 'Bash_256', content: 'ok' }] },
{ role: 'assistant', content: [{ type: 'tool_use', id: 'Read_257', name: 'Read', input: { file: 'a.ts' } }] },
{ role: 'user', content: [{ type: 'tool_result', tool_use_id: 'Read_257', content: 'file content' }] },
],
};
const r = await post(proxy.url, cleanBody);
expect(r.status).toBe(200);
expect(upstream.bodies).toHaveLength(1);
// cache 安全契约在链路上的实测:无异常时 upstream 收到的字节与客户端发出的一致。
expect(upstream.bodies[0]).toBe(JSON.stringify(cleanBody));
});
it('recovers from a 400 "`tool_use` ids must be unique" via transparent retry', async () => {
const upstream = await startFakeUpstream((idx, _body, res) => {
if (idx === 0) {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(DUPLICATE_TOOL_USE_ID_ERROR_BODY);
} else {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true }));
}
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
// 空 transform 链:验证 recovery 在主动 transform 未接入的链路上独立工作。
transformRequest: [],
recoveryRules: [createDuplicateToolUseIdRecoveryRule({ enabled: () => true })],
});
const r = await post(proxy.url, kimiBodyWithDuplicatedToolUseIds());
expect(r.status).toBe(200);
expect(upstream.bodies).toHaveLength(2);
// 第一次原样发出(重复 id 还在),第二次已唯一化。
expect(upstream.bodies[0]).toBe(JSON.stringify(kimiBodyWithDuplicatedToolUseIds()));
const retried = JSON.parse(upstream.bodies[1]);
expect(retried.messages[3].content[1].id).toBe('Edit_306_2');
expect(retried.messages[4].content[0].tool_use_id).toBe('Edit_306_2');
});
it('recovers from the moonshot "tool_call_id is not found" 400 by dropping the orphan result', async () => {
const upstream = await startFakeUpstream((idx, _body, res) => {
if (idx === 0) {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(MOONSHOT_TOOL_CALL_ID_NOT_FOUND_BODY);
} else {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true }));
}
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createToolExchangeAdjacencyRecoveryRule({ enabled: () => true })],
});
const r = await post(proxy.url, {
model: 'moonshot/kimi-k3',
messages: [
{ role: 'user', content: 'go' },
{ role: 'assistant', content: [{ type: 'tool_use', id: 'Bash_1', name: 'Bash', input: {} }] },
{
role: 'user',
content: [
{ type: 'tool_result', tool_use_id: 'Bash_1', content: 'ok' },
{ type: 'tool_result', tool_use_id: 'Edit_999', content: 'stray' },
],
},
],
});
expect(r.status).toBe(200);
expect(upstream.bodies).toHaveLength(2);
const retried = JSON.parse(upstream.bodies[1]);
// 孤儿块被丢,合法配对保留。
expect(retried.messages[2].content).toEqual([
{ type: 'tool_result', tool_use_id: 'Bash_1', content: 'ok' },
]);
});
it('returns the 400 as-is when the history has nothing to repair', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(DUPLICATE_TOOL_USE_ID_ERROR_BODY);
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createDuplicateToolUseIdRecoveryRule({ enabled: () => true })],
});
const r = await post(proxy.url, {
model: 'moonshot/kimi-k3',
messages: [{ role: 'user', content: 'hi' }],
});
// strip 无东西可改 → 不重试,400 原样回客户端(不误伤)。
expect(r.status).toBe(400);
expect(upstream.bodies).toHaveLength(1);
});
it('repairs a multiply-polluted history in one proactive pass (host chain order)', async () => {
// host 装配顺序的组合场景: 同一请求同时含重复 id + 错位 result + 缺失 result,
// repair → dedupe 链式应用后一次修好,只发一次(不等 400)。
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true }));
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [repairToolExchangeAdjacency, dedupeDuplicateToolUseIds], // host 同序: repair 先于 dedupe
recoveryRules: [],
});
const r = await post(proxy.url, {
model: 'moonshot/kimi-k3',
messages: [
{ role: 'user', content: 'go' },
{ role: 'assistant', content: [{ type: 'tool_use', id: 'Edit_306', name: 'Edit', input: { a: 1 } }] },
{ role: 'user', content: [{ type: 'tool_result', tool_use_id: 'Edit_306', content: 'ok' }] },
// 第二对: 同 id(重复)且 result 错位(隔了一条 user text)。
{ role: 'assistant', content: [{ type: 'tool_use', id: 'Edit_306', name: 'Edit', input: { a: 2 } }] },
{ role: 'user', content: [{ type: 'text', text: 'intervening' }] },
{ role: 'user', content: [{ type: 'tool_result', tool_use_id: 'Edit_306', content: 'late' }] },
// 第三个 call: 同 id 且从此无 result(缺失,后面有 assistant 推进 → 非 trailing)。
{ role: 'assistant', content: [{ type: 'tool_use', id: 'Edit_306', name: 'Edit', input: { a: 3 } }] },
{ role: 'assistant', content: [{ type: 'text', text: '我以为发出去了' }] },
],
});
expect(r.status).toBe(200);
expect(upstream.bodies).toHaveLength(1);
const sent = JSON.parse(upstream.bodies[0]);
// dedupe: 三个同 id call → Edit_306 / Edit_306_2 / Edit_306_3。
const callIds = sent.messages
.filter((m: { role: string }) => m.role === 'assistant')
.flatMap((m: { content: Array<{ id?: string }> }) => m.content)
.filter((b: { id?: string }) => b.id !== undefined)
.map((b: { id?: string }) => b.id);
expect(callIds).toEqual(['Edit_306', 'Edit_306_2', 'Edit_306_3']);
// repair: 错位的 result(已改名 Edit_306_2)前移到第二对 call 紧邻的 user 消息开头;
// 第三个 call 合成占位(Edit_306_3),新建 user 消息插入在两个 assistant 之间。
const roles = sent.messages.map((m: { role: string }) => m.role);
expect(roles).toEqual(['user', 'assistant', 'user', 'assistant', 'user', 'assistant', 'user', 'assistant']);
expect(sent.messages[4].content[0]).toMatchObject({ type: 'tool_result', tool_use_id: 'Edit_306_2', content: 'late' });
expect(sent.messages[6].content[0]).toMatchObject({ type: 'tool_result', tool_use_id: 'Edit_306_3' });
// 每个 tool_use 都有紧邻的配对 result —— 修复后的历史对 strict 上游合法。
});
});
describe('anthropic-compat-proxy empty-assistant-message recovery (moonshot/kimi)', () => {
it('drops the empty assistant message and retries once on the moonshot 400', async () => {
const upstream = await startFakeUpstream((idx, _body, res) => {
if (idx === 0) {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(MOONSHOT_EMPTY_ASSISTANT_ERROR_BODY);
} else {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true }));
}
});
upstreamClose = upstream.close;
let marked: { threadId: string; model: string } | null = null;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createEmptyAssistantMessageRecoveryRule({
enabled: () => true,
onRetry: (threadId, model) => { marked = { threadId, model }; },
})],
});
const r = await post(proxy.url, kimiBodyWithEmptyAssistant());
expect(r.status).toBe(200);
expect(upstream.bodies).toHaveLength(2);
expect(upstream.bodies[0]).toContain('"thinking":""');
// 重发 body: 空 thinking-only assistant 整条被丢(5 → 4 条),tool_use/tool_result 配对保留。
const retried = JSON.parse(upstream.bodies[1]);
expect(retried.messages).toHaveLength(4);
expect(retried.messages.map((m: { role: string }) => m.role)).toEqual([
'user', 'assistant', 'user', 'user',
]);
expect(upstream.bodies[1]).not.toContain('"thinking":""');
expect(marked).toEqual({ threadId: 'thread-a', model: 'moonshot/kimi-k3' });
});
it('does not retry when there is no empty assistant message to drop', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(MOONSHOT_EMPTY_ASSISTANT_ERROR_BODY);
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createEmptyAssistantMessageRecoveryRule({ enabled: () => true })],
});
const r = await post(proxy.url, {
model: 'moonshot/kimi-k3',
messages: [
{ role: 'user', content: 'hi' },
{ role: 'assistant', content: [{ type: 'thinking', thinking: 'real reasoning', signature: '' }, { type: 'text', text: 'ok' }] },
],
});
expect(r.status).toBe(400);
expect(upstream.bodies).toHaveLength(1);
});
it('does not retry a second time after the retry still returns the moonshot 400', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(MOONSHOT_EMPTY_ASSISTANT_ERROR_BODY);
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createEmptyAssistantMessageRecoveryRule({ enabled: () => true })],
});
const r = await post(proxy.url, kimiBodyWithEmptyAssistant());
expect(r.status).toBe(400);
expect(upstream.bodies).toHaveLength(2);
});
it('also recovers when the stale assistant carries an empty text block instead of empty thinking', async () => {
// PR #821 review 实测反馈形态: bridge 清理路径的 text-only 空块。
const upstream = await startFakeUpstream((idx, _body, res) => {
if (idx === 0) {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(MOONSHOT_EMPTY_ASSISTANT_ERROR_BODY);
} else {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true }));
}
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createEmptyAssistantMessageRecoveryRule({ enabled: () => true })],
});
const r = await post(proxy.url, {
model: 'moonshot/kimi-k3',
messages: [
{ role: 'user', content: 'hi' },
{ role: 'assistant', content: [{ type: 'text', text: '' }] },
{ role: 'user', content: 'continue' },
],
});
expect(r.status).toBe(200);
expect(upstream.bodies).toHaveLength(2);
expect(JSON.parse(upstream.bodies[1]).messages).toHaveLength(2);
});
it('decodes a gzip-encoded moonshot 400 and still triggers the retry', async () => {
const upstream = await startFakeUpstream((idx, _body, res) => {
if (idx === 0) {
res.writeHead(400, { 'content-type': 'application/json', 'content-encoding': 'gzip' });
res.end(gzipSync(Buffer.from(MOONSHOT_EMPTY_ASSISTANT_ERROR_BODY, 'utf8')));
} else {
res.writeHead(200, { 'content-type': 'application/json' });
res.end('{}');
}
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createEmptyAssistantMessageRecoveryRule({ enabled: () => true })],
});
const r = await post(proxy.url, kimiBodyWithEmptyAssistant());
expect(r.status).toBe(200);
expect(upstream.bodies).toHaveLength(2);
expect(upstream.bodies[1]).not.toContain('"thinking":""');
});
});
describe('anthropic-compat-proxy localHandler(路由决策交本地 handler,不转发上游)', () => {
it.skipIf(!existsSync(TEST_PI_BINARY))(
'real PI zstd request crosses the proxy parse boundary and reaches the raw local handler',
{ timeout: 30_000 },
async () => {
const gateway = await startFakeUpstream((_i, _b, res) => {
res.writeHead(500);
res.end('default upstream must not be reached');
});
upstreamClose = gateway.close;
let seen: { raw: Buffer; encoding: string | undefined; parsed: unknown; url: string } | null = null;
let resolveSeen: (() => void) | null = null;
const seenPromise = new Promise<void>((resolve) => { resolveSeen = resolve; });
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
routingTransform: (body, ctx) => {
if (ctx.headers['x-native-route'] !== 'openai') return null;
return {
localHandler: async ({ rawBody, parsedBody, res }) => {
seen = {
raw: Buffer.from(rawBody),
encoding: ctx.headers['content-encoding'],
parsed: parsedBody,
url: ctx.url,
};
resolveSeen?.();
res.writeHead(401, { 'content-type': 'application/json' });
res.end('{"error":{"message":"intentional test stop"}}');
},
};
},
});
const configHome = mkdtempSync(path.join(tmpdir(), 'pi-zstd-proxy-e2e-'));
const encode = (value: unknown): string => Buffer.from(JSON.stringify(value)).toString('base64url');
const placeholderJwt = `${encode({ alg: 'none', typ: 'JWT' })}.${encode({
'https://api.openai.com/auth': { chatgpt_account_id: 'cindy-pi-proxy' },
})}.`;
let child: ChildProcessWithoutNullStreams | null = null;
try {
writeFileSync(path.join(configHome, 'models.json'), JSON.stringify({
providers: {
'openai-codex': {
baseUrl: proxy.url,
apiKey: '$CINDY_PI_OPENAI_PROXY_KEY',
headers: { 'x-native-route': 'openai' },
models: [{
id: 'gpt-cindy-zstd-test',
name: 'GPT Cindy zstd test',
reasoning: false,
input: ['text'],
contextWindow: 128_000,
maxTokens: 16_000,
}],
},
},
}));
writeFileSync(path.join(configHome, 'settings.json'), JSON.stringify({ transport: 'sse' }));
child = spawn(TEST_PI_BINARY, [
'--provider', 'openai-codex',
'--model', 'gpt-cindy-zstd-test',
'--no-session',
'--no-tools',
'--no-extensions',
'--no-skills',
'--no-prompt-templates',
'--no-context-files',
'--mode', 'rpc',
], {
cwd: TEST_REPO_ROOT,
env: {
...process.env,
PI_CODING_AGENT_DIR: configHome,
CINDY_PI_OPENAI_PROXY_KEY: placeholderJwt,
},
});
let stderr = '';
child.stderr.on('data', (chunk: Buffer) => { stderr += chunk.toString('utf8'); });
child.stdin.write(JSON.stringify({ id: 'test-prompt', type: 'prompt', message: 'ping' }) + '\n');
let reachTimeout: NodeJS.Timeout | undefined;
try {
await Promise.race([
seenPromise,
new Promise<never>((_resolve, reject) => {
// real-wait: bound the real PI process handshake if the proxy is never reached.
reachTimeout = setTimeout(
() => reject(new Error(`real PI did not reach proxy: ${stderr}`)),
10_000,
);
}),
]);
} finally {
if (reachTimeout) clearTimeout(reachTimeout);
}
const observed = seen as {
raw: Buffer;
encoding: string | undefined;
parsed: unknown;
url: string;
} | null;
expect(observed).not.toBeNull();
expect(observed?.url).toBe('/codex/responses');
expect(observed?.encoding).toBe('zstd');
expect(observed?.parsed).toBeUndefined();
expect([...observed!.raw.subarray(0, 4)]).toEqual([0x28, 0xb5, 0x2f, 0xfd]);
expect(gateway.bodies).toHaveLength(0);
} finally {
if (child && child.exitCode === null && child.signalCode === null) {
await new Promise<void>((resolve) => {
// real-wait: bound child shutdown after sending SIGTERM to the real PI process.
const timer = setTimeout(() => {
if (child?.exitCode === null && child.signalCode === null) child.kill('SIGKILL');
resolve();
}, 1_000);
child!.once('close', () => {
clearTimeout(timer);
resolve();
});
child!.kill('SIGTERM');
});
}
rmSync(configHome, { recursive: true, force: true });
}
},
);
it('JSON content-type with compressed bytes still routes by headers and preserves raw body', async () => {
const gateway = await startFakeUpstream((_i, _b, res) => { res.writeHead(200); res.end('{}'); });
upstreamClose = gateway.close;
const compressed = gzipSync(Buffer.from(JSON.stringify({ model: 'gpt-native' })));
let seen: Buffer | null = null;
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
routingTransform: (body, ctx) => {
expect(body).toBeUndefined();
if (ctx.headers['x-native-route'] !== 'openai') return null;
return {
localHandler: async ({ rawBody, parsedBody, res }) => {
seen = Buffer.from(rawBody);
expect(parsedBody).toBeUndefined();
res.writeHead(204);
res.end();
},
};
},
});
const response = await fetch(`${proxy.url}/codex/responses`, {
method: 'POST',
headers: {
'content-type': 'application/json',
'content-encoding': 'gzip',
'x-native-route': 'openai',
},
body: compressed,
});
expect(response.status).toBe(204);
expect(seen).toEqual(compressed);
expect(gateway.bodies).toHaveLength(0);
});
it('命中 handler:收到原始字节 + 已解析 body + ctx,自写响应(含 SSE 流式),上游零请求', async () => {
const gateway = await startFakeUpstream((_i, _b, res) => { res.writeHead(200); res.end('{}'); });
upstreamClose = gateway.close;
const seen: Array<{ parsed: unknown; raw: string; url: string; hasHeader: boolean }> = [];
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
routingTransform: (body) => {
const model = (body as { model?: string } | undefined)?.model ?? '';
if (!model.startsWith('chatgpt/')) return null;
return {
localHandler: async ({ rawBody, parsedBody, ctx, res }) => {
seen.push({ parsed: parsedBody, raw: rawBody.toString('utf8'), url: ctx.url, hasHeader: ctx.headers['thread-id'] === 'thread-a' });
res.writeHead(200, { 'content-type': 'text/event-stream' });
res.write('event: message_start\ndata: {}\n\n');
res.end('event: message_stop\ndata: {}\n\n');
},
};
},
});
const body = { model: 'chatgpt/gpt-5.5', messages: [] };
const r = await post(proxy.url, body);
expect(r.status).toBe(200);
expect(r.text).toContain('message_start');
expect(r.text).toContain('message_stop');
expect(seen).toHaveLength(1);
expect(seen[0].parsed).toEqual(body); // parsedBody 复用路由阶段解析结果
expect(seen[0].raw).toBe(JSON.stringify(body)); // rawBody 是原始字节
expect(seen[0].url).toContain('/v1/responses');
expect(seen[0].hasHeader).toBe(true);
expect(gateway.bodies).toHaveLength(0); // 上游一个请求都没收到
// 同一 proxy 上不命中 handler 的请求照常转发(混跑不互扰)。
const r2 = await post(proxy.url, { model: 'claude-opus-4-8', messages: [] });
expect(r2.status).toBe(200);
expect(gateway.bodies).toHaveLength(1);
});
it('handler 抛错且未写头 → 502 fail-open;上游不受影响', async () => {
const gateway = await startFakeUpstream((_i, _b, res) => { res.writeHead(200); res.end('{}'); });
upstreamClose = gateway.close;
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
routingTransform: () => ({ localHandler: async () => { throw new Error('boom'); } }),
});
const r = await post(proxy.url, { model: 'chatgpt/gpt-5.5' });
expect(r.status).toBe(502);
expect(r.text).toContain('local handler failed');
expect(gateway.bodies).toHaveLength(0);
});
it('handler resolve 但没 end 响应 → 防御性收尾(未写头按 502),请求不悬挂', async () => {
const gateway = await startFakeUpstream((_i, _b, res) => { res.writeHead(200); res.end('{}'); });
upstreamClose = gateway.close;
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
routingTransform: () => ({ localHandler: async () => { /* 什么都不写 */ } }),
});
const r = await post(proxy.url, { model: 'chatgpt/gpt-5.5' });
expect(r.status).toBe(502);
expect(r.text).toContain('no response');
});
it('handler 已写头后抛错 → 连接被 destroy(与上游流中断语义一致)', async () => {
const gateway = await startFakeUpstream((_i, _b, res) => { res.writeHead(200); res.end('{}'); });
upstreamClose = gateway.close;
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
routingTransform: () => ({
localHandler: async ({ res }) => {
res.writeHead(200, { 'content-type': 'text/event-stream' });
res.write('event: message_start\ndata: {}\n\n');
throw new Error('mid-stream boom');
},
}),
});
await expect(post(proxy.url, { model: 'chatgpt/gpt-5.5' })).rejects.toThrow();
});
it('GET(无 body)也可命中 handler:parsedBody undefined、rawBody 空', async () => {
const gateway = await startFakeUpstream((_i, _b, res) => { res.writeHead(200); res.end('{}'); });
upstreamClose = gateway.close;
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
routingTransform: (body, ctx) => {
if (body !== undefined || !ctx.url.includes('/bridge-models')) return null;
return {
localHandler: async ({ rawBody, parsedBody, res }) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ raw: rawBody.length, parsed: parsedBody === undefined }));
},
};
},
});
const res = await fetch(`${proxy.url}/bridge-models`, { method: 'GET' });
expect(JSON.parse(await res.text())).toEqual({ raw: 0, parsed: true });
expect(gateway.bodies).toHaveLength(0);
});
it('decision 同时给 handler 与转发字段时 handler 优先,转发字段忽略(互斥契约)', async () => {
const gateway = await startFakeUpstream((_i, _b, res) => { res.writeHead(200); res.end('{}'); });
upstreamClose = gateway.close;
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
routingTransform: () => ({
upstreamOverride: gateway.url,
headerOverride: { authorization: 'Bearer x' },
localHandler: async ({ res }) => { res.writeHead(204); res.end(); },
}),
});
const r = await post(proxy.url, { model: 'chatgpt/gpt-5.5' });
expect(r.status).toBe(204);
expect(gateway.bodies).toHaveLength(0);
});
});
describe('anthropic-compat-proxy request body limit(超限回可读 413,不斩连接)', () => {
it('content-length 声明超限 → 立即 413 可读 JSON + connection: close,上游零请求', async () => {
const gateway = await startFakeUpstream((_i, _b, res) => { res.writeHead(200); res.end('{}'); });
upstreamClose = gateway.close;
const warns: Array<Record<string, unknown>> = [];
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
maxRequestBodyBytes: 1024,
logger: {
warn: (msg, ctx) => {
if (msg === '✖ request body exceeds proxy limit → 413') warns.push(ctx ?? {});
},
},
});
const body = JSON.stringify({ model: 'gpt-5.5', input: 'x'.repeat(4096) });
const res = await fetch(`${proxy.url}/v1/responses`, {
method: 'POST',
headers: { 'content-type': 'application/json', 'thread-id': 'thread-huge' },
body,
});
expect(res.status).toBe(413);
expect(res.headers.get('connection')).toBe('close');
const json = await res.json() as { error: { type: string; message: string } };
expect(json.error.type).toBe('proxy_error');
expect(json.error.message).toContain('1024');
// 上游零请求:预检直接拦下,客户端不用白传 body
expect(gateway.bodies).toHaveLength(0);
// warn 日志带 threadId + 字节数,线上可 grep(旧实现这条路径完全静默)
expect(warns).toHaveLength(1);
expect(warns[0].threadId).toBe('thread-huge');
expect(warns[0].limitBytes).toBe(1024);
expect(warns[0].declaredBytes).toBe(Buffer.byteLength(body));
});
it('chunked 上传(无 content-length)超限 → 流式守卫命中,仍收到完整 413', async () => {
const gateway = await startFakeUpstream((_i, _b, res) => { res.writeHead(200); res.end('{}'); });
upstreamClose = gateway.close;
const warns: Array<Record<string, unknown>> = [];
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
maxRequestBodyBytes: 256 * 1024,
logger: {
warn: (msg, ctx) => {
if (msg === '✖ request body exceeds proxy limit → 413') warns.push(ctx ?? {});
},
},
});
const chunk = new Uint8Array(64 * 1024).fill(0x78);
const stream = new ReadableStream<Uint8Array>({
start(controller) {
for (let i = 0; i < 16; i++) controller.enqueue(chunk); // 1MB > 256KB 上限
controller.close();
},
});
const res = await fetch(`${proxy.url}/v1/responses`, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: stream,
// Node fetch(undici)流式上传必须显式 half duplex
...({ duplex: 'half' } as Record<string, unknown>),
});
expect(res.status).toBe(413);
const json = await res.json() as { error: { type: string } };
expect(json.error.type).toBe('proxy_error');
expect(gateway.bodies).toHaveLength(0);
expect(warns).toHaveLength(1);
expect(warns[0].declaredBytes).toBeUndefined();
expect(Number(warns[0].receivedBytes)).toBeGreaterThan(256 * 1024);
});
it('自定义上限内的请求正常转发,行为不受影响', async () => {
const gateway = await startFakeUpstream((_i, _b, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end('{"ok":true}');
});
upstreamClose = gateway.close;
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
maxRequestBodyBytes: 1024 * 1024,
});
const r = await post(proxy.url, { model: 'gpt-5.5', input: 'x'.repeat(4096) });
expect(r.status).toBe(200);
expect(gateway.bodies).toHaveLength(1);
});
it('超出硬上限但在有界 ingress 内时先压缩,压缩后正常转发', async () => {
const gateway = await startFakeUpstream((_i, body, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ bytes: Buffer.byteLength(body, 'utf8'), body: JSON.parse(body) }));
});
upstreamClose = gateway.close;
let compactorCalls = 0;
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
maxRequestBodyBytes: 1024,
oversizedRequestIngressBytes: 8 * 1024,
oversizedRequestCompactor: (body) => {
compactorCalls += 1;
return { model: (body as Record<string, unknown>).model, compacted: true };
},
});
const res = await post(proxy.url, { model: 'test-model', history: 'x'.repeat(4096) });
expect(res.status).toBe(200);
const json = JSON.parse(res.text) as { bytes: number; body: Record<string, unknown> };
expect(json.body.compacted).toBe(true);
expect(json.bytes).toBeLessThan(1024);
expect(compactorCalls).toBe(1);
});
it('命中 localHandler 时同样先压缩超限 JSON,再交给 handler', async () => {
const gateway = await startFakeUpstream((_i, _b, res) => {
res.writeHead(500);
res.end('local handler must prevent forwarding');
});
upstreamClose = gateway.close;
let compactorCalls = 0;
let seen: { raw: string; parsed: Record<string, unknown> } | null = null;
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
maxRequestBodyBytes: 1024,
oversizedRequestIngressBytes: 8 * 1024,
oversizedRequestCompactor: (body) => {
compactorCalls += 1;
return { model: (body as Record<string, unknown>).model, compacted: true };
},
routingTransform: () => ({
localHandler: async ({ rawBody, parsedBody, res }) => {
seen = { raw: rawBody.toString('utf8'), parsed: parsedBody as Record<string, unknown> };
res.writeHead(204);
res.end();
},
}),
});
const res = await post(proxy.url, { model: 'gpt-5.5', history: 'x'.repeat(4096) });
expect(res.status).toBe(204);
expect(compactorCalls).toBe(1);
expect(seen).toEqual({
raw: JSON.stringify({ model: 'gpt-5.5', compacted: true }),
parsed: { model: 'gpt-5.5', compacted: true },
});
expect(gateway.bodies).toHaveLength(0);
});
it('硬上限以内的请求完全跳过 oversized compactor', async () => {
const gateway = await startFakeUpstream((_i, _body, res) => { res.writeHead(200); res.end('{}'); });
upstreamClose = gateway.close;
let compactorCalls = 0;
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
maxRequestBodyBytes: 8 * 1024,
oversizedRequestCompactor: () => {
compactorCalls += 1;
return null;
},
});
const res = await post(proxy.url, { model: 'test-model', input: 'small' });
expect(res.status).toBe(200);
expect(compactorCalls).toBe(0);
});
it('压缩器无法安全缩小时,最终仍返回结构化 413', async () => {
const gateway = await startFakeUpstream((_i, _body, res) => { res.writeHead(200); res.end('{}'); });
upstreamClose = gateway.close;
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
maxRequestBodyBytes: 1024,
oversizedRequestIngressBytes: 8 * 1024,
oversizedRequestCompactor: () => null,
});
const res = await post(proxy.url, { model: 'test-model', history: 'x'.repeat(4096) });
expect(res.status).toBe(413);
const json = JSON.parse(res.text) as { error: { reason: string } };
expect(json.error.reason).toBe('request_body_too_large');
expect(gateway.bodies).toHaveLength(0);
});
it('超过 ingress 上限时仍立即 413,不会把无限 body 读入内存', async () => {
const gateway = await startFakeUpstream((_i, _body, res) => { res.writeHead(200); res.end('{}'); });
upstreamClose = gateway.close;
let compactorCalls = 0;
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
maxRequestBodyBytes: 1024,
oversizedRequestIngressBytes: 2048,
oversizedRequestCompactor: () => {
compactorCalls += 1;
return null;
},
});
const body = JSON.stringify({ model: 'test-model', history: 'x'.repeat(4096) });
const res = await fetch(`${proxy.url}/v1/messages`, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body,
});
expect(res.status).toBe(413);
const json = await res.json() as { error: { reason: string } };
expect(json.error.reason).toBe('request_body_too_large');
expect(compactorCalls).toBe(0);
expect(gateway.bodies).toHaveLength(0);
});
it('非法 ingress 配置不会关闭流式大小守卫', async () => {
const gateway = await startFakeUpstream((_i, _b, res) => { res.writeHead(200); res.end('{}'); });
upstreamClose = gateway.close;
let compactorCalls = 0;
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
maxRequestBodyBytes: 1024,
oversizedRequestIngressBytes: Number.NaN,
oversizedRequestCompactor: () => {
compactorCalls += 1;
return null;
},
});
const body = JSON.stringify({ model: 'test-model', history: 'x'.repeat(4096) });
const res = await fetch(`${proxy.url}/v1/messages`, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body,
});
expect(res.status).toBe(413);
expect(compactorCalls).toBe(0);
expect(gateway.bodies).toHaveLength(0);
});
it('启用压缩器时,非 JSON 请求仍按硬上限预检', async () => {
const gateway = await startFakeUpstream((_i, _b, res) => { res.writeHead(200); res.end('{}'); });
upstreamClose = gateway.close;
const warns: Array<Record<string, unknown>> = [];
proxy = await createAnthropicCompatProxy({
upstream: gateway.url,
transformRequest: [],
maxRequestBodyBytes: 1024,
oversizedRequestIngressBytes: 8 * 1024,
oversizedRequestCompactor: () => null,
logger: {
warn: (msg, ctx) => {
if (msg === '✖ request body exceeds proxy limit → 413') warns.push(ctx ?? {});
},
},
});
const res = await fetch(`${proxy.url}/v1/messages`, {
method: 'POST',
headers: { 'content-type': 'text/plain' },
body: 'x'.repeat(4096),
});
expect(res.status).toBe(413);
expect(warns).toHaveLength(1);
expect(warns[0].receivedBytes).toBe(0);
expect(gateway.bodies).toHaveLength(0);
});
});
describe('anthropic-compat-proxy 客户端中断传播', () => {
it('客户端在流式响应中途断开时,同步掐掉上游请求(费用泄漏止血)', async () => {
let sawAbort!: () => void;
const upstreamAborted = new Promise<void>((r) => { sawAbort = r; });
const errorLogs: string[] = [];
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, { 'content-type': 'text/event-stream' });
res.write('event: message_start\ndata: {}\n\n');
// 永不 end —— 模拟仍在生成的 SSE。中断传播生效时,proxy destroy 上游请求,
// 这里的 'close' 才会在 upstream.close() 之前触发。
res.on('close', () => sawAbort());
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
logger: { error: (msg) => { errorLogs.push(msg); } },
});
const controller = new AbortController();
const res = await fetch(`${proxy.url}/v1/messages`, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ model: 'test-model' }),
signal: controller.signal,
});
expect(res.status).toBe(200);
// 确认已收到首个 SSE 字节、进入流式阶段后再中断
const reader = (res.body as ReadableStream<Uint8Array>).getReader();
await reader.read();
controller.abort();
await upstreamAborted;
expect(errorLogs.filter((m) => m.includes('upstream response stream error'))).toHaveLength(0);
});
// 回归:Codex CLI 收到 response.completed 即断开,上游 body 往往尚未 end —— 日志里 ~97%
// 的 /responses 被误记成 client-aborted。终态事件后断开须按正常完成收口(仍释放上游),
// 只有终态前断开才是失败。
it.each([
{
name: 'terminal event forwarded → complete',
events: 'event: response.created\ndata: {"type":"response.created"}\n\n'
+ 'event: response.completed\ndata: {"type":"response.completed","response":{}}\n\n',
waitFor: 'response.completed',
expected: { type: 'complete', status: 200 },
observerEnds: 1,
disconnectLogs: 0,
},
{
name: 'terminal event only half sent (no blank line yet) → client-aborted',
events: 'event: response.created\ndata: {"type":"response.created"}\n\n'
+ 'event: response.completed\n',
waitFor: 'response.completed',
expected: { type: 'failure', failure: 'client-aborted' },
observerEnds: 0,
disconnectLogs: 1,
},
{
name: 'no terminal event yet → client-aborted',
events: 'event: response.created\ndata: {"type":"response.created"}\n\n',
waitFor: 'response.created',
expected: { type: 'failure', failure: 'client-aborted' },
observerEnds: 0,
disconnectLogs: 1,
},
])('client close after SSE: $name', async ({ events: sse, waitFor, expected, observerEnds, disconnectLogs }) => {
let sawUpstreamClose!: () => void;
const upstreamClosed = new Promise<void>((r) => { sawUpstreamClose = r; });
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, { 'content-type': 'text/event-stream' });
res.write(sse);
// 永不 end:上游在终态事件后仍保持 body 打开。
res.on('close', () => sawUpstreamClose());
});
upstreamClose = upstream.close;
const lifecycle: Array<Record<string, unknown>> = [];
const infoLogs: string[] = [];
let ends = 0;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
logger: { info: (msg) => { infoLogs.push(msg); } },
routingTransform: () => ({
forwardLifecycle: {
onComplete: (status) => lifecycle.push({ type: 'complete', status }),
onFailure: (failure) => lifecycle.push({ type: 'failure', failure }),
},
}),
responseObserver: () => ({ onEnd: () => { ends += 1; } }),
});
const controller = new AbortController();
const res = await fetch(`${proxy.url}/v1/responses`, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ model: 'test-model', stream: true }),
signal: controller.signal,
});
const reader = (res.body as ReadableStream<Uint8Array>).getReader();
const decoder = new TextDecoder();
let received = '';
while (!received.includes(waitFor)) {
const { value, done } = await reader.read();
if (done) break;
received += decoder.decode(value, { stream: true });
}
controller.abort();
await upstreamClosed;
await vi.waitFor(() => expect(lifecycle).toEqual([expected]));
expect(ends).toBe(observerEnds);
expect(infoLogs.filter((m) => m.includes('client disconnected'))).toHaveLength(disconnectLogs);
});
it('透明重试后的上游 2xx SSE 中断时,立即收口且旧 listener 不误报客户端断开', async () => {
const errorLogs: Array<{ msg: string; ctx?: Record<string, unknown> }> = [];
const infoLogs: string[] = [];
const observerErrors: string[] = [];
let observerEnds = 0;
const upstream = await startFakeUpstream((idx, _body, res) => {
if (idx === 0) {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(ENC_ERROR_BODY);
return;
}
res.writeHead(200, { 'content-type': 'text/event-stream' });
res.write('event: message_start\ndata: {}\n\n');
// 不发送 end,模拟上游生成过程中连接被对端掐断。Node 可能发
// `aborted`、`error`、`close` 中的一个或多个,代理必须幂等收口。
setTimeout(() => res.destroy(), 50);
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
recoveryRules: [createEncryptedContentRecoveryRule({ enabled: () => true })],
logger: {
info: (msg) => infoLogs.push(msg),
error: (msg, ctx) => errorLogs.push({ msg, ctx }),
},
responseObserver: () => ({
onEnd: () => { observerEnds += 1; },
onError: (err) => { observerErrors.push(err.message); },
}),
});
const controller = new AbortController();
let responseStatus: number | null = null;
let clientError: unknown = null;
const operation = fetch(`${proxy.url}/v1/messages?api_key=must-not-appear-in-logs`, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({
model: 'test-model',
input: [{ type: 'reasoning', encrypted_content: 'gAAAsecret' }],
}),
signal: controller.signal,
}).then(async (res) => {
responseStatus = res.status;
await res.text();
}).catch((err: unknown) => {
// destroy() 后 undici 通常会以 body read error 收口,这正是期望的
// “立即失败”语义;测试只关心它不能悬挂到 watchdog。
clientError = err;
});
let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
const outcome = await Promise.race([
operation.then(() => 'settled' as const),
new Promise<'timeout'>((resolve) => {
// real-wait: watchdog the upstream abort path so a hung response cannot stall the test.
timeoutHandle = setTimeout(() => resolve('timeout'), 1000);
}),
]);
if (timeoutHandle !== undefined) clearTimeout(timeoutHandle);
if (outcome === 'timeout') controller.abort();
expect(outcome).toBe('settled');
expect(responseStatus).toBe(200);
expect(clientError).toBeInstanceOf(Error);
expect(upstream.bodies).toHaveLength(2);
expect(infoLogs.filter((m) => m.includes('client disconnected'))).toHaveLength(0);
const responseFailures = errorLogs.filter((entry) => entry.msg === 'upstream response stream error');
expect(responseFailures).toHaveLength(1);
expect(responseFailures[0].ctx).toMatchObject({
status: 200,
reason: expect.stringMatching(/^(error|aborted|close)$/),
bytes: expect.any(Number),
lastChunkBytes: expect.any(Number),
lastChunkAt: expect.any(Number),
});
expect(responseFailures[0].ctx?.path).toBe('/v1/messages');
expect(JSON.stringify(responseFailures[0].ctx)).not.toContain('must-not-appear-in-logs');
expect(Number(responseFailures[0].ctx?.bytes)).toBeGreaterThan(0);
expect(responseFailures[0].ctx).not.toHaveProperty('body');
expect(responseFailures[0].ctx).not.toHaveProperty('requestBody');
expect(responseFailures[0].ctx).not.toHaveProperty('chunk');
expect(observerErrors).toHaveLength(1);
expect(observerEnds).toBe(0);
});
it('正常完成的响应不受影响:不误判为客户端断开,连接复用下后续请求照常', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ ok: true }));
});
upstreamClose = upstream.close;
// 记录型 logger:锁住 writableEnded 守卫 —— 正常完成的请求绝不能触发
// "client disconnected mid-response" 的中断传播路径(否则每笔请求都会对
// 完成态上游请求调 destroy 并刷一条误导日志)。
const infoLogs: string[] = [];
const errorLogs: string[] = [];
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
// 此测试同时确保 upstream end 后迟到的 request/response error 不会重复收口。
logger: {
info: (msg) => { infoLogs.push(msg); },
error: (msg) => { errorLogs.push(msg); },
},
});
const r1 = await post(proxy.url, { model: 'test-model' });
const r2 = await post(proxy.url, { model: 'test-model' });
expect(r1.status).toBe(200);
expect(r2.status).toBe(200);
expect(upstream.bodies).toHaveLength(2);
expect(infoLogs.filter((m) => m.includes('client disconnected'))).toHaveLength(0);
expect(errorLogs.filter((m) => m.includes('upstream response stream error'))).toHaveLength(0);
});
});
describe('anthropic-compat-proxy 入站请求体 dump 开关(debugDumpRequestBody,默认关)', () => {
it('默认(不传开关)debug inbound 日志只有元数据,不含 body dump', async () => {
const upstream = await startFakeUpstream((_i, _b, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end('{}');
});
upstreamClose = upstream.close;
const debugs: Array<{ msg: string; ctx?: Record<string, unknown> }> = [];
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
logger: { isDebugEnabled: () => true, debug: (msg, ctx) => debugs.push({ msg, ctx }) },
});
await post(proxy.url, { model: 'test-model', secretPayload: 'x'.repeat(2048) });
const inbound = debugs.find((d) => d.msg.includes('inbound request'));
expect(inbound).toBeDefined();
// 元数据照旧(reqId/method/url/bytes),定位问题不受影响。
expect(inbound?.ctx?.method).toBe('POST');
expect(typeof inbound?.ctx?.bytes).toBe('number');
// 但绝不 dump 请求体 —— dev trace 级别 + 高并发下这是 main event loop 风暴源。
expect(inbound?.ctx).not.toHaveProperty('body');
});
it('显式开启后 debug inbound 日志携带截断 dump(诊断模式)', async () => {
const upstream = await startFakeUpstream((_i, _b, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end('{}');
});
upstreamClose = upstream.close;
const debugs: Array<{ msg: string; ctx?: Record<string, unknown> }> = [];
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
debugDumpRequestBody: true,
logger: { isDebugEnabled: () => true, debug: (msg, ctx) => debugs.push({ msg, ctx }) },
});
await post(proxy.url, { model: 'test-model', marker: 'dump-me' });
const inbound = debugs.find((d) => d.msg.includes('inbound request'));
expect(String(inbound?.ctx?.body)).toContain('dump-me');
});
it('localHandler 分支同样受开关约束(默认不 dump)', async () => {
const debugs: Array<{ msg: string; ctx?: Record<string, unknown> }> = [];
proxy = await createAnthropicCompatProxy({
upstream: () => '',
transformRequest: [],
routingTransform: () => ({
localHandler: async ({ res }) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end('{}');
},
}),
logger: { isDebugEnabled: () => true, debug: (msg, ctx) => debugs.push({ msg, ctx }) },
});
await post(proxy.url, { model: 'local-model', secretPayload: 'y'.repeat(2048) });
const inbound = debugs.find((d) => d.msg.includes('inbound request'));
expect(inbound).toBeDefined();
expect(inbound?.ctx).not.toHaveProperty('body');
});
});
describe('tool_use id 响应流去重改写(kimi 撞车自愈)', () => {
const SSE_BODY =
'event: message_start\n' +
'data: {"type":"message_start","message":{"id":"chatcmpl-x","role":"assistant","content":[]}}\n\n' +
'event: content_block_start\n' +
'data: {"type":"content_block_start","index":0,"content_block":{"type":"thinking","thinking":"想"}}\n\n' +
'event: content_block_start\n' +
'data: {"type":"content_block_start","index":1,"content_block":{"type":"tool_use","id":"Bash_210","name":"Bash","input":{}}}\n\n' +
'event: content_block_start\n' +
'data: {"type":"content_block_start","index":2,"content_block":{"type":"tool_use","id":"Bash_999","name":"Bash","input":{}}}\n\n' +
'event: message_stop\n' +
'data: {"type":"message_stop"}\n\n';
function sseUpstream() {
return startFakeUpstream((_i, _b, res) => {
res.writeHead(200, { 'content-type': 'text/event-stream' });
res.end(SSE_BODY);
});
}
it('请求历史带铸造形态 id 时, 响应里撞车的 tool_use id 被改名, 新 id 不动', async () => {
const upstream = await sseUpstream();
upstreamClose = upstream.close;
const infos: Array<{ msg: string; ctx?: Record<string, unknown> }> = [];
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
logger: { info: (msg, ctx) => infos.push({ msg, ctx }) },
});
const res = await post(proxy.url, {
model: 'kimi-k3',
messages: [
{ role: 'user', content: '分析' },
{ role: 'assistant', content: [{ type: 'tool_use', id: 'Bash_210', name: 'Bash', input: {} }] },
{ role: 'user', content: [{ type: 'tool_result', tool_use_id: 'Bash_210', content: 'ok' }] },
],
});
expect(res.status).toBe(200);
// 撞车 id 被改名; 新 id(Bash_999)与历史无关 → 不动
expect(res.text).toContain('"id":"Bash_210_dup2"');
expect(res.text).toContain('"id":"Bash_999"');
expect(res.text).not.toContain('"id":"Bash_210"');
// thinking / 事件框架行原样
expect(res.text).toContain('event: message_stop');
expect(
infos.some(
(l) => l.msg.includes('renamed duplicate tool_use id') && l.ctx?.from === 'Bash_210' && l.ctx?.to === 'Bash_210_dup2',
),
).toBe(true);
});
it('请求历史无铸造形态 id 时, 响应流字节透传(零干预)', async () => {
const upstream = await sseUpstream();
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
});
const res = await post(proxy.url, {
model: 'claude-sonnet-4',
messages: [
{ role: 'user', content: '分析' },
{ role: 'assistant', content: [{ type: 'tool_use', id: 'toolu_01Jx4AbC', name: 'Bash', input: {} }] },
{ role: 'user', content: [{ type: 'tool_result', tool_use_id: 'toolu_01Jx4AbC', content: 'ok' }] },
],
});
expect(res.status).toBe(200);
expect(res.text).toBe(SSE_BODY);
});
it('非 SSE 响应不接管(字节透传)', async () => {
const upstream = await startFakeUpstream((_i, _b, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(
JSON.stringify({
id: 'chatcmpl-x',
content: [{ type: 'tool_use', id: 'Bash_210', name: 'Bash', input: {} }],
}),
);
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
});
const res = await post(proxy.url, {
model: 'kimi-k3',
messages: [
{ role: 'assistant', content: [{ type: 'tool_use', id: 'Bash_210', name: 'Bash', input: {} }] },
],
});
expect(res.status).toBe(200);
expect(res.text).toContain('"id":"Bash_210"');
});
it('SSE 改写长度变化时自动剥离 content-length,客户端不截断(GPT-5.5 第 5 轮 P1)', async () => {
const upstream = await startFakeUpstream((_i, _b, res) => {
const sseBody =
'event: content_block_start\n' +
'data: {"type":"content_block_start","index":1,"content_block":{"type":"tool_use","id":"Bash_210","name":"Bash","input":{}}}\n\n' +
'event: message_stop\n' +
'data: {"type":"message_stop"}\n\n';
// upstream 发出定长 content-length(改写后 body 会变得更长)
res.writeHead(200, {
'content-type': 'text/event-stream',
'content-length': String(Buffer.byteLength(sseBody)),
});
res.end(sseBody);
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
});
const res = await post(proxy.url, {
model: 'kimi-k3',
messages: [
{ role: 'assistant', content: [{ type: 'tool_use', id: 'Bash_210', name: 'Bash', input: {} }] },
],
});
expect(res.status).toBe(200);
// 改写后 id 被改名,且完整的 SSE 帧无截断(message_stop 存在)
expect(res.text).toContain('"id":"Bash_210_dup2"');
expect(res.text).toContain('"type":"message_stop"');
});
});
describe('压缩 SSE 不接管(Greptile review)', () => {
it('content-encoding 存在时保持字节透传,不改名、不删 content-length', async () => {
const { gzipSync } = await import('node:zlib');
const upstream = await startFakeUpstream((_i, _b, res) => {
const sseBody =
'event: content_block_start\n' +
'data: {"type":"content_block_start","index":1,"content_block":{"type":"tool_use","id":"Bash_210","name":"Bash","input":{}}}\n\n';
// 真实 gzip 压缩的 SSE:改写器不得接管(压缩字节按明文行切分会漏改/误改)
const gzipped = gzipSync(Buffer.from(sseBody, 'utf8'));
res.writeHead(200, {
'content-type': 'text/event-stream',
'content-encoding': 'gzip',
'content-length': String(gzipped.length),
});
res.end(gzipped);
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
});
const res = await post(proxy.url, {
model: 'kimi-k3',
messages: [
{ role: 'assistant', content: [{ type: 'tool_use', id: 'Bash_210', name: 'Bash', input: {} }] },
],
});
expect(res.status).toBe(200);
// 字节透传:客户端自解压后内容完整、id 不改名(未进入改写器)
expect(res.text).toContain('"id":"Bash_210"');
expect(res.text).not.toContain('Bash_210_dup2');
});
it('content-encoding: identity(明文,不压缩)仍接管改写(Greptile P1)', async () => {
const upstream = await startFakeUpstream((_i, _b, res) => {
const sseBody =
'event: content_block_start\n' +
'data: {"type":"content_block_start","index":1,"content_block":{"type":"tool_use","id":"Bash_210","name":"Bash","input":{}}}\n\n';
res.writeHead(200, {
'content-type': 'text/event-stream',
'content-encoding': 'identity',
'content-length': String(Buffer.byteLength(sseBody)),
});
res.end(sseBody);
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
transformRequest: [],
});
const res = await post(proxy.url, {
model: 'kimi-k3',
messages: [
{ role: 'assistant', content: [{ type: 'tool_use', id: 'Bash_210', name: 'Bash', input: {} }] },
],
});
expect(res.status).toBe(200);
// identity 是明文:必须接管并改名(改写后长度变化,content-length 被剥离)
expect(res.text).toContain('"id":"Bash_210_dup2"');
});
});
describe('per-thread 已见 id 缓存(codex-connector P1:请求体缺席历史 id 时仍拦截重铸)', () => {
const MINTED_SSE =
'event: content_block_start\n' +
'data: {"type":"content_block_start","index":1,"content_block":{"type":"tool_use","id":"Bash_210","name":"Bash","input":{}}}\n\n';
function mintingUpstream() {
return startFakeUpstream((_i, _b, res) => {
res.writeHead(200, { 'content-type': 'text/event-stream' });
res.end(MINTED_SSE);
});
}
// per-thread 缓存需要**同一 proxy 实例**跨请求累积(每个请求独立建 proxy 会丢缓存),
// 因此 postAs 复用同一个 upstream + proxy。
async function setupSingleProxy(compatibilityProfiles?: string[]): Promise<void> {
const upstream = await mintingUpstream();
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({ upstream: upstream.url, transformRequest: [],
...(compatibilityProfiles ? { routingTransform: () => ({ upstreamOverride: upstream.url, compatibilityProfiles }) } : {}),
});
}
async function postAs(sessionId: string, body: unknown): Promise<string> {
const res = await fetch(`${proxy!.url}/v1/responses`, {
method: 'POST',
headers: { 'content-type': 'application/json', 'x-claude-code-session-id': sessionId },
body: JSON.stringify(body),
});
return res.text();
}
it('全新 kimi 会话(无 minted id 历史)仍接管并记录首个 streamed id(codex-connector P1)', async () => {
await setupSingleProxy();
// 全新 kimi 会话: 请求体无任何铸造形态 id → requestedIds null, cache 空;
// 修复前 responseToolUseIds 也 null → 不接管 → 首 fresh id 未记录。
// 修复后: 请求体 model=kimi 判定接管, onObserved 记录 Bash_210。
const r1 = await postAs('sess-fresh', {
model: 'moonshot/kimi-k3',
messages: [{ role: 'user', content: '你好' }],
});
expect(r1).toContain('"id":"Bash_210"'); // fresh id 透传(无撞车)
// 第二次请求(同 session, 无铸造 id 历史, 模拟 rewind): 缓存里已有 Bash_210
// → 响应铸 Bash_210 仍被拦截改名
const r2 = await postAs('sess-fresh', {
model: 'moonshot/kimi-k3',
messages: [{ role: 'user', content: '继续' }],
});
expect(r2).not.toContain('"id":"Bash_210"');
expect(r2).toMatch(/Bash_210_dup\d+/);
});
it.each(['k3', 'k3-256k', 'k3.1-pro', 'k3.1-pro-highspeed', 'future-catalog-model'])('Kimi Code 的 %s 首次工具流在 rewind 后仍去重 (#7005)', async (model) => {
await setupSingleProxy(model === 'future-catalog-model' ? ['kimi-tool-ids-v1'] : undefined);
// Coding ID 不带 kimi 前缀;小数版本也必须记录首个 streamed id。
const r1 = await postAs('sess-k3', {
model,
messages: [{ role: 'user', content: '你好' }],
});
expect(r1).toContain('"id":"Bash_210"'); // fresh id 透传(无撞车)
// 第二次请求(同 session, 模拟 rewind): 缓存里已有 Bash_210 → 拦截改名
const r2 = await postAs('sess-k3', {
model,
messages: [{ role: 'user', content: '继续' }],
});
expect(r2).not.toContain('"id":"Bash_210"');
expect(r2).toMatch(/Bash_210_dup\d+/);
});
it('请求1(历史含 Bash_210)改名;请求2(同 session,历史不含 Bash_210)仍拦截重铸', async () => {
await setupSingleProxy();
// 请求1: 历史带 Bash_210 → 响应铸 Bash_210 → 撞车 → 改名; Bash_210 进线程缓存
const r1 = await postAs('sess-1', {
model: 'kimi-k3',
messages: [
{ role: 'assistant', content: [{ type: 'tool_use', id: 'Bash_210', name: 'Bash', input: {} }] },
],
});
expect(r1).toContain('"id":"Bash_210_dup2"');
// 请求2: 同 session, 历史**不含** Bash_210(模拟 rewind 后历史缺席)
// → 若只从请求体建 usedIds, 该 id 会被当「新 id」放行; per-thread 缓存必须拦截
const r2 = await postAs('sess-1', {
model: 'kimi-k3',
messages: [{ role: 'user', content: '继续分析' }],
});
// 缓存让 r2 仍设防:响应铸 Bash_210 被改名(后缀可能顺延为 _dup3,因为 r1
// 的 onRename 已把 _dup2 写进缓存),绝不能原样放行 Bash_210
expect(r2).not.toContain('"id":"Bash_210"');
expect(r2).toMatch(/Bash_210_dup\d+/);
});
it('请求2 仍含部分铸造 id 时,缓存里缺席的旧 id 也并入种子(codex-connector P1)', async () => {
await setupSingleProxy();
// 请求1: 历史带 Bash_210 → 改名 → 进缓存
const r1 = await postAs('sess-partial', {
model: 'kimi-k3',
messages: [
{ role: 'assistant', content: [{ type: 'tool_use', id: 'Bash_210', name: 'Bash', input: {} }] },
],
});
expect(r1).toContain('"id":"Bash_210_dup2"');
// 请求2: 同 session, 请求体**仍含另一个**铸造 id(Read_5, 使 requestedIds 非空),
// 但 Bash_210 缺席 —— 若只从请求体建种子, Bash_210 会漏; 缓存必须并入。
// fake upstream 恒铸 Bash_210 → 必须仍被改名, 不得原样放行。
const r2 = await postAs('sess-partial', {
model: 'kimi-k3',
messages: [
{ role: 'assistant', content: [{ type: 'tool_use', id: 'Read_5', name: 'Read', input: {} }] },
],
});
expect(r2).not.toContain('"id":"Bash_210"');
expect(r2).toMatch(/Bash_210_dup\d+/);
});
it('不同 session 的缓存互不串扰', async () => {
await setupSingleProxy();
// 请求1 在 sess-A 铸 Bash_210(缓存入 sess-A)
await postAs('sess-A', {
model: 'kimi-k3',
messages: [
{ role: 'assistant', content: [{ type: 'tool_use', id: 'Bash_210', name: 'Bash', input: {} }] },
],
});
// 请求2 在 sess-B(全新会话, 无缓存)铸 Bash_210 → 请求体不带历史 id → 应放行
const r2 = await postAs('sess-B', {
model: 'kimi-k3',
messages: [{ role: 'user', content: '你好' }],
});
expect(r2).toContain('"id":"Bash_210"');
expect(r2).not.toContain('Bash_210_dup2');
});
});
describe('streaming response validity gate (#2242)', () => {
const SSE_HEADERS = { 'content-type': 'text/event-stream; charset=utf-8' };
const SSE_BODY = 'event: message_start\ndata: {"type":"message_start"}\n\nevent: message_stop\ndata: {"type":"message_stop"}\n\n';
it('流式请求收到空 2xx → 结构化 502(empty_stream_response)', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, SSE_HEADERS);
res.end();
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({ upstream: upstream.url });
const result = await post(proxy.url, { model: 'test-model', stream: true });
expect(result.status).toBe(502);
const parsed = JSON.parse(result.text) as { error: { type: string; code?: string } };
expect(parsed.error.type).toBe('proxy_error');
expect(parsed.error.code).toBe('empty_stream_response');
});
it('流式请求收到非 SSE 2xx → 502(non_sse_stream_response)', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end(JSON.stringify({ error: { type: 'gateway_hiccup', message: 'nope' } }));
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({ upstream: upstream.url });
const result = await post(proxy.url, { model: 'test-model', stream: true });
expect(result.status).toBe(502);
expect((JSON.parse(result.text) as { error: { code?: string } }).error.code)
.toBe('non_sse_stream_response');
});
it('Codex HTTP fallback accepts SSE without Content-Type after encrypted reasoning recovery', async () => {
const upstream = await startFakeUpstream((idx, _body, res) => {
if (idx === 0) {
res.writeHead(400, { 'content-type': 'application/json' });
res.end(ENC_ERROR_BODY);
return;
}
res.writeHead(200);
res.write(': keepalive\r\n\r\nev');
setImmediate(() => res.end(SSE_BODY.slice(2)));
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({
upstream: upstream.url,
recoveryRules: [createEncryptedContentRecoveryRule({ enabled: () => true })],
});
const response = await fetch(`${proxy.url}/responses`, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ model: 'gpt-6-astra', stream: true, input: [
{ type: 'reasoning', encrypted_content: 'foreign-reasoning', summary: [] },
{ role: 'user', content: 'Remember the test code' },
] }),
});
expect(response.status).toBe(200);
expect(response.headers.get('content-type')).toBe('text/event-stream');
expect(await response.text()).toBe(`: keepalive\r\n\r\n${SSE_BODY}`);
expect(upstream.bodies).toHaveLength(2);
expect(upstream.bodies[1]).not.toContain('foreign-reasoning');
expect(upstream.bodies[1]).toContain('Remember the test code');
});
it('accepts a large complete first SSE event without Content-Type', async () => {
const created = JSON.stringify({
type: 'response.created',
response: { instructions: 'large-context-fixture '.repeat(12_000), output: [] },
});
const body = `event: response.created\ndata: ${created}\n\ndata: {"type":"response.completed"}\n\n`;
expect(Buffer.byteLength(body)).toBeGreaterThan(64 * 1024);
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200); // Intentionally omit Content-Type for the Codex HTTP fallback.
res.write(body.slice(0, 80 * 1024));
setImmediate(() => res.end(body.slice(80 * 1024)));
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({ upstream: upstream.url });
const response = await fetch(`${proxy.url}/responses`, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ model: 'test-model', stream: true }),
});
const responseText = await response.text();
expect(response.status).toBe(200);
expect(response.headers.get('content-type')).toBe('text/event-stream');
expect(responseText).toBe(body);
expect(upstream.bodies).toHaveLength(1);
});
it('bounds an unfinished inferred SSE event with its dedicated error code', async () => {
const body = `event: response.created\ndata: ${'x'.repeat(8 * 1024 * 1024)}`;
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200); // Intentionally omit Content-Type.
res.end(body);
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({ upstream: upstream.url });
const result = await post(proxy.url, { model: 'test-model', stream: true });
expect(result.status).toBe(502);
expect(JSON.parse(result.text).error.code).toBe('sse_inference_limit_exceeded');
});
it('commits a complete inferred event before rejecting bytes after its cap', async () => {
const prefix = 'event: response.created\ndata: ';
const firstEvent = `${prefix}${'x'.repeat(8 * 1024 * 1024 - Buffer.byteLength(prefix) - 18)}\n\n`;
const remainder = 'data: {"type":"response.completed"}\n\n';
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200); // Intentionally omit Content-Type.
res.end(`${firstEvent}${remainder}`);
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({ upstream: upstream.url });
const result = await post(proxy.url, { model: 'test-model', stream: true });
expect(result).toEqual({ status: 200, text: `${firstEvent}${remainder}` });
});
it('infers a complete event with mixed LF and CRLF event delimiters', async () => {
const body = 'event: response.created\ndata: {}\n\r\n';
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200); // Intentionally omit Content-Type.
res.end(body);
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({ upstream: upstream.url });
const result = await post(proxy.url, { model: 'test-model', stream: true });
expect(result).toEqual({ status: 200, text: body });
});
it('still rejects a large unfinished inferred SSE event below its cap', async () => {
const body = `event: response.created\ndata: ${'x'.repeat(128 * 1024)}`;
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200); // Intentionally omit Content-Type.
res.end(body);
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({ upstream: upstream.url });
const result = await post(proxy.url, { model: 'test-model', stream: true });
expect(result.status).toBe(502);
expect(JSON.parse(result.text).error.code).toBe('non_sse_stream_response');
});
it.each([
{ name: 'JSON without MIME', body: '{"ok":true}', headers: {} },
{ name: 'HTML containing an SSE line', body: '<html>\ndata: fake\n</html>', headers: {} },
{ name: 'explicit HTML MIME with SSE bytes', body: SSE_BODY, headers: { 'content-type': 'text/html' } },
{ name: 'comment-only body without MIME', body: ': keepalive\n\n', headers: {} },
{ name: 'truncated data field', body: 'data: upstream timeout', headers: {} },
{ name: 'data line without event boundary', body: 'data: upstream timeout\n', headers: {} },
{ name: 'event-only block', body: 'event: response.created\n\n', headers: {} },
{ name: 'heartbeat followed by unfinished data', body: ': ping\n\ndata: {}\n', headers: {} },
])('does not infer SSE from $name', async ({ body, headers }) => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, headers);
res.end(body);
});
upstreamClose = upstream.close;
const transformResponse = vi.fn(() => { throw new Error('must not adapt invalid streams'); });
proxy = await createAnthropicCompatProxy({ upstream: upstream.url, transformResponse });
const result = await post(proxy.url, { model: 'test-model', stream: true });
expect(result.status).toBe(502);
expect(JSON.parse(result.text).error.code).toBe('non_sse_stream_response');
expect(transformResponse).not.toHaveBeenCalled();
});
it.each(['\n', '\r\n'])('infers a complete data event across chunk boundaries (%j)', async (newline) => {
const body = `: keepalive${newline}${newline}event: response.created${newline}data: {}${newline}${newline}`;
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200);
const chunks = [...Buffer.from(body)];
const writeNext = () => {
const byte = chunks.shift();
if (byte === undefined) {
res.end();
} else {
res.write(Buffer.from([byte]));
setImmediate(writeNext);
}
};
writeNext();
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({ upstream: upstream.url });
const result = await post(proxy.url, { model: 'test-model', stream: true });
expect(result).toEqual({ status: 200, text: body });
});
it('零事件 SSE(只有注释/心跳)正常结束 → 502(sse_without_events)', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, SSE_HEADERS);
res.write(': ping\n\n');
res.end(': bye\n\n');
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({ upstream: upstream.url });
const result = await post(proxy.url, { model: 'test-model', stream: true });
expect(result.status).toBe(502);
expect((JSON.parse(result.text) as { error: { code?: string } }).error.code)
.toBe('sse_without_events');
});
it('合法 SSE 原样透传,事件前的注释心跳不丢', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, SSE_HEADERS);
res.write(': keepalive\n\n');
res.end(SSE_BODY);
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({ upstream: upstream.url });
const result = await post(proxy.url, { model: 'test-model', stream: true });
expect(result.status).toBe(200);
expect(result.text).toBe(`: keepalive\n\n${SSE_BODY}`);
});
it('压缩 SSE 不按明文扫行:首字节提交并透传', async () => {
const gz = gzipSync(Buffer.from(SSE_BODY, 'utf8'));
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, { ...SSE_HEADERS, 'content-encoding': 'gzip' });
res.end(gz);
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({ upstream: upstream.url });
const result = await post(proxy.url, { model: 'test-model', stream: true });
expect(result.status).toBe(200);
expect(result.text).toBe(SSE_BODY);
});
it('非流式请求不受门控:空 200 照旧字节透传(行为保持)', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end();
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({ upstream: upstream.url });
const result = await post(proxy.url, { model: 'test-model' });
expect(result).toEqual({ status: 200, text: '' });
});
it('已提交后的截断保持连接失败语义,不补成正常结束', async () => {
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, SSE_HEADERS);
res.write('event: message_start\ndata: {"type":"message_start"}\n\n');
setTimeout(() => res.destroy(), 30);
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({ upstream: upstream.url });
await expect(post(proxy.url, { model: 'test-model', stream: true })).rejects.toThrow();
});
});
describe('anthropic-compat-proxy stream gate pending-buffer boundary', () => {
it('commits every gated byte when the pending buffer lands exactly on the gate cap', async () => {
// 回归:入队条件曾是 `pendingBytes < CAP` 而拒收条件是 `> CAP` —— 累计恰好
// 落在 64KiB(回环读常见块大小)时, 后续 chunk 只计数不入队; 事件标记在这些
// chunk 里到达并提交后, 它们被永久跳过, 客户端收到中间有缺口的 200 SSE。
const pad = 'x'.repeat(64 * 1024);
const marker = 'event: message_start\ndata: {"type":"message_start"}\n\n';
const upstream = await startFakeUpstream((_idx, _body, res) => {
res.writeHead(200, { 'content-type': 'text/event-stream' });
res.write(pad);
res.write(marker);
res.end();
});
upstreamClose = upstream.close;
proxy = await createAnthropicCompatProxy({ upstream: upstream.url });
const result = await post(proxy.url, { model: 'test-model', stream: true });
expect(result.status).toBe(200);
expect(result.text).toBe(pad + marker);
});
});