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

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

@@ -0,0 +1,305 @@
+import assert from 'node:assert/strict';
+import { createServer } from 'node:http';
+import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { spawn } from 'node:child_process';
+const ROOT = join(import.meta.dirname, '..', '..');
+const TS_DIR = join(import.meta.dirname, '..');
+const TIMEOUT_MS = 90_000;
+const TOOL = 'gotry_artifacts_list';
+const SOFT_MS = 5_000;
+const HARD_MS = 10_000;
+const RELAY_STALL_MS = HARD_MS + 1_000;
+const HANDOFF = 'TURN_DEADLINE_HANDOFF';
+const HANDOFF_SCHEMA = 'gotry_turn_handoff.v1';
+const DEEP_MESSAGE = '2026年我还有6天IRW额度,我准备再请几天假,在国内待个十几天。' + '其中10.3要去湖南衡阳参加同学婚礼。请根据我的实际情况和偏好,给我安排行程';
+function sse(data) {
+    return `data: ${JSON.stringify(data)}\n\n`;
+}
+function toolResponse(idSuffix) {
+    const call = {
+        index: 0,
+        id: `deadline-call-${idSuffix}`,
+        type: 'function',
+        function: {
+            name: TOOL,
+            arguments: JSON.stringify({
+                query: {
+                    limit: 1
+                }
+            })
+        }
+    };
+    return sse({
+        id: `deadline-${idSuffix}`,
+        object: 'chat.completion.chunk',
+        created: 1,
+        model: 'synthetic-deadline-model',
+        choices: [
+            {
+                index: 0,
+                delta: {
+                    role: 'assistant',
+                    tool_calls: [
+                        call
+                    ]
+                },
+                finish_reason: null
+            }
+        ]
+    }) + sse({
+        id: `deadline-${idSuffix}-finish`,
+        object: 'chat.completion.chunk',
+        created: 1,
+        model: 'synthetic-deadline-model',
+        choices: [
+            {
+                index: 0,
+                delta: {},
+                finish_reason: 'tool_calls'
+            }
+        ]
+    }) + 'data: [DONE]\n\n';
+}
+function textResponse(text, id = 'deadline-final') {
+    return sse({
+        id,
+        object: 'chat.completion.chunk',
+        created: 1,
+        model: 'synthetic-deadline-model',
+        choices: [
+            {
+                index: 0,
+                delta: {
+                    role: 'assistant',
+                    content: text
+                },
+                finish_reason: null
+            }
+        ]
+    }) + sse({
+        id: `${id}-finish`,
+        object: 'chat.completion.chunk',
+        created: 1,
+        model: 'synthetic-deadline-model',
+        choices: [
+            {
+                index: 0,
+                delta: {},
+                finish_reason: 'stop'
+            }
+        ]
+    }) + 'data: [DONE]\n\n';
+}
+async function startRelay() {
+    const bodies = [];
+    const plannerBodies = [];
+    const server = createServer((req, res)=>{
+        if (req.method !== 'POST' || !req.url?.endsWith('/chat/completions')) {
+            res.writeHead(404).end('not found');
+            return;
+        }
+        const chunks = [];
+        req.on('data', (chunk)=>chunks.push(Buffer.from(chunk)));
+        req.on('end', ()=>{
+            let body;
+            try {
+                body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+            } catch  {
+                body = {};
+            }
+            bodies.push(body);
+            res.writeHead(200, {
+                'content-type': 'text/event-stream',
+                'cache-control': 'no-cache'
+            });
+            if (toolNames(body).includes(TOOL)) {
+                plannerBodies.push(body);
+                const plannerIndex = plannerBodies.length;
+                const realToolMessages = (body.messages ?? []).filter((message)=>message.role === 'tool');
+                const alreadyHandedOff = realToolMessages.some((message)=>JSON.stringify(message).includes(HANDOFF));
+                const stall = !alreadyHandedOff && plannerIndex === 1 ? RELAY_STALL_MS : 0;
+                setTimeout(()=>{
+                    if (!alreadyHandedOff && plannerIndex === 1) {
+                        res.end(toolResponse(String(plannerIndex)));
+                    } else {
+                        res.end(textResponse('deadline E2E final answer'));
+                    }
+                }, stall);
+            } else {
+                res.end(textResponse('deadline E2E final answer', 'deadline-auxiliary'));
+            }
+        });
+    });
+    await new Promise((resolve)=>server.listen(0, '127.0.0.1', resolve));
+    return {
+        port: server.address().port,
+        bodies,
+        plannerBodies,
+        close: ()=>new Promise((resolve)=>server.close(()=>resolve()))
+    };
+}
+function allToolMessages(bodies) {
+    return bodies.flatMap((body)=>(body.messages ?? []).filter((message)=>message.role === 'tool'));
+}
+function toolNames(body) {
+    return (body.tools ?? []).map((tool)=>{
+        const fn = tool.function;
+        return String(fn?.name ?? tool.name ?? '');
+    }).filter(Boolean);
+}
+async function main() {
+    for (const file of [
+        'dist/src/index.js',
+        'dist/capabilities/artifacts.js'
+    ]){
+        assert.ok(existsSync(join(ROOT, file)), `missing ${file}; run node scripts/build-dist.mjs first`);
+    }
+    const relay = await startRelay();
+    const dshHome = mkdtempSync(join(tmpdir(), 'gotry-deadline-dsh-home-'));
+    const childCwd = mkdtempSync(join(tmpdir(), 'gotry-deadline-cwd-'));
+    const handoffRoot = mkdtempSync(join(tmpdir(), 'gotry-deadline-handoff-'));
+    let exitCode = null;
+    let output = '';
+    const configuredBin = process.env.GOTRY_DEADLINE_E2E_BIN;
+    assert.ok(configuredBin && existsSync(configuredBin), 'GOTRY_DEADLINE_E2E_BIN must point to the clean installed-package binary');
+    try {
+        const executableArgs = [
+            DEEP_MESSAGE
+        ];
+        const childEnv = {
+            ...process.env
+        };
+        childEnv.DSH_HOME = dshHome;
+        childEnv.HOME = dshHome;
+        childEnv.LLM_API_KEY = 'synthetic-e2e-key';
+        childEnv.LLM_BASE_URL = 'http://127.0.0.1:' + relay.port + '/v1';
+        childEnv.LLM_MODEL = 'synthetic-deadline-model';
+        childEnv.GOTRY_LOCALE = 'zh-CN';
+        childEnv.GOTRY_TURN_DEADLINE_SOFT_MS = String(SOFT_MS);
+        childEnv.GOTRY_TURN_DEADLINE_HARD_MS = String(HARD_MS);
+        childEnv.GOTRY_TURN_HANDOFF_ROOT = handoffRoot;
+        delete childEnv.GOTRY_LLM_MODEL;
+        delete childEnv.GOTRY_FORCE_TURN_DEADLINE;
+        const child = spawn(configuredBin, executableArgs, {
+            cwd: childCwd,
+            env: childEnv,
+            stdio: [
+                'ignore',
+                'pipe',
+                'pipe'
+            ]
+        });
+        child.stdout.on('data', (chunk)=>{
+            output += chunk.toString();
+        });
+        child.stderr.on('data', (chunk)=>{
+            output += chunk.toString();
+        });
+        exitCode = await new Promise((resolve)=>{
+            const timer = setTimeout(()=>{
+                child.kill('SIGKILL');
+                resolve(null);
+            }, TIMEOUT_MS);
+            child.once('exit', (code)=>{
+                clearTimeout(timer);
+                resolve(code);
+            });
+        });
+    } finally{
+        await new Promise((resolve)=>setTimeout(resolve, 200));
+    }
+    assert.equal(exitCode, 0, `headless exit=${exitCode}; output tail=${output.slice(-1200)}`);
+    assert.ok(relay.plannerBodies.length >= 1, `expected at least one tool-enabled planner request, got ${relay.plannerBodies.length}; output tail=${output.slice(-12_000)}`);
+    const toolMessages = allToolMessages(relay.bodies);
+    const toolMessageDiagnostic = JSON.stringify(toolMessages).slice(-12_000);
+    const handoffResults = toolMessages.filter((message)=>JSON.stringify(message).includes(HANDOFF));
+    const successfulResults = toolMessages.filter((message)=>!JSON.stringify(message).includes(HANDOFF));
+    assert.ok(handoffResults.length >= 1, `expected at least one handoff result; messages=${toolMessageDiagnostic}`);
+    assert.equal(successfulResults.length, 0, `no tool body should run past the hard deadline; messages=${toolMessageDiagnostic}`);
+    assert.match(JSON.stringify(handoffResults[0]), /th-/, 'handoff result carries the ticket id');
+    const ticketDir = join(handoffRoot, 'gotry-state', 'turn-handoffs');
+    assert.ok(existsSync(ticketDir), `ticket dir missing: ${ticketDir}`);
+    const ticketFiles = readdirSync(ticketDir).filter((name)=>name.endsWith('.json'));
+    assert.equal(ticketFiles.length, 1, `expected exactly one handoff ticket, got ${ticketFiles.join(', ')}`);
+    const ticket = JSON.parse(readFileSync(join(ticketDir, ticketFiles[0]), 'utf8'));
+    assert.equal(ticket['schema'], HANDOFF_SCHEMA);
+    assert.equal(ticket['status'], 'open');
+    assert.ok(String(ticket['userMessage']).includes('婚礼'), 'ticket carries the verbatim deep-planning ask');
+    assert.ok(String(ticket['etaLabel']).includes('约 1 小时'));
+    const finalRequest = relay.bodies.at(-1);
+    const finalNames = toolNames(finalRequest);
+    assert.ok(!finalNames.includes(TOOL), `final request inherited GoTry tool: ${finalNames.join(', ')}`);
+    assert.match(output, /deadline E2E final answer/);
+    {
+        const ticketId = String(ticket['id']);
+        const collector = spawn(process.execPath, [
+            join(TS_DIR, 'node_modules', 'tsx', 'dist', 'cli.mjs'),
+            join(TS_DIR, 'scripts', 'turn-handoff-collect.ts'),
+            ticketId,
+            handoffRoot
+        ], {
+            cwd: TS_DIR,
+            env: {
+                ...process.env,
+                GOTRY_HANDOFF_PLANNER_BIN: configuredBin,
+                LLM_API_KEY: 'synthetic-e2e-key',
+                LLM_BASE_URL: 'http://127.0.0.1:' + relay.port + '/v1',
+                LLM_MODEL: 'synthetic-deadline-model',
+                GOTRY_LOCALE: 'zh-CN'
+            },
+            stdio: [
+                'ignore',
+                'pipe',
+                'pipe'
+            ]
+        });
+        let collectorOut = '';
+        let collectorErr = '';
+        collector.stdout.on('data', (chunk)=>{
+            collectorOut += chunk.toString();
+        });
+        collector.stderr.on('data', (chunk)=>{
+            collectorErr += chunk.toString();
+        });
+        const collectorCode = await new Promise((resolve)=>{
+            const timer = setTimeout(()=>{
+                collector.kill('SIGKILL');
+                resolve(null);
+            }, 90_000);
+            collector.once('exit', (code)=>{
+                clearTimeout(timer);
+                resolve(code);
+            });
+        });
+        assert.equal(collectorCode, 0, `collector exit=${collectorCode}; stderr tail=${collectorErr.slice(-800)}; stdout tail=${collectorOut.slice(-400)}`);
+        const terminal = JSON.parse(collectorOut.trim().split('\n').at(-1));
+        assert.equal(terminal['schema'], 'gotry_turn_handoff_terminal.v1');
+        assert.equal(terminal['status'], 'succeeded');
+        assert.ok(String(terminal['deliverable_path']).includes(`${ticketId}.deliverable.md`));
+        const settled = JSON.parse(readFileSync(join(ticketDir, `${ticketId}.json`), 'utf8'));
+        assert.equal(settled['status'], 'settled');
+        assert.ok(settled['settledAt'], 'settledAt recorded');
+        const deliverable = readFileSync(join(ticketDir, `${ticketId}.deliverable.md`), 'utf8');
+        assert.ok(deliverable.includes('deadline E2E final answer'), `deliverable carries planner final; got: ${deliverable.slice(-400)}`);
+    }
+    console.log(`agent turn deadline E2E: OK (exit=${exitCode}, plannerRequests=${relay.plannerBodies.length}, handoffResults=${handoffResults.length}, ticket=${ticketFiles[0]}, collected=settled)`);
+    await relay.close();
+    rmSync(dshHome, {
+        recursive: true,
+        force: true
+    });
+    rmSync(childCwd, {
+        recursive: true,
+        force: true
+    });
+    rmSync(handoffRoot, {
+        recursive: true,
+        force: true
+    });
+}
+await main();
+
+
+//# sourceURL=ts/scripts/agent-planning-turn-deadline-e2e.ts

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