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

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

@@ -1,220 +1,233 @@
 import { accessSync, constants, lstatSync, readFileSync, statSync } from 'node:fs';
 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';
+import { assertSupportedJsonSchema, validateJsonSchemaValue, ToolArgsError, } from '@deepseek-ai/dsh-tools';
+import { validateTerminalOutputConfig, } from './benchmark-agent-conformance.js';
+// v4(#215 Round 12):terminal_output 携带 closed body schema(结构关键字白名单,
+// 禁数据值注解面);v3 及更早配置缺该面,按契约不兼容 fail-closed。
 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',
-    'retry_same',
-    'revise_arguments',
-    'choose_alternative'
-];
+export const BENCHMARK_DOMAIN_RECOVERIES = ['none', 'retry_same', 'revise_arguments', 'choose_alternative'];
 const IDENTIFIER = /^[A-Za-z][A-Za-z0-9_.-]*$/;
 const RECOVERIES = new Set(BENCHMARK_DOMAIN_RECOVERIES);
-const CONFIG_KEYS = [
-    'argv_prefix',
-    'cwd',
-    'enabled',
-    'executable',
-    'isolation',
-    'max_output_bytes',
-    'schema_version',
-    'terminal_output',
-    'timeout_ms',
-    'tools'
-];
+const CONFIG_KEYS = ['argv_prefix', 'cwd', 'enabled', 'executable', 'isolation', 'max_output_bytes', 'schema_version', 'terminal_output', 'timeout_ms', 'tools'];
 const INPUT_SCHEMA_MAX_BYTES = 16 * 1024;
 const INPUT_SCHEMA_MAX_DEPTH = 8;
 const INPUT_SCHEMA_MAX_NODES = 256;
 const INPUT_SCHEMA_MAX_PROPERTIES = 256;
 const INPUT_SCHEMA_MAX_ENUM_VALUES = 256;
 const INPUT_SCHEMA_MAX_DESCRIPTION_LENGTH = 512;
