feat: pin controlled Harness profile and verify owned tool and model bridge

This commit is contained in:
Agent Workbench Dev
2026-10-31 04:25:44 +08:00
parent 60b63bc70f
commit a01c41811b
14 changed files with 1928 additions and 0 deletions
+102
View File
@@ -0,0 +1,102 @@
// The literal is copied into each owned runtime. Bundling preserves its bytes;
// no third-party program or currently running release is modified.
export const CONTROLLED_BRIDGE_PLUGIN = String.raw`import fs from 'node:fs';
import { createHash } from 'node:crypto';
export const name = 'agent-workbench-controlled-bridge';
export const inject = ['tools', 'llm', 'appReady'];
const canonical = value => Array.isArray(value) ? value.map(canonical) : value && typeof value === 'object'
? Object.fromEntries(Object.keys(value).sort().map(key => [key, canonical(value[key])])) : value;
const digest = value => createHash('sha256').update(JSON.stringify(canonical(value))).digest('hex');
export async function apply(ctx, config) {
const { LlmAdapter } = await import(config.llmModule);
const controller = new AbortController();
ctx.effect(() => () => controller.abort(new Error('Owned engine bridge disposed.')));
const descriptors = config.tools.map(({ name, description, parameters }) => ({ name, description, parameters }));
const names = new Set(descriptors.map(tool => tool.name));
const catalogue = () => ctx.tools.schemas().map(({ name, description, parameters }) => ({ name, description, parameters }))
.sort((left, right) => left.name.localeCompare(right.name));
const assertCatalogue = () => {
if (digest(catalogue()) !== config.catalogueSha256) throw new Error('The owned tool catalogue changed.');
};
const post = async (route, data, signal) => {
controller.signal.throwIfAborted(); signal?.throwIfAborted(); assertCatalogue();
const response = await fetch(config.endpoint + route, { method: 'POST',
headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + config.nonce },
signal: signal ? AbortSignal.any([signal, controller.signal]) : controller.signal,
body: JSON.stringify({ owner: config.owner, sessionId: config.sdkSessionId, pid: process.pid, data }) });
let size = 0; const chunks = [];
for await (const chunk of response.body) {
size += chunk.length;
if (size > config.maximumFrameBytes) throw new Error('Owned bridge response exceeded its bound.');
chunks.push(chunk);
}
const value = JSON.parse(Buffer.concat(chunks).toString('utf8'));
if (!response.ok) throw new Error(value.error || 'Owned bridge rejected the request.');
return value;
};
for (const descriptor of descriptors) ctx.tools.register({ ...descriptor,
output: { schema: {}, render: (_args, value) => [{ type: 'text', text: JSON.stringify(value) }] },
async execute(args, execution) {
if (execution.agent?.session?.id !== config.sdkSessionId) throw new Error('Tool caller is not the owned SDK session.');
return post('/tool', { callId: execution.callId, name: descriptor.name, arguments: args }, execution.signal);
},
});
ctx.on('tools/pre-execute', async (execution, next) => {
assertCatalogue();
if (execution.agent?.session?.id !== config.sdkSessionId || !names.has(execution.name)) {
return { kind: 'deny', reason: 'This tool or caller is outside the owned workbench scope.' };
}
return next();
});
class WorkbenchAdapter extends LlmAdapter {
async resolveModel(provider, model) {
if (provider !== 'agent-workbench' || model !== config.model) throw new Error('Owned model route changed.');
return { provider, id: model, name: model, contextWindow: config.contextLimit, defaultMaxTokens: config.maxOutputTokens };
}
async *stream(options) {
if (options.provider !== 'agent-workbench' || options.model !== config.model) throw new Error('Unowned model route.');
const result = await post('/model', { messages: options.messages, system: options.system ?? null,
tools: options.tools ?? [], toolHistory: options.toolHistory ?? null,
model: options.model, maxTokens: options.maxTokens ?? config.maxOutputTokens }, options.signal);
const message = result.message;
if (!message || message.role !== 'assistant' || typeof message.content !== 'string'
|| message.tool_calls !== undefined && !Array.isArray(message.tool_calls)) throw new Error('Invalid owned model result.');
let index = 0;
if (message.content) {
yield { type: 'block-start', index, blockType: 'text' };
yield { type: 'text-delta', index, text: message.content };
yield { type: 'block-end', index, block: { type: 'text', text: message.content } }; index++;
}
for (const call of message.tool_calls ?? []) {
if (typeof call.id !== 'string' || typeof call.function?.name !== 'string'
|| typeof call.function.arguments !== 'string') throw new Error('Incomplete owned tool call.');
JSON.parse(call.function.arguments);
yield { type: 'block-start', index, blockType: 'tool-call' };
yield { type: 'tool-call-delta', index, id: call.id, name: call.function.name, argumentsDelta: call.function.arguments };
yield { type: 'block-end', index, block: { type: 'tool-call', id: call.id, name: call.function.name, arguments: call.function.arguments } }; index++;
}
const usage = result.usage, valid = value => Number.isSafeInteger(value) && value >= 0;
if (valid(usage?.prompt_tokens) && valid(usage?.completion_tokens)) {
yield { type: 'usage', usage: { inputTokens: usage.prompt_tokens, outputTokens: usage.completion_tokens } };
}
yield { type: 'finish', reason: { kind: message.tool_calls?.length ? 'tool-calls' : 'stop' } };
}
}
ctx.llm.registerAdapter(['agent-workbench'], new WorkbenchAdapter());
const off = ctx.appReady.onReady(() => {
assertCatalogue();
const providers = ctx.llm.listProviders().map(provider => provider.id).sort();
if (providers.length !== 1 || providers[0] !== 'agent-workbench') throw new Error('Unexpected native model provider.');
const marker = { schemaVersion: 1, nonce: config.nonce, pid: process.pid, signal: 'appReady', readyAt: new Date().toISOString(),
owner: config.owner, sdkSessionId: config.sdkSessionId, catalogue: catalogue(), catalogueSha256: config.catalogueSha256, providers };
fs.writeFileSync(config.marker + '.writing', JSON.stringify(marker), { flag: 'wx' });
fs.renameSync(config.marker + '.writing', config.marker);
});
ctx.effect(() => off, 'workbench.controlled-ready');
}
`;
export const CONTROLLED_DISABLED_PLUGINS = Object.freeze(['tool-fs', 'tool-working-directory', 'persistent-bash', 'persistent-pwsh',
'terminal-bash', 'terminal-pwsh', 'llm-deepseek', 'llm-retry']);
export const canonicalEngineValue = value => Array.isArray(value) ? value.map(canonicalEngineValue) : value && typeof value === 'object'
? Object.fromEntries(Object.keys(value).sort().map(key => [key, canonicalEngineValue(value[key])])) : value;