amos b773033658 Record model requests and payloads as prefix deltas in the native trace
Each model_request/model_payload repeated the full context, so the trace
grew with the square of the request count: batch 6 Qwen runs hit 64 MiB
at ~75 requests and 14 attempts (13 graded PASS) were discarded.
Requests now record only items after the common prefix with the previous
one (schema embedded-rollout.pi/2), and pi_run.expand rebuilds full
payloads before the unchanged broker/feedback checks. Needs a new image
(trace6) and recalibration before use.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-18 10:50:56 +08:00

262 lines
12 KiB
JavaScript

#!/usr/bin/env node
import fs from 'node:fs';
import path from 'node:path';
import os from 'node:os';
import {fileURLToPath, pathToFileURL} from 'node:url';
import {isIP} from 'node:net';
export const PI_VERSION = '0.73.1';
// Long reasoning streams ~110 bytes per token; requests record only context added since the last one.
export const MAX_TRACE_BYTES = 64 * 1024 * 1024;
const PROVIDER = 'rollout-proxy';
const MODEL = 'glm-5.3';
const QWEN_MODEL = 'qwen3.8-27b-nvfp4';
export function proxyUrl(value) {
const url = new URL(value);
if (url.protocol !== 'http:' || !isIP(url.hostname) || url.username || url.password ||
url.search || url.hash) throw new Error('PRIVATE_PROXY_URL_REQUIRED');
return url.href.replace(/\/$/, '');
}
export function closure(messages, requests) {
const calls = new Set(), results = new Map();
for (const message of messages) {
for (const block of Array.isArray(message.content) ? message.content : []) {
if (block.type !== 'toolCall') continue;
if (!block.id || calls.has(block.id)) return {closed: false, feedback_consumed: false};
calls.add(block.id);
}
if (message.role === 'toolResult') {
if (!calls.has(message.toolCallId) || results.has(message.toolCallId)) {
return {closed: false, feedback_consumed: false};
}
results.set(message.toolCallId, message);
}
}
return {
closed: calls.size === results.size,
feedback_consumed: results.size > 0 && [...results.values()].every(result =>
requests.some(context => context.messages.some(message => message.role === 'toolResult' &&
message.toolCallId === result.toolCallId &&
JSON.stringify(message.content) === JSON.stringify(result.content)))),
};
}
export function glmPayload(payload) {
return {...payload, thinking: {type: 'enabled'}, reasoning_effort: 'high'};
}
// Pi context only grows, so each request records the items after its common prefix with the last one.
export function prefixDelta(previous, items) {
const encoded = items.map(item => JSON.stringify(item));
let from = 0;
while (from < previous.length && from < encoded.length && previous[from] === encoded[from]) from++;
return {from, encoded};
}
export function compactEvent(event) {
if (event.type !== 'message_update') return event;
// message_end keeps the full message; streaming snapshots duplicate every prior token.
const {message, assistantMessageEvent, ...fields} = event;
const {partial, ...delta} = assistantMessageEvent;
return {...fields, assistantMessageEvent: delta};
}
export function writeAll(fd, text, write = fs.writeSync) {
const data = Buffer.from(text);
for (let offset = 0; offset < data.length;) {
try {
offset += write(fd, data, offset, data.length - offset);
} catch (error) {
// stdout can be a nonblocking pipe: a full pipe must slow the writer, never drop host evidence.
if (error.code !== 'EAGAIN') throw error;
Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
}
}
}
export function traceWriter(fd, mirror, abort) {
const terminal = JSON.stringify({type: 'session_end', complete: false, error: 'TRACE_LIMIT_EXCEEDED'}) + '\n';
const reserve = Buffer.byteLength(terminal);
let bytes = 0;
const write = line => {
writeAll(fd, line);
fs.fsyncSync(fd);
mirror(line);
bytes += Buffer.byteLength(line);
};
const output = value => {
if (output.limitExceeded) return;
const line = JSON.stringify(compactEvent(value)) + '\n';
if (bytes + Buffer.byteLength(line) + reserve > MAX_TRACE_BYTES) {
output.limitExceeded = true;
write(terminal);
abort();
return;
}
write(line);
};
output.limitExceeded = false;
return output;
}
export async function run(prompt, {traceFile, baseUrl, token = 'rollout-proxy', cwd = process.cwd(),
modelId = MODEL, maxTokens,
mirror = line => writeAll(1, line)}, sdk) {
if (!prompt.trim() || !token || /[\r\n]/.test(token)) throw new Error('INVALID_INPUT');
if (![MODEL, QWEN_MODEL].includes(modelId)) throw new Error('UNSUPPORTED_MODEL');
// The controller owns this limit so changing it never needs a new image or recalibration.
if (!Number.isInteger(maxTokens) || maxTokens < 1 || maxTokens > 1048576) throw new Error('INVALID_MAX_TOKENS');
const responses = modelId === QWEN_MODEL;
const api = responses ? 'openai-responses' : 'openai-completions';
baseUrl = proxyUrl(baseUrl);
const fd = fs.openSync(traceFile, 'wx', 0o644);
fs.fchmodSync(fd, 0o644);
const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), 'embedded-pi-'));
let session, interrupted = false;
const output = traceWriter(fd, mirror, () => session?.agent.abort());
let generation = 0;
const requests = [];
const sent = {messages: [], payload: []};
try {
const settings = sdk.SettingsManager.inMemory({
compaction: {enabled: false}, retry: {enabled: false, provider: {maxRetries: 0}},
enableInstallTelemetry: false, enableSkillCommands: false, images: {blockImages: true},
});
const auth = sdk.AuthStorage.inMemory();
auth.setRuntimeApiKey(PROVIDER, token);
const registry = sdk.ModelRegistry.inMemory(auth);
registry.registerProvider(PROVIDER, {baseUrl, apiKey: 'rollout-proxy', api, models: [{
id: modelId, name: modelId, reasoning: !responses, input: ['text'], contextWindow: 1000000,
maxTokens, cost: {input: 0, output: 0, cacheRead: 0, cacheWrite: 0},
...(!responses && {compat: {supportsStore: false, supportsDeveloperRole: false,
supportsReasoningEffort: true, maxTokensField: 'max_tokens',
thinkingFormat: 'openai', zaiToolStream: true}}),
}]});
const resources = new sdk.DefaultResourceLoader({cwd,
agentDir, settingsManager: settings,
noExtensions: true, noSkills: true, noPromptTemplates: true, noThemes: true,
noContextFiles: true,
});
await resources.reload();
const manager = sdk.SessionManager.inMemory(cwd);
const result = await sdk.createAgentSession({cwd, agentDir, authStorage: auth, modelRegistry: registry,
model: registry.find(PROVIDER, modelId), settingsManager: settings, resourceLoader: resources,
sessionManager: manager, thinkingLevel: responses ? 'off' : 'high', tools: ['read', 'edit', 'write', 'bash'],
});
session = result.session;
if (result.modelFallbackMessage || session.model?.id !== modelId || session.model?.baseUrl !== baseUrl ||
session.model?.provider !== PROVIDER || session.model?.api !== api) throw new Error('MODEL_MISMATCH');
output({type: 'trace_header', schema: 'embedded-rollout.pi/2', pi_version: PI_VERSION,
message_update_omits: ['message', 'assistantMessageEvent.partial'],
session: manager.getHeader(), model: session.model, system_prompt: session.systemPrompt,
cost_available: false, credential: 'attempt_proxy_token',
tools: session.agent.state.tools.map(({name, description, parameters}) => ({name, description, parameters})),
});
const stream = session.agent.streamFn;
session.agent.streamFn = (model, context, options) => {
const generationId = generation++;
const request = prefixDelta(sent.messages, context.messages);
sent.messages = request.encoded;
const messages = context.messages.slice(request.from);
// The prefix was in earlier requests, so feedback checks over all requests need only new messages.
requests.push(JSON.parse(JSON.stringify({messages})));
output({type: 'model_request', generation_id: generationId, model, context: {...context, messages},
delta: {field: 'messages', from: request.from}});
if (output.limitExceeded) throw new Error('TRACE_LIMIT_EXCEEDED');
// Without an explicit value the SDK caps output at 32000 tokens, which long reasoning exhausts.
return stream(model, context, {...options, maxTokens: options?.maxTokens ?? model.maxTokens,
onPayload: async payload => {
const prepared = await options?.onPayload?.(payload, model) ?? payload;
const wire = responses ? prepared : glmPayload(prepared);
const field = responses ? 'input' : 'messages';
const items = prefixDelta(sent.payload, wire[field]);
sent.payload = items.encoded;
output({type: 'model_payload', generation_id: generationId,
payload: {...wire, [field]: wire[field].slice(items.from)}, delta: {field, from: items.from}});
if (output.limitExceeded) throw new Error('TRACE_LIMIT_EXCEEDED');
return wire;
}, onResponse: async response => {
output({type: 'model_http_response', generation_id: generationId, status: response.status});
await options?.onResponse?.(response, model);
}});
};
session.subscribe(output);
const beforeTool = session.agent.beforeToolCall;
session.agent.beforeToolCall = async (context, signal) => {
const blocked = await beforeTool?.(context, signal);
if (blocked) return blocked;
// The pinned SDK otherwise skips its event barrier when extensions are disabled.
if (!session._agentEventQueue?.then) throw new Error('UNSUPPORTED_PI_EVENT_QUEUE');
await session._agentEventQueue;
if (output.limitExceeded) return {block: true, reason: 'TRACE_LIMIT_EXCEEDED'};
return undefined;
};
const stop = () => {interrupted = true; session.agent.abort();};
process.on('SIGTERM', stop);
process.on('SIGINT', stop);
try {
await session.prompt(prompt);
// Pi 0.73.1 persists subscribed message events on this queue.
if (!session._agentEventQueue?.then) throw new Error('UNSUPPORTED_PI_EVENT_QUEUE');
await session._agentEventQueue;
if (output.limitExceeded) throw new Error('TRACE_LIMIT_EXCEEDED');
} finally {
process.off('SIGTERM', stop);
process.off('SIGINT', stop);
}
const messages = session.state.messages;
const causal = closure(messages, requests);
const last = messages.at(-1);
const complete = !interrupted && last?.role === 'assistant' && last.stopReason === 'stop' && causal.closed;
const summary = {type: 'session_end', complete, interrupted, ...causal,
model_requests: generation, final_stop_reason: last?.stopReason || null, cost_available: false};
output({type: 'session_entries', entries: manager.getEntries()});
output(summary);
if (output.limitExceeded) throw new Error('TRACE_LIMIT_EXCEEDED');
return summary;
} catch (error) {
if (!output.limitExceeded) {
output({type: 'session_end', complete: false, interrupted,
error: /^[A-Z_]+$/.test(error.message) ? error.message : 'PI_SESSION_FAILED'});
}
throw error;
} finally {
session?.dispose();
fs.closeSync(fd);
fs.rmSync(agentDir, {recursive: true, force: true});
}
}
export async function loadSdk() {
const root = path.dirname(path.dirname(fileURLToPath(import.meta.resolve('@mariozechner/pi-coding-agent'))));
if (JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8')).version !== PI_VERSION) {
throw new Error('UNSUPPORTED_PI_VERSION');
}
return import('@mariozechner/pi-coding-agent');
}
export async function main(args = process.argv.slice(2)) {
if (args.length !== 6 || args[0] !== '--trace' || !path.isAbsolute(args[1]) || args[2] !== '--model' ||
args[4] !== '--max-tokens' || !/^[1-9][0-9]{0,6}$/.test(args[5])) {
throw new Error('USAGE_PI_TRACE_MODEL_MAX_TOKENS');
}
const modelId = args[3];
if (![MODEL, QWEN_MODEL].includes(modelId)) throw new Error('UNSUPPORTED_MODEL');
const tokenFile = process.env.ROLLOUT_MODEL_TOKEN_FILE;
const token = tokenFile ? fs.readFileSync(tokenFile, 'utf8').trim() : 'rollout-proxy';
const sdk = await loadSdk();
const summary = await run(fs.readFileSync(0, 'utf8'), {traceFile: args[1],
baseUrl: process.env.ROLLOUT_MODEL_BASE_URL, token, modelId, maxTokens: Number(args[5])}, sdk);
return summary.complete ? 0 : 1;
}
if (process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
main().then(code => {process.exitCode = code;}).catch(error => {
process.stderr.write(JSON.stringify({type: 'adapter_error',
error: /^[A-Z_]+$/.test(error.message) ? error.message : 'PI_ADAPTER_FAILED'}) + '\n');
process.exitCode = 2;
});
}