-const INPUT_SCHEMA_TYPES = new Set([
-    'string',
-    'number',
-    'integer',
-    'boolean',
-    'null',
-    'array',
-    'object'
-]);
+const INPUT_SCHEMA_TYPES = new Set(['string', 'number', 'integer', 'boolean', 'null', 'array', 'object']);
 function plainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 function deepFreezeJson(value) {
-    if (!value || typeof value !== 'object' || Object.isFrozen(value)) return value;
-    for (const child of Object.values(value))deepFreezeJson(child);
+    if (!value || typeof value !== 'object' || Object.isFrozen(value))
+        return value;
+    for (const child of Object.values(value))
+        deepFreezeJson(child);
     return Object.freeze(value);
 }
 function existingExecutable(value) {
-    if (typeof value !== 'string' || !isAbsolute(value)) return false;
+    if (typeof value !== 'string' || !isAbsolute(value))
+        return false;
     try {
         const stat = statSync(value);
         accessSync(value, constants.X_OK);
         return stat.isFile();
-    } catch  {
+    }
+    catch {
         return false;
     }
 }
 function existingDirectory(value) {
-    if (typeof value !== 'string' || !isAbsolute(value)) return false;
+    if (typeof value !== 'string' || !isAbsolute(value))
+        return false;
     try {
         return statSync(value).isDirectory();
-    } catch  {
+    }
+    catch {
         return false;
     }
 }
 function identifiers(value, allowEmpty = false) {
-    return Array.isArray(value) && (allowEmpty || value.length > 0) && value.length <= 64 && new Set(value).size === value.length && value.every((item)=>typeof item === 'string' && item.length > 0 && IDENTIFIER.test(item));
+    return Array.isArray(value) && (allowEmpty || value.length > 0) && value.length <= 64 && new Set(value).size === value.length && value.every(item => typeof item === 'string' && item.length > 0 && IDENTIFIER.test(item));
 }
 function exactKeys(value, allowed) {
-    return Object.keys(value).every((key)=>allowed.includes(key));
+    return Object.keys(value).every(key => allowed.includes(key));
 }
 function validDescription(value, required = false) {
-    if (value === undefined) return !required;
-    return typeof value === 'string' && (!required || value.trim().length > 0) && value.length <= INPUT_SCHEMA_MAX_DESCRIPTION_LENGTH && !/[\u0000-\u001f\u007f]/.test(value);
+    if (value === undefined)
+        return !required;
+    return typeof value === 'string'
+        && (!required || value.trim().length > 0)
+        && value.length <= INPUT_SCHEMA_MAX_DESCRIPTION_LENGTH
+        && !/[\u0000-\u001f\u007f]/.test(value);
 }
 function scalarMatches(type, value) {
-    if (type === 'string') return typeof value === 'string' && value.length <= 512;
-    if (type === 'number') return typeof value === 'number' && Number.isFinite(value);
-    if (type === 'integer') return typeof value === 'number' && Number.isSafeInteger(value);
-    if (type === 'boolean') return typeof value === 'boolean';
+    if (type === 'string')
+        return typeof value === 'string' && value.length <= 512;
+    if (type === 'number')
+        return typeof value === 'number' && Number.isFinite(value);
+    if (type === 'integer')
+        return typeof value === 'number' && Number.isSafeInteger(value);
+    if (type === 'boolean')
+        return typeof value === 'boolean';
     return type === 'null' && value === null;
 }
 function validInputSchema(value) {
-    if (!plainObject(value)) return false;
+    if (!plainObject(value))
+        return false;
     let serialized;
     try {
         serialized = JSON.stringify(value);
-    } catch  {
+    }
+    catch {
         return false;
     }
-    if (Buffer.byteLength(serialized, 'utf8') > INPUT_SCHEMA_MAX_BYTES) return false;
-    const pending = [
-        {
-            node: value,
-            depth: 0
-        }
-    ];
+    if (Buffer.byteLength(serialized, 'utf8') > INPUT_SCHEMA_MAX_BYTES)
+        return false;
+    const pending = [{ node: value, depth: 0 }];
     const seen = new Set();
     let nodes = 0;
     let properties = 0;
     let enumValues = 0;
-    while(pending.length > 0){
+    while (pending.length > 0) {
         const { node, depth } = pending.pop();
-        if (seen.has(node) || ++nodes > INPUT_SCHEMA_MAX_NODES || depth > INPUT_SCHEMA_MAX_DEPTH) return false;
+        if (seen.has(node) || ++nodes > INPUT_SCHEMA_MAX_NODES || depth > INPUT_SCHEMA_MAX_DEPTH)
+            return false;
         seen.add(node);
-        if (!INPUT_SCHEMA_TYPES.has(String(node.type)) || !validDescription(node.description)) return false;
+        if (!INPUT_SCHEMA_TYPES.has(String(node.type)) || !validDescription(node.description))
+            return false;
         if (node.type === 'object') {
-            if (!exactKeys(node, [
-                'type',
-                'description',
-                'properties',
-                'required',
-                'additionalProperties'
-            ]) || !plainObject(node.properties) || !Array.isArray(node.required) || node.additionalProperties !== false) return false;
+            if (!exactKeys(node, ['type', 'description', 'properties', 'required', 'additionalProperties'])
+                || !plainObject(node.properties)
+                || !Array.isArray(node.required)
+                || node.additionalProperties !== false)
+                return false;
             const propertyEntries = Object.entries(node.properties);
             properties += propertyEntries.length;
-            if (properties > INPUT_SCHEMA_MAX_PROPERTIES || propertyEntries.some(([key, child])=>!IDENTIFIER.test(key) || !plainObject(child))) return false;
+            if (properties > INPUT_SCHEMA_MAX_PROPERTIES || propertyEntries.some(([key, child]) => !IDENTIFIER.test(key) || !plainObject(child)))
+                return false;
             const required = node.required;
-            if (required.length > propertyEntries.length || new Set(required).size !== required.length || required.some((key)=>typeof key !== 'string' || !Object.hasOwn(node.properties, key))) return false;
-            for (const [, child] of propertyEntries)pending.push({
-                node: child,
-                depth: depth + 1
-            });
+            if (required.length > propertyEntries.length
+                || new Set(required).size !== required.length
+                || required.some(key => typeof key !== 'string' || !Object.hasOwn(node.properties, key)))
+                return false;
+            for (const [, child] of propertyEntries)
+                pending.push({ node: child, depth: depth + 1 });
             continue;
         }
         if (node.type === 'array') {
-            if (!exactKeys(node, [
-                'type',
-                'description',
-                'items'
-            ]) || !plainObject(node.items)) return false;
-            pending.push({
-                node: node.items,
-                depth: depth + 1
-            });
+            if (!exactKeys(node, ['type', 'description', 'items']) || !plainObject(node.items))
+                return false;
+            pending.push({ node: node.items, depth: depth + 1 });
             continue;
         }
-        if (!exactKeys(node, [
-            'type',
-            'description',
-            'enum',
-            'const'
-        ]) || Object.hasOwn(node, 'enum') && Object.hasOwn(node, 'const')) return false;
-        if (Object.hasOwn(node, 'const') && !scalarMatches(String(node.type), node.const)) return false;
+        if (!exactKeys(node, ['type', 'description', 'enum', 'const'])
+            || (Object.hasOwn(node, 'enum') && Object.hasOwn(node, 'const')))
+            return false;
+        if (Object.hasOwn(node, 'const') && !scalarMatches(String(node.type), node.const))
+            return false;
         if (Object.hasOwn(node, 'enum')) {
-            if (!Array.isArray(node.enum) || node.enum.length === 0 || node.enum.length > 64) return false;
+            if (!Array.isArray(node.enum) || node.enum.length === 0 || node.enum.length > 64)
+                return false;
             enumValues += node.enum.length;
-            if (enumValues > INPUT_SCHEMA_MAX_ENUM_VALUES || new Set(node.enum).size !== node.enum.length || node.enum.some((item)=>!scalarMatches(String(node.type), item))) return false;
+            if (enumValues > INPUT_SCHEMA_MAX_ENUM_VALUES
+                || new Set(node.enum).size !== node.enum.length
+                || node.enum.some(item => !scalarMatches(String(node.type), item)))
+                return false;
         }
     }
     return value.type === 'object';
 }
 function toolDescriptors(value) {
-    if (!Array.isArray(value) || value.length === 0 || value.length > 64) return false;
+    if (!Array.isArray(value) || value.length === 0 || value.length > 64)
+        return false;
     const names = new Set();
-    return value.every((item)=>{
-        if (!plainObject(item)) return false;
+    return value.every(item => {
+        if (!plainObject(item))
+            return false;
         const keys = Object.keys(item).sort();
-        const required = [
-            'description',
-            'domain_outcomes',
-            'input_schema',
-            'name'
-        ];
-        if (JSON.stringify(keys) !== JSON.stringify([
-            ...required,
-            'output_keys'
-        ].sort())) return false;
-        if (typeof item.name !== 'string' || !IDENTIFIER.test(item.name) || names.has(item.name)) return false;
+        const required = ['description', 'domain_outcomes', 'input_schema', 'name'];
+        if (JSON.stringify(keys) !== JSON.stringify([...required, 'output_keys'].sort()))
+            return false;
+        if (typeof item.name !== 'string' || !IDENTIFIER.test(item.name) || names.has(item.name))
+            return false;
         names.add(item.name);
-        if (!validDescription(item.description, true) || !validInputSchema(item.input_schema)) return false;
-        if (!Array.isArray(item.domain_outcomes) || item.domain_outcomes.length > 64) return false;
+        if (!validDescription(item.description, true) || !validInputSchema(item.input_schema))
+            return false;
+        if (!Array.isArray(item.domain_outcomes) || item.domain_outcomes.length > 64)
+            return false;
         const outcomeKeys = new Set();
-        if (!item.domain_outcomes.every((outcome)=>plainObject(outcome) && JSON.stringify(Object.keys(outcome).sort()) === JSON.stringify([
-                'code',
-                'recovery',
-                'status'
-            ]) && (outcome.status === 'miss' || outcome.status === 'error') && typeof outcome.code === 'string' && IDENTIFIER.test(outcome.code) && typeof outcome.recovery === 'string' && RECOVERIES.has(outcome.recovery) && !outcomeKeys.has(outcome.code) && (outcomeKeys.add(outcome.code), true))) return false;
+        if (!item.domain_outcomes.every(outcome => plainObject(outcome)
+            && JSON.stringify(Object.keys(outcome).sort()) === JSON.stringify(['code', 'recovery', 'status'])
+            && (outcome.status === 'miss' || outcome.status === 'error')
+            && typeof outcome.code === 'string' && IDENTIFIER.test(outcome.code)
+            && typeof outcome.recovery === 'string' && RECOVERIES.has(outcome.recovery)
+            && !outcomeKeys.has(outcome.code)
+            && (outcomeKeys.add(outcome.code), true)))
+            return false;
         return identifiers(item.output_keys);
     });
 }
+// These are passed as direct argv entries (never through a shell), so options
+// such as "-m" and dotted module names are valid. Keep the prefix bounded and
+// reject line/control separators that could make diagnostics ambiguous.
 function argvPrefix(value) {
-    return Array.isArray(value) && value.length > 0 && value.length <= 32 && value.every((item)=>typeof item === 'string' && item.length > 0 && item.length <= 256 && !item.includes('\0') && !item.includes('\r') && !item.includes('\n'));
+    return Array.isArray(value) && value.length > 0 && value.length <= 32 && value.every(item => typeof item === 'string'
+        && item.length > 0
+        && item.length <= 256
+        && !item.includes('\0')
+        && !item.includes('\r')
+        && !item.includes('\n'));
 }
 function exactIsolation(value) {
-    if (!plainObject(value)) return false;
+    if (!plainObject(value))
+        return false;
     const keys = Object.keys(value).sort();
-    return JSON.stringify(keys) === JSON.stringify([
-        'mode',
-        'network',
-        'writes'
-    ]) && value.mode === 'host-enforced' && value.writes === 'forbidden' && value.network === 'denied';
+    return JSON.stringify(keys) === JSON.stringify(['mode', 'network', 'writes'])
+        && value.mode === 'host-enforced'
+        && value.writes === 'forbidden'
+        && value.network === 'denied';
 }
 function validBound(value, maximum) {
     return typeof value === 'number' && Number.isInteger(value) && value >= 1 && value <= maximum;
 }
 function validate(value) {
     const configKeys = plainObject(value) ? Object.keys(value).sort() : [];
-    const baseKeys = [
-        ...CONFIG_KEYS
-    ].sort();
-    if (!plainObject(value) || JSON.stringify(configKeys) !== JSON.stringify(baseKeys) || value.schema_version !== SCHEMA_VERSION || value.enabled !== true || !existingExecutable(value.executable) || !existingDirectory(value.cwd) || !argvPrefix(value.argv_prefix) || !toolDescriptors(value.tools) || !validBound(value.timeout_ms, 120_000) || !validBound(value.max_output_bytes, 10 * 1024 * 1024) || !validateTerminalOutputConfig(value.terminal_output) || !exactIsolation(value.isolation)) return false;
+    const baseKeys = [...CONFIG_KEYS].sort();
+    if (!plainObject(value)
+        || JSON.stringify(configKeys) !== JSON.stringify(baseKeys)
+        || value.schema_version !== SCHEMA_VERSION
+        || value.enabled !== true
+        || !existingExecutable(value.executable)
+        || !existingDirectory(value.cwd)
+        || !argvPrefix(value.argv_prefix)
+        || !toolDescriptors(value.tools)
+        || !validBound(value.timeout_ms, 120_000)
+        || !validBound(value.max_output_bytes, 10 * 1024 * 1024)
+        || !validateTerminalOutputConfig(value.terminal_output)
+        || !exactIsolation(value.isolation))
+        return false;
     return true;
 }
+/** Read and validate an owner-local bridge config without exposing its contents. */
 export function loadBenchmarkEnvironmentConfig(path) {
     try {
-        if (!isAbsolute(path)) return null;
+        if (!isAbsolute(path))
+            return null;
         const metadata = lstatSync(path);
-        if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.size > 64 * 1024) return null;
-        if (typeof getuid !== 'function' || metadata.uid !== getuid()) return null;
-        if ((metadata.mode & 0o022) !== 0) return null;
+        if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.size > 64 * 1024)
+            return null;
+        if (typeof getuid !== 'function' || metadata.uid !== getuid())
+            return null;
+        if ((metadata.mode & 0o022) !== 0)
+            return null;
         const parsed = JSON.parse(readFileSync(path, 'utf8'));
         return validate(parsed) ? deepFreezeJson(parsed) : null;
-    } catch  {
+    }
+    catch {
         return null;
     }
 }
@@ -222,7 +235,8 @@ function structuredObject(text) {
     try {
         const parsed = JSON.parse(text.trim());
         return plainObject(parsed) ? parsed : null;
-    } catch  {
+    }
+    catch {
         return null;
     }
 }
@@ -230,123 +244,68 @@ function jsonObject(value) {
     return JSON.parse(JSON.stringify(value));
 }
 const FORBIDDEN_OUTPUT_KEY_FRAGMENTS = [
-    'answer',
-    'expected',
-    'gold',
-    'groundtruth',
-    'hiddenquery',
-    'label',
-    'loadermetadata',
-    'oracle',
-    'reference',
-    'reward',
-    'score'
+    'answer', 'expected', 'gold', 'groundtruth', 'hiddenquery', 'label',
+    'loadermetadata', 'oracle', 'reference', 'reward', 'score',
 ];
 export const BRIDGE_ERROR_CONTRACT = Object.freeze({
-    invalid_action: {
-        recoverable: true,
-        remedy: 'action 只允许 tools、call 或 errors'
-    },
-    disallowed_tool: {
-        recoverable: true,
-        remedy: '先 action=tools 列出 allowed_tools 清单,再从清单内选工具'
-    },
-    invalid_arguments: {
-        recoverable: true,
-        remedy: 'arguments 必须是可序列化 JSON 对象(≤64KB、深度≤12);收窄后重试'
-    },
-    timed_out: {
-        recoverable: true,
-        remedy: '上游超时;可原样重试一次或换其他工具'
-    },
-    output_truncated: {
-        recoverable: true,
-        remedy: '输出超出上限;让被调工具收窄查询范围后重试'
-    },
-    invalid_json: {
-        recoverable: true,
-        remedy: '上游输出不是合法 JSON;重试一次或换工具'
-    },
-    invalid_output: {
-        recoverable: true,
-        remedy: '上游输出结构不符;重试或换工具'
-    },
-    runner_failed: {
-        recoverable: true,
-        remedy: '上游进程非零退出;可重试一次,持续失败换工具'
-    },
-    spawn_failed: {
-        recoverable: false,
-        remedy: '可执行文件不可用——环境问题,调用方不可恢复'
-    },
-    forbidden_output: {
-        recoverable: false,
-        remedy: '输出含未授权键(策略边界)——不可恢复,换工具或放弃'
-    }
+    invalid_action: { recoverable: true, remedy: 'action 只允许 tools、call 或 errors' },
+    disallowed_tool: { recoverable: true, remedy: '先 action=tools 列出 allowed_tools 清单,再从清单内选工具' },
+    invalid_arguments: { recoverable: true, remedy: 'arguments 必须是可序列化 JSON 对象(≤64KB、深度≤12);收窄后重试' },
+    timed_out: { recoverable: true, remedy: '上游超时;可原样重试一次或换其他工具' },
+    output_truncated: { recoverable: true, remedy: '输出超出上限;让被调工具收窄查询范围后重试' },
+    invalid_json: { recoverable: true, remedy: '上游输出不是合法 JSON;重试一次或换工具' },
+    invalid_output: { recoverable: true, remedy: '上游输出结构不符;重试或换工具' },
+    runner_failed: { recoverable: true, remedy: '上游进程非零退出;可重试一次,持续失败换工具' },
+    spawn_failed: { recoverable: false, remedy: '可执行文件不可用——环境问题,调用方不可恢复' },
+    forbidden_output: { recoverable: false, remedy: '输出含未授权键(策略边界)——不可恢复,换工具或放弃' },
 });
 function inspectOutput(value) {
-    const pending = [
-        {
-            value,
-            depth: 0
-        }
-    ];
+    const pending = [{ value, depth: 0 }];
     let nodes = 0;
-    while(pending.length > 0){
+    while (pending.length > 0) {
         const current = pending.pop();
-        if (++nodes > 10_000 || current.depth > 24) return 'structure_limit';
+        if (++nodes > 10_000 || current.depth > 24)
+            return 'structure_limit';
         if (Array.isArray(current.value)) {
-            for (const child of current.value)pending.push({
-                value: child,
-                depth: current.depth + 1
-            });
+            for (const child of current.value)
+                pending.push({ value: child, depth: current.depth + 1 });
             continue;
         }
-        if (!plainObject(current.value)) continue;
-        for (const [key, child] of Object.entries(current.value)){
-            if (!/^[\x20-\x7E]+$/.test(key)) return 'forbidden_key';
+        if (!plainObject(current.value))
+            continue;
+        for (const [key, child] of Object.entries(current.value)) {
+            if (!/^[\x20-\x7E]+$/.test(key))
+                return 'forbidden_key';
             const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, '');
-            if (FORBIDDEN_OUTPUT_KEY_FRAGMENTS.some((fragment)=>normalized.includes(fragment))) return 'forbidden_key';
-            pending.push({
-                value: child,
-                depth: current.depth + 1
-            });
+            if (FORBIDDEN_OUTPUT_KEY_FRAGMENTS.some(fragment => normalized.includes(fragment)))
+                return 'forbidden_key';
+            pending.push({ value: child, depth: current.depth + 1 });
         }
     }
     return 'ok';
 }
 function inspectAllowedOutput(value, allowedKeys) {
     const allowed = new Set(allowedKeys);
-    const pending = [
-        {
-            value,
-            depth: 0,
-            coveredByDeclaredKey: false
-        }
-    ];
+    const pending = [{ value, depth: 0, coveredByDeclaredKey: false }];
     let nodes = 0;
-    while(pending.length > 0){
+    while (pending.length > 0) {
         const current = pending.pop();
-        if (++nodes > 10_000 || current.depth > 24) return false;
+        if (++nodes > 10_000 || current.depth > 24)
+            return false;
         if (Array.isArray(current.value)) {
-            for (const child of current.value)pending.push({
-                value: child,
-                depth: current.depth + 1,
-                coveredByDeclaredKey: current.coveredByDeclaredKey
-            });
+            for (const child of current.value)
+                pending.push({ value: child, depth: current.depth + 1, coveredByDeclaredKey: current.coveredByDeclaredKey });
             continue;
         }
         if (!plainObject(current.value)) {
-            if (!current.coveredByDeclaredKey) return false;
+            if (!current.coveredByDeclaredKey)
+                return false;
             continue;
         }
-        for (const [key, child] of Object.entries(current.value)){
-            if (!allowed.has(key)) return false;
-            pending.push({
-                value: child,
-                depth: current.depth + 1,
-                coveredByDeclaredKey: true
-            });
+        for (const [key, child] of Object.entries(current.value)) {
+            if (!allowed.has(key))
+                return false;
+            pending.push({ value: child, depth: current.depth + 1, coveredByDeclaredKey: true });
         }
     }
     return true;
@@ -355,68 +314,52 @@ function serializedArguments(value) {
     const seen = new Set();
     let nodes = 0;
     let keys = 0;
-    const inspect = (current, depth)=>{
-        if (++nodes > 10_000 || depth > 12) return false;
+    const inspect = (current, depth) => {
+        if (++nodes > 10_000 || depth > 12)
+            return false;
         if (current && typeof current === 'object') {
-            if (seen.has(current)) return false;
+            if (seen.has(current))
+                return false;
             seen.add(current);
-            if (Array.isArray(current)) return current.every((item)=>inspect(item, depth + 1));
-            return Object.entries(current).every(([key, child])=>{
-                if (++keys > 10_000) return false;
+            if (Array.isArray(current))
+                return current.every(item => inspect(item, depth + 1));
+            return Object.entries(current).every(([key, child]) => {
+                if (++keys > 10_000)
+                    return false;
                 return inspect(key, depth + 1) && inspect(child, depth + 1);
             });
         }
         return true;
     };
-    if (!inspect(value, 0)) return {
-        reason: 'serialization_limit'
-    };
+    if (!inspect(value, 0))
+        return { reason: 'serialization_limit' };
     try {
         const json = JSON.stringify(value);
-        if (typeof json !== 'string' || Buffer.byteLength(json, 'utf8') > 65_536) return {
-            reason: 'serialization_limit'
-        };
-        return {
-            json
-        };
-    } catch  {
-        return {
-            reason: 'serialization_limit'
-        };
+        if (typeof json !== 'string' || Buffer.byteLength(json, 'utf8') > 65_536)
+            return { reason: 'serialization_limit' };
+        return { json };
+    }
+    catch {
+        return { reason: 'serialization_limit' };
     }
 }
+/** Register the opt-in model-facing bridge. */
 export function registerBenchmarkEnvironmentBridge(path, register, subprocess) {
     const bridge = loadBenchmarkEnvironmentConfig(path);
-    if (!bridge) throw new Error('benchmark environment bridge configuration unavailable');
-    if (!subprocess) throw new Error('benchmark environment bridge subprocess unavailable');
+    if (!bridge)
+        throw new Error('benchmark environment bridge configuration unavailable');
+    if (!subprocess)
+        throw new Error('benchmark environment bridge subprocess unavailable');
     const parameters = deepFreezeJson({
         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 时传给工具的参数对象'
-            }
+            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
+        required: ['action'],
+        additionalProperties: false,
     });
     assertSupportedJsonSchema(parameters);
     const definition = {
@@ -425,206 +368,148 @@ export function registerBenchmarkEnvironmentBridge(path, register, subprocess) {
         parameters,
         output: {
             schema: {},
-            render: (_args, value)=>[
-                    {
-                        type: 'text',
-                        text: JSON.stringify(value)
-                    }
-                ]
+            render: (_args, value) => [{ type: 'text', text: JSON.stringify(value) }],
         },
-        async execute (args) {
+        async execute(args) {
             const violations = validateJsonSchemaValue(parameters, args, 'arguments');
-            if (violations.length > 0) throw new ToolArgsError(violations);
+            if (violations.length > 0)
+                throw new ToolArgsError(violations);
             const query = args;
             const tool = query.tool;
-            const descriptor = bridge.tools.find((item)=>item.name === tool);
+            const descriptor = bridge.tools.find(item => item.name === tool);
             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 (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 (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'
-                });
+                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'
-                ]);
+                throw new ToolArgsError(['arguments: call action requires exactly tool and arguments']);
             }
             if (typeof tool !== 'string' || !descriptor) {
-                return jsonObject({
-                    ok: false,
-                    error: 'disallowed_tool'
-                });
+                return jsonObject({ ok: false, error: 'disallowed_tool' });
             }
             if (!plainObject(query.arguments)) {
-                return jsonObject({
-                    ok: false,
-                    error: 'invalid_arguments'
-                });
+                return jsonObject({ ok: false, error: 'invalid_arguments' });
             }
             const callArguments = query.arguments;
             const argumentViolations = validateJsonSchemaValue(descriptor.input_schema, callArguments, 'arguments');
-            if (argumentViolations.length > 0) throw new ToolArgsError(argumentViolations);
+            if (argumentViolations.length > 0)
+                throw new ToolArgsError(argumentViolations);
             const serialized = serializedArguments(callArguments);
-            if (serialized.reason) return jsonObject({
-                ok: false,
-                error: 'invalid_arguments',
-                reason: serialized.reason
-            });
+            if (serialized.reason)
+                return jsonObject({ ok: false, error: 'invalid_arguments', reason: serialized.reason });
             const controller = new AbortController();
-            const timer = setTimeout(()=>{
+            const timer = setTimeout(() => {
                 controller.abort();
             }, bridge.timeout_ms);
             let handle;
             try {
-                const env = Object.fromEntries(Object.keys(process.env).map((key)=>[
-                        key,
-                        undefined
-                    ]));
-                for (const key of [
-                    'PATH',
-                    'LANG',
-                    'LC_ALL',
-                    'LC_CTYPE',
-                    'TZ'
-                ]){
-                    if (process.env[key] !== undefined) env[key] = process.env[key];
+                const env = Object.fromEntries(Object.keys(process.env).map(key => [key, undefined]));
+                for (const key of ['PATH', 'LANG', 'LC_ALL', 'LC_CTYPE', 'TZ']) {
+                    if (process.env[key] !== undefined)
+                        env[key] = process.env[key];
                 }
                 env.PYTHONDONTWRITEBYTECODE = '1';
                 env.PYTHONNOUSERSITE = '1';
-                handle = subprocess.spawn({
-                    argv: [
-                        bridge.executable,
-                        ...bridge.argv_prefix,
-                        'call',
-                        tool,
-                        serialized.json
-                    ],
-                    cwd: bridge.cwd,
-                    stdio: {
-                        stdin: 'ignore',
-                        stdout: {
-                            maxBytes: bridge.max_output_bytes
+                try {
+                    handle = subprocess.spawn({
+                        argv: [bridge.executable, ...bridge.argv_prefix, 'call', tool, serialized.json],
+                        cwd: bridge.cwd,
+                        stdio: {
+                            stdin: 'ignore',
+                            stdout: { maxBytes: bridge.max_output_bytes },
+                            stderr: { maxBytes: bridge.max_output_bytes },
                         },
-                        stderr: {
-                            maxBytes: bridge.max_output_bytes
-                        }
-                    },
-                    graceMs: Math.min(1_000, bridge.timeout_ms),
-                    env,
-                    signal: controller.signal
-                });
-                const status = await handle.done;
-                if (controller.signal.aborted) return jsonObject({
-                    ok: false,
-                    error: 'timed_out'
-                });
-                const stdout = handle.collected.stdout.readFrom(0);
-                const stderr = handle.collected.stderr.readFrom(0);
-                if (stdout.lossy || stderr.lossy) return jsonObject({
-                    ok: false,
-                    error: 'output_truncated'
-                });
+                        graceMs: Math.min(1_000, bridge.timeout_ms),
+                        env,
+                        signal: controller.signal,
+                    });
+                }
+                catch {
+                    if (controller.signal.aborted)
+                        return jsonObject({ ok: false, error: 'timed_out' });
+                    return jsonObject({ ok: false, error: 'spawn_failed' });
+                }
+                let status;
+                try {
+                    status = await handle.done;
+                }
+                catch {
+                    if (controller.signal.aborted)
+                        return jsonObject({ ok: false, error: 'timed_out' });
+                    return jsonObject({ ok: false, error: 'spawn_failed' });
+                }
+                if (controller.signal.aborted)
+                    return jsonObject({ ok: false, error: 'timed_out' });
+                let stdout;
+                let stderr;
+                try {
+                    stdout = handle.collected.stdout.readFrom(0);
+                    stderr = handle.collected.stderr.readFrom(0);
+                }
+                catch {
+                    return jsonObject({
+                        ok: false,
+                        error: 'runner_failed',
+                        exit_code: status.exitCode,
+                        signal: status.signal ?? null,
+                    });
+                }
+                if (stdout.lossy || stderr.lossy)
+                    return jsonObject({ ok: false, error: 'output_truncated' });
                 if (status.exitCode !== 0) {
                     return jsonObject({
                         ok: false,
                         error: 'runner_failed',
                         exit_code: status.exitCode,
-                        signal: status.signal ?? null
+                        signal: status.signal ?? null,
                     });
                 }
                 const parsed = structuredObject(stdout.text);
-                if (!parsed) return jsonObject({
-                    ok: false,
-                    error: 'invalid_json'
-                });
+                if (!parsed)
+                    return jsonObject({ ok: false, error: 'invalid_json' });
                 const outputInspection = inspectOutput(parsed);
-                if (outputInspection === 'forbidden_key') return jsonObject({
-                    ok: false,
-                    error: 'forbidden_output'
-                });
-                if (outputInspection === 'structure_limit') return jsonObject({
-                    ok: false,
-                    error: 'invalid_output'
-                });
+                if (outputInspection === 'forbidden_key')
+                    return jsonObject({ ok: false, error: 'forbidden_output' });
+                if (outputInspection === 'structure_limit')
+                    return jsonObject({ ok: false, error: 'invalid_output' });
                 if (parsed.schema_version !== BENCHMARK_TOOL_RESULT_SCHEMA_VERSION || typeof parsed.status !== 'string') {
-                    return jsonObject({
-                        ok: false,
-                        error: 'invalid_output'
-                    });
+                    return jsonObject({ ok: false, error: 'invalid_output' });
                 }
                 if (parsed.status === 'miss' || parsed.status === 'error') {
-                    if (typeof parsed.code !== 'string' || typeof parsed.recovery !== 'string' || !descriptor.domain_outcomes.some((outcome)=>outcome.status === parsed.status && outcome.code === parsed.code && outcome.recovery === parsed.recovery)) return jsonObject({
-                        ok: false,
-                        error: 'invalid_output'
-                    });
-                    if (Object.keys(parsed).sort().join(',') !== 'code,recovery,schema_version,status') return jsonObject({
-                        ok: false,
-                        error: 'invalid_output'
-                    });
-                    return jsonObject({
-                        ok: true,
-                        outcome: parsed
-                    });
+                    if (typeof parsed.code !== 'string' || typeof parsed.recovery !== 'string' || !descriptor.domain_outcomes.some(outcome => outcome.status === parsed.status && outcome.code === parsed.code && outcome.recovery === parsed.recovery))
+                        return jsonObject({ ok: false, error: 'invalid_output' });
+                    if (Object.keys(parsed).sort().join(',') !== 'code,recovery,schema_version,status')
+                        return jsonObject({ ok: false, error: 'invalid_output' });
+                    return jsonObject({ ok: true, outcome: parsed });
                 }
-                if (parsed.status !== 'ok' || !Object.hasOwn(parsed, 'result') || Object.keys(parsed).sort().join(',') !== 'result,schema_version,status') return jsonObject({
-                    ok: false,
-                    error: 'invalid_output'
-                });
+                if (parsed.status !== 'ok' || !Object.hasOwn(parsed, 'result') || Object.keys(parsed).sort().join(',') !== 'result,schema_version,status')
+                    return jsonObject({ ok: false, error: 'invalid_output' });
                 const visibleResult = parsed.result;
-                if (!plainObject(visibleResult) && !Array.isArray(visibleResult)) return jsonObject({
-                    ok: false,
-                    error: 'invalid_output'
-                });
-                if (!inspectAllowedOutput(visibleResult, descriptor.output_keys)) return jsonObject({
-                    ok: false,
-                    error: 'forbidden_output'
-                });
-                return jsonObject({
-                    ok: true,
-                    result: visibleResult
-                });
-            } catch  {
-                if (controller.signal.aborted) return jsonObject({
-                    ok: false,
-                    error: 'timed_out'
-                });
-                return jsonObject({
-                    ok: false,
-                    error: !handle || handle.pid === -1 ? 'spawn_failed' : 'runner_failed'
-                });
-            } finally{
+                if (!plainObject(visibleResult) && !Array.isArray(visibleResult))
+                    return jsonObject({ ok: false, error: 'invalid_output' });
+                if (!inspectAllowedOutput(visibleResult, descriptor.output_keys))
+                    return jsonObject({ ok: false, error: 'forbidden_output' });
+                return jsonObject({ ok: true, result: visibleResult });
+            }
+            finally {
                 clearTimeout(timer);
             }
-        }
+        },
     };
     register(definition);
     return Object.freeze({
         toolName: 'gotry_benchmark_environment',
-        allowedTools: Object.freeze(bridge.tools.map((item)=>item.name)),
-        terminal: Object.freeze({
-            ...bridge.terminal_output
-        })
+        allowedTools: Object.freeze(bridge.tools.map(item => item.name)),
+        terminal: Object.freeze({ ...bridge.terminal_output }),
     });
 }
-
-
-//# sourceURL=ts/src/benchmark-environment-bridge.ts