@danceiny/gotry 0.0.1-rc.9 → 0.2.0-rc.28

package/dist/scripts/booking-copilot-planner-live-probe.js

@@ -0,0 +1,95 @@
+/**
+ * Live planner probe: boots the real dsh runtime against the real LLM gateway
+ * and one booking task turn, to verify the per-kind tool registration works
+ * with the currently routed model (not only the DeepSeek default).
+ *
+ * Usage: npx tsx scripts/booking-copilot-planner-live-probe.ts
+ *   Requires DEEPSEEK_API_KEY (gateway token) and DEEPSEEK_BASE_URL.
+ */
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createDshEmbeddedBookingPlanner } from '../src/booking-surface/dsh-planner.js';
+const apiKey = process.env.DEEPSEEK_API_KEY;
+const baseUrl = process.env.DEEPSEEK_BASE_URL ?? 'http://173.208.218.132:3000/v1';
+const model = process.env.DEEPSEEK_MODEL ?? 'deepseek-flash';
+if (!apiKey)
+    throw new Error('DEEPSEEK_API_KEY required');
+const contextRef = 'ctx-live-probe-1';
+const workspace = {
+    schemaVersion: 'booking.surface',
+    contextRef,
+    surface: 'tenant',
+    revision: 0,
+    locale: 'zh-CN',
+    currency: 'CNY',
+    searchDraft: {},
+    results: { status: 'idle' },
+    visibleHotels: [],
+    loadedOffers: [],
+    shortlistedOfferRefs: [],
+    capabilities: { surface: 'tenant', allowedActions: ['search.patch', 'search.run'] },
+};
+const turn = {
+    schemaVersion: 'booking.surface',
+    kind: 'user.turn',
+    taskId: 'task-live-probe-1',
+    turnId: 'live-probe-turn-1',
+    workspace,
+    request: { text: '明天入住北京的酒店，两晚，四星级，帮我找最便宜的' },
+};
+const availability = { initialized: true, recoveryStarted: false, availabilityPhase: 'need_offers', activeHotelOrdinal: 0, hotelRefs: [], hotels: {}, attempts: [], queryReservations: [] };
+const task = {
+    schemaVersion: 'booking.surface',
+    taskId: 'task-live-probe-1',
+    contextRef,
+    surface: 'tenant',
+    revision: 0,
+    allowedActions: ['search.patch', 'search.run'],
+    userTurnCount: 1,
+    lastTurnId: 'live-probe-turn-1',
+    operationCount: 0,
+    phase: 'planning',
+    lastSequence: 0,
+    availability,
+    workspaceSnapshot: workspace,
+};
+const metrics = [];
+const stateRoot = mkdtempSync(join(tmpdir(), 'gotry-planner-live-probe-'));
+let planner;
+try {
+    const startedAt = Date.now();
+    planner = await createDshEmbeddedBookingPlanner({
+        stateRoot,
+        env: {
+            PATH: process.env.PATH ?? '',
+            DEEPSEEK_API_KEY: apiKey,
+            DEEPSEEK_BASE_URL: baseUrl,
+            DEEPSEEK_MODEL: model,
+        },
+        // Match the UAT deployment deadline (planner-model-plane.yaml turnTimeoutMs).
+        turnTimeoutMs: 45_000,
+        onMetric: (metric) => metrics.push(metric),
+    });
+    const decisions = await planner.plannerFactory(task).next({ turn, task });
+    const elapsedMs = Date.now() - startedAt;
+    console.log('=== elapsedMs:', elapsedMs);
+    console.log('=== metric:', JSON.stringify(metrics[0]));
+    assert.ok(decisions.length >= 1, 'planner produced a decision');
+    const first = decisions[0];
+    if (first?.kind === 'operation') {
+        console.log('=== operation kind:', first.action.kind);
+        console.log('=== action input:', JSON.stringify(first.action.input).slice(0, 400));
+        assert.equal(first.action.kind, 'search.patch', 'fresh search turn must produce search.patch (runtime compiles search.run itself)');
+    }
+    else {
+        console.log('=== decision kind:', first?.kind, JSON.stringify(first).slice(0, 300));
+        throw new Error(`unexpected decision kind: ${first?.kind}`);
+    }
+    console.log('LIVE PLANNER PROBE OK');
+}
+finally {
+    await planner?.close();
+    rmSync(stateRoot, { recursive: true, force: true });
+}

package/dist/scripts/booking-copilot-proof-runtime.js

