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

package/dist/scripts/agent-planning-turn-deadline-tests.js

@@ -0,0 +1,281 @@
+import assert from 'node:assert/strict';
+import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { installTurnDeadline, TURN_DEADLINE_EXHAUSTED, TURN_DEADLINE_HANDOFF, TURN_HANDOFF_SCHEMA, writeTurnHandoffTicket } from '../src/turn-deadline.js';
+const success = ()=>({
+        isError: false,
+        value: null,
+        content: []
+    });
+const handlers = new Map();
+const restricted = [];
+const lifted = [];
+const makeAgent = (id)=>({
+        id,
+        ctx: {
+            tools: {
+                restrict (filter) {
+                    restricted.push({
+                        agentId: id,
+                        deny: [
+                            ...filter.deny
+                        ]
+                    });
+                    return ()=>lifted.push(id);
+                }
+            }
+        }
+    });
+const ctx = {
+    tools: {
+        schemas: ()=>[
+                {
+                    name: 'gotry_alpha'
+                },
+                {
+                    name: 'gotry_beta'
+                }
+            ]
+    },
+    on (event, listener) {
+        const bucket = handlers.get(event) ?? [];
+        bucket.push(listener);
+        handlers.set(event, bucket);
+        return ()=>{};
+    }
+};
+const productCtx = {
+    tools: {
+        schemas: ()=>[]
+    },
+    on (event) {
+        throw new Error(`opt-out path must not subscribe to ${event}`);
+    }
+};
+installTurnDeadline(productCtx, {
+    enabled: false
+});
+const clock = (()=>{
+    let t = 1_000_000;
+    return {
+        now: ()=>t,
+        advance: (ms)=>{
+            t += ms;
+        }
+    };
+})();
+const handoffRoot = mkdtempSync(join(tmpdir(), 'gotry-turn-handoff-tests-'));
+installTurnDeadline(ctx, {
+    stateRoot: handoffRoot,
+    now: clock.now
+});
+const execute = handlers.get('tools/execute')?.[0];
+const postExecute = handlers.get('tools/post-execute')?.[0];
+const sessionEvent = handlers.get('session/event')?.[0];
+const sessionDisposed = handlers.get('session/disposed')?.[0];
+assert.ok(execute && postExecute && sessionEvent && sessionDisposed, 'all Cordis boundary hooks register');
+const userMessage = (id, text, kind = 'user')=>sessionEvent({
+        id
+    }, {
+        type: 'user/message',
+        data: {
+            source: {
+                kind
+            },
+            content: [
+                {
+                    type: 'text',
+                    text
+                }
+            ]
+        }
+    });
+const turnEvent = (id, type)=>sessionEvent({
+        id
+    }, {
+        type
+    });
+{
+    let directBodies = 0;
+    for(let i = 0; i < 5; i++){
+        const result = await execute({
+            token: Symbol(`direct-${i}`)
+        }, async ()=>{
+            directBodies++;
+            return success();
+        });
+        assert.equal(result.isError, false);
+    }
+    assert.equal(directBodies, 5);
+}{
+    const agent = makeAgent('agent-converge');
+    turnEvent(agent.id, 'turn/start');
+    userMessage(agent.id, '帮我看看10.1去杭州的高铁票');
+    {
+        const exec = {
+            token: Symbol('conv-1'),
+            agent
+        };
+        const result = await execute(exec, async ()=>success());
+        const post = await postExecute(exec, result, async ()=>({
+                kind: 'accept'
+            }));
+        assert.equal(result.isError, false);
+        assert.equal((post.additionalContexts ?? []).length, 0, 'no convergence context before soft');
+        assert.equal(restricted.length, 0);
+    }
+    clock.advance(300_001);
+    {
+        const exec = {
+            token: Symbol('conv-2'),
+            agent
+        };
+        const result = await execute(exec, async ()=>success());
+        const post = await postExecute(exec, result, async ()=>({
+                kind: 'accept'
+            }));
+        const contextText = post.additionalContexts?.flatMap((item)=>item.content ?? []).map((item)=>item.text ?? '').join('\n') ?? '';
+        assert.ok(contextText.includes('TURN_DEADLINE_SOFT'), 'soft context after crossing softMs');
+        assert.ok(contextText.includes('final answer'), 'converge soft text asks for a final answer');
+    }
+    clock.advance(300_000);
+    {
+        const exec = {
+            token: Symbol('conv-3'),
+            agent
+        };
+        let bodyRan = false;
+        const result = await execute(exec, async ()=>{
+            bodyRan = true;
+            return success();
+        });
+        assert.equal(bodyRan, false);
+        assert.equal(result.isError, true);
+        assert.deepEqual(result.error?.info, {
+            name: 'TurnDeadlineError',
+            code: TURN_DEADLINE_EXHAUSTED
+        });
+        assert.match(result.content[0]?.text ?? '', /TURN_DEADLINE_EXHAUSTED/);
+    }
+    assert.deepEqual(restricted.at(-1), {
+        agentId: agent.id,
+        deny: [
+            'gotry_alpha',
+            'gotry_beta'
+        ]
+    });
+    const convergeTicketDir = join(handoffRoot, 'gotry-state', 'turn-handoffs');
+    assert.equal(existsSync(convergeTicketDir) ? readdirSync(convergeTicketDir).length : 0, 0, 'converge writes no ticket');
+    turnEvent(agent.id, 'turn/end');
+    assert.equal(lifted.at(-1), agent.id);
+}{
+    const agent = makeAgent('agent-handoff');
+    turnEvent(agent.id, 'turn/start');
+    const deepMessage = '2026年我还有6天IRW额度 ,我准备再请几天假,在国内待个十几天。' + '其中10.3要去湖南衡阳参加同学婚礼。其他我没有特别的要求,请根据我的实际情况,偏好,外部环境等因素,给我安排行程';
+    userMessage(agent.id, deepMessage);
+    clock.advance(120_001);
+    {
+        const exec = {
+            token: Symbol('hand-1'),
+            agent
+        };
+        const result = await execute(exec, async ()=>success());
+        const post = await postExecute(exec, result, async ()=>({
+                kind: 'accept'
+            }));
+        const contextText = post.additionalContexts?.flatMap((item)=>item.content ?? []).map((item)=>item.text ?? '').join('\n') ?? '';
+        assert.ok(contextText.includes('background planning'), 'handoff soft text announces the handoff');
+        assert.equal(result.isError, false);
+    }
+    clock.advance(120_000);
+    {
+        const exec = {
+            token: Symbol('hand-2'),
+            agent
+        };
+        let bodyRan = false;
+        const result = await execute(exec, async ()=>{
+            bodyRan = true;
+            return success();
+        });
+        assert.equal(bodyRan, false);
+        assert.equal(result.isError, true);
+        assert.deepEqual(result.error?.info, {
+            name: 'TurnDeadlineHandoff',
+            code: TURN_DEADLINE_HANDOFF
+        });
+        const text = result.content[0]?.text ?? '';
+        assert.match(text, /TURN_DEADLINE_HANDOFF/);
+        assert.match(text, /th-/, 'result names the persisted ticket id');
+        assert.match(text, /约 1 小时/, 'ETA label mirrors the S5 promise');
+    }
+    assert.deepEqual(restricted.at(-1), {
+        agentId: agent.id,
+        deny: [
+            'gotry_alpha',
+            'gotry_beta'
+        ]
+    });
+    const tickets = readdirSync(join(handoffRoot, 'gotry-state', 'turn-handoffs'));
+    assert.equal(tickets.length, 1, 'exactly one handoff ticket');
+    const ticket = JSON.parse(readFileSync(join(handoffRoot, 'gotry-state', 'turn-handoffs', tickets[0]), 'utf8'));
+    assert.equal(ticket.schema, TURN_HANDOFF_SCHEMA);
+    assert.equal(ticket.status, 'open');
+    assert.equal(ticket.userMessage, deepMessage, 'ticket carries the verbatim user ask');
+    assert.ok(ticket.requestedAt);
+    assert.equal(ticket.etaLabel, '约 1 小时');
+    turnEvent(agent.id, 'turn/end');
+    userMessage(agent.id, '你好');
+    {
+        const result = await execute({
+            token: Symbol('hand-3'),
+            agent
+        }, async ()=>success());
+        assert.equal(result.isError, false);
+    }
+    turnEvent(agent.id, 'turn/end');
+    assert.equal(readdirSync(join(handoffRoot, 'gotry-state', 'turn-handoffs')).length, 1, 'no extra tickets');
+}{
+    const agent = makeAgent('agent-plugin-msg');
+    turnEvent(agent.id, 'turn/start');
+    userMessage(agent.id, '你好');
+    userMessage(agent.id, deepPlanningNoise(), 'plugin');
+    clock.advance(1_000_000);
+    {
+        const exec = {
+            token: Symbol('plug-1'),
+            agent
+        };
+        const result = await execute(exec, async ()=>success());
+        assert.deepEqual(result.error?.info, {
+            name: 'TurnDeadlineError',
+            code: TURN_DEADLINE_EXHAUSTED
+        });
+    }
+    turnEvent(agent.id, 'turn/end');
+}function deepPlanningNoise() {
+    return '系统提醒样例:10.3 婚礼 IRW 请假 十几天 安排行程——这是插件注入,不该参与路由';
+}
+{
+    const root = mkdtempSync(join(tmpdir(), 'gotry-turn-handoff-writer-'));
+    const ticket = await writeTurnHandoffTicket(root, '短消息');
+    const dir = join(root, 'gotry-state', 'turn-handoffs');
+    assert.equal(readdirSync(dir).length, 1);
+    const loaded = JSON.parse(readFileSync(join(dir, `${ticket.id}.json`), 'utf8'));
+    assert.equal(loaded.userMessage, '短消息');
+    rmSync(root, {
+        recursive: true,
+        force: true
+    });
+}sessionDisposed({
+    id: 'agent-handoff'
+});
+rmSync(handoffRoot, {
+    recursive: true,
+    force: true
+});
+console.log('agent turn deadline tests: OK (routing→converge/handoff exits, ticket persistence, plugin-message discipline, lifecycle)');
+
+
+//# sourceURL=ts/scripts/agent-planning-turn-deadline-tests.ts

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

@@ -61,10 +61,7 @@ function assertRuntimeSelectionAndVersionGuards() {
     const legacyFallback = runRuntimeProbe({
         vendorVersion: '0.1.2-alpha.1'
     });
-    assert.deepEqual(legacyFallback, {
-        source: 'legacy-vendored',
-        version: '0.1.2-alpha.1'
-    }, 'non-benchmark source checkout may use the legacy vendored dsh fallback');
+    assert.equal(legacyFallback, null, 'D-27 removal (#120): legacy vendored fallback no longer resolves even outside benchmark — fail-closed');
     const wrongBenchmarkVersion = runRuntimeProbe({
         rootVersion: '0.1.2-alpha.1',
         vendorVersion: '0.1.2-alpha.1',
@@ -202,12 +199,10 @@ function toolCall(callId = 'bridge-call-1') {
                             function: {
                                 name: TOOL,
                                 arguments: JSON.stringify({
-                                    query: {
-                                        action: 'call',
-                                        tool: 'lookup',
-                                        arguments: {
-                                            city: 'Dubai'
-                                        }
+                                    action: 'call',
+                                    tool: 'lookup',
+                                    arguments: {
+                                        city: 'Dubai'
                                     }
                                 })
                             }