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

package/dist/scripts/booking-copilot-bin-proof-tests.js

@@ -0,0 +1,89 @@
+import assert from 'node:assert/strict';
+import { spawn, spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+const root = resolve(import.meta.dirname, '../..');
+const packageJson = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
+assert.equal(packageJson.bin?.['gotry-booking-copilot'], 'bin/gotry-booking-copilot.js');
+const build = spawnSync(process.execPath, [
+    'scripts/build-dist.mjs'
+], {
+    cwd: root,
+    encoding: 'utf8'
+});
+assert.equal(build.status, 0, build.stderr || build.stdout);
+const bin = join(root, 'bin/gotry-booking-copilot.js');
+const missingKey = spawnSync(process.execPath, [
+    bin
+], {
+    cwd: root,
+    env: {
+        PATH: process.env.PATH
+    },
+    encoding: 'utf8'
+});
+assert.equal(missingKey.status, 1);
+assert.match(missingKey.stderr, /booking_copilot_api_key_required/);
+const stateRoot = mkdtempSync(join(tmpdir(), 'gotry-booking-bin-'));
+try {
+    const child = spawn(process.execPath, [
+        bin
+    ], {
+        cwd: root,
+        env: {
+            PATH: process.env.PATH,
+            GOTRY_BOOKING_COPILOT_API_KEY: 'fixture-bff-key',
+            GOTRY_BOOKING_COPILOT_STATE_ROOT: stateRoot,
+            GOTRY_BOOKING_COPILOT_HOST: '127.0.0.1',
+            GOTRY_BOOKING_COPILOT_PORT: '0',
+            DEEPSEEK_API_KEY: 'fixture-model-key'
+        },
+        stdio: [
+            'ignore',
+            'pipe',
+            'pipe'
+        ]
+    });
+    let stderr = '';
+    child.stderr.setEncoding('utf8');
+    child.stderr.on('data', (chunk)=>{
+        stderr += chunk;
+    });
+    await new Promise((resolveReady, reject)=>{
+        const timeout = setTimeout(()=>reject(new Error(`booking copilot bin did not listen: ${stderr}`)), 10_000);
+        const inspect = ()=>{
+            if (!stderr.includes('/a2a/booking-copilot/turn')) return;
+            clearTimeout(timeout);
+            resolveReady();
+        };
+        child.stderr.on('data', inspect);
+        child.once('exit', (code)=>{
+            clearTimeout(timeout);
+            reject(new Error(`booking copilot bin exited before listen: ${code}: ${stderr}`));
+        });
+    });
+    assert.match(stderr, /listening on http:\/\/127\.0\.0\.1:\d+\/a2a\/booking-copilot\/turn/);
+    assert.ok(!stderr.includes('fixture-bff-key'));
+    assert.ok(!stderr.includes('fixture-model-key'));
+    child.kill('SIGTERM');
+    const exit = await new Promise((resolveExit)=>{
+        child.once('exit', (code, signal)=>resolveExit({
+                code,
+                signal
+            }));
+    });
+    assert.deepEqual(exit, {
+        code: 0,
+        signal: null
+    }, `graceful shutdown failed: ${stderr}`);
+} finally{
+    rmSync(stateRoot, {
+        recursive: true,
+        force: true
+    });
+}
+console.log('BOOKING COPILOT BIN PROOF: startup failure/listen/SIGTERM lifecycle OK');
+
+
+//# sourceURL=ts/scripts/booking-copilot-bin-proof-tests.ts

package/dist/scripts/booking-copilot-crossrepo-fixture-server.js

@@ -0,0 +1,113 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { ensureLedger } from '../src/state-ledger.js';
+import { BOOKING_SURFACE_SCHEMA_SHA256, BOOKING_SURFACE_SCHEMA_VERSION } from '../src/booking-surface/contracts.js';
+import { BookingCopilotTaskRuntime } from '../src/booking-surface/runtime.js';
+import { startBookingCopilotServer } from '../src/booking-surface/server.js';
+const API_KEY = 'test-only-cross-repo-key';
+const stateRoot = mkdtempSync(join(tmpdir(), 'gotry-booking-copilot-crossrepo-'));
+const ledger = ensureLedger(stateRoot);
+let sequence = 0;
+const plannerFactory = (initialTask)=>{
+    let receiptObserved = initialTask.lastReceipt !== undefined;
+    return {
+        async next ({ turn, task }) {
+            if (turn.kind === 'action.receipt.continuation') {
+                receiptObserved = true;
+                return [
+                    {
+                        kind: 'terminal',
+                        terminal: {
+                            status: 'completed',
+                            summary: 'Fixture receipt observed.',
+                            factRefs: []
+                        }
+                    }
+                ];
+            }
+            if (receiptObserved) {
+                return [
+                    {
+                        kind: 'terminal',
+                        terminal: {
+                            status: 'completed',
+                            summary: 'Fixture task already has a receipt.',
+                            factRefs: []
+                        }
+                    }
+                ];
+            }
+            const action = task.surface === 'payment_link' ? {
+                schemaVersion: BOOKING_SURFACE_SCHEMA_VERSION,
+                kind: 'hotel.select',
+                actionId: 'cross-repo-action-1',
+                contextRef: task.contextRef,
+                expectedRevision: task.revision,
+                reason: 'Select the requested hotel.',
+                factRefs: [],
+                input: {
+                    hotelRef: 'hotel-proof-1'
+                }
+            } : {
+                schemaVersion: BOOKING_SURFACE_SCHEMA_VERSION,
+                kind: 'search.run',
+                actionId: 'cross-repo-action-1',
+                contextRef: task.contextRef,
+                expectedRevision: task.revision,
+                reason: 'Run the requested search.',
+                factRefs: [],
+                input: {}
+            };
+            return [
+                {
+                    kind: 'operation',
+                    action
+                }
+            ];
+        }
+    };
+};
+async function main() {
+    const runtime = new BookingCopilotTaskRuntime(ledger, {
+        idFactory: (prefix)=>`${prefix}-cross-repo-${++sequence}`,
+        now: ()=>'2026-08-31T00:00:00.000Z'
+    });
+    const handle = await startBookingCopilotServer({
+        apiKey: API_KEY,
+        runtime,
+        plannerFactory,
+        host: '127.0.0.1',
+        port: 0
+    });
+    process.stdout.write(`BOOKING_COPILOT_FIXTURE_STARTUP=${JSON.stringify({
+        url: `http://127.0.0.1:${handle.port}`,
+        version: BOOKING_SURFACE_SCHEMA_VERSION,
+        sha256: BOOKING_SURFACE_SCHEMA_SHA256
+    })}\n`);
+    await new Promise((resolve)=>{
+        const stop = ()=>resolve();
+        process.once('SIGTERM', stop);
+        process.once('SIGINT', stop);
+    });
+    await handle.close();
+}
+try {
+    await main();
+} catch (error) {
+    process.stderr.write(`booking-copilot-crossrepo-fixture failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+} finally{
+    try {
+        ledger.close();
+    } catch (error) {
+        process.stderr.write(`booking-copilot-crossrepo-fixture ledger close failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    }
+    rmSync(stateRoot, {
+        recursive: true,
+        force: true
+    });
+}
+
+
+//# sourceURL=ts/scripts/booking-copilot-crossrepo-fixture-server.ts

package/dist/scripts/booking-copilot-dsh-core-proof-tests.js

@@ -0,0 +1,356 @@
+import assert from 'node:assert/strict';
+import { createServer } from 'node:http';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createDshEmbeddedBookingPlanner, createDshEmbeddedBookingPlannerV2, DSH_EMBEDDED_BOOKING_TOOL_NAMES } from '../src/booking-surface/dsh-planner.js';
+const action = {
+    schemaVersion: 'booking.surface.v1',
+    kind: 'search.run',
+    actionId: 'action-real-dsh-1',
+    contextRef: 'ctx-real-dsh-1',
+    expectedRevision: 0,
+    reason: 'Run the authoritative workspace search.',
+    factRefs: [],
+    input: {}
+};
+function sse(res, chunks) {
+    res.writeHead(200, {
+        'content-type': 'text/event-stream; charset=utf-8',
+        'cache-control': 'no-cache'
+    });
+    for (const chunk of chunks)res.write(`data: ${JSON.stringify(chunk)}\n\n`);
+    res.end('data: [DONE]\n\n');
+}
+function objectKeys(value) {
+    if (Array.isArray(value)) return value.flatMap(objectKeys);
+    if (typeof value !== 'object' || value === null) return [];
+    return Object.entries(value).flatMap(([key, child])=>[
+            key,
+            ...objectKeys(child)
+        ]);
+}
+const requests = [];
+let modelCall = 0;
+const modelServer = createServer((req, res)=>{
+    const parts = [];
+    req.on('data', (part)=>parts.push(part));
+    req.on('end', ()=>{
+        const body = JSON.parse(Buffer.concat(parts).toString('utf8'));
+        requests.push({
+            headers: req.headers,
+            body
+        });
+        modelCall += 1;
+        if (modelCall === 1) {
+            sse(res, [
+                {
+                    id: 'chatcmpl-booking-1',
+                    object: 'chat.completion.chunk',
+                    created: 0,
+                    model: 'deepseek-v4-flash',
+                    choices: [
+                        {
+                            index: 0,
+                            delta: {
+                                role: 'assistant',
+                                tool_calls: [
+                                    {
+                                        index: 0,
+                                        id: 'call-booking-1',
+                                        type: 'function',
+                                        function: {
+                                            name: 'booking_search_hotels',
+                                            arguments: JSON.stringify({
+                                                decision: {
+                                                    kind: 'operation',
+                                                    action
+                                                }
+                                            })
+                                        }
+                                    }
+                                ]
+                            },
+                            finish_reason: 'tool_calls'
+                        }
+                    ],
+                    usage: {
+                        prompt_tokens: 10,
+                        completion_tokens: 5,
+                        total_tokens: 15
+                    }
+                }
+            ]);
+            return;
+        }
+        if (modelCall === 3) {
+            sse(res, [
+                {
+                    id: 'chatcmpl-booking-v2-continuation',
+                    object: 'chat.completion.chunk',
+                    created: 0,
+                    model: 'deepseek-v4-flash',
+                    choices: [
+                        {
+                            index: 0,
+                            delta: {
+                                role: 'assistant',
+                                tool_calls: [
+                                    {
+                                        index: 0,
+                                        id: 'call-booking-v2-continuation',
+                                        type: 'function',
+                                        function: {
+                                            name: 'booking_search_hotels',
+                                            arguments: JSON.stringify({
+                                                decision: {
+                                                    kind: 'terminal',
+                                                    terminal: {
+                                                        status: 'stopped',
+                                                        summary: 'v2 continuation handled',
+                                                        factRefs: []
+                                                    }
+                                                }
+                                            })
+                                        }
+                                    }
+                                ]
+                            },
+                            finish_reason: 'tool_calls'
+                        }
+                    ]
+                }
+            ]);
+            return;
+        }
+        sse(res, [
+            {
+                id: 'chatcmpl-booking-2',
+                object: 'chat.completion.chunk',
+                created: 0,
+                model: 'deepseek-v4-flash',
+                choices: [
+                    {
+                        index: 0,
+                        delta: {
+                            role: 'assistant',
+                            content: 'Typed decision emitted.'
+                        },
+                        finish_reason: 'stop'
+                    }
+                ],
+                usage: {
+                    prompt_tokens: 20,
+                    completion_tokens: 4,
+                    total_tokens: 24
+                }
+            }
+        ]);
+    });
+});
+await new Promise((resolve, reject)=>{
+    modelServer.once('error', reject);
+    modelServer.listen(0, '127.0.0.1', ()=>resolve());
+});
+const address = modelServer.address();
+assert.ok(typeof address === 'object' && address);
+const stateRoot = mkdtempSync(join(tmpdir(), 'gotry-booking-dsh-core-'));
+const workspace = {
+    schemaVersion: 'booking.surface.v1',
+    contextRef: action.contextRef,
+    surface: 'tenant',
+    revision: 0,
+    locale: 'zh-CN',
+    currency: 'AED',
+    searchDraft: {},
+    results: {
+        status: 'idle'
+    },
+    visibleHotels: [],
+    loadedOffers: [],
+    shortlistedOfferRefs: [],
+    capabilities: {
+        surface: 'tenant',
+        allowedActions: [
+            'search.run'
+        ]
+    }
+};
+const turn = {
+    schemaVersion: 'booking.surface.v1',
+    kind: 'user.turn',
+    taskId: 'task-real-dsh-1',
+    workspace: {
+        ...workspace,
+        capabilities: {
+            ...workspace.capabilities,
+            allowedActions: [
+                ...workspace.capabilities.allowedActions
+            ]
+        }
+    },
+    request: {
+        text: '执行当前酒店搜索'
+    }
+};
+const task = {
+    schemaVersion: 'booking.surface.v1',
+    taskId: 'task-real-dsh-1',
+    contextRef: action.contextRef,
+    surface: 'tenant',
+    revision: 0,
+    allowedActions: [
+        'search.run'
+    ],
+    userTurnCount: 1,
+    lastUserTurnDigest: 'digest-only',
+    phase: 'planning',
+    lastSequence: 0
+};
+let planner;
+try {
+    planner = await createDshEmbeddedBookingPlanner({
+        stateRoot,
+        env: {
+            PATH: process.env.PATH,
+            DEEPSEEK_API_KEY: 'fixture-model-key',
+            DEEPSEEK_BASE_URL: `http://127.0.0.1:${address.port}/v1`,
+            GOTRY_BOOKING_COPILOT_API_KEY: 'must-not-enter-dsh',
+            HOTELBYTE_TOKEN: 'must-not-enter-dsh'
+        },
+        maxTokens: 512
+    });
+    const decisions = await planner.plannerFactory(task).next({
+        turn,
+        task
+    });
+    assert.deepEqual(decisions, [
+        {
+            kind: 'operation',
+            action
+        }
+    ]);
+    assert.equal(requests.length, 2, 'real dsh loop executes the typed tool then reaches idle');
+    const toolNames = requests[0].body.tools.map((tool)=>tool.function.name).sort();
+    assert.deepEqual(toolNames, [
+        ...DSH_EMBEDDED_BOOKING_TOOL_NAMES
+    ].sort(), 'real model request exposes exactly the seven embedded tools');
+    assert.ok(!toolNames.some((name)=>/gotry_book|payment|holder|guest/i.test(name)), 'real model request exposes no booking write or PII tool');
+    const executableKeys = requests[0].body.tools.flatMap((tool)=>objectKeys(tool.function.parameters));
+    assert.ok(!executableKeys.some((key)=>/^(book|payment|holder|guest|portalToken|supplierCost)$/i.test(key)), 'tool inputs expose no write or PII field');
+    assert.equal(requests[0].headers.authorization, 'Bearer fixture-model-key');
+    assert.ok(!JSON.stringify(requests).includes('must-not-enter-dsh'), 'BFF and portal credentials never enter the dsh model transport');
+    const v2Workspace = {
+        schemaVersion: 'booking.surface.v2',
+        contextRef: 'ctx-real-dsh-v2',
+        surface: 'tenant',
+        revision: 1,
+        locale: 'en-US',
+        currency: 'AED',
+        searchDraft: {},
+        results: {
+            status: 'idle'
+        },
+        visibleHotels: [],
+        loadedOffers: [],
+        shortlistedOfferRefs: [],
+        capabilities: {
+            surface: 'tenant',
+            allowedActions: [
+                'search.run'
+            ]
+        }
+    };
+    const v2Task = {
+        schemaVersion: 'booking.surface.v2',
+        taskId: 'task-real-dsh-v2',
+        contextRef: v2Workspace.contextRef,
+        surface: 'tenant',
+        revision: 1,
+        allowedActions: [
+            'search.run'
+        ],
+        userTurnCount: 1,
+        operationCount: 1,
+        phase: 'planning',
+        lastSequence: 1,
+        availability: {
+            initialized: true,
+            recoveryStarted: false,
+            availabilityPhase: 'need_offers',
+            activeHotelOrdinal: 0,
+            hotelRefs: [],
+            hotels: {},
+            attempts: [],
+            queryReservations: []
+        },
+        workspaceSnapshot: v2Workspace
+    };
+    const v2Continuation = {
+        schemaVersion: 'booking.surface.v2',
+        kind: 'action.receipt.continuation',
+        taskId: v2Task.taskId,
+        workspace: v2Workspace,
+        receipt: {
+            schemaVersion: 'booking.surface.v2',
+            kind: 'action.receipt',
+            actionId: 'action-real-dsh-v2',
+            contextRef: v2Workspace.contextRef,
+            status: 'applied',
+            revision: 1,
+            observation: {
+                kind: 'search.state',
+                resultCount: 1
+            },
+            resultContract: {
+                outcome: 'complete',
+                hardCriteriaMet: true,
+                factRefs: [],
+                gapCodes: [],
+                blockers: [],
+                relaxationsApplied: []
+            }
+        }
+    };
+    const v2Planner = await createDshEmbeddedBookingPlannerV2({
+        stateRoot,
+        env: {
+            PATH: process.env.PATH,
+            DEEPSEEK_API_KEY: 'fixture-model-key',
+            DEEPSEEK_BASE_URL: `http://127.0.0.1:${address.port}/v1`
+        },
+        maxTokens: 512
+    });
+    try {
+        const continuationDecisions = await v2Planner.plannerFactory(v2Task).next({
+            turn: v2Continuation,
+            task: {
+                ...v2Task,
+                lastReceipt: v2Continuation.receipt
+            }
+        });
+        assert.deepEqual(continuationDecisions, [
+            {
+                kind: 'terminal',
+                terminal: {
+                    status: 'stopped',
+                    summary: 'v2 continuation handled',
+                    factRefs: []
+                }
+            }
+        ], 'real dsh v2 accepts action.receipt.continuation through the typed planner seam');
+    } finally{
+        await v2Planner.close();
+    }
+} finally{
+    await planner?.close();
+    await new Promise((resolve, reject)=>modelServer.close((error)=>error ? reject(error) : resolve()));
+    rmSync(stateRoot, {
+        recursive: true,
+        force: true
+    });
+}
+console.log('BOOKING COPILOT DSH CORE PROOF: real subprocess/sdk/plugin/tool-call/session event/idle OK');
+
+
+//# sourceURL=ts/scripts/booking-copilot-dsh-core-proof-tests.ts