test/devin-connect.test.js
Rama master · réplica de lectura del repositorio original.
import { afterEach, describe, it } from 'node:test';
import assert from 'node:assert/strict';
import {
getConnectToken,
buildGetChatMessageRequest,
decodeFrame,
mapFinishReason,
resolveFinishReason,
classifyUpstreamError,
isRetryable,
streamChat,
getImageFieldTag,
getToolDefTags,
extractInlineImages,
normalizeToolSchema,
__setRequestImpl,
__testing,
mergeToolCallFragment,
} from '../src/devin-connect.js';
import {
writeStringField, writeVarintField, writeMessageField,
parseFields, getField, getAllFields,
} from '../src/proto.js';
import { wrapEnvelope, endOfStreamEnvelope } from '../src/connect.js';
import { EventEmitter } from 'node:events';
import { mkdtempSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
const ENV_KEYS = ['DEVIN_CONNECT_TOKEN', 'WINDSURF_API_KEY', 'DEVIN_CONNECT_IMAGE_TAG',
'DEVIN_CONNECT_IMAGE_INNER_TAGS', 'DEVIN_CONNECT_TOOL_DEF_TAGS',
'DEVIN_CONNECT_REPLAY_REASONING', 'DEVIN_CONNECT_COLLAPSE_SYSTEM'];
const originalEnv = Object.fromEntries(ENV_KEYS.map(k => [k, process.env[k]]));
afterEach(() => {
for (const k of ENV_KEYS) {
if (originalEnv[k] === undefined) delete process.env[k];
else process.env[k] = originalEnv[k];
}
});
const TOKEN = 'devin-session-token$test.jwt.sig';
describe('getConnectToken', () => {
it('prefers DEVIN_CONNECT_TOKEN over WINDSURF_API_KEY', () => {
assert.equal(
getConnectToken({ DEVIN_CONNECT_TOKEN: 'a', WINDSURF_API_KEY: 'b' }),
'a',
);
});
it('falls back to WINDSURF_API_KEY', () => {
assert.equal(getConnectToken({ WINDSURF_API_KEY: 'b' }), 'b');
});
it('returns empty string when neither is set', () => {
assert.equal(getConnectToken({}), '');
});
});
describe('generateFingerprint', () => {
it('produces 732 hex chars (the server-required length)', () => {
const fp = __testing.generateFingerprint();
assert.equal(fp.length, 732);
assert.match(fp, /^[0-9a-f]{732}$/);
});
it('is random per call', () => {
assert.notEqual(__testing.generateFingerprint(), __testing.generateFingerprint());
});
});
describe('messageText', () => {
it('passes strings through', () => {
assert.equal(__testing.messageText('hi'), 'hi');
});
it('joins text parts of array content', () => {
assert.equal(
__testing.messageText([{ type: 'text', text: 'a' }, { type: 'image' }, { type: 'text', text: 'b' }]),
'a\nb',
);
});
it('handles null', () => {
assert.equal(__testing.messageText(null), '');
});
});
describe('buildGetChatMessageRequest', () => {
it('throws without a token', () => {
assert.throws(() => buildGetChatMessageRequest({ model: 'm', messages: [] }), /session token/);
});
it('throws without a model', () => {
assert.throws(() => buildGetChatMessageRequest({ token: TOKEN, messages: [] }), /model selector/);
});
it('encodes the calibrated top-level field shape', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN,
model: 'swe-1-6-slow',
messages: [
{ role: 'system', content: 'be nice' },
{ role: 'user', content: 'hello' },
],
});
const fields = parseFields(proto);
// #1 ClientMetadata (message), #2 system_prompt (string), #3 ChatMessage,
// #7 mode varint, #8 CompletionConfig, #15 ModelConfig, #16 session id,
// #20 varint, #21 model selector.
assert.ok(getField(fields, 1, 2), 'has ClientMetadata #1');
assert.equal(getField(fields, 2, 2).value.toString('utf8'), 'be nice');
assert.equal(getField(fields, 7, 0).value, 5);
assert.ok(getField(fields, 8, 2), 'has CompletionConfig #8');
assert.ok(getField(fields, 15, 2), 'has ModelConfig #15');
assert.ok(getField(fields, 16, 2), 'has session id #16');
assert.equal(getField(fields, 20, 0).value, 1);
assert.equal(getField(fields, 21, 2).value.toString('utf8'), 'swe-1-6-slow');
// #22 request_id — MUST BE ABSENT. Re-calibrated from the full capture set:
// the verified turn-1 wire (req009) carries no #22; it only appears turn 2+
// as a reused user-exchange id. The gateway is stateless (turn-1 every
// request), so it must not emit a fabricated random #22 (see buildGet…Request).
assert.ok(!getField(fields, 22, 2), '#22 request_id is absent on a turn-1 request');
});
// ★ 2026-08-05: ModelConfig #15 parity with genuine devin.exe. Captures show
// #15.1 stable per session and #15.2 monotonic; the stateless default stays
// {fresh uuid, 1, 4} (turn-1 wire req009). sessionModelConfig opts into the
// stable shape when session-continuity resolved a session (DEVIN_CONNECT_
// MODEL_CONFIG_STABLE).
it('ModelConfig #15 stateless default: fresh uuid, turn 1, const 4', () => {
const proto = buildGetChatMessageRequest({ token: TOKEN, model: 'm', messages: [{ role: 'user', content: 'hi' }] });
const sub = parseFields(getField(parseFields(proto), 15, 2).value);
assert.match(getField(sub, 1, 2).value.toString('utf8'), /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i, '#15.1 is a uuid by default');
assert.equal(getField(sub, 2, 0).value, 1, '#15.2 defaults to turn 1');
assert.equal(getField(sub, 3, 0).value, 4, '#15.3 stays the calibrated constant 4');
});
it('ModelConfig #15 rides devin.exe shape when sessionModelConfig is passed', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'm', messages: [{ role: 'user', content: 'hi' }],
sessionModelConfig: { id: 'cfg-stable-session-1', turn: 7 },
});
const sub = parseFields(getField(parseFields(proto), 15, 2).value);
assert.equal(getField(sub, 1, 2).value.toString('utf8'), 'cfg-stable-session-1', '#15.1 carries the stable session config id');
assert.equal(getField(sub, 2, 0).value, 7, '#15.2 carries the session turn counter');
assert.equal(getField(sub, 3, 0).value, 4, '#15.3 unchanged');
});
// ★ 2026-08-05: T1 reasoning continuity — the checkpoint block rides as a
// system-prompt suffix inside tag #2. Byte-compatible: only longer.
it('continuityTrail appends to the system prompt inside #2', () => {
const trail = '\n\n[Continuity checkpoint — prior analysis trace, may be stale]\nr1\n[End]';
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'm',
messages: [{ role: 'system', content: 'BASE SYSTEM' }, { role: 'user', content: 'hi' }],
continuityTrail: trail,
});
const sys = getField(parseFields(proto), 2, 2).value.toString('utf8');
assert.ok(sys.startsWith('BASE SYSTEM'), 'client system kept verbatim');
assert.ok(sys.endsWith('[End]'), 'trail appended after the client system');
assert.ok(sys.includes('[Continuity checkpoint'));
});
it('without continuityTrail the system prompt is byte-identical to pre-feature', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'm',
messages: [{ role: 'system', content: 'BASE SYSTEM' }, { role: 'user', content: 'hi' }],
});
assert.equal(getField(parseFields(proto), 2, 2).value.toString('utf8'), 'BASE SYSTEM');
});
// ★ 2026-07-10: empty-system + tools guard. Verified from live devin.exe capture
// + boundary experiment: Devin's upstream returns "internal error occurred" for a
// Claude-family request that declares tools (#10) but has an EMPTY/absent system
// prompt (#2). A single char of system is enough to pass. We inject a minimal
// system when tools are present and system is empty.
it('injects a non-empty system #2 when tools are present but no system given', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'claude-opus-4-8-medium',
messages: [{ role: 'user', content: 'hi' }],
tools: [{ type: 'function', function: { name: 'edit', description: 'edit', parameters: { type: 'object', properties: {} } } }],
nativeToolCall: true,
});
const f2 = getField(parseFields(proto), 2, 2);
assert.ok(f2 && f2.value.length > 0, '#2 system_prompt is non-empty when tools present');
});
it('does NOT inject a system when no tools (empty system stays empty)', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'claude-opus-4-8-medium',
messages: [{ role: 'user', content: 'hi' }],
});
const f2 = getField(parseFields(proto), 2, 2);
// no system + no tools → #2 empty (length 0) or absent; must NOT fabricate one
assert.ok(!f2 || f2.value.length === 0, '#2 stays empty when no tools and no system');
});
it('preserves a caller-supplied system verbatim even with tools', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'claude-opus-4-8-medium',
messages: [{ role: 'system', content: 'be nice' }, { role: 'user', content: 'hi' }],
tools: [{ type: 'function', function: { name: 'edit', description: 'edit', parameters: { type: 'object', properties: {} } } }],
nativeToolCall: true,
});
assert.equal(getField(parseFields(proto), 2, 2).value.toString('utf8'), 'be nice');
});
// ★ 2026-07-13: native ToolDef descriptions are replaced with the tool name.
// Live A/B against Cursor's real 21-tool inventory proved upstream fingerprints
// both top-level and parameter descriptions as an "MCP configuration issue".
// Name, schema structure, types, required fields and enums remain native.
it('replaces a very long tool description with the name in #10 ToolDef', () => {
const longDesc = 'x'.repeat(1200);
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'claude-opus-4-8-medium',
messages: [{ role: 'system', content: 'sys' }, { role: 'user', content: 'hi' }],
tools: [{ type: 'function', function: { name: 'edit', description: longDesc, parameters: { type: 'object', properties: {} } } }],
nativeToolCall: true,
});
const fields = parseFields(proto);
const td = getField(fields, 10, 2);
assert.ok(td, 'has #10 ToolDef');
const inner = parseFields(td.value);
const desc = getField(inner, 2, 2).value.toString('utf8');
assert.equal(desc, 'edit');
// name (#1) still intact
assert.equal(getField(inner, 1, 2).value.toString('utf8'), 'edit');
});
it('replaces a short tool description with the name', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'claude-opus-4-8-medium',
messages: [{ role: 'system', content: 'sys' }, { role: 'user', content: 'hi' }],
tools: [{ type: 'function', function: { name: 'edit', description: 'edit a file', parameters: { type: 'object', properties: {} } } }],
nativeToolCall: true,
});
const inner = parseFields(getField(parseFields(proto), 10, 2).value);
assert.equal(getField(inner, 2, 2).value.toString('utf8'), 'edit');
});
it('embeds the SINGLE token in ClientMetadata #3 (header doubling is separate)', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'm', messages: [{ role: 'user', content: 'x' }],
});
const meta = parseFields(getField(parseFields(proto), 1, 2).value);
assert.equal(getField(meta, 3, 2).value.toString('utf8'), TOKEN);
});
it('uses a 732-hex fingerprint in ClientMetadata #31', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'm', messages: [{ role: 'user', content: 'x' }],
});
const meta = parseFields(getField(parseFields(proto), 1, 2).value);
const fp = getField(meta, 31, 2).value.toString('utf8');
assert.equal(fp.length, 732);
});
it('emits one ChatMessage per non-system turn with the right source enum', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN,
model: 'm',
messages: [
{ role: 'user', content: 'q1' },
{ role: 'assistant', content: 'a1' },
{ role: 'user', content: 'q2' },
],
});
const chats = getAllFields(parseFields(proto), 3).filter(f => f.wireType === 2);
assert.equal(chats.length, 3);
const sources = chats.map(c => getField(parseFields(c.value), 2, 0).value);
assert.deepEqual(sources, [__testing.SOURCE.USER, __testing.SOURCE.ASSISTANT, __testing.SOURCE.USER]);
});
it('folds tool turns into user-visible text', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'm',
messages: [{ role: 'tool', tool_call_id: 'call_7', content: '42' }],
});
const chat = getAllFields(parseFields(proto), 3).find(f => f.wireType === 2);
const text = getField(parseFields(chat.value), 3, 2).value.toString('utf8');
assert.match(text, /tool result for call_7/);
assert.match(text, /42/);
});
// Same-source text runs: a client history that splits one turn into several
// same-role entries produces consecutive same-source ChatMessages on the wire,
// and the upstream validator rejects a run of length >= 3 with
// invalid_argument. The builder merges text-only same-role runs before
// encoding; structured entries (tool_calls / tool_call_id / reasoning /
// images) are never merged.
it('merges a consecutive same-role text-only run into one ChatMessage', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN,
model: 'm',
messages: [
{ role: 'user', content: 'q1' },
{ role: 'assistant', content: 'a1' },
{ role: 'assistant', content: 'a2' },
{ role: 'assistant', content: 'a3' },
{ role: 'user', content: 'q2' },
{ role: 'user', content: 'q2b' },
],
});
const chats = getAllFields(parseFields(proto), 3).filter((f) => f.wireType === 2);
const sources = chats.map((c) => getField(parseFields(c.value), 2, 0).value);
// 6 text entries -> 3 wire turns; no same-source run survives.
assert.deepEqual(sources, [__testing.SOURCE.USER, __testing.SOURCE.ASSISTANT, __testing.SOURCE.USER]);
const merged = getField(parseFields(chats[1].value), 3, 2).value.toString('utf8');
assert.equal(merged, 'a1\n\na2\n\na3');
});
it('never merges entries carrying tool_calls / tool_call_id / reasoning', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN,
model: 'm',
nativeToolCall: true,
env: { DEVIN_CONNECT_REPLAY_REASONING: '1' },
messages: [
{ role: 'assistant', content: '', tool_calls: [{ id: 'call_1', function: { name: 'bash', arguments: '{}' } }] },
{ role: 'tool', tool_call_id: 'call_1', content: 'done' },
{ role: 'assistant', content: 'a3', reasoning: 'r3' },
{ role: 'assistant', content: 'a4' },
],
});
const chats = getAllFields(parseFields(proto), 3).filter((f) => f.wireType === 2);
const sources = chats.map((c) => getField(parseFields(c.value), 2, 0).value);
// The tool_call entry, the tool result, and the reasoning entry are all
// non-mergeable — 'a4' is mergeable but its neighbour ('a3', reasoning)
// is not, so nothing collapses.
assert.deepEqual(sources, [
__testing.SOURCE.ASSISTANT, __testing.SOURCE.TOOL_RESULT,
__testing.SOURCE.ASSISTANT, __testing.SOURCE.ASSISTANT,
]);
assert.ok(getField(parseFields(chats[0].value), 6, 2), 'tool_call entry keeps #6');
assert.ok(getField(parseFields(chats[1].value), 7, 2), 'tool result keeps #7 tool_call_id');
assert.ok(getField(parseFields(chats[2].value), 11, 2), 'reasoning entry keeps #11');
assert.equal(getField(parseFields(chats[3].value), 3, 2).value.toString('utf8'), 'a4', 'a4 stays its own turn');
});
it('does not merge a tool_calls assistant into the following same-role text', () => {
// The previous test's tool_calls neighbour is role:tool, so deleting the
// tool_calls half of isMergeableText would still go green. This pair is
// same-role: if that guard vanished, 'pre' and 'post' would collapse and
// the #6 would ride a merged text turn.
const proto = buildGetChatMessageRequest({
token: TOKEN,
model: 'm',
nativeToolCall: true,
messages: [
{ role: 'assistant', content: 'pre', tool_calls: [{ id: 'call_1', function: { name: 'bash', arguments: '{}' } }] },
{ role: 'assistant', content: 'post' },
],
});
const chats = getAllFields(parseFields(proto), 3).filter((f) => f.wireType === 2);
const sources = chats.map((c) => getField(parseFields(c.value), 2, 0).value);
// Encoder emits leading text, then a separate #6 frame per tool_call.
// If isMergeableText dropped the tool_calls check, 'pre' and 'post' would
// collapse first and the wire would be text='pre\n\npost' plus #6 (2 frames).
assert.deepEqual(sources, [
__testing.SOURCE.ASSISTANT, __testing.SOURCE.ASSISTANT, __testing.SOURCE.ASSISTANT,
]);
assert.equal(getField(parseFields(chats[0].value), 3, 2).value.toString('utf8'), 'pre');
assert.ok(getField(parseFields(chats[1].value), 6, 2), 'tool_calls stay on their own #6 frame');
assert.equal(getField(parseFields(chats[2].value), 3, 2).value.toString('utf8'), 'post');
});
it('does not merge consecutive image_url user turns', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN,
model: 'm',
env: { DEVIN_CONNECT_IMAGE_TAG: '10' },
messages: [
{ role: 'user', content: [{ type: 'image_url', image_url: { url: `data:image/png;base64,${RED_DOT}` } }] },
{ role: 'user', content: [{ type: 'image_url', image_url: { url: `data:image/png;base64,${RED_DOT}` } }] },
],
});
const chats = getAllFields(parseFields(proto), 3).filter((f) => f.wireType === 2);
assert.equal(chats.length, 2, 'two image turns stay two ChatMessages');
assert.equal(getAllFields(parseFields(chats[0].value), 10).length, 1);
assert.equal(getAllFields(parseFields(chats[1].value), 10).length, 1);
});
it('looks past system turns when judging same-source adjacency', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN,
model: 'm',
messages: [
{ role: 'assistant', content: 'a1' },
{ role: 'system', content: 'mid-conversation system' },
{ role: 'assistant', content: 'a2' },
{ role: 'user', content: 'q' },
],
});
const chats = getAllFields(parseFields(proto), 3).filter((f) => f.wireType === 2);
const sources = chats.map((c) => getField(parseFields(c.value), 2, 0).value);
// system hoists to #2, so the two assistant texts are wire-adjacent and merge.
assert.deepEqual(sources, [__testing.SOURCE.ASSISTANT, __testing.SOURCE.USER]);
assert.equal(getField(parseFields(chats[0].value), 3, 2).value.toString('utf8'), 'a1\n\na2');
});
it('does not mutate the caller messages array', () => {
const messages = [
{ role: 'user', content: 'q1' },
{ role: 'user', content: 'q2' },
];
buildGetChatMessageRequest({ token: TOKEN, model: 'm', messages });
assert.equal(messages.length, 2);
assert.equal(messages[0].content, 'q1');
assert.equal(messages[1].content, 'q2');
});
it('drops empty assistant turns without tool_calls but keeps ones with tool_calls', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN,
model: 'm',
messages: [
{ role: 'user', content: 'hello' },
{ role: 'assistant', content: ' ' },
{ role: 'assistant', content: '', tool_calls: [{ id: 'tc1', name: 'bash', arguments: '{}' }] },
],
});
const chats = getAllFields(parseFields(proto), 3).filter((f) => f.wireType === 2);
// User message + assistant message with tool calls = 2 messages (empty assistant dropped)
assert.equal(chats.length, 2);
});
it('concatenates multiple system turns', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'm',
messages: [
{ role: 'system', content: 'a' },
{ role: 'system', content: 'b' },
{ role: 'user', content: 'x' },
],
});
assert.equal(getField(parseFields(proto), 2, 2).value.toString('utf8'), 'a\nb');
});
it('honours CompletionConfig overrides', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'm',
messages: [{ role: 'user', content: 'x' }],
completion: { maxTokens: 256 },
});
const comp = parseFields(getField(parseFields(proto), 8, 2).value);
assert.equal(getField(comp, 2, 0).value, 256); // #2 = max_tokens
});
it('forwards all sampling controls (temperature/top_p/top_k/max_tokens)', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'm',
messages: [{ role: 'user', content: 'x' }],
completion: { maxTokens: 512, temperature: 0.7, topP: 0.5, topK: 100 },
});
const comp = parseFields(getField(parseFields(proto), 8, 2).value);
assert.equal(getField(comp, 2, 0).value, 512); // max_tokens (#2)
assert.equal(getField(comp, 7, 0).value, 100); // top_k
assert.ok(Math.abs(getField(comp, 5, 1).value.readDoubleLE(0) - 0.7) < 1e-9); // temperature
assert.ok(Math.abs(getField(comp, 8, 1).value.readDoubleLE(0) - 0.5) < 1e-9); // top_p
});
it('clamps temperature=0 to the epsilon floor (upstream rejects exact 0)', () => {
// LIVE-VERIFIED: temperature=0 → upstream "internal error". A caller asking
// for greedy decoding must get the nearest working value, not a hard failure.
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'm',
messages: [{ role: 'user', content: 'x' }],
completion: { temperature: 0 },
});
const comp = parseFields(getField(parseFields(proto), 8, 2).value);
const temp = getField(comp, 5, 1).value.readDoubleLE(0);
assert.ok(temp > 0 && temp <= 0.001, `expected clamped epsilon, got ${temp}`);
});
describe('DEVIN_CONNECT_REPLAY_REASONING probe gate', () => {
const messages = [
{ role: 'user', content: 'user Q' },
{ role: 'assistant', content: 'thought text', reasoning: 'thinking 123' },
{ role: 'assistant', content: '', reasoning_content: 'thinking 456', tool_calls: [{ id: 'tc1', name: 'bash', arguments: '{}' }] },
];
it('gate unset/off: does not emit reasoning tags on assistant turns', () => {
delete process.env.DEVIN_CONNECT_REPLAY_REASONING;
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'm', messages, nativeToolCall: true,
});
const chats = getAllFields(parseFields(proto), 3).filter((f) => f.wireType === 2);
for (const chat of chats) {
const inner = parseFields(chat.value);
assert.ok(!getField(inner, 11, 2), 'no tag #11');
assert.ok(!getField(inner, 9, 2), 'no tag #9');
}
});
it('gate=1: emits tag #11 with reasoning text on assistant turns, user turns clean', () => {
process.env.DEVIN_CONNECT_REPLAY_REASONING = '1';
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'm', messages, nativeToolCall: true,
});
const chats = getAllFields(parseFields(proto), 3).filter((f) => f.wireType === 2);
// chat[0]: user message
const userInner = parseFields(chats[0].value);
assert.equal(getField(userInner, 2, 0).value, 1); // SOURCE.USER
assert.ok(!getField(userInner, 11, 2), 'user turn has no #11');
// chat[1]: assistant text turn with reasoning
const astTextInner = parseFields(chats[1].value);
assert.equal(getField(astTextInner, 2, 0).value, 2); // SOURCE.ASSISTANT
assert.equal(getField(astTextInner, 11, 2).value.toString('utf8'), 'thinking 123');
// chat[2]: assistant native tool call turn with reasoning
const astToolInner = parseFields(chats[2].value);
assert.equal(getField(astToolInner, 2, 0).value, 2); // SOURCE.ASSISTANT
assert.equal(getField(astToolInner, 11, 2).value.toString('utf8'), 'thinking 456');
});
it('gate=9: emits tag #9 for negative control RE probes', () => {
process.env.DEVIN_CONNECT_REPLAY_REASONING = '9';
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'm', messages, nativeToolCall: true,
});
const chats = getAllFields(parseFields(proto), 3).filter((f) => f.wireType === 2);
const astTextInner = parseFields(chats[1].value);
assert.ok(!getField(astTextInner, 11, 2), 'no tag #11 when gate=9');
assert.equal(getField(astTextInner, 9, 2).value.toString('utf8'), 'thinking 123');
});
});
});
describe('decodeFrame', () => {
it('reads the final answer from field #3 (content)', () => {
const payload = Buffer.concat([
writeStringField(1, 'bot-123'),
writeStringField(3, 'the answer'),
writeStringField(9, 'thinking...'),
writeStringField(17, 'uuid'),
]);
const d = decodeFrame(payload);
assert.equal(d.content, 'the answer');
assert.equal(d.reasoning, 'thinking...');
});
it('does not confuse the nested #7.#9 model name with top-level #9 reasoning', () => {
// #7 metadata carries its own #9 (model name); only top-level #9 is reasoning.
const meta = Buffer.concat([writeVarintField(6, 6), writeStringField(9, 'swe-1-6-slow')]);
const payload = Buffer.concat([
writeStringField(1, 'bot-123'),
writeMessageField(7, meta),
]);
const d = decodeFrame(payload);
assert.equal(d.reasoning, '');
assert.equal(d.content, '');
});
it('reads token usage from the terminal #7 metadata frame', () => {
const meta = Buffer.concat([
writeVarintField(2, 386), // prompt_tokens
writeVarintField(3, 48), // completion_tokens
writeVarintField(6, 6),
]);
const payload = Buffer.concat([writeStringField(1, 'bot-1'), writeMessageField(7, meta)]);
const d = decodeFrame(payload);
assert.deepEqual(d.usage, { prompt: 386, completion: 48 });
});
it('omits usage when completion_tokens is absent (non-terminal frame)', () => {
const meta = Buffer.concat([writeVarintField(2, 386), writeVarintField(6, 6)]);
const payload = Buffer.concat([writeStringField(1, 'bot-1'), writeMessageField(7, meta)]);
assert.equal(decodeFrame(payload).usage, null);
});
it('billing is null by default (no tag map configured)', () => {
// The whole groundwork is opt-in: without DEVIN_CONNECT_BILLING_TAGS, even a
// frame that happens to carry billing varints must NOT surface them — zero
// regression on free tier / un-calibrated deployments.
const meta = Buffer.concat([
writeVarintField(2, 386), writeVarintField(3, 48),
writeVarintField(6, 250), // a value that, IF mis-parsed as billing, would show
]);
const payload = Buffer.concat([writeStringField(1, 'bot-1'), writeMessageField(7, meta)]);
assert.equal(decodeFrame(payload).billing, null);
});
it('parses billing varints from the #7 metadata sub-message when tags are pinned', () => {
// Operator calibrated: credit_cost=#10, committed_credit_cost=#11, committed_acu_cost=#12.
const billingTags = { credit_cost: 10, committed_credit_cost: 11, committed_acu_cost: 12 };
const meta = Buffer.concat([
writeVarintField(2, 386), writeVarintField(3, 48),
writeVarintField(10, 1500), // credit_cost
writeVarintField(11, 1400), // committed_credit_cost
writeVarintField(12, 3), // committed_acu_cost
]);
const payload = Buffer.concat([writeStringField(1, 'bot-1'), writeMessageField(7, meta)]);
const d = decodeFrame(payload, { billingTags });
assert.deepEqual(d.billing, { credit_cost: 1500, committed_credit_cost: 1400, committed_acu_cost: 3 });
// usage still decodes alongside billing
assert.deepEqual(d.usage, { prompt: 386, completion: 48 });
});
it('routes cache_*_tokens into usage (not billing) when their tags are pinned', () => {
// cache_read_tokens / cache_write_tokens are ModelUsageStats fields → they
// belong in usage, not billing. Same opt-in tag mechanism as cost fields.
const tags = { cache_read_tokens: 14, cache_write_tokens: 15, credit_cost: 10 };
const meta = Buffer.concat([
writeVarintField(2, 386), writeVarintField(3, 48),
writeVarintField(10, 1500), // credit_cost → billing
writeVarintField(14, 1200), // cache_read_tokens → usage
writeVarintField(15, 64), // cache_write_tokens → usage
]);
const payload = Buffer.concat([writeStringField(1, 'bot-1'), writeMessageField(7, meta)]);
const d = decodeFrame(payload, { billingTags: tags });
assert.deepEqual(d.usage, { prompt: 386, completion: 48, cache_read_tokens: 1200, cache_write_tokens: 64 });
assert.deepEqual(d.billing, { credit_cost: 1500 });
});
it('dumpMeta exposes every metadata varint subfield for tag calibration', () => {
// The DEVIN_CONNECT_DEBUG_META hook: surfaces {tag: value} for every varint
// in the #7 sub-message so an operator can discover unknown tags from a real
// capture. Off unless requested; never affects normal decode output.
const meta = Buffer.concat([
writeVarintField(2, 386), writeVarintField(3, 48), writeVarintField(6, 6),
writeVarintField(14, 1200),
]);
const payload = Buffer.concat([writeStringField(1, 'bot-1'), writeMessageField(7, meta)]);
assert.equal(decodeFrame(payload).metaDump, undefined); // off by default
const d = decodeFrame(payload, { dumpMeta: true });
assert.deepEqual(d.metaDump, { 2: 386, 3: 48, 6: 6, 14: 1200 });
});
it('decodes actual_model_uid from #7.9 (nested in metadata) only when its tag is pinned', () => {
// FRAME-VERIFIED 2026-07-05 (paid opus-4-8): actual_model_uid rides the #7
// metadata sub-message at INNER tag 9, NOT a top-level field. Opt-in via
// DEVIN_CONNECT_ACTUAL_MODEL_TAG (calibrated value = 9).
const meta = Buffer.concat([
writeVarintField(2, 777), // prompt_tokens
writeVarintField(3, 180), // completion_tokens
writeStringField(9, 'claude-opus-4-8-medium'), // actual_model_uid at #7.9
]);
const payload = Buffer.concat([
writeStringField(1, 'bot-1'),
writeMessageField(7, meta),
]);
assert.equal(decodeFrame(payload).actualModel, undefined); // off by default
assert.equal(decodeFrame(payload, { actualModelTag: 9 }).actualModel, 'claude-opus-4-8-medium');
// wrong inner tag → nothing surfaced
assert.equal(decodeFrame(payload, { actualModelTag: 99 }).actualModel, undefined);
});
it('coalesces native tool_call arguments fragmented across frames (#6.3)', () => {
// FRAME-VERIFIED 2026-07-05: one logical call streams as {id,name} then
// id-less argument fragments. Merging must reconstruct the full JSON.
const acc = [];
mergeToolCallFragment(acc, { id: 'toolu_1', name: 'grep_repo' });
mergeToolCallFragment(acc, { arguments: '{"patter' });
mergeToolCallFragment(acc, { arguments: 'n": "DEV' });
mergeToolCallFragment(acc, { arguments: 'IN_CONNECT"}' });
assert.equal(acc.length, 1);
assert.deepEqual(acc[0], { id: 'toolu_1', name: 'grep_repo', arguments: '{"pattern": "DEVIN_CONNECT"}' });
assert.equal(JSON.parse(acc[0].arguments).pattern, 'DEVIN_CONNECT');
});
it('coalesce keeps distinct tool_calls separate (each new id starts a call)', () => {
const acc = [];
mergeToolCallFragment(acc, { id: 'a', name: 'read_file', arguments: '{"p":' });
mergeToolCallFragment(acc, { arguments: '"1"}' });
mergeToolCallFragment(acc, { id: 'b', name: 'grep_repo', arguments: '{"q":"x"}' });
assert.equal(acc.length, 2);
assert.deepEqual(acc[0], { id: 'a', name: 'read_file', arguments: '{"p":"1"}' });
assert.deepEqual(acc[1], { id: 'b', name: 'grep_repo', arguments: '{"q":"x"}' });
});
it('dumpMeta also surfaces top-level frame fields (e.g. actual_model_uid)', () => {
// Top-level string fields like actual_model_uid (the concrete model that
// served a router request) are discoverable via the same hook.
const payload = Buffer.concat([
writeStringField(1, 'bot-1'),
writeStringField(11, 'claude-opus-4-8'), // pretend actual_model_uid at #11
writeVarintField(5, 2), // stop_reason
]);
assert.equal(decodeFrame(payload).frameDump, undefined); // off by default
const d = decodeFrame(payload, { dumpMeta: true });
assert.equal(d.frameDump[11], 'claude-opus-4-8');
assert.equal(d.frameDump[5], 2);
// binary / oversized fields are not stringified into the dump
const big = Buffer.concat([writeStringField(1, 'x'.repeat(100))]);
assert.equal(decodeFrame(big, { dumpMeta: true }).frameDump?.[1], undefined);
});
it('dumpMeta recursively decodes inner fields of non-printable top-level sub-messages (#28 calibration)', () => {
// The recurring #28 trailer is a 186b usage/billing/stop-metadata block the
// flat frameDump could only mark "<msg Nb>". subDump exposes its inner
// {tag: {kind, preview}} so `calibrate:devin` surfaces the guts in one run.
const trailer = Buffer.concat([
writeStringField(1, 'stop'), // inner string → stop-reason / model-id candidate
writeVarintField(3, 1200), // inner varint → billing/usage candidate
writeVarintField(4, 34), // inner varint → billing/usage candidate
]);
const payload = Buffer.concat([writeStringField(1, 'bot-1'), writeMessageField(28, trailer)]);
assert.equal(decodeFrame(payload).subDump, undefined); // off by default
const d = decodeFrame(payload, { dumpMeta: true });
// presence still marked in the flat dump (contract unchanged)
assert.match(String(d.frameDump[28]), /^<msg \d+b>$/);
// inner fields now decoded under subDump keyed by the top-level tag
assert.deepEqual(d.subDump[28][1], { kind: 'string', preview: 'stop' });
assert.deepEqual(d.subDump[28][3], { kind: 'varint', preview: 1200 });
assert.deepEqual(d.subDump[28][4], { kind: 'varint', preview: 34 });
});
it('subDump recurses one level deeper into nested messages (#28.2 Response Statistics counters)', () => {
// PAID-1 2026-07-03 capture: #28 is a "Response Statistics" container whose
// real usage/billing counters live in a NESTED message at #28.2, one level
// below the flat decode. subDump must descend and attach them under `.fields`.
const stats = Buffer.concat([
writeVarintField(3, 1200), // e.g. completion tokens
writeVarintField(4, 34), // e.g. credit_cost
]);
const trailer = Buffer.concat([
writeStringField(1, 'Response Statistics'), // label string
writeMessageField(2, stats), // nested stats message
]);
const payload = Buffer.concat([writeStringField(1, 'bot-1'), writeMessageField(28, trailer)]);
const d = decodeFrame(payload, { dumpMeta: true });
assert.deepEqual(d.subDump[28][1], { kind: 'string', preview: 'Response Statistics' });
// #28.2 marked as a message AND its inner counters decoded under .fields
assert.equal(d.subDump[28][2].kind, 'message');
assert.deepEqual(d.subDump[28][2].fields[3], { kind: 'varint', preview: 1200 });
assert.deepEqual(d.subDump[28][2].fields[4], { kind: 'varint', preview: 34 });
});
it('subDump retains the FULL raw-hex of every inner sub-message (D1: single-capture offline tag recovery)', () => {
// The 48-char preview alone dropped the tail of #28.2's counter block on the
// last capture. Retaining complete raw-hex means one text-only PAID capture is
// enough to reverse ALL inner tags offline — no per-field probe loop.
const stats = Buffer.concat([
writeVarintField(3, 1200),
writeVarintField(4, 34),
]);
const trailer = Buffer.concat([
writeStringField(1, 'Response Statistics'),
writeMessageField(2, stats),
]);
const payload = Buffer.concat([writeStringField(1, 'bot-1'), writeMessageField(28, trailer)]);
const d = decodeFrame(payload, { dumpMeta: true });
// the nested #28.2 message node carries the exact bytes, losslessly
assert.equal(d.subDump[28][2].raw, stats.toString('hex'));
// and the raw round-trips back to the same fields (offline re-decode works)
assert.ok(d.subDump[28][2].raw.length > 0);
assert.equal(Buffer.from(d.subDump[28][2].raw, 'hex').toString('hex'), stats.toString('hex'));
});
it('subDump recursion is depth-capped so a deeply nested / adversarial blob cannot recurse unbounded', () => {
// Build 6 levels of nesting; SUB_DUMP_MAX_DEPTH (4) must stop decoding before
// the deepest, leaving it as a presence-only "<msg Nb>" with no `.fields`.
let buf = Buffer.concat([writeVarintField(1, 7)]);
for (let i = 0; i < 6; i++) buf = Buffer.concat([writeMessageField(2, buf)]);
const payload = Buffer.concat([writeStringField(1, 'bot-1'), writeMessageField(28, buf)]);
const d = decodeFrame(payload, { dumpMeta: true });
// walk down .fields; at some point a message node must lack `.fields` (capped)
let node = d.subDump[28][2];
let depth = 1;
while (node && node.fields && node.fields[2]) { node = node.fields[2]; depth++; }
assert.ok(depth <= 4, `recursion capped at <=4 levels, got ${depth}`);
});
it('subDump skips a sub-message that is not valid protobuf (opaque encrypted blob) without throwing', () => {
// An opaque/encrypted trailer must never crash the hot decode path — it is
// silently left as presence-only in the flat dump.
const opaque = Buffer.from([0xff, 0xff, 0xff, 0x07, 0x80]); // not parseable as fields
const payload = Buffer.concat([writeStringField(1, 'bot-1'), writeMessageField(28, opaque)]);
const d = decodeFrame(payload, { dumpMeta: true });
assert.match(String(d.frameDump[28]), /^<msg \d+b>$/); // presence noted
assert.equal(d.subDump?.[28], undefined); // inner not decoded, no throw
});
it('billing only includes keys whose tags are actually present in the frame', () => {
// A free / partially-billed turn omits zero-valued fields entirely; decode
// must surface only what's on the wire, never invent zeros.
const billingTags = { credit_cost: 10, committed_credit_cost: 11, committed_acu_cost: 12 };
const meta = Buffer.concat([
writeVarintField(2, 386), writeVarintField(3, 48),
writeVarintField(11, 1400), // only committed_credit_cost present
]);
const payload = Buffer.concat([writeStringField(1, 'bot-1'), writeMessageField(7, meta)]);
assert.deepEqual(decodeFrame(payload, { billingTags }).billing, { committed_credit_cost: 1400 });
});
it('parseBillingTagMap: defaults to cache_read_tokens=5 + cache_write_tokens=4, parses pairs, rejects garbage', () => {
const { parseBillingTagMap } = __testing;
// Unset → the calibrated defaults (#220 + 2026-07-25):
// tag 5 = cache_read (confirmed on GPT+Claude paid accounts)
// tag 4 = cache_write (confirmed on Claude paid account — GPT carries no tag 4)
assert.deepEqual(parseBillingTagMap({}), { cache_read_tokens: 5, cache_write_tokens: 4 });
assert.deepEqual(parseBillingTagMap({ DEVIN_CONNECT_BILLING_TAGS: ' ' }), { cache_read_tokens: 5, cache_write_tokens: 4 });
// Explicit opt-out decodes nothing at all.
assert.equal(parseBillingTagMap({ DEVIN_CONNECT_BILLING_TAGS: 'off' }), null);
assert.equal(parseBillingTagMap({ DEVIN_CONNECT_BILLING_TAGS: 'OFF' }), null);
// An explicit map REPLACES the default (no implicit merge).
assert.deepEqual(
parseBillingTagMap({ DEVIN_CONNECT_BILLING_TAGS: 'credit_cost=10' }),
{ credit_cost: 10 },
);
assert.deepEqual(
parseBillingTagMap({ DEVIN_CONNECT_BILLING_TAGS: 'credit_cost=10, committed_acu_cost=12' }),
{ credit_cost: 10, committed_acu_cost: 12 },
);
// unknown key dropped, non-int tag dropped, negative dropped → null (nothing valid)
assert.equal(
parseBillingTagMap({ DEVIN_CONNECT_BILLING_TAGS: 'bogus_key=5,credit_cost=abc,committed_acu_cost=-1' }),
null,
);
// a typo'd tag is skipped but valid siblings survive
assert.deepEqual(
parseBillingTagMap({ DEVIN_CONNECT_BILLING_TAGS: 'credit_cost=10,committed_credit_cost=xx' }),
{ credit_cost: 10 },
);
});
it('reads the finish signal from field #5', () => {
const payload = Buffer.concat([writeStringField(1, 'bot-1'), writeVarintField(5, 2)]);
assert.equal(decodeFrame(payload).finish, 2);
});
it('returns empties for a metadata-only frame', () => {
const payload = Buffer.concat([
writeStringField(1, 'bot-123'),
writeMessageField(7, writeVarintField(6, 6)),
]);
const d = decodeFrame(payload);
assert.equal(d.content, '');
assert.equal(d.reasoning, '');
assert.equal(d.finish, null);
assert.equal(d.usage, null);
});
it('reads credit_cost from the TOP level when the tag is declared with ^', () => {
// Four independent .proto reimplementations put credit_cost at top-level #14
// (not in the #7 metadata sub-message where every calibrated tag so far lived).
// `^14` in DEVIN_CONNECT_BILLING_TAGS means "top level", so a paid capture that
// confirms the coordinate can wire it without a second env var. A frame with
// #14 and NO #7 sub-message is the exact shape the top-level pass exists for.
const payload = Buffer.concat([
writeStringField(1, 'bot-1'),
writeStringField(3, 'the answer'),
writeVarintField(14, 12345), // credit_cost, top-level
]);
const d = decodeFrame(payload, { billingTags: { credit_cost: -14 } });
assert.equal(d.billing.credit_cost, 12345);
});
it('does not let a top-level cache-token tag leak into billing (usage stays usage)', () => {
// A cache_read_tokens tag pinned at the top level would, without the guard,
// land in `billing` instead of `usage`, silently zeroing the dashboard's cache
// split. The usage vs billing routing must follow the KEY, not the location.
const payload = Buffer.concat([
writeStringField(1, 'bot-1'),
writeVarintField(14, 4096), // cache_read_tokens pinned top-level for the test
]);
const d = decodeFrame(payload, { billingTags: { cache_read_tokens: -14 } });
assert.equal(d.usage.cache_read_tokens, 4096, 'token counts must stay usage');
assert.equal(d.billing?.cache_read_tokens, undefined,
'a token count must not surface as a billing field');
});
});
describe('decodeFrame malformed-frame resilience (FRAME-1)', () => {
// A malformed upstream frame must degrade to an empty delta, never throw:
// decodeFrame runs inside res.on('data'), so a synchronous throw there escapes
// the streamChat generator's try/finally → uncaughtException → process.exit(1),
// taking down every concurrent tenant over one bad frame.
const EMPTY = { content: '', reasoning: '', finish: null, usage: null, billing: null };
it('returns an empty delta (no throw) on an unknown wire type at the top level', () => {
// wire type 7 is illegal; parseFields throws "Unknown wire type 7".
// tag = (field<<3)|7 = (1<<3)|7 = 15.
const payload = Buffer.from([0x0f]);
let d;
assert.doesNotThrow(() => { d = decodeFrame(payload); });
assert.deepEqual(d, EMPTY);
});
it('returns an empty delta (no throw) on a truncated varint at the top level', () => {
// tag byte says field #1 varint (0x08), then a varint with the continuation
// bit set but no following byte → "Truncated varint".
const payload = Buffer.from([0x08, 0x80]);
let d;
assert.doesNotThrow(() => { d = decodeFrame(payload); });
assert.deepEqual(d, EMPTY);
});
it('returns an empty delta (no throw) on a truncated length-delimited field', () => {
// field #3 (content), wire type 2 → tag 0x1a; declared length 10 but only 3
// bytes follow → "truncated len-delim field".
const payload = Buffer.concat([Buffer.from([0x1a, 0x0a]), Buffer.from('abc')]);
let d;
assert.doesNotThrow(() => { d = decodeFrame(payload); });
assert.deepEqual(d, EMPTY);
});
it('does not throw when the #7 metadata sub-message body is malformed protobuf', () => {
// Outer frame parses fine, but the length-delimited #7 payload is itself an
// illegal wire type (7) → the nested parseFields(meta.value) would throw.
// Content still decodes; usage degrades to null.
const payload = Buffer.concat([
writeStringField(3, 'hello'),
writeMessageField(7, Buffer.from([0x0f])),
]);
let d;
assert.doesNotThrow(() => { d = decodeFrame(payload); });
assert.equal(d.content, 'hello');
assert.equal(d.usage, null);
assert.equal(d.billing, null);
});
it('processes valid fields following the same rules (well-formed frame unaffected)', () => {
// Regression guard: the try/catch must not swallow good frames.
const payload = Buffer.concat([writeStringField(3, 'ok'), writeVarintField(5, 2)]);
const d = decodeFrame(payload);
assert.equal(d.content, 'ok');
assert.equal(d.finish, 2);
});
});
describe('mapFinishReason', () => {
it('maps the live-anchored stop enum (2) to "stop"', () => {
assert.equal(mapFinishReason(2), 'stop');
});
it('returns null when no finish signal was seen', () => {
assert.equal(mapFinishReason(null), null);
});
it('maps the descriptor-pinned 3 and 5 to "length"', () => {
// These were name-order guesses when the only evidence was the variant
// NAMES. The binary descriptor set now pins the integers themselves:
// 3 = MAX_TOKENS, 5 = MAX_NEWLINES — both are limit cuts, i.e. 'length'.
// (4 stays 'stop': the paid 2026-07-27 capture is a stronger authority for
// that value than the MIN_LOG_PROB name.)
assert.equal(mapFinishReason(3), 'length');
assert.equal(mapFinishReason(5), 'length');
});
it('maps 4 to "stop" — paid capture overturned the name-order guess', () => {
// 4 was guessed as max_turn_requests→'length' from the protobuf variant NAME
// order. Calibrated 2026-07-27 on a paid teams account: three probes with
// max_tokens 300 / 8 / 40 all returned 4, and the max_tokens=300 one answered
// "HI" (2 chars, unambiguously complete). Mapping it to 'length' made EVERY
// complete paid response read as truncated — finish_reason='length' on
// /v1/chat/completions and status='incomplete' on /v1/responses.
assert.equal(mapFinishReason(4), 'stop');
});
it('handles BigInt finish values (proto varints decode as BigInt)', () => {
assert.equal(mapFinishReason(2n), 'stop');
// A BigInt must resolve through the same table as its Number twin — the Number
// conversion is what makes the map lookup hit at all.
assert.equal(mapFinishReason(3n), mapFinishReason(3));
assert.equal(mapFinishReason(7n, { DEVIN_CONNECT_STOP_REASON_MAP: '7=length' }), 'length');
});
it('falls back to "stop" for unknown values (never an error)', () => {
assert.equal(mapFinishReason(99), 'stop');
});
it('honors DEVIN_CONNECT_STOP_REASON_MAP override (calibrated capture)', () => {
const env = { DEVIN_CONNECT_STOP_REASON_MAP: '3=stop,7=length,8=content_filter' };
assert.equal(mapFinishReason(3, env), 'stop'); // overridden from default 'length'
assert.equal(mapFinishReason(7, env), 'length');
assert.equal(mapFinishReason(8, env), 'content_filter');
assert.equal(mapFinishReason(2, env), 'stop'); // anchor still holds
// An operator WITH a real capture can restore 'length' for 3.
assert.equal(mapFinishReason(3, { DEVIN_CONNECT_STOP_REASON_MAP: '3=length' }), 'length');
// garbage in the override is ignored, defaults survive
const env2 = { DEVIN_CONNECT_STOP_REASON_MAP: '3=bogus,xx=length' };
assert.equal(mapFinishReason(3, env2), 'length'); // bad value ignored → descriptor default
});
});
describe('resolveFinishReason — truncation from usage, not from the un-calibrated enum', () => {
it('reports "length" when completion_tokens lands exactly on the requested cap', () => {
assert.equal(resolveFinishReason(2, { completion_tokens: 64 }, 64), 'length');
});
it('reports "stop" for a complete answer well under the cap', () => {
// The regression that made v3.9.0 unusable in reverse: a 12-token answer under
// a 4096 cap is complete, and must never read as truncated.
assert.equal(resolveFinishReason(4, { completion_tokens: 12 }, 4096), 'stop');
});
it('reports "stop" when the caller set no cap at all', () => {
// Nothing to compare against → no truncation claim. Covers the common case of a
// client that never sends max_tokens.
assert.equal(resolveFinishReason(2, { completion_tokens: 4096 }, null), 'stop');
assert.equal(resolveFinishReason(2, { completion_tokens: 4096 }, undefined), 'stop');
assert.equal(resolveFinishReason(2, { completion_tokens: 4096 }, 0), 'stop');
});
it('reports "stop" when usage is missing entirely', () => {
// Free-tier / un-instrumented turns carry no usage block; absence of evidence
// must not become evidence of truncation.
assert.equal(resolveFinishReason(2, null, 100), 'stop');
assert.equal(resolveFinishReason(2, {}, 100), 'stop');
});
it('never overwrites a stronger signal than "stop"', () => {
// tool_calls / content_filter say something specific about what the turn did.
// Only a clean stop is eligible for the truncation upgrade.
const env = { DEVIN_CONNECT_STOP_REASON_MAP: '9=tool_calls,10=content_filter' };
assert.equal(resolveFinishReason(9, { completion_tokens: 50 }, 50, env), 'tool_calls');
assert.equal(resolveFinishReason(10, { completion_tokens: 50 }, 50, env), 'content_filter');
});
it('an operator override for that value wins over the inference', () => {
// Someone who captured the real integers is the better authority: with 2 pinned
// to 'stop' explicitly, a cap-equal turn stays 'stop'.
const env = { DEVIN_CONNECT_STOP_REASON_MAP: '2=stop' };
assert.equal(resolveFinishReason(2, { completion_tokens: 30 }, 30, env), 'stop');
});
it('an UNRELATED override does not disable the inference for other values', () => {
// Found by adversarial review of the first cut. The override test used
// `Object.hasOwn(map, n)` against the merged table, but the defaults already
// cover 0..6 — so pinning any single unrelated value made EVERY value read as
// "operator-calibrated" and silently switched the usage inference off wholesale.
// An operator pinning 7 has said nothing at all about 2 or 4.
const env = { DEVIN_CONNECT_STOP_REASON_MAP: '7=length' };
assert.equal(resolveFinishReason(2, { completion_tokens: 64 }, 64, env), 'length');
assert.equal(resolveFinishReason(4, { completion_tokens: 64 }, 64, env), 'length');
// Same for the BigInt form the wire actually decodes to.
assert.equal(resolveFinishReason(2n, { completion_tokens: 64 }, 64, env), 'length');
// And the pinned value itself still maps as the operator asked.
assert.equal(resolveFinishReason(7, { completion_tokens: 5 }, 4096, env), 'length');
});
it('passes a null finish through as null (no finish signal seen)', () => {
assert.equal(resolveFinishReason(null, { completion_tokens: 30 }, 30), null);
});
it('tolerates a string cap (max_tokens arriving as JSON text)', () => {
assert.equal(resolveFinishReason(2, { completion_tokens: 16 }, '16'), 'length');
});
});
describe('classifyUpstreamError', () => {
it('maps a free-tier /upgrade rejection to MODEL_BLOCKED', () => {
const r = classifyUpstreamError('Please /upgrade to access claude-opus-4-8');
assert.equal(r.code, 'MODEL_BLOCKED');
});
it('maps "upgrade to access" prose to MODEL_BLOCKED', () => {
assert.equal(classifyUpstreamError('You must upgrade to access this model').code, 'MODEL_BLOCKED');
});
it('maps insufficient credit/quota to QUOTA_EXHAUSTED (account dry-well, not a tier wall)', () => {
// Distinct from MODEL_BLOCKED: this account ran out of balance and must be
// cooled down, not treated as a healthy free account hitting a paid model.
assert.equal(classifyUpstreamError('insufficient credits remaining').code, 'QUOTA_EXHAUSTED');
assert.equal(classifyUpstreamError('Your account quota has been exceeded').code, 'QUOTA_EXHAUSTED');
assert.equal(classifyUpstreamError('credit exhausted for this billing cycle').code, 'QUOTA_EXHAUSTED');
});
it('maps the LIVE "daily usage quota has been exhausted" body to QUOTA_EXHAUSTED', () => {
// Exact live shape (2026-10-22, Pro account, daily bucket dry), carried on gRPC
// code `failed_precondition`. Before `exhausted` was in the arm this matched
// NOTHING, fell through to the verbatim passthrough, and became
// `failed_precondition` — rendered as HTTP 502 `upstream_error`, absent from
// isAccountFailoverError (no cross-account failover), and present in
// TRANSPORT_FAULT_CODES (charged the internal-error breaker).
const live = 'Your daily usage quota has been exhausted. Visit '
+ 'https://app.devin.ai/settings/usage to review your plan and usage. (trace ID: 6f1c9a2e)';
const r = classifyUpstreamError(live, 'failed_precondition', 400);
assert.equal(r.code, 'QUOTA_EXHAUSTED');
assert.equal(r.message, live, 'the raw body is preserved for the client/log');
// Same account state, different upstream wording.
assert.equal(classifyUpstreamError('Your weekly usage quota has been exhausted.').code, 'QUOTA_EXHAUSTED');
assert.equal(classifyUpstreamError('Your on-demand usage has been exhausted').code, 'QUOTA_EXHAUSTED');
assert.equal(classifyUpstreamError('on-demand balance exhausted').code, 'QUOTA_EXHAUSTED');
assert.equal(classifyUpstreamError('You are running out of credits').code, 'QUOTA_EXHAUSTED');
assert.equal(classifyUpstreamError('quota depleted', 'insufficient_quota').code, 'QUOTA_EXHAUSTED');
});
it('keeps capacity / tier-wall / rate-limit bodies out of the quota arm', () => {
// Widening the quota regex must not swallow the narrower classes that were
// already ordered ahead of it.
assert.equal(classifyUpstreamError('We are facing high demand for this model. Please try again later.').code, 'CAPACITY');
assert.equal(classifyUpstreamError('Please /upgrade to access this model').code, 'MODEL_BLOCKED');
assert.equal(classifyUpstreamError('Reached message rate limit for this model. Resets in: 3h0m0s').code, 'RATE_LIMITED');
assert.equal(classifyUpstreamError('blocked by our content policy').code, 'CONTENT_BLOCKED');
});
it('still maps a paid-entitlement /upgrade wall to MODEL_BLOCKED (no penalty)', () => {
assert.equal(classifyUpstreamError('insufficient entitlement for this model').code, 'MODEL_BLOCKED');
assert.equal(classifyUpstreamError('this model requires a paid plan').code, 'MODEL_BLOCKED');
});
it('maps HTTP 401 to UNAUTHORIZED', () => {
assert.equal(classifyUpstreamError('', null, 401).code, 'UNAUTHORIZED');
});
it('maps permission_denied code to UNAUTHORIZED', () => {
assert.equal(classifyUpstreamError('nope', 'permission_denied').code, 'UNAUTHORIZED');
});
it('maps HTTP 429 to RATE_LIMITED', () => {
assert.equal(classifyUpstreamError('', null, 429).code, 'RATE_LIMITED');
});
it('maps resource_exhausted text to RATE_LIMITED', () => {
assert.equal(classifyUpstreamError('resource_exhausted: too many requests').code, 'RATE_LIMITED');
});
it('falls back to the upstream code, else UPSTREAM_ERROR', () => {
assert.equal(classifyUpstreamError('boom', 'weird_code').code, 'weird_code');
assert.equal(classifyUpstreamError('boom').code, 'UPSTREAM_ERROR');
});
it('prefers MODEL_BLOCKED even on a non-200 status', () => {
// an /upgrade message returned with a 403 is still an entitlement issue
assert.equal(classifyUpstreamError('/upgrade required', null, 403).code, 'MODEL_BLOCKED');
});
it('classifies high-demand capacity throttling as CAPACITY, NOT UNAUTHORIZED (P0 #56)', () => {
// LIVE-OBSERVED: the upstream wraps a transient "model is busy" in a 401/403
// auth-shell: HTTP 401 body "We're currently facing high demand for this
// model. Please try again later." Misreading it as UNAUTHORIZED triggers an
// auto re-login → fresh token is STILL busy → second UNAUTHORIZED gets
// mislabeled MODEL_BLOCKED → the free model is cooled down forever over a
// retryable hiccup. CAPACITY must win even with a 401/403 status.
assert.equal(classifyUpstreamError("We're currently facing high demand for this model. Please try again later.", null, 401).code, 'CAPACITY');
assert.equal(classifyUpstreamError("We're currently facing high demand for this model. Please try again later.", null, 403).code, 'CAPACITY');
assert.equal(classifyUpstreamError('the model is currently overloaded', null, 503).code, 'CAPACITY');
assert.equal(classifyUpstreamError('server is busy, try again later').code, 'CAPACITY');
assert.equal(classifyUpstreamError('model is busy').code, 'CAPACITY');
});
it('does NOT let a real auth failure read as CAPACITY', () => {
// permission_denied / invalid token with no capacity wording stays UNAUTHORIZED
assert.equal(classifyUpstreamError('permission_denied', 'permission_denied').code, 'UNAUTHORIZED');
assert.equal(classifyUpstreamError('invalid session token', null, 401).code, 'UNAUTHORIZED');
});
it('rel-01: an explicit HTTP 429 wins over capacity-ish body text → RATE_LIMITED, not CAPACITY', () => {
// The bug: a 429 whose body contains "try again later" / "capacity" / "overloaded"
// used to hit the text-based CAPACITY branch first (retryable + 60s cooldown), so
// the pool retried straight back into a real rate limit. An explicit 429 status is
// an authoritative account-scoped throttle → RATE_LIMITED (non-retryable).
assert.equal(classifyUpstreamError('Please try again later.', null, 429).code, 'RATE_LIMITED');
assert.equal(classifyUpstreamError('the model is currently overloaded', null, 429).code, 'RATE_LIMITED');
assert.equal(classifyUpstreamError('high demand, try again later', null, 429).code, 'RATE_LIMITED');
// gRPC resource_exhausted code is the same authoritative signal.
assert.equal(classifyUpstreamError('capacity', 'resource_exhausted').code, 'RATE_LIMITED');
});
it('rel-01: capacity text WITHOUT a 429 still reads as CAPACITY (401/403/503 shell unchanged)', () => {
// The rel-01 fix must NOT over-reach: the live-observed "high demand" blip
// arrives in a 401/403/503 shell (NOT 429) and must stay retryable CAPACITY.
assert.equal(classifyUpstreamError("We're currently facing high demand for this model. Please try again later.", null, 401).code, 'CAPACITY');
assert.equal(classifyUpstreamError('the model is currently overloaded', null, 503).code, 'CAPACITY');
assert.equal(classifyUpstreamError('server is busy, try again later').code, 'CAPACITY');
});
it('rel-01: hard "Resets in: 3h" rate limit still parses its window (matched before the 429 guard)', () => {
// The explicit-reset branch runs before the new bare-429 guard, so a body with a
// Go-duration reset window keeps producing resetMs for the real cooldown.
const r = classifyUpstreamError('Reached message rate limit for this model. Please try again later. Resets in: 3h0m0s', null, 429);
assert.equal(r.code, 'RATE_LIMITED');
assert.equal(r.resetMs, 3 * 60 * 60 * 1000);
});
});
describe('streamChat abort / preconditions', () => {
it('throws AbortError when the signal is already aborted (no network leak)', async () => {
const ac = new AbortController();
ac.abort();
await assert.rejects(
(async () => {
for await (const _ of streamChat({
messages: [{ role: 'user', content: 'hi' }],
model: 'swe-1-6-slow',
token: 'devin-session-token$fake.jwt.sig',
signal: ac.signal,
})) { /* drain */ }
})(),
(err) => err.name === 'AbortError' || err.code === 'ABORT_ERR',
);
});
it('throws NO_TOKEN before any network attempt when token is missing', async () => {
await assert.rejects(
(async () => {
for await (const _ of streamChat({ messages: [], model: 'm', env: {} })) { /* drain */ }
})(),
(err) => err.code === 'NO_TOKEN',
);
});
it('fires the absolute deadline against a hung-but-silent upstream (idle timer would never catch a trickle)', async () => {
// Fake transport: accepts the request, never invokes the response callback,
// never emits data — i.e. a socket that connected and then hung. The idle
// timer is long; only the absolute deadline can end this.
let destroyed = false;
__setRequestImpl(() => {
const req = {
destroyed: false,
on() { return req; },
setTimeout() { return req; }, // swallow the idle timer (never fires)
write() {},
end() {},
destroy() { destroyed = true; req.destroyed = true; },
};
return req;
});
try {
const t0 = Date.now();
await assert.rejects(
(async () => {
for await (const _ of streamChat({
messages: [{ role: 'user', content: 'hi' }],
model: 'swe-1-6-slow',
token: 'devin-session-token$fake.jwt.sig',
timeoutMs: 60000, // idle timer far away
deadlineMs: 50, // absolute deadline must fire first
})) { /* drain */ }
})(),
// audit flaw 1: the absolute deadline throws its OWN code
// (DEADLINE_EXCEEDED, non-retryable), distinct from the idle-silence
// 'TIMEOUT' (retryable) — so a hung-full-window upstream is surfaced
// immediately instead of replayed for another ~600s.
(err) => err.code === 'DEADLINE_EXCEEDED' && /deadline/.test(err.message),
);
assert.ok(Date.now() - t0 < 5000, 'ended promptly via the absolute deadline');
assert.equal(destroyed, true, 'destroyed the hung request');
} finally {
__setRequestImpl(null);
}
});
});
describe('wire-01: multi-byte UTF-8 split across frames', () => {
afterEach(() => __setRequestImpl(null));
// Build a raw protobuf `content` field (#3, wire type 2) from ARBITRARY bytes —
// used to place HALF of a multi-byte UTF-8 sequence in one frame. writeStringField
// can't do this (it takes a JS string, which can't hold a lone continuation byte).
function rawContentField(bytes) {
const len = [];
let n = bytes.length;
do { let b = n & 0x7f; n >>>= 7; if (n) b |= 0x80; len.push(b); } while (n);
return Buffer.concat([Buffer.from([0x1a]), Buffer.from(len), Buffer.from(bytes)]);
}
async function drainContent() {
let text = '';
for await (const ev of streamChat({
messages: [{ role: 'user', content: 'hi' }],
model: 'swe-1-6-slow',
token: TOKEN,
})) {
if (ev.type === 'content') text += ev.text;
}
return text;
}
it('reassembles a Chinese char whose 3 UTF-8 bytes straddle two frames (no U+FFFD)', async () => {
// '你' = E4 BD A0. Put E4 in frame 1, BD A0 in frame 2. Per-frame toString('utf8')
// would yield '�' + '��'; the StringDecoder holds E4 until BD A0.
const full = Buffer.from('你好世界', 'utf8');
const cut = 1; // split after the first byte of '你'
__setRequestImpl(mkTransport([full.subarray(0, cut), full.subarray(cut)]));
const text = await drainContent();
assert.equal(text, '你好世界');
assert.ok(!text.includes('�'), 'no replacement chars');
});
it('reassembles an emoji (4-byte) split mid-sequence', async () => {
const full = Buffer.from('🚀ok', 'utf8'); // F0 9F 9A 80 6F 6B
__setRequestImpl(mkTransport([full.subarray(0, 2), full.subarray(2)]));
const text = await drainContent();
assert.equal(text, '🚀ok');
});
it('a whole char in one frame is unaffected (regression guard)', async () => {
__setRequestImpl(mkTransport([Buffer.from('中文', 'utf8')]));
assert.equal(await drainContent(), '中文');
});
// Transport builder shared by the cases above. streamChat calls
// requestImpl(opts, cb) and expects cb(res) with a streaming response.
function mkTransport(byteChunks) {
return (_opts, cb) => {
const req = { on() { return req; }, setTimeout() { return req; }, write() {}, end() {}, destroy() {} };
const res = new EventEmitter();
res.statusCode = 200;
if (cb) cb(res);
queueMicrotask(() => {
for (const b of byteChunks) res.emit('data', wrapEnvelope(rawContentField(b), { compress: false }));
res.emit('data', endOfStreamEnvelope());
res.emit('end');
});
return req;
};
}
});
describe('isRetryable', () => {
it('retries transient network codes', () => {
for (const code of ['ECONNRESET', 'ETIMEDOUT', 'TIMEOUT', 'EPIPE']) {
assert.equal(isRetryable({ code }), true, code);
}
});
it('retries idle TIMEOUT but NOT DEADLINE_EXCEEDED (audit flaw 1)', () => {
// Idle timeout (120s of silence) is often a transient upstream stall → a
// same-token replay is worth it, so 'TIMEOUT' is retryable.
assert.equal(isRetryable({ code: 'TIMEOUT' }), true);
// Absolute wall-clock deadline (upstream hung the full 600s window) has its
// OWN code and is deliberately NOT retryable — a replay would run another
// full idle+deadline cycle against the same stuck upstream (~2× wall-clock,
// ~1200s) and almost always fail again. Surface immediately instead.
assert.equal(isRetryable({ code: 'DEADLINE_EXCEEDED' }), false);
});
it('retries server "unavailable" but NOT RATE_LIMITED or internal', () => {
assert.equal(isRetryable({ code: 'unavailable' }), true);
// RATE_LIMITED: in-process retry would triple load on a throttled upstream
// before the pool cooldown applies — let cooldown + failover handle it.
assert.equal(isRetryable({ code: 'RATE_LIMITED' }), false);
// internal: upstream returns it for PERMANENT client mistakes (bad
// fingerprint / gzipped body) — retrying just burns attempts.
assert.equal(isRetryable({ code: 'internal' }), false);
});
it('retries CAPACITY even though it arrives with a 401/403 status (P0 #56)', () => {
// CAPACITY is "model busy, try again" — transient. The code is checked before
// the status, so a 401/403-shelled capacity error is still retried in place
// (same token) instead of triggering re-login.
assert.equal(isRetryable({ code: 'CAPACITY' }), true);
assert.equal(isRetryable({ code: 'CAPACITY', status: 401 }), true);
assert.equal(isRetryable({ code: 'CAPACITY', status: 403 }), true);
});
it('retries HTTP 5xx (except 501) and not 4xx', () => {
assert.equal(isRetryable({ status: 500 }), true);
assert.equal(isRetryable({ status: 503 }), true);
assert.equal(isRetryable({ status: 501 }), false);
assert.equal(isRetryable({ status: 429 }), false); // status-only 429: code path handles it
assert.equal(isRetryable({ status: 400 }), false);
});
it('does not retry terminal codes', () => {
assert.equal(isRetryable({ code: 'MODEL_BLOCKED' }), false);
assert.equal(isRetryable({ code: 'QUOTA_EXHAUSTED' }), false);
assert.equal(isRetryable({ code: 'UNAUTHORIZED' }), false);
assert.equal(isRetryable(null), false);
});
});
const RED_DOT = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==';
describe('getImageFieldTag (vision gate)', () => {
it('defaults to the wire-verified #10 tag when unset', () => {
assert.equal(getImageFieldTag({}), 10);
});
it('parses a positive integer tag', () => {
assert.equal(getImageFieldTag({ DEVIN_CONNECT_IMAGE_TAG: '6' }), 6);
});
it('rejects non-numeric / non-positive / out-of-range values (→ 0)', () => {
assert.equal(getImageFieldTag({ DEVIN_CONNECT_IMAGE_TAG: 'abc' }), 0);
assert.equal(getImageFieldTag({ DEVIN_CONNECT_IMAGE_TAG: '0' }), 0);
assert.equal(getImageFieldTag({ DEVIN_CONNECT_IMAGE_TAG: '-3' }), 0);
assert.equal(getImageFieldTag({ DEVIN_CONNECT_IMAGE_TAG: '999999999' }), 0);
});
});
describe('buildGetChatMessageRequest — collapse system messages', () => {
const cmsOf = (proto) => getAllFields(parseFields(proto), 3).map(f => parseFields(f.value));
const roleOf = (cm) => Number(getField(cm, 2, 0)?.value);
const textOf = (cm) => getField(cm, 3, 2)?.value.toString('utf8') || '';
it('defaults off: system remains field #2 and user text is unchanged', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN,
model: 'm',
messages: [{ role: 'system', content: 'SYSTEM' }, { role: 'user', content: 'hello' }],
env: {},
});
assert.equal(getField(parseFields(proto), 2, 2).value.toString('utf8'), 'SYSTEM');
assert.deepEqual(cmsOf(proto).map(textOf), ['hello']);
});
it('enabled: multiple system messages are wrapped and prepended to the next user turn', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN,
model: 'm',
messages: [
{ role: 'system', content: 'FIRST' },
{ role: 'system', content: 'SECOND' },
{ role: 'user', content: 'hello' },
],
env: { DEVIN_CONNECT_COLLAPSE_SYSTEM: '1' },
});
assert.equal(getField(parseFields(proto), 2, 2).value.toString('utf8'), '');
assert.equal(textOf(cmsOf(proto)[0]), '<system>\nFIRST\n\nSECOND\n</system>\nhello');
});
it('enabled + tools: field #2 keeps only the existing benign tools placeholder', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN,
model: 'claude-opus-4-8-medium',
messages: [{ role: 'system', content: 'BRAND-SENSITIVE' }, { role: 'user', content: 'hello' }],
tools: [{ type: 'function', function: { name: 'read', parameters: { type: 'object' } } }],
env: { DEVIN_CONNECT_COLLAPSE_SYSTEM: '1' },
});
const fields = parseFields(proto);
const system = getField(fields, 2, 2).value.toString('utf8');
assert.match(system, /helpful assistant/i);
assert.doesNotMatch(system, /BRAND-SENSITIVE/);
assert.match(textOf(cmsOf(proto)[0]), /BRAND-SENSITIVE/);
});
it('system followed by an image user stays one source=USER message with image #10', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN,
model: 'swe-1-7',
messages: [{ role: 'system', content: 'VISION SYSTEM' }, {
role: 'user',
content: [
{ type: 'text', text: 'what is this?' },
{ type: 'image_url', image_url: { url: `data:image/png;base64,${RED_DOT}` } },
],
}],
env: { DEVIN_CONNECT_COLLAPSE_SYSTEM: '1', DEVIN_CONNECT_IMAGE_TAG: '10' },
});
const [user] = cmsOf(proto);
assert.equal(roleOf(user), 1);
assert.equal(textOf(user), '<system>\nVISION SYSTEM\n</system>\nwhat is this?');
assert.equal(getAllFields(user, 10).length, 1);
assert.equal(getField(user, 6, 2), null, 'no synthetic assistant tool call');
});
it('assistant history does not consume a pending system block', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN,
model: 'm',
messages: [
{ role: 'system', content: 'FOR NEXT USER' },
{ role: 'assistant', content: 'old answer' },
{ role: 'user', content: 'new question' },
],
env: { DEVIN_CONNECT_COLLAPSE_SYSTEM: '1' },
});
const messages = cmsOf(proto);
assert.equal(roleOf(messages[0]), 2);
assert.equal(textOf(messages[0]), 'old answer');
assert.equal(roleOf(messages[1]), 1);
assert.equal(textOf(messages[1]), '<system>\nFOR NEXT USER\n</system>\nnew question');
});
it('does not merge users across a mid-conversation system when collapse is on', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN,
model: 'm',
messages: [
{ role: 'user', content: 'q1' },
{ role: 'system', content: 'MID' },
{ role: 'user', content: 'q2' },
],
env: { DEVIN_CONNECT_COLLAPSE_SYSTEM: '1' },
});
assert.deepEqual(cmsOf(proto).map(textOf), [
'q1',
'<system>\nMID\n</system>\nq2',
]);
});
it('trailing system content becomes a final synthetic user turn', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN,
model: 'm',
messages: [{ role: 'user', content: 'hello' }, { role: 'system', content: 'TRAILING' }],
env: { DEVIN_CONNECT_COLLAPSE_SYSTEM: '1' },
});
assert.deepEqual(cmsOf(proto).map(textOf), ['hello', '<system>\nTRAILING\n</system>']);
});
it('continuityTrail follows the collapsed system content instead of leaking back into field #2', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN,
model: 'm',
messages: [{ role: 'system', content: 'SYSTEM' }, { role: 'user', content: 'hello' }],
continuityTrail: '\n\n[Continuity checkpoint]\nprior\n[End]',
env: { DEVIN_CONNECT_COLLAPSE_SYSTEM: '1' },
});
assert.equal(getField(parseFields(proto), 2, 2).value.toString('utf8'), '');
const userText = textOf(cmsOf(proto)[0]);
assert.match(userText, /SYSTEM/);
assert.match(userText, /Continuity checkpoint/);
assert.ok(userText.indexOf('SYSTEM') < userText.indexOf('Continuity checkpoint'));
});
});
describe('getToolDefTags (native tool-def gate)', () => {
it('returns null (disabled → prompt emulation) when unset', () => {
assert.equal(getToolDefTags({}), null);
assert.equal(getToolDefTags({ DEVIN_CONNECT_TOOL_DEF_TAGS: ' ' }), null);
});
it('parses a 4-tuple "outer,name,description,schema" (parameters is the primary key, schema kept as back-compat alias)', () => {
assert.deepEqual(
getToolDefTags({ DEVIN_CONNECT_TOOL_DEF_TAGS: '10,1,2,3' }),
{ outer: 10, name: 1, description: 2, parameters: 3, schema: 3 },
);
});
it('key=val form: outer defaults to the VFB #10 when omitted', () => {
assert.deepEqual(
getToolDefTags({ DEVIN_CONNECT_TOOL_DEF_TAGS: 'name=1,description=2,parameters=3' }),
{ outer: 10, name: 1, description: 2, parameters: 3, schema: 3 },
);
});
it('key=val form: strict is optional and only kept when a valid tag is given', () => {
const withStrict = getToolDefTags({ DEVIN_CONNECT_TOOL_DEF_TAGS: 'name=1,description=2,parameters=3,strict=6' });
assert.equal(withStrict.strict, 6);
const noStrict = getToolDefTags({ DEVIN_CONNECT_TOOL_DEF_TAGS: 'name=1,description=2,parameters=3' });
assert.equal(noStrict.strict, undefined);
});
it('rejects Devin-proprietary keys (custom_tool/defer_loading) silently — they are never emitted', () => {
// A stray proprietary key must not break the gate; it is ignored, and the
// mandatory trio still resolves.
const t = getToolDefTags({ DEVIN_CONNECT_TOOL_DEF_TAGS: 'name=1,description=2,parameters=3,custom_tool=4,defer_loading=5' });
assert.deepEqual(t, { outer: 10, name: 1, description: 2, parameters: 3, schema: 3 });
});
it('key=val form fails closed when a mandatory inner tag is missing', () => {
assert.equal(getToolDefTags({ DEVIN_CONNECT_TOOL_DEF_TAGS: 'name=1,description=2' }), null); // no parameters
assert.equal(getToolDefTags({ DEVIN_CONNECT_TOOL_DEF_TAGS: 'outer=10,name=1' }), null);
});
it('fails closed (→ null) on wrong arity or garbage', () => {
assert.equal(getToolDefTags({ DEVIN_CONNECT_TOOL_DEF_TAGS: '10,1,2' }), null);
assert.equal(getToolDefTags({ DEVIN_CONNECT_TOOL_DEF_TAGS: '10,1,2,3,4' }), null);
assert.equal(getToolDefTags({ DEVIN_CONNECT_TOOL_DEF_TAGS: '10,1,x,3' }), null);
assert.equal(getToolDefTags({ DEVIN_CONNECT_TOOL_DEF_TAGS: '0,1,2,3' }), null);
});
});
describe('native tool defs in the request (gated)', () => {
const TOOLS = [{
type: 'function',
function: { name: 'get_weather', description: 'Get weather', parameters: { type: 'object', properties: { city: { type: 'string' } } } },
}];
it('emits NO tools field by default (tag map unset → prompt emulation)', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'm', messages: [{ role: 'user', content: 'x' }], tools: TOOLS,
});
// #10 is the calibrated tools tag; with the gate off, none must be present.
assert.equal(getAllFields(parseFields(proto), 10).length, 0);
});
it('encodes a ToolDef when the inner tags are calibrated', () => {
const prev = process.env.DEVIN_CONNECT_TOOL_DEF_TAGS;
process.env.DEVIN_CONNECT_TOOL_DEF_TAGS = '10,1,2,3';
try {
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'm', messages: [{ role: 'user', content: 'x' }], tools: TOOLS,
});
const toolFields = getAllFields(parseFields(proto), 10).filter(f => f.wireType === 2);
assert.equal(toolFields.length, 1, 'one ToolDef emitted at #10');
const td = parseFields(toolFields[0].value);
assert.equal(getField(td, 1, 2).value.toString('utf8'), 'get_weather');
assert.equal(getField(td, 2, 2).value.toString('utf8'), 'get_weather');
assert.deepEqual(JSON.parse(getField(td, 3, 2).value.toString('utf8')), TOOLS[0].function.parameters);
} finally {
if (prev === undefined) delete process.env.DEVIN_CONNECT_TOOL_DEF_TAGS;
else process.env.DEVIN_CONNECT_TOOL_DEF_TAGS = prev;
}
});
it('emits the strict varint only when the strict tag is calibrated AND function.strict is true', () => {
const prev = process.env.DEVIN_CONNECT_TOOL_DEF_TAGS;
process.env.DEVIN_CONNECT_TOOL_DEF_TAGS = 'name=1,description=2,parameters=3,strict=6';
try {
const strictTool = [{ type: 'function', function: { name: 'f', description: 'd', parameters: {}, strict: true } }];
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'm', messages: [{ role: 'user', content: 'x' }], tools: strictTool,
});
const td = parseFields(getAllFields(parseFields(proto), 10)[0].value);
assert.equal(Number(getField(td, 6, 0).value), 1, 'strict=6 varint emitted as 1');
// strict:false (or absent) → no #6 field
const noStrict = buildGetChatMessageRequest({
token: TOKEN, model: 'm', messages: [{ role: 'user', content: 'x' }],
tools: [{ type: 'function', function: { name: 'f', description: 'd', parameters: {} } }],
});
const td2 = parseFields(getAllFields(parseFields(noStrict), 10)[0].value);
assert.equal(getField(td2, 6, 0), null, 'no strict field when function.strict absent');
} finally {
if (prev === undefined) delete process.env.DEVIN_CONNECT_TOOL_DEF_TAGS;
else process.env.DEVIN_CONNECT_TOOL_DEF_TAGS = prev;
}
});
it('defaults outer to the VFB #10 when the gate omits it (key=val form)', () => {
const prev = process.env.DEVIN_CONNECT_TOOL_DEF_TAGS;
process.env.DEVIN_CONNECT_TOOL_DEF_TAGS = 'name=1,description=2,parameters=3';
try {
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'm', messages: [{ role: 'user', content: 'x' }], tools: TOOLS,
});
// outer defaulted to 10 → ToolDef rides at #10 exactly as the positional form.
assert.equal(getAllFields(parseFields(proto), 10).filter(f => f.wireType === 2).length, 1);
} finally {
if (prev === undefined) delete process.env.DEVIN_CONNECT_TOOL_DEF_TAGS;
else process.env.DEVIN_CONNECT_TOOL_DEF_TAGS = prev;
}
});
});
describe('parseToolCallTagMap (native tool-call decode gate)', () => {
it('returns null when unset', () => {
assert.equal(__testing.parseToolCallTagMap({}), null);
});
it('parses key=tag pairs and requires the outer tag', () => {
assert.deepEqual(
__testing.parseToolCallTagMap({ DEVIN_CONNECT_TOOL_CALL_TAGS: 'outer=12,id=4,name=1,arguments_json=3' }),
{ outer: 12, id: 4, name: 1, arguments_json: 3 },
);
// no `outer` → unusable → null
assert.equal(__testing.parseToolCallTagMap({ DEVIN_CONNECT_TOOL_CALL_TAGS: 'id=4,name=1' }), null);
});
it('ignores unknown keys and bad tags', () => {
assert.deepEqual(
__testing.parseToolCallTagMap({ DEVIN_CONNECT_TOOL_CALL_TAGS: 'outer=12,bogus=9,name=x' }),
{ outer: 12 },
);
});
it('parses the CONFIRMED calibrated tags (static disasm 2026-07-04, all 7 subfields)', () => {
// verified-from-binary: encode_raw @0x1442fe1f0 + merge_field jump table.
// Locks the value shipped in .devin-connect-calibrated.env so a typo can't
// silently ship the wrong outer tag (the old #2 guess was wrong; it's #6).
assert.deepEqual(
__testing.parseToolCallTagMap({
DEVIN_CONNECT_TOOL_CALL_TAGS:
'outer=6,id=1,name=2,arguments_json=3,invalid_json_str=4,invalid_json_err=5,is_custom_tool_call=6',
}),
{ outer: 6, id: 1, name: 2, arguments_json: 3, invalid_json_str: 4, invalid_json_err: 5, is_custom_tool_call: 6 },
);
});
});
describe('decodeFrame native tool calls (gated)', () => {
const tags = { outer: 12, id: 4, name: 1, arguments_json: 3 };
function frameWithToolCall() {
const tc = Buffer.concat([
writeStringField(1, 'get_weather'),
writeStringField(3, '{"city":"SF"}'),
writeStringField(4, 'call_abc'),
]);
return Buffer.concat([
writeStringField(1, 'bot-1'),
writeMessageField(12, tc),
]);
}
it('does NOT decode tool calls without the tag map (emulation stays)', () => {
const d = decodeFrame(frameWithToolCall());
assert.equal(d.toolCalls, undefined);
});
it('decodes repeated ChatToolCall when tags are calibrated', () => {
const d = decodeFrame(frameWithToolCall(), { toolCallTags: tags });
assert.deepEqual(d.toolCalls, [{ name: 'get_weather', arguments: '{"city":"SF"}', id: 'call_abc' }]);
});
it('decodes multiple tool calls from repeated fields', () => {
const mk = (name, args, id) => writeMessageField(12, Buffer.concat([
writeStringField(1, name), writeStringField(3, args), writeStringField(4, id),
]));
const payload = Buffer.concat([writeStringField(1, 'bot-1'), mk('a', '{}', 'c1'), mk('b', '{"k":1}', 'c2')]);
const d = decodeFrame(payload, { toolCallTags: tags });
assert.equal(d.toolCalls.length, 2);
assert.equal(d.toolCalls[1].name, 'b');
assert.equal(d.toolCalls[1].id, 'c2');
});
// ── Fault tolerance: response-side ChatToolCall structure (NW1 §2) ──────────
// Tags below are EXAMPLES only (free tier never emits a tool call, so the real
// wire tags are uncalibrated/UNVERIFIED). They exercise the decoder's tolerance
// contract, not a calibrated layout.
const ftags = {
outer: 12, id: 4, arguments_json: 3,
is_custom_tool_call: 5, invalid_json_str: 6, invalid_json_err: 7,
};
const tcField = (parts) => writeMessageField(12, Buffer.concat(parts));
it('decodes is_custom_tool_call (bool) alongside id + arguments', () => {
const payload = Buffer.concat([writeStringField(1, 'bot-1'), tcField([
writeStringField(4, 'call_x'),
writeStringField(3, '{"q":1}'),
writeVarintField(5, 1), // is_custom_tool_call = true
])]);
const d = decodeFrame(payload, { toolCallTags: ftags });
assert.equal(d.toolCalls.length, 1);
assert.equal(d.toolCalls[0].id, 'call_x');
assert.equal(d.toolCalls[0].arguments, '{"q":1}');
assert.equal(d.toolCalls[0].isCustom, true);
});
it('falls back to {} when only invalid_json_str/err are present (upstream malformed-args contract)', () => {
// arguments_json absent, the model emitted unparseable args the upstream kept
// in invalid_json_str → emit {} placeholder, preserve the raw + error.
const payload = Buffer.concat([writeStringField(1, 'bot-1'), tcField([
writeStringField(4, 'call_bad'),
writeStringField(6, '{city:"SF"'), // invalid_json_str (no quotes/closing)
writeStringField(7, 'expected property name'), // invalid_json_err
])]);
const d = decodeFrame(payload, { toolCallTags: ftags });
assert.equal(d.toolCalls.length, 1);
assert.equal(d.toolCalls[0].id, 'call_bad');
assert.equal(d.toolCalls[0].arguments, '{}'); // safe placeholder
assert.deepEqual(d.toolCalls[0].invalidJson, { str: '{city:"SF"', err: 'expected property name' });
});
it('downgrades unparseable arguments_json to {} when an invalid signal co-exists', () => {
const payload = Buffer.concat([writeStringField(1, 'bot-1'), tcField([
writeStringField(4, 'call_dg'),
writeStringField(3, 'not json at all'), // arguments_json present but invalid
writeStringField(7, 'unexpected token'), // invalid_json_err signal present
])]);
const d = decodeFrame(payload, { toolCallTags: ftags });
assert.equal(d.toolCalls[0].arguments, '{}');
assert.equal(d.toolCalls[0].invalidJson.str, 'not json at all'); // raw kept
assert.equal(d.toolCalls[0].invalidJson.err, 'unexpected token');
});
it('keeps raw arguments_json (never drops data) when unparseable and NO invalid signal', () => {
const payload = Buffer.concat([writeStringField(1, 'bot-1'), tcField([
writeStringField(4, 'call_raw'),
writeStringField(3, '{partial'), // unparseable, but no invalid_json_* fields
])]);
const d = decodeFrame(payload, { toolCallTags: ftags });
assert.equal(d.toolCalls[0].arguments, '{partial'); // preserved verbatim
assert.equal(d.toolCalls[0].invalidJson, undefined);
});
it('never throws on a malformed sub-message — skips the bad item, keeps the good one', () => {
// First delta_tool_calls field carries truncated bytes (a len-delim header that
// overruns); parseFields throws on it → decoder must swallow + continue.
const broken = Buffer.from([ (3 << 3) | 2, 0x7f ]); // tag #3 wt2, len=127, no data
const good = Buffer.concat([writeStringField(4, 'ok'), writeStringField(3, '{"a":1}')]);
const payload = Buffer.concat([
writeStringField(1, 'bot-1'),
writeMessageField(12, broken),
writeMessageField(12, good),
]);
let d;
assert.doesNotThrow(() => { d = decodeFrame(payload, { toolCallTags: ftags }); });
assert.equal(d.toolCalls.length, 1);
assert.equal(d.toolCalls[0].id, 'ok');
});
it('drops an empty sub-message (no phantom tool call manufactured)', () => {
const payload = Buffer.concat([
writeStringField(1, 'bot-1'),
writeMessageField(12, writeVarintField(5, 0)), // only is_custom=false, nothing else
]);
const d = decodeFrame(payload, { toolCallTags: ftags });
// isCustom alone is not enough to count as a call → no toolCalls surfaced.
assert.equal(d.toolCalls, undefined);
});
it('recovers the function name via single-tool reverse-lookup (response item carries no name)', () => {
// Response-side ChatToolCall has no `name` (NW1 §2). When exactly one tool was
// offered, the call is unambiguously that tool → opts.toolNames supplies it.
const payload = Buffer.concat([writeStringField(1, 'bot-1'), tcField([
writeStringField(4, 'call_only'),
writeStringField(3, '{"loc":"NYC"}'),
])]);
const d = decodeFrame(payload, { toolCallTags: ftags, toolNames: ['get_weather'] });
assert.equal(d.toolCalls[0].name, 'get_weather');
assert.equal(d.toolCalls[0].id, 'call_only');
// Ambiguous (more than one tool) → no name guessed, left for the 'unknown' default.
const d2 = decodeFrame(payload, { toolCallTags: ftags, toolNames: ['a', 'b'] });
assert.equal(d2.toolCalls[0].name, undefined);
});
});
describe('decodeFrame thinking signature (gated)', () => {
// delta_signature is a top-level string at an UNKNOWN tag (free tier never
// emits it). Pick #8 here only as an example tag — NOT a calibrated value.
const SIG_TAG = 8, TYPE_TAG = 10, TID_TAG = 11;
const SIG = 'ErUBCkYIBxg...base64-opaque...=='; // shape of an Anthropic signature
function frameWithSignature({ sig = SIG, type, tid } = {}) {
const parts = [writeStringField(1, 'bot-1'), writeStringField(SIG_TAG, sig)];
if (type != null) parts.push(writeVarintField(TYPE_TAG, type));
if (tid != null) parts.push(writeStringField(TID_TAG, tid));
return Buffer.concat(parts);
}
it('does NOT decode a signature without the tag map (zero regression)', () => {
const d = decodeFrame(frameWithSignature());
assert.equal(d.signature, undefined);
});
it('decodes delta_signature verbatim when the tag is calibrated', () => {
const d = decodeFrame(frameWithSignature(), { signatureTags: { signature: SIG_TAG } });
assert.deepEqual(d.signature, { text: SIG });
});
it('preserves the opaque payload byte-for-byte (no printable filter on signature)', () => {
// A real signature is base64 of encrypted bytes; the printable check used for
// actual_model_uid must NOT be applied here or a round-trip would corrupt it.
const binSig = Buffer.from([0xff, 0x00, 0x41, 0x80, 0x42]).toString('utf8');
const d = decodeFrame(
Buffer.concat([writeStringField(1, 'bot-1'), writeStringField(SIG_TAG, binSig)]),
{ signatureTags: { signature: SIG_TAG } },
);
assert.equal(d.signature.text, binSig);
});
it('decodes optional signature_type and thinking_id when their tags are pinned', () => {
const d = decodeFrame(
frameWithSignature({ type: 1, tid: 'think-abc' }),
{ signatureTags: { signature: SIG_TAG, type: TYPE_TAG, thinkingId: TID_TAG } },
);
assert.equal(d.signature.text, SIG);
assert.equal(d.signature.signatureType, 1);
assert.equal(d.signature.thinkingId, 'think-abc');
});
it('a frame without the signature field yields no signature even when calibrated', () => {
const payload = Buffer.concat([writeStringField(1, 'bot-1'), writeStringField(3, 'hi')]);
assert.equal(decodeFrame(payload, { signatureTags: { signature: SIG_TAG } }).signature, undefined);
});
it('parseSignatureTagMap: off when unset, requires the signature tag, parses optional tags', () => {
const { parseSignatureTagMap } = __testing;
assert.equal(parseSignatureTagMap({}), null);
// optional tags alone (no signature tag) → null (nothing to surface)
assert.equal(parseSignatureTagMap({ DEVIN_CONNECT_SIGNATURE_TYPE_TAG: '10' }), null);
assert.deepEqual(parseSignatureTagMap({ DEVIN_CONNECT_SIGNATURE_TAG: '8' }), { signature: 8 });
assert.deepEqual(
parseSignatureTagMap({
DEVIN_CONNECT_SIGNATURE_TAG: '8',
DEVIN_CONNECT_SIGNATURE_TYPE_TAG: '10',
DEVIN_CONNECT_SIGNATURE_THINKING_ID_TAG: '11',
}),
{ signature: 8, type: 10, thinkingId: 11 },
);
// garbage signature tag → null
assert.equal(parseSignatureTagMap({ DEVIN_CONNECT_SIGNATURE_TAG: 'abc' }), null);
assert.equal(parseSignatureTagMap({ DEVIN_CONNECT_SIGNATURE_TAG: '-1' }), null);
});
});
describe('streamChat signature surface (gated, mock transport)', () => {
const SIG_TAG = 8;
// Build a fake https.request that streams the given response frames (each a
// raw GetChatMessageResponse payload) followed by the success trailer.
function mockTransport(framePayloads) {
return (opts, cb) => {
const req = new EventEmitter();
req.destroyed = false;
req.setTimeout = () => req;
req.write = () => {};
req.end = () => {
const res = new EventEmitter();
res.statusCode = 200;
setImmediate(() => {
for (const p of framePayloads) res.emit('data', wrapEnvelope(p, { compress: false }));
res.emit('data', endOfStreamEnvelope());
res.emit('end');
});
cb(res);
};
req.destroy = () => { req.destroyed = true; };
return req;
};
}
async function collect(env) {
const events = [];
for await (const ev of streamChat({
messages: [{ role: 'user', content: 'hi' }],
model: 'claude-opus-4-8',
token: 'devin-session-token$fake.jwt.sig',
env,
})) events.push(ev);
return events;
}
it('does NOT yield a signature event when the tag is uncalibrated (zero regression)', async () => {
__setRequestImpl(mockTransport([
Buffer.concat([writeStringField(1, 'bot-1'), writeStringField(SIG_TAG, 'sig-xyz')]),
Buffer.concat([writeStringField(3, 'hello'), writeVarintField(5, 2)]),
]));
try {
const events = await collect({ DEVIN_CONNECT_TOKEN: 'devin-session-token$fake.jwt.sig' });
assert.equal(events.find(e => e.type === 'signature'), undefined);
const finish = events.find(e => e.type === 'finish');
assert.equal(finish.reasoning_signature, null);
assert.equal(finish.signature, null);
} finally { __setRequestImpl(null); }
});
it('surfaces a signature delta event + accumulates onto the finish event when calibrated', async () => {
__setRequestImpl(mockTransport([
Buffer.concat([writeStringField(SIG_TAG, 'Er')]),
Buffer.concat([writeStringField(SIG_TAG, 'UBCg')]),
Buffer.concat([writeStringField(3, 'hello'), writeVarintField(5, 2)]),
]));
try {
const events = await collect({
DEVIN_CONNECT_TOKEN: 'devin-session-token$fake.jwt.sig',
DEVIN_CONNECT_SIGNATURE_TAG: String(SIG_TAG),
});
const sigEvents = events.filter(e => e.type === 'signature');
assert.equal(sigEvents.length, 2);
assert.deepEqual(sigEvents.map(e => e.reasoning_signature), ['Er', 'UBCg']);
// Terminal finish carries the FULL concatenated signature, name-aligned with
// what messages.js round-trips (delta.reasoning_signature → signature_delta).
const finish = events.find(e => e.type === 'finish');
assert.equal(finish.reasoning_signature, 'ErUBCg');
assert.equal(finish.signature.text, 'ErUBCg');
} finally { __setRequestImpl(null); }
});
});
describe('streamChat malformed-frame resilience (FRAME-1, mock transport)', () => {
// End-to-end proof of the FRAME-1 fix: a malformed data frame arriving mid-stream
// must NOT propagate out of res.on('data') as an uncaughtException. Before the fix
// decodeFrame threw synchronously inside the data callback, crashing the process
// and every concurrent tenant; now the bad frame is skipped and the good frames
// (before and after it) still stream to completion.
function mockTransportRaw(rawFrames) {
return (opts, cb) => {
const req = new EventEmitter();
req.destroyed = false;
req.setTimeout = () => req;
req.write = () => {};
req.end = () => {
const res = new EventEmitter();
res.statusCode = 200;
setImmediate(() => {
for (const f of rawFrames) res.emit('data', f);
res.emit('data', endOfStreamEnvelope());
res.emit('end');
});
cb(res);
};
req.destroy = () => { req.destroyed = true; };
return req;
};
}
it('skips a malformed data frame and still yields the surrounding content', async () => {
// frame 1: valid content. frame 2: an unknown wire type (0x0f) that makes
// parseFields throw. frame 3: valid content + finish. All wrapped uncompressed.
const good1 = wrapEnvelope(writeStringField(3, 'before'), { compress: false });
const bad = wrapEnvelope(Buffer.from([0x0f]), { compress: false });
const good2 = wrapEnvelope(
Buffer.concat([writeStringField(3, 'after'), writeVarintField(5, 2)]),
{ compress: false });
__setRequestImpl(mockTransportRaw([good1, bad, good2]));
try {
const events = [];
// The whole point: this loop must complete normally (no throw/crash).
for await (const ev of streamChat({
messages: [{ role: 'user', content: 'hi' }],
model: 'claude-opus-4-8',
token: 'devin-session-token$fake.jwt.sig',
env: { DEVIN_CONNECT_TOKEN: 'devin-session-token$fake.jwt.sig' },
})) events.push(ev);
const text = events.filter(e => e.type === 'content').map(e => e.text).join('');
assert.equal(text, 'beforeafter');
const finish = events.find(e => e.type === 'finish');
assert.ok(finish, 'stream reached its terminal finish event despite the bad frame');
} finally { __setRequestImpl(null); }
});
});
describe('extractInlineImages', () => {
it('returns [] for string / non-array content', () => {
assert.deepEqual(extractInlineImages('hi'), []);
assert.deepEqual(extractInlineImages(null), []);
});
it('extracts an Anthropic-style base64 image block', () => {
const imgs = extractInlineImages([
{ type: 'text', text: 'see this' },
{ type: 'image', source: { type: 'base64', media_type: 'image/png', data: RED_DOT } },
]);
assert.deepEqual(imgs, [{ base64_data: RED_DOT, mime_type: 'image/png' }]);
});
it('extracts an OpenAI image_url data URL', () => {
const imgs = extractInlineImages([
{ type: 'image_url', image_url: { url: `data:image/jpeg;base64,${RED_DOT}` } },
]);
assert.deepEqual(imgs, [{ base64_data: RED_DOT, mime_type: 'image/jpeg' }]);
});
it('skips PDF image blocks (text-extracted upstream, not sent as image)', () => {
const imgs = extractInlineImages([
{ type: 'image', source: { type: 'base64', media_type: 'application/pdf', data: 'JVBER' } },
]);
assert.deepEqual(imgs, []);
});
it('ignores remote https image_url (needs async fetch, out of scope for the builder)', () => {
const imgs = extractInlineImages([
{ type: 'image_url', image_url: { url: 'https://example.com/cat.png' } },
]);
assert.deepEqual(imgs, []);
});
});
describe('encodeImageData', () => {
it('encodes { base64_data=#1, mime_type=#2 } (Cascade-proven ImageData shape)', () => {
const buf = __testing.encodeImageData({ base64_data: 'AAAA', mime_type: 'image/png' });
const f = parseFields(buf);
assert.equal(getField(f, 1, 2).value.toString('utf8'), 'AAAA');
assert.equal(getField(f, 2, 2).value.toString('utf8'), 'image/png');
});
it('defaults mime_type to image/png', () => {
const buf = __testing.encodeImageData({ base64_data: 'AAAA' });
assert.equal(getField(parseFields(buf), 2, 2).value.toString('utf8'), 'image/png');
});
});
describe('buildGetChatMessageRequest — vision (gated)', () => {
const visionMsg = {
role: 'user',
content: [
{ type: 'text', text: 'what color?' },
{ type: 'image_url', image_url: { url: `data:image/png;base64,${RED_DOT}` } },
],
};
// Decode every #3 ChatMessage.
const cmsOf = (proto) => getAllFields(parseFields(proto), 3).map(f => parseFields(f.value));
const roleOf = (cm) => Number(getField(cm, 2, 0)?.value);
const imagesOf = (cm) => getAllFields(cm, 10).map(f => parseFields(f.value));
it('the explicit DEVIN_CONNECT_IMAGE_TAG=0 rollback disables image emission', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'm', messages: [visionMsg], env: { DEVIN_CONNECT_IMAGE_TAG: '0' },
});
const cms = cmsOf(proto);
// Rollback off → one plain user ChatMessage and no image field.
assert.equal(cms.length, 1, 'single ChatMessage when gate off');
assert.equal(getField(cms[0], 3, 2).value.toString('utf8'), 'what color?');
assert.equal(cms[0].filter(f => f.wireType === 2 && f.field > 3).length, 0, 'no image sub-message');
assert.ok(!cms.some(cm => roleOf(cm) === 4), 'no role=4 tool_result when gate off');
assert.ok(!cms.some(cm => getField(cm, 7, 2)), 'no #7 tool_call_id when gate off');
});
it('default: image stays on the source=USER message as repeated field #10', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN,
model: 'swe-1-7',
messages: [visionMsg],
env: {},
});
const cms = cmsOf(proto);
assert.equal(cms.length, 1, 'one input message stays one wire message');
const user = cms[0];
assert.equal(roleOf(user), 1, 'source=USER');
assert.equal(getField(user, 3, 2).value.toString('utf8'), 'what color?');
assert.equal(getField(user, 6, 2), null, 'no synthetic read tool_call');
assert.equal(getField(user, 7, 2), null, 'no synthetic tool_call_id');
const [img] = imagesOf(user);
assert.equal(getField(img, 1, 2).value.toString('utf8'), RED_DOT);
assert.equal(getField(img, 2, 2).value.toString('utf8'), 'image/png');
});
it('text-only turns are unaffected by the gate being on', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'm', messages: [{ role: 'user', content: 'plain text' }],
env: { DEVIN_CONNECT_IMAGE_TAG: '10' },
});
const cms = cmsOf(proto);
assert.equal(cms.length, 1);
assert.equal(getField(cms[0], 3, 2).value.toString('utf8'), 'plain text');
assert.equal(getField(cms[0], 6, 2), null, 'no tool_call on a text-only turn');
assert.equal(getField(cms[0], 10, 2), null, 'no image on a text-only turn');
assert.ok(!cms.some(cm => roleOf(cm) === 4), 'no tool_result on a text-only turn');
});
it('multi-image: every image is repeated on the same user message', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'm', messages: [{
role: 'user', content: [
{ type: 'text', text: 'compare' },
{ type: 'image_url', image_url: { url: `data:image/png;base64,${RED_DOT}` } },
{ type: 'image_url', image_url: { url: `data:image/jpeg;base64,${RED_DOT}` } },
],
}],
env: { DEVIN_CONNECT_IMAGE_TAG: '10' },
});
const cms = cmsOf(proto);
assert.equal(cms.length, 1);
const images = imagesOf(cms[0]);
assert.equal(images.length, 2);
assert.equal(getField(images[0], 2, 2).value.toString('utf8'), 'image/png');
assert.equal(getField(images[1], 2, 2).value.toString('utf8'), 'image/jpeg');
});
it('native role:tool image keeps the caller tool_call_id and attaches field #10 directly', () => {
const proto = buildGetChatMessageRequest({
token: TOKEN, model: 'm', messages: [{
role: 'tool', tool_call_id: 'toolu_ABC123',
content: [{ type: 'image', source: { type: 'base64', media_type: 'image/png', data: RED_DOT } }],
}],
nativeToolCall: true,
env: { DEVIN_CONNECT_IMAGE_TAG: '10' },
});
const cms = cmsOf(proto);
assert.equal(cms.length, 1);
const result = cms[0];
assert.equal(roleOf(result), 4);
assert.equal(getField(result, 7, 2).value.toString('utf8'), 'toolu_ABC123', '#7 echoes caller id verbatim');
assert.equal(imagesOf(result).length, 1);
});
});
describe('normalizeToolSchema', () => {
it('coerces null/non-object/array to the canonical empty object schema', () => {
assert.deepEqual(normalizeToolSchema(null), { type: 'object', properties: {} });
assert.deepEqual(normalizeToolSchema(undefined), { type: 'object', properties: {} });
assert.deepEqual(normalizeToolSchema('x'), { type: 'object', properties: {} });
assert.deepEqual(normalizeToolSchema([1, 2]), { type: 'object', properties: {} });
});
it('forces type=object and an object properties', () => {
const r = normalizeToolSchema({ type: 'string' });
assert.equal(r.type, 'object');
assert.deepEqual(r.properties, {});
const r2 = normalizeToolSchema({ properties: 'nope' });
assert.deepEqual(r2.properties, {});
});
it('drops $schema meta key', () => {
const r = normalizeToolSchema({ $schema: 'http://json-schema.org', type: 'object', properties: { a: { type: 'string' } } });
assert.equal(r.$schema, undefined);
assert.deepEqual(r.properties, { a: { type: 'string' } });
});
it('required: keeps only string names that are real properties', () => {
const r = normalizeToolSchema({ type: 'object', properties: { a: {}, b: {} }, required: ['a', 'ghost', 42, 'b'] });
assert.deepEqual(r.required, ['a', 'b']);
});
it('required: non-array is dropped; empty-after-filter is dropped', () => {
assert.equal(normalizeToolSchema({ type: 'object', properties: {}, required: 'a' }).required, undefined);
assert.equal(normalizeToolSchema({ type: 'object', properties: { a: {} }, required: ['ghost'] }).required, undefined);
});
it('strips schema annotations but preserves structure and a parameter named description', () => {
const src = {
type: 'object',
description: 'root hint',
properties: {
path: { type: 'string', description: 'file path' },
description: { type: 'string', description: 'parameter hint' },
nested: { type: 'object', description: 'nested hint', properties: { value: { type: 'integer', description: 'value hint' } } },
},
required: ['path', 'description'],
};
const r = normalizeToolSchema(src);
assert.deepEqual(r, {
type: 'object',
properties: {
path: { type: 'string' },
description: { type: 'string' },
nested: { type: 'object', properties: { value: { type: 'integer' } } },
},
required: ['path', 'description'],
});
});
it('does not mutate the caller object', () => {
const src = { $schema: 'x', type: 'string', properties: {} };
normalizeToolSchema(src);
assert.equal(src.$schema, 'x');
assert.equal(src.type, 'string');
});
it('strips description from oneOf/anyOf/allOf nested schemas', () => {
const src = {
type: 'object',
properties: {
mode: {
oneOf: [
{ type: 'string', description: 'string mode' },
{ type: 'object', description: 'object mode', properties: { value: { type: 'string', description: 'inner' } } },
],
},
filter: {
anyOf: [
{ type: 'string', description: 'filter by name' },
{ type: 'integer', description: 'filter by id' },
],
},
combine: {
allOf: [
{ type: 'string', description: 'part a' },
{ type: 'string', enum: ['x', 'y'], description: 'part b' },
],
},
},
};
const r = normalizeToolSchema(src);
// oneOf: descriptions stripped, structure preserved
assert.equal(r.properties.mode.oneOf[0].description, undefined);
assert.equal(r.properties.mode.oneOf[1].description, undefined);
assert.equal(r.properties.mode.oneOf[1].properties.value.type, 'string');
assert.equal(r.properties.mode.oneOf[1].properties.value.description, undefined);
// anyOf: descriptions stripped
assert.equal(r.properties.filter.anyOf[0].description, undefined);
assert.equal(r.properties.filter.anyOf[1].description, undefined);
// allOf: descriptions stripped, enum preserved
assert.equal(r.properties.combine.allOf[0].description, undefined);
assert.equal(r.properties.combine.allOf[1].description, undefined);
assert.deepEqual(r.properties.combine.allOf[1].enum, ['x', 'y']);
});
it('strips description from array items and additionalProperties schemas', () => {
const src = {
type: 'object',
properties: {
files: {
type: 'array',
description: 'list of files',
items: { type: 'string', description: 'a file path' },
},
meta: {
type: 'object',
description: 'metadata bag',
additionalProperties: { type: 'string', description: 'any string value' },
},
},
};
const r = normalizeToolSchema(src);
assert.equal(r.properties.files.description, undefined);
assert.equal(r.properties.files.type, 'array');
assert.equal(r.properties.files.items.type, 'string');
assert.equal(r.properties.files.items.description, undefined);
assert.equal(r.properties.meta.description, undefined);
assert.equal(r.properties.meta.additionalProperties.type, 'string');
assert.equal(r.properties.meta.additionalProperties.description, undefined);
});
it('preserves const, format, and enum while stripping description annotations', () => {
const src = {
type: 'object',
properties: {
kind: { type: 'string', const: 'fixed', description: 'the kind' },
date: { type: 'string', format: 'date-time', description: 'when' },
level: { type: 'string', enum: ['low', 'high'], description: 'severity' },
withDefault: { type: 'string', default: 'auto', description: 'default val', examples: ['auto', 'manual'] },
},
};
const r = normalizeToolSchema(src);
assert.equal(r.properties.kind.const, 'fixed');
assert.equal(r.properties.kind.description, undefined);
assert.equal(r.properties.date.format, 'date-time');
assert.equal(r.properties.date.description, undefined);
assert.deepEqual(r.properties.level.enum, ['low', 'high']);
assert.equal(r.properties.level.description, undefined);
// default and examples are NOT description annotations → preserved
assert.equal(r.properties.withDefault.default, 'auto');
assert.deepEqual(r.properties.withDefault.examples, ['auto', 'manual']);
assert.equal(r.properties.withDefault.description, undefined);
assert.equal(r.properties.withDefault.type, 'string');
});
it('handles deeply nested objects (5 levels) without losing structure', () => {
const src = {
type: 'object',
properties: {
a: { type: 'object', description: 'a', properties: { b: { type: 'object', description: 'b', properties: { c: { type: 'object', description: 'c', properties: { d: { type: 'object', description: 'd', properties: { e: { type: 'string', description: 'e' } } } } } } } } },
},
};
const r = normalizeToolSchema(src);
const a = r.properties.a;
assert.equal(a.description, undefined);
assert.equal(a.type, 'object');
const b = a.properties.b;
assert.equal(b.description, undefined);
const c = b.properties.c;
assert.equal(c.description, undefined);
const d = c.properties.d;
assert.equal(d.description, undefined);
const e = d.properties.e;
assert.equal(e.type, 'string');
assert.equal(e.description, undefined);
});
it('preserves a parameter named "description" with its type and enum', () => {
// Regression guard: the MCP-gate fix strips description ANNOTATIONS, not
// parameters that happen to be named "description".
const src = {
type: 'object',
properties: {
description: { type: 'string', description: 'a human-readable description', enum: ['short', 'long'] },
},
required: ['description'],
};
const r = normalizeToolSchema(src);
assert.ok(r.properties.description, 'parameter named "description" must survive');
assert.equal(r.properties.description.type, 'string');
assert.deepEqual(r.properties.description.enum, ['short', 'long']);
assert.equal(r.properties.description.description, undefined, 'annotation stripped');
assert.deepEqual(r.required, ['description']);
});
// ── Top-level combinator stripping (P4, ported from kiro.rs) ──────────────
describe('top-level oneOf/anyOf/allOf stripping', () => {
it('BYTE-IDENTICAL for a schema with no top-level combinator (regression baseline)', () => {
// The whole safety of P4 rests on this: an ordinary schema must serialize
// exactly as before. Compare against normalization WITHOUT any combinator.
const src = { type: 'object', properties: { a: { type: 'string' }, b: { type: 'integer' } }, required: ['a'] };
const r = normalizeToolSchema(src);
assert.deepEqual(r, { type: 'object', properties: { a: { type: 'string' }, b: { type: 'integer' } }, required: ['a'] });
});
it('does NOT touch combinators NESTED under properties (only top level)', () => {
// Guards the top-level-only contract: a oneOf inside properties.mode must
// survive (it is a legitimate per-parameter schema), unlike a ROOT oneOf.
const src = { type: 'object', properties: { mode: { oneOf: [{ type: 'string' }, { type: 'integer' }] } } };
const r = normalizeToolSchema(src);
assert.ok(Array.isArray(r.properties.mode.oneOf), 'nested oneOf preserved');
assert.equal(r.properties.mode.oneOf.length, 2);
});
it('strips a top-level oneOf and recovers properties from the first object variant', () => {
const src = {
oneOf: [
{ type: 'object', properties: { city: { type: 'string' } }, required: ['city'] },
{ type: 'object', properties: { lat: { type: 'number' }, lon: { type: 'number' } } },
],
};
const r = normalizeToolSchema(src);
assert.equal(r.oneOf, undefined, 'top-level oneOf removed');
assert.equal(r.type, 'object');
assert.deepEqual(r.properties, { city: { type: 'string' } }, 'properties recovered from first object variant');
assert.deepEqual(r.required, ['city']);
});
it('strips top-level anyOf and allOf the same way', () => {
const anyR = normalizeToolSchema({ anyOf: [{ type: 'object', properties: { x: { type: 'string' } } }, { type: 'string' }] });
assert.equal(anyR.anyOf, undefined);
assert.deepEqual(anyR.properties, { x: { type: 'string' } });
const allR = normalizeToolSchema({ allOf: [{ type: 'object', properties: { y: { type: 'integer' } } }] });
assert.equal(allR.allOf, undefined);
assert.deepEqual(allR.properties, { y: { type: 'integer' } });
});
it('with EXISTING top-level properties: strips the combinator but does NOT overwrite properties', () => {
const src = {
type: 'object',
properties: { keep: { type: 'string' } },
oneOf: [{ type: 'object', properties: { other: { type: 'number' } } }],
};
const r = normalizeToolSchema(src);
assert.equal(r.oneOf, undefined, 'combinator removed');
assert.deepEqual(r.properties, { keep: { type: 'string' } }, 'existing properties untouched (or_insert semantics)');
});
it('top-level combinator with no object variant → forced empty object schema', () => {
const r = normalizeToolSchema({ oneOf: [{ type: 'string' }, { type: 'integer' }] });
assert.equal(r.oneOf, undefined);
assert.equal(r.type, 'object');
assert.deepEqual(r.properties, {}, 'no object variant to recover from → canonical empty');
});
it('does not mutate the caller schema when stripping a top-level combinator', () => {
const src = { oneOf: [{ type: 'object', properties: { a: { type: 'string' } } }] };
normalizeToolSchema(src);
assert.ok(Array.isArray(src.oneOf), 'caller oneOf preserved');
});
});
});
describe('streamChat transport resetMs propagation', () => {
afterEach(() => __setRequestImpl(null));
it('attaches resetMs to streamError on a non-200 rate-limit response with a reset window', async () => {
__setRequestImpl((_opts, cb) => {
const req = { on() { return req; }, setTimeout() { return req; }, write() {}, end() {}, destroy() {} };
const res = new EventEmitter();
res.statusCode = 429;
if (cb) cb(res);
queueMicrotask(() => {
res.emit('data', Buffer.from('Reached message rate limit for this model. Please try again later. Resets in: 2h30m0s'));
res.emit('end');
});
return req;
});
await assert.rejects(
(async () => {
for await (const _ of streamChat({
messages: [{ role: 'user', content: 'hi' }],
model: 'swe-1-7',
token: TOKEN,
})) { /* drain */ }
})(),
(err) => {
assert.equal(err.code, 'RATE_LIMITED');
assert.equal(err.resetMs, (2 * 3600 + 30 * 60) * 1000);
return true;
},
);
});
it('attaches resetMs to streamError on a JSON trailer rate-limit response with a reset window', async () => {
__setRequestImpl((_opts, cb) => {
const req = { on() { return req; }, setTimeout() { return req; }, write() {}, end() {}, destroy() {} };
const res = new EventEmitter();
res.statusCode = 200;
if (cb) cb(res);
queueMicrotask(() => {
const trailerJson = JSON.stringify({
error: {
message: 'Reached message rate limit for this model. Please try again later. Resets in: 1h15m0s',
code: 'resource_exhausted',
},
});
const payload = Buffer.from(trailerJson);
const trailerFrame = Buffer.alloc(5 + payload.length);
trailerFrame[0] = 0x02; // end-of-stream flag
trailerFrame.writeUInt32BE(payload.length, 1);
payload.copy(trailerFrame, 5);
res.emit('data', trailerFrame);
res.emit('end');
});
return req;
});
await assert.rejects(
(async () => {
for await (const _ of streamChat({
messages: [{ role: 'user', content: 'hi' }],
model: 'swe-1-7',
token: TOKEN,
})) { /* drain */ }
})(),
(err) => {
assert.equal(err.code, 'RATE_LIMITED');
assert.equal(err.resetMs, (1 * 3600 + 15 * 60) * 1000);
return true;
},
);
});
});
describe('encodeAssistantToolCall reasoning-tag guard (PR #241 review point 3)', () => {
it('refuses to serialize field 0: reasoning with tag 0 is dropped, not written', () => {
const base = { id: 'call_1', name: 'read_file', argsJson: '{}' };
// uuid field is the only random part (fixed 36 chars), so dropped-reasoning
// output must be byte-length-identical to a no-reasoning frame.
const withZero = __testing.encodeAssistantToolCall({
...base, reasoning: 'some reasoning text', reasoningTagNum: 0,
});
const bare = __testing.encodeAssistantToolCall({ ...base, reasoningTagNum: 0 });
assert.equal(
withZero.length, bare.length,
'reasoning with a zero tag must be dropped entirely, not serialized as reserved field 0',
);
assert.equal(decodeFrame(withZero).reasoning, '', 'decoding the zero-tag frame must yield no reasoning');
// Regression: a legal tag still carries the reasoning payload end to end.
const withEleven = __testing.encodeAssistantToolCall({
...base, reasoning: 'some reasoning text', reasoningTagNum: 11,
});
assert.ok(withEleven.length > bare.length, 'tag 11 reasoning must still be serialized');
assert.ok(
withEleven.indexOf(writeStringField(11, 'some reasoning text')) >= 0,
'tag 11 reasoning must still be serialized verbatim',
);
});
});
// A non-200 error body is a diagnostic, but it arrives on an unbounded stream.
// Before the ceiling, a hostile or broken upstream could push past V8's string
// limit; the resulting ERR_STRING_TOO_LONG is thrown inside the 'end' listener
// where nothing catches it, escapes as an uncaughtException and exits the
// process — so one bad response disconnects every tenant. The cap has to keep
// the classification path working AND make the truncation visible.
describe('non-200 error body is bounded', () => {
const realMax = process.env.DEVIN_CONNECT_MAX_ERROR_BODY_BYTES;
afterEach(() => {
__setRequestImpl(null);
if (realMax === undefined) delete process.env.DEVIN_CONNECT_MAX_ERROR_BODY_BYTES;
else process.env.DEVIN_CONNECT_MAX_ERROR_BODY_BYTES = realMax;
});
// The module reads the cap at load, so a case that needs a different ceiling
// has to load a fresh copy of the module graph under its own env. `body` may
// be an array of chunks: production delivers an error body as many ≤64 KiB
// socket chunks, and only a test that emits more than one can pin the
// accumulator that counts them.
const withCap = async (cap, body, statusCode = 500) => {
const dir = mkdtempSync(join(tmpdir(), 'dc-cap-'));
const prev = process.env.DEVIN_CONNECT_MAX_ERROR_BODY_BYTES;
process.env.DEVIN_CONNECT_MAX_ERROR_BODY_BYTES = String(cap);
try {
const mod = await import(`${new URL('../src/devin-connect.js', import.meta.url).href}?cap=${cap}&r=${Math.random()}`);
mod.__setRequestImpl((_opts, cb) => {
const req = { on() { return req; }, setTimeout() { return req; }, write() {}, end() {}, destroy() {} };
const res = new EventEmitter();
res.statusCode = statusCode;
if (cb) cb(res);
queueMicrotask(() => {
for (const chunk of Array.isArray(body) ? body : [body]) res.emit('data', chunk);
res.emit('end');
});
return req;
});
const err = await mod.streamChat({
messages: [{ role: 'user', content: 'hi' }], model: 'swe-1-7', token: TOKEN,
}).next().then(() => null, (e) => e);
return err;
} finally {
if (prev === undefined) delete process.env.DEVIN_CONNECT_MAX_ERROR_BODY_BYTES;
else process.env.DEVIN_CONNECT_MAX_ERROR_BODY_BYTES = prev;
rmSync(dir, { recursive: true, force: true });
}
};
it('truncates an oversized error body instead of buffering without bound', async () => {
// 4 KiB of body against a 64-byte ceiling. The previous assertion compared
// the result against the INPUT size, which the uncapped path also satisfies
// — it could not tell the two implementations apart. Compare against the
// CEILING instead: only a bounded implementation can come back that small.
const err = await withCap(64, Buffer.alloc(4096, 0x41));
assert.ok(err, 'an oversized error body must still produce a classified error');
const marker = '\n[... truncated: upstream error body exceeded the cap ...]';
assert.ok(err.message.length < 512,
`a 64-byte ceiling must not yield a ${err.message.length}-character message`);
// ceiling + marker + nothing else. The earlier form compared against a
// hand-counted marker length and was off by one; derive it instead.
assert.equal(err.message.length, 64 + marker.length);
});
it('counts the ceiling across data events, not per chunk', async () => {
// Every other case emits the body as ONE event, so an implementation that
// never accumulated `bodyBytes` across events (production delivers many
// ≤64 KiB socket chunks) would pass them all while re-opening unbounded
// buffering. Three 32-byte chunks against a 64-byte ceiling: the first two
// exactly fill it, the third must trigger truncation instead of extending
// the buffer — kept bytes are the ceiling plus the marker, and the third
// chunk is never kept.
const err = await withCap(64, [Buffer.alloc(32, 0x41), Buffer.alloc(32, 0x42), Buffer.alloc(32, 0x43)]);
const marker = '\n[... truncated: upstream error body exceeded the cap ...]';
assert.equal(err.message, 'A'.repeat(32) + 'B'.repeat(32) + marker,
'the ceiling must be counted across data events: keep A+B (64 bytes) + marker, never C');
});
it('keeps the body a genuine prefix of the real one, not a reordering', async () => {
const err = await withCap(64, Buffer.from('ABCDEFGH'.repeat(512), 'utf8'));
const kept = err.message.split('\n[... truncated')[0];
assert.ok('ABCDEFGH'.repeat(512).startsWith(kept), 'kept text must be a prefix of the body');
assert.ok(kept.length > 0, 'truncation must not discard everything');
});
it('marks the truncation so the error does not silently describe a prefix', async () => {
const err = await withCap(64, Buffer.alloc(4096, 0x41));
assert.match(err.message, /truncated: upstream error body exceeded the cap/);
});
it('leaves a body under the cap untouched and still classifies it', async () => {
const err = await withCap(64 * 1024, Buffer.from('upstream said no', 'utf8'), 429);
assert.equal(err.code, 'RATE_LIMITED');
assert.match(err.message, /upstream said no/);
assert.doesNotMatch(err.message, /truncated/, 'a body that fit must not be marked truncated');
});
it('falls back to the default ceiling when the override is not a positive integer', async () => {
for (const bad of ['0', '-1', 'abc', '', '1e400', ' ']) {
const err = await withCap(bad, Buffer.from('short', 'utf8'), 500);
assert.ok(err, `override ${JSON.stringify(bad)} must not break the path`);
}
});
it('never treats a bad override as "no ceiling"', async () => {
// A body larger than the 8MiB default is what makes this case load-bearing:
// a 1KiB body is kept whole by an 8MiB ceiling AND by no ceiling at all, so
// it cannot tell the two apart. Only a finite fallback truncates this one,
// at exactly the default ceiling.
const err = await withCap('not-a-number', Buffer.alloc(8 * 1024 * 1024 + 64, 0x43), 500);
const marker = '\n[... truncated: upstream error body exceeded the cap ...]';
assert.match(err.message, /truncated/, 'a body above the default ceiling must be truncated');
assert.equal(err.message.length, 8 * 1024 * 1024 + marker.length,
'an unparseable override must fall back to the real 8MiB ceiling, not to no ceiling');
});
});