@@ -0,0 +1,42 @@
+/**
+ * Legacy regression-test adapter.
+ *
+ * Production callers must pass an explicit final-waypoint intent to
+ * BookingCopilotTaskRuntime.issueOperation. Older low-level tests predate that
+ * boundary and exercise unrelated ledger/availability behavior, so this
+ * adapter repeats an existing durable intent or supplies a local single-step
+ * fixture intent. New intent-boundary tests use the production runtime class.
+ */
+import { BookingCopilotTaskRuntime as StrictBookingCopilotTaskRuntime, } from '../src/booking-surface/runtime.js';
+const ACTION_TARGET = {
+    'search.patch': 'search.results',
+    'search.run': 'search.results',
+    'results.view.patch': 'results.refined',
+    'hotel.focus': 'hotel.focused',
+    'hotel.select': 'hotel.selected',
+    'offers.query': 'offers.loaded',
+    'offers.view.patch': 'offers.refined',
+    'offers.compare': 'offers.compared',
+    'offer.select': 'offer.selected',
+    'offer.check': 'offer.verified',
+    'checkout.prepare': 'checkout.prepared',
+    'order.observe': 'order.observed',
+};
+function singleStepFixtureIntent(action) {
+    const offerCriteria = action.kind === 'offers.query' || action.kind === 'offers.view.patch'
+        ? action.input.criteria
+        : action.kind === 'offers.compare'
+            ? { targetCount: action.input.requestedCount }
+            : undefined;
+    return {
+        schemaVersion: 'booking.intent.v1',
+        target: ACTION_TARGET[action.kind],
+        ...(offerCriteria ? { offerCriteria } : {}),
+    };
+}
+export class BookingCopilotProofRuntime extends StrictBookingCopilotTaskRuntime {
+    issueOperation(taskId, action, intent) {
+        const durable = this.resumeTask(taskId)?.activeIntent?.projection;
+        return super.issueOperation(taskId, action, intent ?? durable ?? singleStepFixtureIntent(action));
+    }
+}

package/dist/scripts/booking-copilot-receipt-ledger-concurrency-proof-tests.js

