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

package/dist/scripts/agent-planning-budget-e2e.js

@@ -0,0 +1,227 @@
+import assert from 'node:assert/strict';
+import { createServer } from 'node:http';
+import { existsSync, mkdtempSync, 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 TIMEOUT_MS = 90_000;
+const TOOL = 'gotry_artifacts_list';
+const EXHAUSTED = 'TOOL_BUDGET_EXHAUSTED';
+function sse(data) {
+    return `data: ${JSON.stringify(data)}\n\n`;
+}
+function toolResponse(number) {
+    const count = number === 18 ? 2 : 1;
+    const calls = Array.from({
+        length: count
+    }, (_, index)=>({
+            index,
+            id: `budget-call-${number}-${index + 1}`,
+            type: 'function',
+            function: {
+                name: TOOL,
+                arguments: JSON.stringify({
+                    query: {
+                        limit: 1
+                    }
+                })
+            }
+        }));
+    return sse({
+        id: `budget-${number}`,
+        object: 'chat.completion.chunk',
+        created: 1,
+        model: 'synthetic-budget-model',
+        choices: [
+            {
+                index: 0,
+                delta: {
+                    role: 'assistant',
+                    tool_calls: calls
+                },
+                finish_reason: null
+            }
+        ]
+    }) + sse({
+        id: `budget-${number}-finish`,
+        object: 'chat.completion.chunk',
+        created: 1,
+        model: 'synthetic-budget-model',
+        choices: [
+            {
+                index: 0,
+                delta: {},
+                finish_reason: 'tool_calls'
+            }
+        ]
+    }) + 'data: [DONE]\n\n';
+}
+function textResponse(text, id = 'budget-final') {
+    return sse({
+        id,
+        object: 'chat.completion.chunk',
+        created: 1,
+        model: 'synthetic-budget-model',
+        choices: [
+            {
+                index: 0,
+                delta: {
+                    role: 'assistant',
+                    content: text
+                },
+                finish_reason: null
+            }
+        ]
+    }) + sse({
+        id: `${id}-finish`,
+        object: 'chat.completion.chunk',
+        created: 1,
+        model: 'synthetic-budget-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);
+                res.end(toolResponse(plannerBodies.length));
+            } else if (plannerBodies.length >= 18) {
+                res.end(textResponse('budget E2E final answer'));
+            } else {
+                res.end(textResponse('budget e2e title', 'budget-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-budget-dsh-home-'));
+    const childCwd = mkdtempSync(join(tmpdir(), 'gotry-budget-cwd-'));
+    let exitCode = null;
+    let output = '';
+    const configuredBin = process.env.GOTRY_BUDGET_E2E_BIN;
+    assert.ok(configuredBin && existsSync(configuredBin), 'GOTRY_BUDGET_E2E_BIN must point to the clean installed-package binary');
+    try {
+        const executable = configuredBin;
+        const executableArgs = [
+            'exercise the tool budget'
+        ];
+        const childEnv = {
+            ...process.env
+        };
+        childEnv.DSH_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-budget-model';
+        childEnv.GOTRY_LOCALE = 'zh-CN';
+        childEnv.GOTRY_DISABLE_OPTIONAL_CALENDAR = '1';
+        delete childEnv.GOTRY_LLM_MODEL;
+        const child = spawn(executable, 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 relay.close();
+        rmSync(dshHome, {
+            recursive: true,
+            force: true
+        });
+        rmSync(childCwd, {
+            recursive: true,
+            force: true
+        });
+    }
+    assert.equal(exitCode, 0, `headless exit=${exitCode}; output tail=${output.slice(-1200)}`);
+    assert.equal(relay.plannerBodies.length, 18, `expected 18 tool-enabled planner requests, got ${relay.plannerBodies.length}; output tail=${output.slice(-12_000)}`);
+    const finalRequest = relay.bodies.at(-1);
+    const toolMessages = allToolMessages([
+        finalRequest
+    ]);
+    const normalResults = toolMessages.filter((message)=>!JSON.stringify(message).includes(EXHAUSTED));
+    const exhaustedResults = toolMessages.filter((message)=>JSON.stringify(message).includes(EXHAUSTED));
+    const toolMessageDiagnostic = JSON.stringify(toolMessages).slice(-12_000);
+    assert.equal(normalResults.length, 18, `exactly 18 real tool results/body dispatches; messages=${toolMessageDiagnostic}`);
+    assert.ok(normalResults.every((message)=>JSON.stringify(message).includes('无在册产物')), `all 18 bodies must return the registered artifact-list result; messages=${toolMessageDiagnostic}`);
+    assert.equal(exhaustedResults.length, 1, `19th call returns one structured exhaustion result; messages=${toolMessageDiagnostic}`);
+    assert.ok(JSON.stringify(exhaustedResults[0]).includes(EXHAUSTED));
+    assert.equal(exhaustedResults[0]?.tool_call_id, 'budget-call-18-2');
+    const finalNames = toolNames(finalRequest);
+    assert.ok(!finalNames.includes(TOOL), `final request inherited GoTry tool: ${finalNames.join(', ')}`);
+    assert.equal(finalNames.length, 0, `final request must be text-only, got ${finalNames.join(', ')}`);
+    assert.match(output, /budget E2E final answer/);
+    console.log(`agent planning budget E2E: OK (exit=${exitCode}, plannerRequests=${relay.plannerBodies.length}, allModelRequests=${relay.bodies.length}, realToolResults=${normalResults.length}, exhausted=${exhaustedResults.length})`);
+}
+await main();
+
+
+//# sourceURL=ts/scripts/agent-planning-budget-e2e.ts

package/dist/scripts/agent-planning-budget-tests.js

@@ -0,0 +1,173 @@
+import assert from 'node:assert/strict';
+import { createToolBudgetState, installToolBudget, TOOL_BUDGET_EXHAUSTED, toolBudgetDecision } from '../src/tool-budget.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 ()=>{};
+    }
+};
+installToolBudget(ctx);
+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 budget hooks register');
+assert.deepEqual(toolBudgetDecision(18), {
+    kind: 'allow',
+    softSignal: false,
+    exhaustsBudget: true
+});
+const pureExhausted = toolBudgetDecision(19);
+assert.equal(pureExhausted.kind, 'deny');
+if (pureExhausted.kind === 'deny') assert.match(pureExhausted.reason, /TOOL_BUDGET_EXHAUSTED/);
+const freshState = createToolBudgetState();
+assert.equal(freshState.nextCall().callNumber, 1);
+let directBodies = 0;
+for(let i = 0; i < 25; i++){
+    const result = await execute({
+        token: Symbol(`direct-${i}`)
+    }, async ()=>{
+        directBodies++;
+        return success();
+    });
+    assert.equal(result.isError, false);
+}
+assert.equal(directBodies, 25);
+const agent = makeAgent('agent-serial');
+let serialBodies = 0;
+let softSignals = 0;
+for(let attempt = 1; attempt <= 18; attempt++){
+    const exec = {
+        token: Symbol(`serial-${attempt}`),
+        agent
+    };
+    const result = await execute(exec, async ()=>{
+        serialBodies++;
+        return success();
+    });
+    const post = await postExecute(exec, result, async ()=>({
+            kind: 'accept'
+        }));
+    const contextText = post.additionalContexts?.flatMap((item)=>item.content ?? []).map((item)=>item.text ?? '').join('\n') ?? '';
+    if (contextText.includes('TOOL_BUDGET_SOFT')) softSignals++;
+}
+assert.equal(serialBodies, 18);
+assert.equal(softSignals, 1);
+assert.equal(restricted.length, 0, 'same-step prepared calls remain resolvable until step/end');
+let nineteenthBodyRan = false;
+const nineteenth = await execute({
+    token: Symbol('serial-19'),
+    agent
+}, async ()=>{
+    nineteenthBodyRan = true;
+    return success();
+});
+assert.equal(nineteenthBodyRan, false);
+assert.equal(nineteenth.isError, true);
+assert.deepEqual(nineteenth.error?.info, {
+    name: 'ToolBudgetError',
+    code: TOOL_BUDGET_EXHAUSTED
+});
+assert.match(nineteenth.content[0]?.text ?? '', /TOOL_BUDGET_EXHAUSTED/);
+assert.match(nineteenth.additionalContexts?.[0]?.content?.[0]?.text ?? '', /Produce the final answer/);
+sessionEvent({
+    id: agent.id
+}, {
+    type: 'step/end'
+});
+assert.deepEqual(restricted.at(-1), {
+    agentId: agent.id,
+    deny: [
+        'gotry_alpha',
+        'gotry_beta'
+    ]
+});
+sessionEvent({
+    id: agent.id
+}, {
+    type: 'turn/end'
+});
+assert.equal(lifted.at(-1), agent.id);
+sessionEvent({
+    id: agent.id
+}, {
+    type: 'turn/start'
+});
+const afterReset = await execute({
+    token: Symbol('new-turn-1'),
+    agent
+}, async ()=>success());
+assert.equal(afterReset.isError, false);
+const parallelAgent = makeAgent('agent-parallel');
+let parallelBodies = 0;
+const parallelResults = await Promise.all(Array.from({
+    length: 19
+}, async (_, index)=>{
+    return execute({
+        token: Symbol(`parallel-${index + 1}`),
+        agent: parallelAgent
+    }, async ()=>{
+        parallelBodies++;
+        await Promise.resolve();
+        return success();
+    });
+}));
+assert.equal(parallelBodies, 18);
+assert.equal(parallelResults.filter((result)=>result.isError).length, 1);
+assert.equal(parallelResults.find((result)=>result.isError)?.error?.info?.code, TOOL_BUDGET_EXHAUSTED);
+sessionEvent({
+    id: parallelAgent.id
+}, {
+    type: 'step/end'
+});
+assert.deepEqual(restricted.at(-1), {
+    agentId: parallelAgent.id,
+    deny: [
+        'gotry_alpha',
+        'gotry_beta'
+    ]
+});
+sessionDisposed({
+    id: parallelAgent.id
+});
+assert.equal(lifted.at(-1), parallelAgent.id);
+console.log('agent planning tool budget tests: OK (Cordis execute/post/lifecycle/parallel integration)');
+
+
+//# sourceURL=ts/scripts/agent-planning-budget-tests.ts

package/dist/scripts/agent-reach-deep-tests.js

@@ -51,4 +51,4 @@ import { videoSubtitle, githubSearch } from '../capabilities/agent-reach-deep.js
 }console.log('\nAGENT-REACH DEEP TESTS: 4/4 OK(yt-dlp/gh 可选工具,不装则降级)');
 
 
-//# sourceURL=/Users/bytedance/work/gotry-publish/ts/scripts/agent-reach-deep-tests.ts
+//# sourceURL=ts/scripts/agent-reach-deep-tests.ts

package/dist/scripts/agent-reach-tests.js

@@ -35,4 +35,4 @@ import { readUrl } from '../capabilities/agent-reach.js';
 }console.log('\nAGENT-REACH TESTS: 3/3 OK(readUrl 薄壳;上游真读见 wrapper 套)');
 
 
