@danceiny/gotry 0.0.1-rc.20 → 0.0.1-rc.21

package/dist/scripts/map-tools-vendor-package-proof.js

@@ -0,0 +1,276 @@
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, symlinkSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import assert from 'node:assert/strict';
+const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../..');
+const upstreamLicenseSha256 = 'b6bbb0c73a02cf8d2c304e9f208b41c32f0a810fabe366986e2b14ac3338f618';
+const upstreamVendorFileCount = 32;
+const upstreamVendorAggregateSha256 = 'd82a38adace8bfe574dcecb4222da5c994a1b9e8792f78dc2dad3a7f50c9925a';
+const expectedTools = [
+    'map_bicycling_route',
+    'map_driving_route',
+    'map_geocode',
+    'map_poi_search',
+    'map_reverse_geocode',
+    'map_transit_route',
+    'map_walking_route'
+];
+function sha256(path) {
+    return createHash('sha256').update(readFileSync(path)).digest('hex');
+}
+function vendorAggregate(root) {
+    const files = [];
+    const walk = (directory)=>{
+        for (const entry of readdirSync(directory, {
+            withFileTypes: true
+        })){
+            const path = join(directory, entry.name);
+            if (entry.isDirectory()) walk(path);
+            else files.push(path.slice(root.length + 1).replaceAll('\\', '/'));
+        }
+    };
+    walk(root);
+    files.sort();
+    const digest = createHash('sha256');
+    for (const relative of files){
+        digest.update(relative);
+        digest.update('\0');
+        digest.update(readFileSync(join(root, relative)));
+        digest.update('\0');
+    }
+    return {
+        count: files.length,
+        sha256: digest.digest('hex')
+    };
+}
+function assertAlpha3LockClosure() {
+    const manifest = JSON.parse(readFileSync(join(repoRoot, 'ts/package.json'), 'utf8'));
+    assert.equal(manifest.dependencies?.['dsh-map-tools'], undefined, 'external map-tools dependency must stay removed');
+    const lock = JSON.parse(readFileSync(join(repoRoot, 'ts/package-lock.json'), 'utf8'));
+    assert.equal(lock.packages?.['']?.dependencies?.['dsh-map-tools'], undefined, 'lock root must not resolve external map-tools');
+    assert.equal(lock.packages?.['node_modules/dsh-map-tools'], undefined, 'lock must not carry external map-tools');
+    const dshEntries = Object.entries(lock.packages ?? {}).filter(([path])=>/(?:^|\/)node_modules\/@deepseek-ai\/(?:dsh|dsh-[^/]+)$/.test(path));
+    assert.ok(dshEntries.length >= 10, 'expected dsh-tools peer closure in the ts lock');
+    for (const [path, entry] of dshEntries){
+        assert.equal(entry.version, '0.1.2-alpha.3', `${path} drifted outside the alpha.3 closure`);
+    }
+    return {
+        packages: dshEntries.length,
+        version: '0.1.2-alpha.3'
+    };
+}
+function findPackageRoot(entry) {
+    let cursor = dirname(entry);
+    for(;;){
+        const manifestPath = join(cursor, 'package.json');
+        if (existsSync(manifestPath)) {
+            const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+            if (manifest.name === '@danceiny/gotry') return cursor;
+        }
+        const parent = dirname(cursor);
+        if (parent === cursor) throw new Error(`cannot locate @danceiny/gotry package root from ${entry}`);
+        cursor = parent;
+    }
+}
+function assertBinTargetsPackage(binPath, expectedTarget) {
+    const resolvedExpectedTarget = realpathSync(expectedTarget);
+    if (realpathSync(binPath) === resolvedExpectedTarget) return;
+    const shim = readFileSync(binPath, 'utf8');
+    assert.ok(Buffer.byteLength(shim, 'utf8') <= 32_768, 'clean-install gotry shim is unexpectedly large');
+    const lines = shim.trimEnd().split(/\r?\n/);
+    const markers = lines.filter((line)=>line.startsWith('# cmd-shim-target='));
+    assert.equal(markers.length, 1, 'pnpm gotry shim must contain exactly one target marker');
+    assert.equal(lines.at(-1), markers[0], 'pnpm gotry shim target marker must be the final line');
+    const markerTarget = markers[0].slice('# cmd-shim-target='.length);
+    assert.ok(isAbsolute(markerTarget), 'pnpm gotry shim target must be absolute');
+    assert.equal(realpathSync(markerTarget), resolvedExpectedTarget, 'GOTRY_MAP_TOOLS_E2E_BIN shim must target this installed GoTry package');
+}
+function prepareProofPackage(cleanInstalledBin) {
+    if (cleanInstalledBin) {
+        const binPath = resolve(cleanInstalledBin);
+        assert.equal(basename(binPath), 'gotry', 'clean-install executable must use the gotry bin name');
+        assert.equal(basename(dirname(binPath)), '.bin', 'clean-install executable must come from node_modules/.bin');
+        assert.equal(basename(dirname(dirname(binPath))), 'node_modules', 'clean-install executable must come from a consumer install');
+        const consumerRoot = dirname(dirname(dirname(binPath)));
+        const packageMain = createRequire(join(consumerRoot, 'package.json')).resolve('@danceiny/gotry');
+        const packageRoot = findPackageRoot(packageMain);
+        const installedManifest = JSON.parse(readFileSync(join(packageRoot, 'package.json'), 'utf8'));
+        assert.equal(installedManifest.name, '@danceiny/gotry', 'clean-install executable must belong to GoTry');
+        const declaredBin = typeof installedManifest.bin === 'string' ? installedManifest.bin : installedManifest.bin?.gotry;
+        assert.equal(declaredBin, 'bin/gotry-inner.js', 'installed package must declare the production gotry bin');
+        assertBinTargetsPackage(binPath, join(packageRoot, declaredBin));
+        return {
+            packageRoot
+        };
+    }
+    const proofRoot = mkdtempSync(join(repoRoot, '.tmp-map-tools-proof-'));
+    try {
+        const packOutput = execFileSync('npm', [
+            'pack',
+            '--ignore-scripts',
+            '--json',
+            '--pack-destination',
+            proofRoot
+        ], {
+            cwd: repoRoot,
+            encoding: 'utf8'
+        });
+        const packInfo = JSON.parse(packOutput);
+        assert.equal(packInfo.length, 1, 'npm pack must produce one artifact');
+        const tarball = join(proofRoot, packInfo[0].filename);
+        assert.ok(existsSync(tarball), `packed artifact missing: ${tarball}`);
+        const unpackRoot = join(proofRoot, 'unpacked');
+        mkdirSync(unpackRoot);
+        execFileSync('tar', [
+            '-xzf',
+            tarball,
+            '-C',
+            unpackRoot
+        ]);
+        const packageRoot = join(unpackRoot, 'package');
+        symlinkSync(join(repoRoot, 'node_modules'), join(packageRoot, 'node_modules'), process.platform === 'win32' ? 'junction' : 'dir');
+        return {
+            packageRoot,
+            proofRoot
+        };
+    } catch (error) {
+        rmSync(proofRoot, {
+            recursive: true,
+            force: true
+        });
+        throw error;
+    }
+}
+const cleanInstalledBin = process.env.GOTRY_MAP_TOOLS_E2E_BIN;
+const { packageRoot, proofRoot } = prepareProofPackage(cleanInstalledBin);
+try {
+    const lockedDsh = assertAlpha3LockClosure();
+    const vendorRoot = join(packageRoot, 'ts/dsh-runtime/vendor/dsh-map-tools');
+    const requiredFiles = [
+        'LICENSE',
+        'package.json',
+        'cordis.patch.yml',
+        'lib/index.js',
+        'lib/settings-ns.js',
+        'lib/config.js',
+        'lib/tools/geocode.js',
+        'lib/tools/routes.js',
+        'lib/tools/poi.js'
+    ];
+    for (const relative of requiredFiles){
+        assert.ok(existsSync(join(vendorRoot, relative)), `required vendor file missing: ${relative}`);
+    }
+    const vendorTree = vendorAggregate(vendorRoot);
+    assert.equal(vendorTree.count, upstreamVendorFileCount, 'vendored payload file count drifted');
+    assert.equal(vendorTree.sha256, upstreamVendorAggregateSha256, 'vendored payload aggregate drifted');
+    const vendorPackage = JSON.parse(readFileSync(join(vendorRoot, 'package.json'), 'utf8'));
+    assert.equal(vendorPackage.name, 'dsh-map-tools');
+    assert.equal(vendorPackage.version, '0.5.1');
+    assert.equal(vendorPackage.license, 'MIT');
+    assert.equal(sha256(join(vendorRoot, 'LICENSE')), upstreamLicenseSha256, 'upstream MIT license changed');
+    const packageRequire = createRequire(join(packageRoot, 'package.json'));
+    const dshTools = JSON.parse(readFileSync(packageRequire.resolve('@deepseek-ai/dsh-tools/package.json'), 'utf8'));
+    const dshSettings = JSON.parse(readFileSync(packageRequire.resolve('@deepseek-ai/dsh-settings/package.json'), 'utf8'));
+    assert.equal(dshTools.version, '0.1.2-alpha.3');
+    assert.equal(dshSettings.version, '0.1.2-alpha.3');
+    const settingsApi = await import(pathToFileURL(packageRequire.resolve('@deepseek-ai/dsh-settings')).href);
+    assert.equal(typeof settingsApi.SettingsProvider?.prototype?.installSection, 'function', 'real alpha.3 SettingsProvider.installSection API must be present');
+    const plugin = await import(pathToFileURL(join(vendorRoot, 'lib/index.js')).href);
+    const registered = [];
+    const settingsCalls = [];
+    const context = {
+        tools: {
+            register (tool) {
+                registered.push(tool);
+                return ()=>undefined;
+            }
+        },
+        effect (effect) {
+            effect();
+        },
+        inject (dependencies, callback) {
+            if (dependencies.includes('settings')) {
+                callback({
+                    settings: {
+                        installSection: (...args)=>{
+                            settingsCalls.push(args);
+                        }
+                    }
+                });
+            } else if (dependencies.includes('webServer')) {
+                callback({
+                    webServer: {
+                        register: ()=>undefined
+                    }
+                });
+            } else {
+                throw new Error(`unexpected dependency injection: ${dependencies.join(',')}`);
+            }
+        }
+    };
+    plugin.apply(context, {
+        provider: 'osm',
+        amapKey: '',
+        timeoutMs: 1000,
+        maxQps: 2,
+        defaultMode: 'driving',
+        language: 'zh'
+    });
+    assert.deepEqual(registered.map((tool)=>tool.name).sort(), expectedTools, 'exactly seven map tools must register');
+    assert.equal(settingsCalls.length, 1, 'alpha.3 settings section must be installed once');
+    assert.equal(settingsCalls[0][1], 'dsh-map-tools', 'settings namespace must be stable');
+    assert.equal(typeof settingsCalls[0][4], 'object', 'alpha.3 installSection hooks must be supplied');
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = async ()=>{
+        throw new Error('network forbidden by package proof');
+    };
+    try {
+        const geocode = registered.find((tool)=>tool.name === 'map_geocode');
+        assert.ok(geocode, 'map_geocode must be registered');
+        const result = await geocode.execute({
+            address: '116.397428,39.90923'
+        }, {
+            signal: new AbortController().signal
+        });
+        assert.equal(result.provider, 'inline');
+        assert.deepEqual(result.location, [
+            116.397428,
+            39.90923
+        ]);
+    } finally{
+        globalThis.fetch = originalFetch;
+    }
+    console.log(JSON.stringify({
+        proof: 'map-tools-vendor-package',
+        status: 'PASS',
+        artifactMode: cleanInstalledBin ? 'clean-installed-tarball' : 'packed-unpacked-focused',
+        vendored: {
+            sourcePackage: 'dsh-map-tools@0.5.1',
+            licenseSha256: upstreamLicenseSha256,
+            vendorFileCount: vendorTree.count,
+            vendorAggregateSha256: vendorTree.sha256
+        },
+        artifactVendor: vendorRoot,
+        dshClosure: {
+            tools: dshTools.version,
+            settings: dshSettings.version,
+            ...lockedDsh
+        },
+        tools: registered.map((tool)=>tool.name).sort(),
+        inlineCoordinate: {
+            provider: 'inline',
+            network: 'forbidden'
+        }
+    }, null, 2));
+} finally{
+    if (proofRoot) rmSync(proofRoot, {
+        recursive: true,
+        force: true
+    });
+}
+
+
+//# sourceURL=ts/scripts/map-tools-vendor-package-proof.ts