@@ -0,0 +1,210 @@
+import assert from 'node:assert/strict';
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ensureLedger } from '../src/state-ledger.js';
+import { BookingCopilotTaskRuntime as StrictBookingCopilotTaskRuntime } from '../src/booking-surface/runtime.js';
+import { validateBookingSurface } from '../src/booking-surface/validation.js';
+const childIndex = process.argv.indexOf('--child');
+const child = childIndex >= 0;
+const root = child ? process.argv[childIndex + 1] : undefined;
+const actionId = child ? process.argv[childIndex + 2] : undefined;
+const variant = child ? process.argv[childIndex + 3] : undefined;
+const release = root ? join(root, 'release') : '';
+const workspace = {
+    schemaVersion: 'booking.surface', contextRef: 'ctx-concurrency-opaque', surface: 'tenant', revision: 0,
+    locale: 'en-US', currency: 'AED', searchDraft: {}, results: { status: 'idle' }, visibleHotels: [],
+    loadedOffers: [], shortlistedOfferRefs: [], capabilities: { surface: 'tenant', allowedActions: ['search.run'] },
+};
+const action = {
+    schemaVersion: 'booking.surface', kind: 'search.run', actionId: 'action-concurrency-opaque', contextRef: workspace.contextRef,
+    expectedRevision: 0, reason: 'opaque reason', factRefs: ['fact-opaque'], input: {},
+};
+const searchResultsIntent = { schemaVersion: 'booking.intent.v1', target: 'search.results' };
+function receipt(which) {
+    const value = {
+        schemaVersion: 'booking.surface', kind: 'action.receipt', actionId: action.actionId, contextRef: workspace.contextRef,
+        status: 'applied', revision: 1, observation: { kind: 'search.state', searchSessionRef: `session-${which === 'same-a' || which === 'same-b' ? 'same' : which}`, resultCount: 1 },
+        resultContract: { outcome: 'complete', hardCriteriaMet: true, factRefs: [`fact-${which === 'same-a' || which === 'same-b' ? 'same' : which}`], gapCodes: [], blockers: [], relaxationsApplied: [] }, undoToken: `undo-${which === 'same-a' || which === 'same-b' ? 'same' : which}`,
+    };
+    if (which === 'same-b')
+        return { undoToken: value.undoToken, resultContract: value.resultContract, observation: value.observation, revision: value.revision, status: value.status, contextRef: value.contextRef, actionId: value.actionId, kind: value.kind, schemaVersion: value.schemaVersion };
+    return value;
+}
+function continuation(r, taskId = 'task-concurrency-opaque') {
+    return { schemaVersion: 'booking.surface', kind: 'action.receipt.continuation', taskId, workspace: { ...workspace, revision: 1 }, receipt: r };
+}
+if (process.argv.includes('--replay')) {
+    const replayRoot = process.argv[process.argv.indexOf('--replay') + 1];
+    const replayVariant = process.argv[process.argv.indexOf('--replay') + 2];
+    const replayLedger = ensureLedger(replayRoot);
+    try {
+        new StrictBookingCopilotTaskRuntime(replayLedger).continueWithReceipt(continuation(receipt(replayVariant)));
+        console.log(JSON.stringify({ result: 'success' }));
+    }
+    catch (error) {
+        console.log(JSON.stringify({ result: 'error', error: error instanceof Error ? error.message : String(error) }));
+    }
+    replayLedger.close();
+    process.exit(0);
+}
+if (child) {
+    const ledger = ensureLedger(root);
+    const r = new StrictBookingCopilotTaskRuntime(ledger);
+    writeFileSync(join(root, `started-${variant}`), 'started');
+    const startDeadline = Date.now() + 10_000;
+    while (!existsSync(join(root, 'start'))) {
+        if (Date.now() > startDeadline)
+            throw new Error('child_start_timeout');
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+    }
+    const originalResume = r.resumeTask.bind(r);
+    let firstPendingRead = true;
+    r.resumeTask = (taskId) => {
+        const state = originalResume(taskId);
+        if (firstPendingRead && state?.pendingAction) {
+            firstPendingRead = false;
+            writeFileSync(join(root, `ready-${variant}`), 'ready');
+            const deadline = Date.now() + 10_000;
+            while (!existsSync(release)) {
+                if (Date.now() > deadline)
+                    throw new Error('child_timeout');
+                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+            }
+        }
+        return state;
+    };
+    try {
+        r.continueWithReceipt(continuation(receipt(variant)));
+        console.log(JSON.stringify({ result: 'success', variant }));
+    }
+    catch (error) {
+        console.log(JSON.stringify({ result: 'error', variant, error: error instanceof Error ? error.message : String(error) }));
+    }
+    ledger.close();
+    process.exit(0);
+}
+function waitFor(predicate, timeoutMs) {
+    return new Promise((resolve, reject) => { const deadline = Date.now() + timeoutMs; const tick = () => predicate() ? resolve() : Date.now() > deadline ? reject(new Error('proof_timeout')) : setTimeout(tick, 10); tick(); });
+}
+async function runPair(stateRoot, left, right) {
+    const script = fileURLToPath(import.meta.url);
+    const args = [script, '--child', stateRoot, action.actionId];
+    const tsxBin = fileURLToPath(new URL('../node_modules/tsx/dist/cli.mjs', import.meta.url));
+    const children = [left, right].map((which) => spawn(tsxBin, [...args, which], { cwd: process.cwd(), stdio: ['ignore', 'pipe', 'pipe'] }));
+    const outputs = children.map(() => '');
+    children.forEach((p, i) => { p.stdout.on('data', (b) => { outputs[i] += b.toString(); }); p.stderr.on('data', (b) => { outputs[i] += b.toString(); }); p.on('error', (e) => { outputs[i] += `spawn_error:${e.message}`; }); });
+    try {
+        await waitFor(() => existsSync(join(stateRoot, `started-${left}`)) && existsSync(join(stateRoot, `started-${right}`)), 10_000);
+        writeFileSync(join(stateRoot, 'start'), 'go');
+        await waitFor(() => existsSync(join(stateRoot, `ready-${left}`)) || existsSync(join(stateRoot, `ready-${right}`)), 10_000);
+        await new Promise((resolve) => setTimeout(resolve, 250));
+        assert.equal(existsSync(join(stateRoot, `ready-${left}`)) && existsSync(join(stateRoot, `ready-${right}`)), false, 'only one serialized pending read may pass the barrier');
+    }
+    catch (error) {
+        children.forEach((p) => p.kill('SIGKILL'));
+        throw new Error(`${error instanceof Error ? error.message : error}:${outputs.join('|')}`);
+    }
+    writeFileSync(join(stateRoot, 'release'), 'go');
+    await Promise.all(children.map((p) => new Promise((resolve, reject) => { const t = setTimeout(() => { p.kill('SIGKILL'); reject(new Error('child_process_timeout')); }, 10_000); p.on('exit', (code) => { clearTimeout(t); code === 0 ? resolve() : reject(new Error(`child_exit_${code}:${outputs.join('|')}`)); }); })));
+    return outputs.map((out) => JSON.parse(out.trim().split('\n').at(-1)));
+}
+const stateRoot = root ?? mkdtempSync(join(tmpdir(), 'gotry-receipt-concurrency-'));
+if (!child) {
+    mkdirSync(stateRoot, { recursive: true });
+    const ledger = ensureLedger(stateRoot);
+    const r = new StrictBookingCopilotTaskRuntime(ledger);
+    const turn = { schemaVersion: 'booking.surface', kind: 'user.turn', taskId: 'task-concurrency-opaque', turnId: 'receipt-anchor-turn', workspace, request: { text: 'unique-pii-marker raw-prompt-marker' } };
+    const sensitiveAction = { ...action, reason: 'unique-pii-marker raw-prompt-marker', input: {} };
+    r.startTask(turn);
+    r.issueOperation(turn.taskId, sensitiveAction, searchResultsIntent);
+    assert.throws(() => r.continueWithReceipt(continuation({ ...receipt('a'), undoToken: 'malicious@example.invalid' })), /invalid_receipt_continuation/);
+    assert.throws(() => r.continueWithReceipt(continuation({ ...receipt('a'), observation: { kind: 'gap', code: 'raw-prompt-marker user prose', factRefs: ['numeric-123'] } })), /invalid_receipt_continuation/);
+    assert.equal(validateBookingSurface({ ...receipt('a'), status: 'no_match', observation: { kind: 'gap', code: 'no_hotels_matched', factRefs: ['123'] } }).ok, true);
+    const differing = await runPair(stateRoot, 'a', 'b');
+    assert.equal(differing.filter((x) => x.result === 'success').length, 1);
+    assert.equal(differing.filter((x) => x.error === 'receipt_conflict').length, 1);
+    const after = ledger;
+    assert.equal(after.db.prepare("SELECT COUNT(*) AS n FROM events WHERE kind = 'booking.copilot.receipt.observed'").get().n, 1);
+    const persisted = after.db.prepare("SELECT payload FROM events WHERE kind LIKE 'booking.copilot.%'").all();
+    assert.ok(!persisted.some((row) => /unique-pii-marker|raw-prompt-marker/i.test(row.payload)));
+    const winner = differing.find((x) => x.result === 'success');
+    assert.ok(winner?.variant);
+    assert.deepEqual(new StrictBookingCopilotTaskRuntime(after).resumeTask(turn.taskId)?.lastReceipt, receipt(winner.variant));
+    after.close();
+    rmSync(stateRoot, { recursive: true, force: true });
+    const equalRoot = mkdtempSync(join(tmpdir(), 'gotry-receipt-equal-'));
+    const equalLedger = ensureLedger(equalRoot);
+    const equalRuntime = new StrictBookingCopilotTaskRuntime(equalLedger);
+    equalRuntime.startTask(turn);
+    equalRuntime.issueOperation('task-concurrency-opaque', action, searchResultsIntent);
+    const equal = await runPair(equalRoot, 'same-a', 'same-b');
+    assert.equal(equal.filter((x) => x.result === 'success').length, 2);
+    const equalCheck = equalLedger;
+    assert.equal(equalCheck.db.prepare("SELECT COUNT(*) AS n FROM events WHERE kind = 'booking.copilot.receipt.observed'").get().n, 1);
+    const equalPayloads = equalCheck.db.prepare("SELECT payload FROM events WHERE kind LIKE 'booking.copilot.%'").all();
+    assert.ok(!equalPayloads.some((row) => /sensitive|Authorization|Bearer|raw prompt|secret/i.test(row.payload)));
+    const tampered = equalCheck.db.prepare("SELECT seq, payload FROM events WHERE kind = 'booking.copilot.receipt.observed' LIMIT 1").get();
+    equalCheck.db.prepare('UPDATE events SET payload = ? WHERE seq = ?').run(tampered.payload.replace(/"receiptDigest":"[a-f0-9]+"/, '"receiptDigest":"0000000000000000000000000000000000000000000000000000000000000000"'), tampered.seq);
+    assert.throws(() => new StrictBookingCopilotTaskRuntime(equalCheck).resumeTask('task-concurrency-opaque'), /ledger_corrupt/);
+    equalCheck.close();
+    rmSync(equalRoot, { recursive: true, force: true });
+    for (let round = 0; round < 20; round++) {
+        const loopRoot = mkdtempSync(join(tmpdir(), 'gotry-receipt-round-'));
+        const loopLedger = ensureLedger(loopRoot);
+        const loopRuntime = new StrictBookingCopilotTaskRuntime(loopLedger);
+        loopRuntime.startTask(turn);
+        loopRuntime.issueOperation('task-concurrency-opaque', action, searchResultsIntent);
+        const result = await runPair(loopRoot, 'a', 'b');
+        assert.equal(result.filter((x) => x.result === 'success').length, 1);
+        assert.equal(result.filter((x) => x.error === 'receipt_conflict').length, 1);
+        loopLedger.close();
+        rmSync(loopRoot, { recursive: true, force: true });
+    }
+    const replayRoot = mkdtempSync(join(tmpdir(), 'gotry-receipt-replay-'));
+    const replayLedger = ensureLedger(replayRoot);
+    const replayRuntime = new StrictBookingCopilotTaskRuntime(replayLedger);
+    replayRuntime.startTask(turn);
+    replayRuntime.issueOperation('task-concurrency-opaque', action, searchResultsIntent);
+    replayRuntime.continueWithReceipt(continuation(receipt('same')));
+    const nextAction = { ...action, actionId: 'action-next-opaque', expectedRevision: 1 };
+    replayRuntime.issueOperation('task-concurrency-opaque', nextAction, searchResultsIntent);
+    const beforeReplay = replayLedger.countEvents();
+    const tsxBin = process.env.PATH?.split(':').map((dir) => join(dir, 'tsx')).find(existsSync);
+    assert.ok(tsxBin);
+    for (const replayVariant of ['same', 'conflict']) {
+        const replayChild = spawn(tsxBin, [fileURLToPath(import.meta.url), '--replay', replayRoot, replayVariant], { cwd: process.cwd(), stdio: ['ignore', 'pipe', 'pipe'] });
+        let replayOutput = '';
+        replayChild.stdout.on('data', (b) => { replayOutput += b.toString(); });
+        replayChild.stderr.on('data', (b) => { replayOutput += b.toString(); });
+        await new Promise((resolve, reject) => { const timer = setTimeout(() => { replayChild.kill('SIGKILL'); reject(new Error('replay_timeout')); }, 10_000); replayChild.on('exit', (code) => { clearTimeout(timer); code === 0 ? resolve() : reject(new Error(`replay_exit_${code}`)); }); });
+        const replayResult = JSON.parse(replayOutput.trim().split('\n').at(-1));
+        assert.equal(replayResult.result, replayVariant === 'same' ? 'success' : 'error');
+        if (replayVariant === 'conflict')
+            assert.equal(replayResult.error, 'receipt_conflict');
+    }
+    const replayCheck = replayLedger;
+    assert.equal(replayCheck.countEvents(), beforeReplay);
+    assert.equal(new StrictBookingCopilotTaskRuntime(replayCheck).resumeTask('task-concurrency-opaque')?.pendingAction?.actionId, nextAction.actionId);
+    replayCheck.close();
+    rmSync(replayRoot, { recursive: true, force: true });
+    const reuseRoot = mkdtempSync(join(tmpdir(), 'gotry-receipt-reuse-'));
+    const reuseLedger = ensureLedger(reuseRoot);
+    const reuseRuntime = new StrictBookingCopilotTaskRuntime(reuseLedger);
+    reuseRuntime.startTask(turn);
+    reuseRuntime.issueOperation('task-concurrency-opaque', action, searchResultsIntent);
+    reuseRuntime.continueWithReceipt(continuation(receipt('same')));
+    const actionB = { ...action, actionId: 'action-b-opaque', expectedRevision: 1 };
+    reuseRuntime.issueOperation('task-concurrency-opaque', actionB, searchResultsIntent);
+    reuseRuntime.continueWithReceipt(continuation({ ...receipt('same'), actionId: actionB.actionId }));
+    const reuseEvents = reuseLedger.countEvents();
+    const reuseState = reuseRuntime.resumeTask('task-concurrency-opaque');
+    assert.throws(() => reuseRuntime.issueOperation('task-concurrency-opaque', action, searchResultsIntent), /stale_revision|ledger_write_failed:action|action_already_receipted/);
+    assert.equal(reuseLedger.countEvents(), reuseEvents);
+    assert.deepEqual(reuseRuntime.resumeTask('task-concurrency-opaque'), reuseState);
+    reuseLedger.close();
+    rmSync(reuseRoot, { recursive: true, force: true });
+    console.log('BOOKING COPILOT RECEIPT LEDGER CONCURRENCY PROOF: winner/conflict/atomic persistence OK');
+}