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>
262 lines
12 KiB
JavaScript
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;
|
|
});
|
|
}
|