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

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

@@ -1,227 +0,0 @@
-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

@@ -1,173 +0,0 @@
-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