-//# sourceURL=/Users/bytedance/work/gotry-publish/ts/scripts/agent-reach-tests.ts
+//# sourceURL=ts/scripts/agent-reach-tests.ts

package/dist/scripts/agent-reach-wrapper-tests.js

@@ -80,4 +80,4 @@ import { reach, reachStatus } from '../capabilities/agent-reach.js';
 }console.log('\nAGENT-REACH WRAPPER TESTS: 7/7 OK(反射桥 + doctor 透传 + 自描述错误)');
 
 
-//# sourceURL=/Users/bytedance/work/gotry-publish/ts/scripts/agent-reach-wrapper-tests.ts
+//# sourceURL=ts/scripts/agent-reach-wrapper-tests.ts

package/dist/scripts/anything-tests.js

@@ -92,4 +92,4 @@ while :; do sleep 5; done
 }
 
 
-//# sourceURL=/Users/bytedance/work/gotry-publish/ts/scripts/anything-tests.ts
+//# sourceURL=ts/scripts/anything-tests.ts

package/dist/scripts/async-collect.js

@@ -62,4 +62,4 @@ console.log(JSON.stringify(outcome));
 process.exitCode = outcome.status === 'succeeded' ? 0 : 2;
 
 
-//# sourceURL=/Users/bytedance/work/gotry-publish/ts/scripts/async-collect.ts
+//# sourceURL=ts/scripts/async-collect.ts