package/dist/scripts/persona-surface-guard-tests.js

@@ -8,12 +8,17 @@ assert.ok(patch.includes('绝不把 gotry_* 名字传给 skill 加载器'), '应
 const markers = new Set([
     ...patch.matchAll(/\((\d{1,2})\)/g)
 ].map((m)=>Number(m[1])));
-for(let i = 1; i <= 22; i += 1){
+for(let i = 1; i <= 23; i += 1){
     assert.ok(markers.has(i), `行为契约 (${i}) 应存在`);
 }
-assert.equal(markers.size, 22, `契约条目应恰为 22 条,实际 ${markers.size}`);
+assert.equal(markers.size, 23, `契约条目应恰为 23 条,实际 ${markers.size}`);
 assert.ok(patch.includes('改回 tool call'), '应指引失败后改回 tool call');
-console.log('PERSONA SURFACE GUARD TESTS: 3/3 OK(表层规则句 / 22 条契约完整 / skill 失败行为指引)');
+assert.ok(patch.includes('澄清卡/访谈/选项里向用户列出的候选时段示例'), '#2 回归:候选时段示例条款应存在');
+assert.ok(patch.includes('已过的节日不进示例枚举'), '应禁止已过节日进澄清卡示例枚举');
+assert.ok(patch.includes('(23)子任务等待纪律'), '#194 回归:子任务等待纪律条款应存在');
+assert.ok(patch.includes('对子代理绝不调用 job_output/job_kill'), '应禁止对子代理调用 job_output/job_kill');
+assert.ok(patch.includes("job_output/job_kill 只用于"), '应限定 job_output/job_kill 的适用面');
+console.log('PERSONA SURFACE GUARD TESTS: 5/5 OK(表层规则句 / 23 条契约完整 / skill 失败行为指引 / 澄清卡示例过锚点卡 / 子任务等待纪律)');
 
 
 //# sourceURL=ts/scripts/persona-surface-guard-tests.ts

package/dist/src/benchmark-agent-conformance.js

@@ -19,6 +19,19 @@ const BENCHMARK_DOMAIN_RECOVERIES = new Set([
     'revise_arguments',
     'choose_alternative'
 ]);
+const TERMINAL_BODY_SCHEMA_MAX_BYTES = 16 * 1024;
+const TERMINAL_BODY_SCHEMA_MAX_DEPTH = 8;
+const TERMINAL_BODY_SCHEMA_MAX_NODES = 256;
+const TERMINAL_BODY_SCHEMA_MAX_PROPERTIES = 256;
+const TERMINAL_BODY_SCALAR_TYPES = new Set([
+    'string',
+    'number',
+    'integer',
+    'boolean',
+    'null'
+]);
+const TERMINAL_BODY_VALUE_MAX_NODES = 10_000;
+const TERMINAL_BODY_VALUE_MAX_DEPTH = 24;
 function plainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -26,9 +39,143 @@ export function validateTerminalOutputConfig(value) {
     if (!plainObject(value)) return false;
     const keys = Object.keys(value).sort();
     return JSON.stringify(keys) === JSON.stringify([
+        'body_schema',
         'max_bytes',
         'tag'
-    ]) && typeof value.tag === 'string' && IDENTIFIER.test(value.tag) && typeof value.max_bytes === 'number' && Number.isInteger(value.max_bytes) && value.max_bytes >= 1 && value.max_bytes <= MAX_TERMINAL_BYTES;
+    ]) && typeof value.tag === 'string' && IDENTIFIER.test(value.tag) && typeof value.max_bytes === 'number' && Number.isInteger(value.max_bytes) && value.max_bytes >= 1 && value.max_bytes <= MAX_TERMINAL_BYTES && validateTerminalBodySchema(value.body_schema);
+}
+export function validateTerminalBodySchema(value) {
+    let serialized;
+    try {
+        serialized = JSON.stringify(value);
+    } catch  {
+        return false;
+    }
+    if (typeof serialized !== 'string' || Buffer.byteLength(serialized, 'utf8') > TERMINAL_BODY_SCHEMA_MAX_BYTES) return false;
+    const pending = [
+        {
+            node: value,
+            depth: 0
+        }
+    ];
+    const seen = new Set();
+    let nodes = 0;
+    let properties = 0;
+    while(pending.length > 0){
+        const { node, depth } = pending.pop();
+        if (!plainObject(node) || seen.has(node) || ++nodes > TERMINAL_BODY_SCHEMA_MAX_NODES || depth > TERMINAL_BODY_SCHEMA_MAX_DEPTH) return false;
+        seen.add(node);
+        const type = node.type;
+        if (type === 'object') {
+            if (!exactKeys(node, [
+                'type',
+                'properties',
+                'required',
+                'additionalProperties'
+            ]) || !plainObject(node.properties) || !Array.isArray(node.required) || node.additionalProperties !== false) return false;
+            const entries = Object.entries(node.properties);
+            properties += entries.length;
+            if (properties > TERMINAL_BODY_SCHEMA_MAX_PROPERTIES || entries.some(([key, child])=>key.length === 0 || key.length > 64 || !plainObject(child))) return false;
+            if (node.required.length > entries.length || new Set(node.required).size !== node.required.length || node.required.some((key)=>typeof key !== 'string' || !Object.hasOwn(node.properties, key))) return false;
+            for (const [, child] of entries)pending.push({
+                node: child,
+                depth: depth + 1
+            });
+            continue;
+        }
+        if (type === 'array') {
+            if (!exactKeys(node, [
+                'type',
+                'items'
+            ]) || !plainObject(node.items)) return false;
+            pending.push({
+                node: node.items,
+                depth: depth + 1
+            });
+            continue;
+        }
+        if (typeof type !== 'string' || !TERMINAL_BODY_SCALAR_TYPES.has(type) || !exactKeys(node, [
+            'type'
+        ])) return false;
+    }
+    return plainObject(value) && value.type === 'object';
+}
+function exactKeys(value, allowed) {
+    return Object.keys(value).every((key)=>allowed.includes(key));
+}
+export function validateTerminalBodyValue(value, schema) {
+    const pending = [
+        {
+            value,
+            schema,
+            depth: 0
+        }
+    ];
+    let nodes = 0;
+    while(pending.length > 0){
+        const current = pending.pop();
+        if (++nodes > TERMINAL_BODY_VALUE_MAX_NODES || current.depth > TERMINAL_BODY_VALUE_MAX_DEPTH) return false;
+        const { schema: node } = current;
+        if (node.type === 'object') {
+            const record = current.value;
+            if (!plainObject(record)) return false;
+            const properties = node.properties;
+            for (const key of node.required){
+                if (!Object.hasOwn(record, key)) return false;
+            }
+            for (const [key, child] of Object.entries(record)){
+                const childSchema = properties[key];
+                if (!childSchema) return false;
+                pending.push({
+                    value: child,
+                    schema: childSchema,
+                    depth: current.depth + 1
+                });
+            }
+            continue;
+        }
+        if (node.type === 'array') {
+            if (!Array.isArray(current.value)) return false;
+            for (const item of current.value)pending.push({
+                value: item,
+                schema: node.items,
+                depth: current.depth + 1
+            });
+            continue;
+        }
+        if (node.type === 'string') {
+            if (typeof current.value !== 'string') return false;
+            continue;
+        }
+        if (node.type === 'boolean') {
+            if (typeof current.value !== 'boolean') return false;
+            continue;
+        }
+        if (node.type === 'null') {
+            if (current.value !== null) return false;
+            continue;
+        }
+        if (node.type === 'integer') {
+            if (typeof current.value !== 'number' || !Number.isSafeInteger(current.value)) return false;
+            continue;
+        }
+        if (typeof current.value !== 'number' || !Number.isFinite(current.value)) return false;
+    }
+    return true;
+}
+export function terminalSchemaOutline(schema) {
+    const render = (node, depth)=>{
+        if (depth > TERMINAL_BODY_SCHEMA_MAX_DEPTH) return '…';
+        if (node.type === 'object') {
+            const properties = node.properties;
+            const required = new Set(node.required);
+            const parts = Object.entries(properties).map(([key, child])=>`${required.has(key) ? '' : '?'}${key}:${render(child, depth + 1)}`);
+            return `object{${parts.join(',')}}`;
+        }
+        if (node.type === 'array') return `array<${render(node.items, depth + 1)}>`;
+        return node.type;
+    };
+    return render(schema, 0);
 }
 function invalidTerminal() {
     return {
@@ -51,10 +198,12 @@ export function parseBenchmarkTerminal(raw, config) {
     if (body.length === 0 || body.includes('```')) return invalidTerminal();
     try {
         const value = JSON.parse(body);
-        return plainObject(value) ? {
+        if (!plainObject(value)) return invalidTerminal();
+        if (!validateTerminalBodyValue(value, config.body_schema)) return invalidTerminal();
+        return {
             ok: true,
             value
-        } : invalidTerminal();
+        };
     } catch  {
         return invalidTerminal();
     }
@@ -263,7 +412,7 @@ function requireDisposer(value, capability) {
     return value;
 }
 function correctionMessage(mode, projection) {
-    const text = mode === 'call' ? `BENCHMARK_CONFORMANCE_CALL: Execute exactly one native ${projection.toolName} action:"call" now. Describing an intended CLI, shell, or Python command does not execute it.` : `BENCHMARK_CONFORMANCE_TERMINAL: Reuse the existing successful tool result. Do not call any tool. Reply only <${projection.terminal.tag}>{"result":"..."}</${projection.terminal.tag}> with one JSON object.`;
+    const text = mode === 'call' ? `BENCHMARK_CONFORMANCE_CALL: Execute exactly one native ${projection.toolName} action:"call" now. Describing an intended CLI, shell, or Python command does not execute it.` : `BENCHMARK_CONFORMANCE_TERMINAL: Reuse the existing successful tool result. Do not call any tool. Reply only <${projection.terminal.tag}> with one JSON object matching exactly ${terminalSchemaOutline(projection.terminal.body_schema)} — no extra keys, no missing keys, exact types.`;
     return createUserMessage({
         content: [
             {
@@ -279,6 +428,7 @@ function correctionMessage(mode, projection) {
 }
 function systemSection(projection) {
     const allowed = projection.allowedTools.join(', ');
+    const outline = terminalSchemaOutline(projection.terminal.body_schema);
     return {
         name: 'benchmark:agent-conformance',
         text: [
@@ -286,7 +436,7 @@ function systemSection(projection) {
             `- Translate every task instruction to use a CLI, shell, Python, or agent_env.cli into the native tool ${projection.toolName}; do not merely describe the intended command.`,
             `- Call it with exactly {"action":"call","tool":"<one of: ${allowed}>","arguments":{...}}.`,
             '- action:"tools" is discovery only and does not satisfy the required environment call.',
-            `- After a successful tool result, reply only <${projection.terminal.tag}>{...one JSON object...}</${projection.terminal.tag}> with no prose or code fence.`,
+            `- After a successful tool result, reply only <${projection.terminal.tag}> with one JSON object matching exactly ${outline} — no extra keys, no missing keys, exact types; no prose or code fence.`,
             '- If a terminal-format correction arrives, reuse the existing result and do not call the tool again.'
         ].join('\n')
     };

package/dist/src/benchmark-environment-bridge.js

@@ -3,7 +3,7 @@ import { getuid } from 'node:process';
 import { isAbsolute } from 'node:path';
 import { assertSupportedJsonSchema, validateJsonSchemaValue, ToolArgsError } from '@deepseek-ai/dsh-tools';
 import { validateTerminalOutputConfig } from './benchmark-agent-conformance.js';
-const SCHEMA_VERSION = 'gotry_benchmark_environment_bridge_v3';
+const SCHEMA_VERSION = 'gotry_benchmark_environment_bridge_v4';
 export const BENCHMARK_TOOL_RESULT_SCHEMA_VERSION = 'gotry_benchmark_tool_result_v1';
 export const BENCHMARK_DOMAIN_RECOVERIES = [
     'none',
@@ -40,61 +40,6 @@ const INPUT_SCHEMA_TYPES = new Set([
     'array',
     'object'
 ]);
-function descriptorSchema(tools) {
-    return {
-        oneOf: [
-            {
-                type: 'object',
-                description: 'List the frozen benchmark tool descriptors.',
-                properties: {
-                    action: {
-                        type: 'string',
-                        const: 'tools'
-                    }
-                },
-                required: [
-                    'action'
-                ],
-                additionalProperties: false
-            },
-            {
-                type: 'object',
-                description: 'List the frozen bridge error contract.',
-                properties: {
-                    action: {
-                        type: 'string',
-                        const: 'errors'
-                    }
-                },
-                required: [
-                    'action'
-                ],
-                additionalProperties: false
-            },
-            ...tools.map((tool)=>({
-                    type: 'object',
-                    description: tool.description,
-                    properties: {
-                        action: {
-                            type: 'string',
-                            const: 'call'
-                        },
-                        tool: {
-                            type: 'string',
-                            const: tool.name
-                        },
-                        arguments: tool.input_schema
-                    },
-                    required: [
-                        'action',
-                        'tool',
-                        'arguments'
-                    ],
-                    additionalProperties: false
-                }))
-        ]
-    };
-}
 function plainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -445,7 +390,33 @@ export function registerBenchmarkEnvironmentBridge(path, register, subprocess) {
     if (!bridge) throw new Error('benchmark environment bridge configuration unavailable');
     if (!subprocess) throw new Error('benchmark environment bridge subprocess unavailable');
     const parameters = deepFreezeJson({
-        oneOf: descriptorSchema(bridge.tools).oneOf
+        type: 'object',
+        description: 'Flat benchmark bridge wire: choose an action, then provide the mapped tool and its arguments.',
+        properties: {
+            action: {
+                type: 'string',
+                enum: [
+                    'tools',
+                    'call',
+                    'errors'
+                ],
+                description: 'tools=列出可调工具;call=执行工具;errors=拉取错误契约'
+            },
+            tool: {
+                type: 'string',
+                enum: bridge.tools.map((item)=>item.name),
+                description: 'action=call 时选择的冻结工具名'
+            },
+            arguments: {
+                type: 'object',
+                additionalProperties: true,
+                description: 'action=call 时传给工具的参数对象'
+            }
+        },
+        required: [
+            'action'
+        ],
+        additionalProperties: false
     });
     assertSupportedJsonSchema(parameters);
     const definition = {
@@ -467,20 +438,36 @@ export function registerBenchmarkEnvironmentBridge(path, register, subprocess) {
             const query = args;
             const tool = query.tool;
             const descriptor = bridge.tools.find((item)=>item.name === tool);
-            if (query.action === 'tools') return jsonObject({
-                ok: true,
-                tools: bridge.tools
-            });
-            if (query.action === 'errors') return jsonObject({
-                ok: true,
-                errors: BRIDGE_ERROR_CONTRACT
-            });
+            const keys = Object.keys(query);
+            if (query.action === 'tools') {
+                if (keys.length !== 1) throw new ToolArgsError([
+                    'arguments: tools action accepts no tool or arguments'
+                ]);
+                return jsonObject({
+                    ok: true,
+                    tools: bridge.tools
+                });
+            }
+            if (query.action === 'errors') {
+                if (keys.length !== 1) throw new ToolArgsError([
+                    'arguments: errors action accepts no tool or arguments'
+                ]);
+                return jsonObject({
+                    ok: true,
+                    errors: BRIDGE_ERROR_CONTRACT
+                });
+            }
             if (query.action !== 'call') {
                 return jsonObject({
                     ok: false,
                     error: 'invalid_action'
                 });
             }
+            if (keys.length !== 3 || !Object.hasOwn(query, 'tool') || !Object.hasOwn(query, 'arguments')) {
+                throw new ToolArgsError([
+                    'arguments: call action requires exactly tool and arguments'
+                ]);
+            }
             if (typeof tool !== 'string' || !descriptor) {
                 return jsonObject({
                     ok: false,
@@ -495,12 +482,7 @@ export function registerBenchmarkEnvironmentBridge(path, register, subprocess) {
             }
             const callArguments = query.arguments;
             const argumentViolations = validateJsonSchemaValue(descriptor.input_schema, callArguments, 'arguments');
-            if (argumentViolations.length > 0) {
-                return jsonObject({
-                    ok: false,
-                    error: 'invalid_arguments'
-                });
-            }
+            if (argumentViolations.length > 0) throw new ToolArgsError(argumentViolations);
             const serialized = serializedArguments(callArguments);
             if (serialized.reason) return jsonObject({
                 ok: false,