@danceiny/gotry 0.0.1-rc.17 → 0.0.1-rc.19

package/dist/scripts/benchmark-environment-bridge-tests.js

@@ -314,6 +314,30 @@ for (const invalid of [
     '<done>{"ok":</done>'
 ])assert.equal(parseBenchmarkTerminal(invalid, projection.terminal).ok, false);
 assert.equal(parseBenchmarkTerminal(`<done>{"x":"${'y'.repeat(1024)}"}</done>`, projection.terminal).ok, false);
+for (const [raw, expectOk] of [
+    [
+        '<think>plan it</think><done>{"ok":true}</done>',
+        true
+    ],
+    [
+        '<think>a</think>\n<THINK>b</THINK>\n<done>{"ok":true}</done>',
+        true
+    ],
+    [
+        '<done>{"ok":true}</done><think>after</think>',
+        true
+    ],
+    [
+        '<think>unclosed<done>{"ok":true}</done>',
+        false
+    ],
+    [
+        'prose<think>x</think><done>{"ok":true}</done>',
+        false
+    ]
+]){
+    assert.equal(parseBenchmarkTerminal(raw, projection.terminal).ok, expectOk, raw);
+}
 function turnStart(turn = 1) {
     return {
         type: 'turn/start',
@@ -343,11 +367,9 @@ function toolCall(callId = 'call-1', options = {}) {
             callId,
             name: projection.toolName,
             arguments: JSON.stringify({
-                query: {
-                    action,
-                    tool,
-                    arguments: {}
-                }
+                action,
+                tool,
+                arguments: {}
             })
         }
     };
@@ -1608,11 +1630,9 @@ try {
         payload: '$(touch /tmp/nope)'
     };
     const result = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: args
-        }
+        action: 'call',
+        tool: 'lookup',
+        arguments: args
     }, null);
     assert.deepEqual(spawnSpecs[0]?.argv, [
         process.execPath,
@@ -1653,12 +1673,10 @@ try {
         stdout: '{"result":{"city":"Dubai"}}'
     });
     const unmappedResult = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'toString',
-            arguments: {
-                city: 'Dubai'
-            }
+        action: 'call',
+        tool: 'toString',
+        arguments: {
+            city: 'Dubai'
         }
     }, null);
     assert.deepEqual(unmappedResult, {
@@ -1671,12 +1689,10 @@ try {
         stdout: '{"result":{"legacy":"value"}}'
     });
     const legacyResult = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'constructor',
-            arguments: {
-                city: 'Dubai'
-            }
+        action: 'call',
+        tool: 'constructor',
+        arguments: {
+            city: 'Dubai'
         }
     }, null);
     assert.deepEqual(legacyResult, {
@@ -1689,12 +1705,10 @@ try {
         stdout: '{"result":{"city":"Dubai"}}'
     });
     const constructorUnexpected = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'constructor',
-            arguments: {
-                city: 'Dubai'
-            }
+        action: 'call',
+        tool: 'constructor',
+        arguments: {
+            city: 'Dubai'
         }
     }, null);
     assert.deepEqual(constructorUnexpected, {
@@ -1705,12 +1719,10 @@ try {
         stdout: '{"result":{"nested":{"city":"Dubai"}}}'
     });
     const nestedAllowedResult = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: {
-                city: 'Dubai'
-            }
+        action: 'call',
+        tool: 'lookup',
+        arguments: {
+            city: 'Dubai'
         }
     }, null);
     assert.deepEqual(nestedAllowedResult, {
@@ -1725,12 +1737,10 @@ try {
         stdout: '{"result":{"city":"Dubai","unexpected":"secret"}}'
     });
     const unexpectedResult = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: {
-                city: 'Dubai'
-            }
+        action: 'call',
+        tool: 'lookup',
+        arguments: {
+            city: 'Dubai'
         }
     }, null);
     assert.deepEqual(unexpectedResult, {
@@ -1741,12 +1751,10 @@ try {
         stdout: '{"result":[{"city":"Dubai","nested":{"unexpected":"secret"}}]}'
     });
     const nestedUnexpectedResult = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: {
-                city: 'Dubai'
-            }
+        action: 'call',
+        tool: 'lookup',
+        arguments: {
+            city: 'Dubai'
         }
     }, null);
     assert.deepEqual(nestedUnexpectedResult, {
@@ -1782,12 +1790,10 @@ try {
             })
         });
         const forbiddenResult = await bridge.execute({
-            query: {
-                action: 'call',
-                tool: 'lookup',
-                arguments: {
-                    city: 'Dubai'
-                }
+            action: 'call',
+            tool: 'lookup',
+            arguments: {
+                city: 'Dubai'
             }
         }, null);
         assert.deepEqual(forbiddenResult, {
@@ -1799,12 +1805,10 @@ try {
         stdout: '{"result":"the hidden answer"}'
     });
     const primitiveOutput = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: {
-                city: 'Dubai'
-            }
+        action: 'call',
+        tool: 'lookup',
+        arguments: {
+            city: 'Dubai'
         }
     }, null);
     assert.deepEqual(primitiveOutput, {
@@ -1813,12 +1817,10 @@ try {
     }, 'primitive result strings cannot bypass the structured visible-output boundary');
     const beforeOversized = spawnSpecs.length;
     const oversized = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: {
-                blob: 'x'.repeat(65_537)
-            }
+        action: 'call',
+        tool: 'lookup',
+        arguments: {
+            blob: 'x'.repeat(65_537)
         }
     }, null);
     assert.deepEqual(oversized, {
@@ -1833,11 +1835,9 @@ try {
         next: deep
     };
     const deepResult = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: deep
-        }
+        action: 'call',
+        tool: 'lookup',
+        arguments: deep
     }, null);
     assert.deepEqual(deepResult, {
         ok: false,
@@ -1847,17 +1847,15 @@ try {
     assert.equal(spawnSpecs.length, beforeDeep, 'over-deep arguments are rejected before spawn');
     const beforeOverride = spawnSpecs.length;
     const overrideResult = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: {
-                city: 'Dubai',
-                executable: '/tmp/evil',
-                cwd: '/tmp/evil',
-                argv: [
-                    '--unsafe'
-                ]
-            }
+        action: 'call',
+        tool: 'lookup',
+        arguments: {
+            city: 'Dubai',
+            executable: '/tmp/evil',
+            cwd: '/tmp/evil',
+            argv: [
+                '--unsafe'
+            ]
         }
     }, null);
     assert.deepEqual(spawnSpecs[beforeOverride]?.argv, [
@@ -1883,12 +1881,10 @@ try {
         lossy: true
     });
     const truncated = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: {
-                city: 'Dubai'
-            }
+        action: 'call',
+        tool: 'lookup',
+        arguments: {
+            city: 'Dubai'
         }
     }, null);
     assert.deepEqual(truncated, {
@@ -1902,12 +1898,10 @@ try {
         signal: 'SIGTERM'
     });
     const failed = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: {
-                city: 'Dubai'
-            }
+        action: 'call',
+        tool: 'lookup',
+        arguments: {
+            city: 'Dubai'
         }
     }, null);
     assert.deepEqual(failed, {
@@ -1916,6 +1910,27 @@ try {
         exit_code: 17,
         signal: 'SIGTERM'
     }, 'nonzero runner result is structured without stderr echo');
+    const errorsTable = await bridge.execute({
+        action: 'errors'
+    }, null);
+    assert.ok(errorsTable.ok === true && errorsTable.errors, 'errors 契约表可拉取');
+    for (const code of [
+        'invalid_action',
+        'disallowed_tool',
+        'invalid_arguments',
+        'timed_out',
+        'output_truncated',
+        'invalid_json',
+        'invalid_output',
+        'runner_failed',
+        'spawn_failed',
+        'forbidden_output'
+    ]){
+        const row = errorsTable.errors?.[code];
+        assert.ok(row && typeof row.recoverable === 'boolean' && row.remedy.length > 0, `契约表应含 ${code}(recoverable+remedy)`);
+    }
+    assert.equal(errorsTable.errors?.invalid_arguments?.recoverable, true, '参数形态错=调用方可恢复');
+    assert.equal(errorsTable.errors?.forbidden_output?.recoverable, false, '策略边界=不可恢复');
     for (const stdout of [
         'not-json',
         '{"result":1}{"result":2}'
@@ -1924,12 +1939,10 @@ try {
             stdout
         });
         const malformed = await bridge.execute({
-            query: {
-                action: 'call',
-                tool: 'lookup',
-                arguments: {
-                    city: 'Dubai'
-                }
+            action: 'call',
+            tool: 'lookup',
+            arguments: {
+                city: 'Dubai'
             }
         }, null);
         assert.deepEqual(malformed, {
@@ -1941,12 +1954,10 @@ try {
         spawnError: true
     });
     const spawnFailed = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: {
-                city: 'Dubai'
-            }
+        action: 'call',
+        tool: 'lookup',
+        arguments: {
+            city: 'Dubai'
         }
     }, null);
     assert.deepEqual(spawnFailed, {
@@ -1957,12 +1968,10 @@ try {
         spawnReject: true
     });
     const asyncSpawnFailed = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: {
-                city: 'Dubai'
-            }
+        action: 'call',
+        tool: 'lookup',
+        arguments: {
+            city: 'Dubai'
         }
     }, null);
     assert.deepEqual(asyncSpawnFailed, {
@@ -1973,12 +1982,10 @@ try {
         waitForAbort: true
     });
     const timedOut = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: {
-                city: 'Dubai'
-            }
+        action: 'call',
+        tool: 'lookup',
+        arguments: {
+            city: 'Dubai'
         }
     }, null);
     assert.deepEqual(timedOut, {
@@ -1987,35 +1994,35 @@ try {
     }, 'deadline abort is surfaced as timed_out');
     assert.equal(timeoutSignal?.aborted, true, 'timeout abort signal is fired');
     const beforeInvalidArgs = spawnSpecs.length;
-    assert.deepEqual(await bridge.execute({
-        query: {
+    let argsTypeRejected = '';
+    try {
+        await bridge.execute({
             action: 'call',
             tool: 'lookup',
             arguments: [
                 'not',
                 'plain'
             ]
-        }
-    }, null), {
-        ok: false,
-        error: 'invalid_arguments'
-    });
+        }, null);
+    } catch (e) {
+        argsTypeRejected = e.name;
+    }
+    assert.equal(argsTypeRejected, 'ToolArgsError', 'arguments 非对象 → 宿主权 schema 结构化拒绝');
     assert.equal(spawnSpecs.length, beforeInvalidArgs, 'non-object arguments are rejected before spawn');
-    assert.deepEqual(await bridge.execute({
-        query: {
+    let actionRejected = '';
+    try {
+        await bridge.execute({
             action: 'inspect'
-        }
-    }, null), {
-        ok: false,
-        error: 'invalid_action'
-    }, 'unknown action is rejected structurally');
+        }, null);
+    } catch (e) {
+        actionRejected = e.name;
+    }
+    assert.equal(actionRejected, 'ToolArgsError', '枚举外 action → 宿主权 schema 结构化拒绝(ToolArgsError)');
     const beforeRejected = spawnSpecs.length;
     const rejected = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'delete_all',
-            arguments: {}
-        }
+        action: 'call',
+        tool: 'delete_all',
+        arguments: {}
     }, null);
     assert.deepEqual(rejected, {
         ok: false,
@@ -2105,7 +2112,8 @@ try {
     assert.deepEqual(disabledVariables, [
         'current_date',
         'time_anchor_card',
-        'motivation_brief'
+        'motivation_brief',
+        'channel_routing_card'
     ], 'normal product mode keeps its prompt variables');
     const whitespace = [];
     const whitespaceCtx = {
@@ -2462,12 +2470,10 @@ try {
     const legacyBridge = legacyTools.find((tool)=>tool.name === 'gotry_benchmark_environment');
     assert.ok(legacyBridge?.execute, 'legacy config without allowed_output_keys registers the bridge');
     assert.deepEqual(await legacyBridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: {
-                city: 'Dubai'
-            }
+        action: 'call',
+        tool: 'lookup',
+        arguments: {
+            city: 'Dubai'
         }
     }, null), {
         ok: true,

package/dist/scripts/booking-copilot-availability-ledger-binding-tests.js

@@ -3,9 +3,9 @@ import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { ensureLedger } from '../src/state-ledger.js';
-import { BookingCopilotTaskRuntimeV2, bookingV2Digest } from '../src/booking-surface/runtime-v2.js';
+import { BookingCopilotTaskRuntime, bookingDigest } from '../src/booking-surface/runtime.js';
 const workspace = (revision)=>({
-        schemaVersion: 'booking.surface.v2',
+        schemaVersion: 'booking.surface',
         contextRef: 'ctx-ledger-binding',
         surface: 'tenant',
         revision,
@@ -56,7 +56,7 @@ const workspace = (revision)=>({
         }
     });
 const offersReceipt = (actionId, revision)=>({
-        schemaVersion: 'booking.surface.v2',
+        schemaVersion: 'booking.surface',
         kind: 'action.receipt',
         actionId,
         contextRef: 'ctx-ledger-binding',
@@ -82,7 +82,7 @@ const offersReceipt = (actionId, revision)=>({
         }
     });
 const checkReceipt = (actionId, revision)=>({
-        schemaVersion: 'booking.surface.v2',
+        schemaVersion: 'booking.surface',
         kind: 'action.receipt',
         actionId,
         contextRef: 'ctx-ledger-binding',
@@ -108,12 +108,12 @@ const checkReceipt = (actionId, revision)=>({
 function fixture(stage) {
     const root = mkdtempSync(join(tmpdir(), 'gotry-availability-ledger-binding-'));
     const ledger = ensureLedger(root);
-    const runtime = new BookingCopilotTaskRuntimeV2(ledger, {
+    const runtime = new BookingCopilotTaskRuntime(ledger, {
         contextRefFactory: ()=>'ctx-ledger-binding'
     });
     const task = 'ledger-binding-task';
     runtime.startTask({
-        schemaVersion: 'booking.surface.v2',
+        schemaVersion: 'booking.surface',
         kind: 'user.turn',
         taskId: task,
         turnId: 'turn-1',
@@ -123,7 +123,7 @@ function fixture(stage) {
         }
     });
     const query = {
-        schemaVersion: 'booking.surface.v2',
+        schemaVersion: 'booking.surface',
         kind: 'offers.query',
         actionId: 'query-1',
         contextRef: 'ctx-ledger-binding',
@@ -139,14 +139,14 @@ function fixture(stage) {
     };
     runtime.issueOperation(task, query);
     runtime.continueWithReceipt({
-        schemaVersion: 'booking.surface.v2',
+        schemaVersion: 'booking.surface',
         kind: 'action.receipt.continuation',
         taskId: task,
         workspace: workspace(1),
         receipt: offersReceipt('query-1', 1)
     });
     const check = {
-        schemaVersion: 'booking.surface.v2',
+        schemaVersion: 'booking.surface',
         kind: 'offer.check',
         actionId: 'check-1',
         contextRef: 'ctx-ledger-binding',
@@ -160,7 +160,7 @@ function fixture(stage) {
     };
     runtime.issueOperation(task, check);
     if (stage === 'receipt') runtime.continueWithReceipt({
-        schemaVersion: 'booking.surface.v2',
+        schemaVersion: 'booking.surface',
         kind: 'action.receipt.continuation',
         taskId: task,
         workspace: {
@@ -191,7 +191,7 @@ function rewrite(root, kind, mutate) {
 }
 function assertCorrupt(root, label) {
     const ledger = ensureLedger(root);
-    const runtime = new BookingCopilotTaskRuntimeV2(ledger, {
+    const runtime = new BookingCopilotTaskRuntime(ledger, {
         contextRefFactory: ()=>'ctx-ledger-binding'
     });
     assert.throws(()=>runtime.resumeTask('ledger-binding-task'), /ledger_corrupt:ledger-binding-task/, label);
@@ -200,7 +200,7 @@ function assertCorrupt(root, label) {
 {
     const fixtureState = fixture('action');
     const ledger = ensureLedger(fixtureState.root);
-    assert.doesNotThrow(()=>new BookingCopilotTaskRuntimeV2(ledger).resumeTask(fixtureState.task));
+    assert.doesNotThrow(()=>new BookingCopilotTaskRuntime(ledger).resumeTask(fixtureState.task));
     ledger.close();
     rmSync(fixtureState.root, {
         recursive: true,
@@ -211,28 +211,28 @@ function assertCorrupt(root, label) {
         'candidate digest',
         (payload)=>{
             payload.availability.candidateSetDigest = 'f'.repeat(64);
-            payload.availabilityDigest = bookingV2Digest(payload.availability);
+            payload.availabilityDigest = bookingDigest(payload.availability);
         }
     ],
     [
         'offer set digest',
         (payload)=>{
             payload.availability.hotels.h1.currentGeneration.offerSetDigest = 'e'.repeat(64);
-            payload.availabilityDigest = bookingV2Digest(payload.availability);
+            payload.availabilityDigest = bookingDigest(payload.availability);
         }
     ],
     [
         'source receipt digest',
         (payload)=>{
             payload.availability.hotels.h1.currentGeneration.source.receiptDigest = 'd'.repeat(64);
-            payload.availabilityDigest = bookingV2Digest(payload.availability);
+            payload.availabilityDigest = bookingDigest(payload.availability);
         }
     ],
     [
         'active ordinal',
         (payload)=>{
             payload.availability.activeHotelOrdinal = 1;
-            payload.availabilityDigest = bookingV2Digest(payload.availability);
+            payload.availabilityDigest = bookingDigest(payload.availability);
         }
     ],
     [
@@ -248,12 +248,12 @@ function assertCorrupt(root, label) {
                 evidence: 'conclusive'
             };
             payload.availability.availabilityPhase = 'terminal';
-            payload.availabilityDigest = bookingV2Digest(payload.availability);
+            payload.availabilityDigest = bookingDigest(payload.availability);
         }
     ]
 ]){
     const fixtureState = fixture('action');
-    rewrite(fixtureState.root, 'booking.copilot.v2.action.issued', mutate);
+    rewrite(fixtureState.root, 'booking.copilot.action.issued', mutate);
     assertCorrupt(fixtureState.root, label);
     rmSync(fixtureState.root, {
         recursive: true,
@@ -262,7 +262,7 @@ function assertCorrupt(root, label) {
 }
 {
     const fixtureState = fixture('action');
-    rewrite(fixtureState.root, 'booking.copilot.v2.action.issued', (payload)=>{
+    rewrite(fixtureState.root, 'booking.copilot.action.issued', (payload)=>{
         payload.availability.activeHotelOrdinal = 1;
     });
     assertCorrupt(fixtureState.root, 'raw ACTION availability digest mismatch');
@@ -272,7 +272,7 @@ function assertCorrupt(root, label) {
     });
 }{
     const fixtureState = fixture('receipt');
-    rewrite(fixtureState.root, 'booking.copilot.v2.receipt.observed', (payload)=>{
+    rewrite(fixtureState.root, 'booking.copilot.receipt.observed', (payload)=>{
         payload.availability.activeHotelOrdinal = 1;
     });
     assertCorrupt(fixtureState.root, 'raw RECEIPT availability digest mismatch');
@@ -282,10 +282,10 @@ function assertCorrupt(root, label) {
     });
 }{
     const fixtureState = fixture('action');
-    rewrite(fixtureState.root, 'booking.copilot.v2.action.issued', (payload)=>{
+    rewrite(fixtureState.root, 'booking.copilot.action.issued', (payload)=>{
         payload.action.input.offerRef = 'o2';
         const { actionDigest: _ignored, ...base } = payload.action;
-        payload.action.actionDigest = bookingV2Digest(base);
+        payload.action.actionDigest = bookingDigest(base);
     });
     assertCorrupt(fixtureState.root, 'wrong action transition');
     rmSync(fixtureState.root, {
@@ -295,10 +295,10 @@ function assertCorrupt(root, label) {
 }{
     const fixtureState = fixture('receipt');
     const runtimeLedger = ensureLedger(fixtureState.root);
-    const runtime = new BookingCopilotTaskRuntimeV2(runtimeLedger);
+    const runtime = new BookingCopilotTaskRuntime(runtimeLedger);
     assert.deepEqual(runtime.resumeTask(fixtureState.task)?.availability.criteria, {}, 'recovery retains the canonical offer criteria after restart');
     const wrongDetour = {
-        schemaVersion: 'booking.surface.v2',
+        schemaVersion: 'booking.surface',
         kind: 'search.run',
         actionId: 'detour',
         contextRef: 'ctx-ledger-binding',
@@ -320,9 +320,9 @@ function assertCorrupt(root, label) {
     });
 }{
     const fixtureState = fixture('receipt');
-    rewrite(fixtureState.root, 'booking.copilot.v2.receipt.observed', (payload)=>{
+    rewrite(fixtureState.root, 'booking.copilot.receipt.observed', (payload)=>{
         payload.receipt.status = 'applied';
-        payload.receiptDigest = bookingV2Digest(payload.receipt);
+        payload.receiptDigest = bookingDigest(payload.receipt);
     });
     assertCorrupt(fixtureState.root, 'wrong receipt transition');
     rmSync(fixtureState.root, {