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

package/dist/capabilities/visa-policy.js

@@ -0,0 +1,126 @@
+import { readFileSync } from 'node:fs';
+import { BOOKABLE_FACT_SCHEMA, makeFactId } from '../src/bookable-facts.js';
+const SOURCE_HOST = 'https://cs.mfa.gov.cn';
+const SOURCE_ID = 'cs-mfa';
+const USER_AGENT = 'GoTry/0.0.1 (+https://github.com/Danceiny/gotry; polite policy reader)';
+const CONTINENTS = [
+    'yz_645708',
+    'feizhou_645714',
+    'ouzhou_645711',
+    'bz_645718',
+    'dyz_645717'
+];
+export function countryPageUrl(continent, country) {
+    if (!/^[a-z0-9_]+$/.test(continent) || !/^[a-z0-9_]+$/.test(country)) return null;
+    return `${SOURCE_HOST}/zggmcg/ljmdd/${continent}/${country}/`;
+}
+function stripTags(html) {
+    return html.replace(/<(script|style)[\s\S]*?<\/\1>/gi, ' ').replace(/<[^>]+>/g, ' ').replace(/&nbsp;/g, ' ').replace(/&amp;/g, '&').replace(/\s+/g, ' ');
+}
+export function extractVisaSection(pageText) {
+    const text = stripTags(pageText);
+    const start = text.indexOf('签证入境');
+    if (start < 0) return null;
+    const rest = text.slice(start + '签证入境'.length);
+    const sectionEnds = [
+        '海关检查',
+        '海关申报',
+        '医疗条件',
+        '交通出行',
+        '实用信息',
+        '领事保护',
+        '国家安全',
+        '特别提醒'
+    ].map((kw)=>rest.indexOf(kw)).filter((i)=>i > 0);
+    const numHeaders = Array.from(rest.matchAll(/[一二三四五六七八九十]+、(?!免签|落地签|签证|入境规定)/g)).map((m)=>m.index).filter((i)=>i > 0);
+    const allEnds = [
+        ...sectionEnds,
+        ...numHeaders
+    ].sort((a, b)=>a - b);
+    const end = allEnds.length > 0 ? allEnds[0] : Math.min(rest.length, 4_000);
+    const section = rest.slice(0, end).trim();
+    return section.length > 20 ? section : null;
+}
+export function splitPolicyEntries(section) {
+    const parts = section.split(/(?:[一二三四五六七八九十]+、|[（(]\s*[一二三四五六七八九十]+\s*[）)])\s*/).map((p)=>p.trim());
+    return parts.filter((p)=>p.length > 30);
+}
+export function policyFactsFromMfa(input) {
+    const entries = splitPolicyEntries(input.section);
+    const asOf = input.fetchedAt.slice(0, 10);
+    const queryId = `visa-policy:${SOURCE_ID}:${input.countryPath}:${asOf}`;
+    return entries.map((entry, i)=>({
+            schema: BOOKABLE_FACT_SCHEMA,
+            fact_id: makeFactId([
+                input.countryPath,
+                String(i),
+                entry.slice(0, 64),
+                queryId
+            ]),
+            kind: 'policy',
+            subject: `${input.countryLabel} 签证入境(条款 ${i + 1})`,
+            statement: entry,
+            source: `${SOURCE_ID}@${input.fetchedAt}`,
+            query_id: queryId,
+            fetched_at: input.fetchedAt,
+            as_of: asOf,
+            review_by: defaultReviewBy(input.fetchedAt)
+        }));
+}
+export function defaultReviewBy(fetchedAt) {
+    const d = new Date(fetchedAt);
+    d.setDate(d.getDate() + 30);
+    return d.toISOString().slice(0, 10);
+}
+export function listCountryPaths(continentListHtml, continent) {
+    const hits = continentListHtml.matchAll(new RegExp(`href="(\\./([a-z0-9_]+)/)"[^>]*>([^<]{2,20})<`, 'g'));
+    const out = [];
+    for (const m of hits){
+        if (!m[2] || !m[3]) continue;
+        out.push({
+            path: m[2],
+            label: m[3].trim()
+        });
+    }
+    return out.map((x)=>x.path).filter((p)=>/^[a-z0-9_]+$/.test(p));
+}
+export function continentListUrl(continent) {
+    if (!/^[a-z0-9_]+$/.test(continent)) return null;
+    return `${SOURCE_HOST}/zggmcg/ljmdd/${continent}/`;
+}
+export function readPageFixture(path) {
+    return readFileSync(path, 'utf-8');
+}
+export async function fetchVisaPolicyPage(url, timeoutMs = 20_000) {
+    const controller = new AbortController();
+    const timer = setTimeout(()=>controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(url, {
+            headers: {
+                'user-agent': USER_AGENT,
+                'accept-language': 'zh-CN,zh'
+            },
+            signal: controller.signal,
+            redirect: 'follow'
+        });
+        if (!res.ok) return {
+            ok: false,
+            error: `HTTP ${res.status}`
+        };
+        return {
+            ok: true,
+            html: await res.text()
+        };
+    } catch (e) {
+        const msg = controller.signal.aborted ? `timeout after ${timeoutMs}ms` : String(e.message ?? e);
+        return {
+            ok: false,
+            error: msg
+        };
+    } finally{
+        clearTimeout(timer);
+    }
+}
+
+
+//# sourceURL=ts/capabilities/visa-policy.ts

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

@@ -0,0 +1,304 @@
+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 alreadyHandedOff = JSON.stringify(body).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