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

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

@@ -30,7 +30,7 @@ const plannerFactory = (initialTask)=>{
                     {
                         kind: 'operation',
                         action: {
-                            schemaVersion: 'booking.surface.v1',
+                            schemaVersion: 'booking.surface',
                             kind: 'search.run',
                             actionId: 'action-http-1',
                             contextRef: task.contextRef,
@@ -72,7 +72,12 @@ const endpoint = `http://127.0.0.1:${serverHandle.port}/a2a/booking-copilot/turn
 const expectedProbe = {
     schemaVersion: SCHEMA_VERSION,
     schemaSha256: SCHEMA_SHA256,
-    status: 'ready'
+    status: 'ready',
+    ingressMode: 'bff-bound-turn-only',
+    acceptedTurnKinds: [
+        'user.turn',
+        'action.receipt.continuation'
+    ]
 };
 const runtimeReport = process.report?.getReport?.();
 const runtimeGlibcVersion = runtimeReport?.header?.glibcVersionRuntime ?? '';
@@ -115,7 +120,7 @@ for (const path of [
     assert.deepEqual(await authorized.json(), expectedProbe, `${path} exposes only typed readiness contract`);
 }
 const workspace = {
-    schemaVersion: 'booking.surface.v1',
+    schemaVersion: 'booking.surface',
     contextRef: 'ctx-http-1',
     surface: 'tenant',
     revision: 0,
@@ -136,9 +141,10 @@ const workspace = {
     }
 };
 const userTurn = {
-    schemaVersion: 'booking.surface.v1',
+    schemaVersion: 'booking.surface',
     kind: 'user.turn',
     taskId: 'task-http-1',
+    turnId: 'http-turn-1',
     workspace,
     request: {
         text: '执行当前搜索'
@@ -173,20 +179,29 @@ const wrongSchemaHash = await post(userTurn, `Bearer ${API_KEY}`, {
 });
 assert.equal(wrongSchemaHash.status, 409, 'schema drift is rejected before planning');
 const directIngress = await post({
-    schemaVersion: 'booking.surface.v1',
+    schemaVersion: 'booking.surface',
     kind: 'user.turn.ingress',
+    requestKey: 'browser-request-1',
     surfaceHint: 'tenant',
     workspace: {
-        ...workspace,
-        contextRef: undefined,
-        surface: undefined,
-        capabilities: undefined
+        schemaVersion: 'booking.surface',
+        revision: 0,
+        locale: 'zh-CN',
+        currency: 'AED',
+        searchDraft: {},
+        results: {
+            status: 'idle'
+        },
+        visibleHotels: [],
+        loadedOffers: [],
+        shortlistedOfferRefs: []
     },
     request: {
         text: 'browser must use same-origin BFF'
     }
 });
-assert.equal(directIngress.status, 400, 'GoTry server rejects unbound browser ingress');
+assert.equal(directIngress.status, 503, 'GoTry server rejects unbound browser ingress');
+assert.equal((await directIngress.json()).error.code, 'trusted_ingress_binding_required');
 const tokenSmuggle = await post({
     ...userTurn,
     portalToken: 'ST:must-not-cross-boundary'
@@ -208,15 +223,17 @@ const firstEvents = parseSse(await first.text());
 assert.deepEqual(firstEvents.map((event)=>event.kind), [
     'status',
     'status',
-    'operation'
+    'operation',
+    'status'
 ]);
+assert.equal(firstEvents[3].kind === 'status' ? firstEvents[3].status : '', 'waiting_receipt', 'the operation leaves the task durably waiting for its receipt');
 assert.ok(firstEvents.every((event)=>event.contextRef === workspace.contextRef), 'every typed event carries BFF-minted contextRef');
 const operation = firstEvents[2];
 assert.equal(operation?.kind, 'operation');
 assert.equal(factoryCalls, 1);
 assert.equal(sessionTurns, 1);
 const receiptTurn = {
-    schemaVersion: 'booking.surface.v1',
+    schemaVersion: 'booking.surface',
     kind: 'action.receipt.continuation',
     taskId: 'task-http-1',
     workspace: {
@@ -229,7 +246,7 @@ const receiptTurn = {
         }
     },
     receipt: {
-        schemaVersion: 'booking.surface.v1',
+        schemaVersion: 'booking.surface',
         kind: 'action.receipt',
         actionId: 'action-http-1',
         contextRef: workspace.contextRef,
@@ -244,7 +261,9 @@ const receiptTurn = {
             outcome: 'complete',
             hardCriteriaMet: true,
             factRefs: [],
-            gapCodes: []
+            gapCodes: [],
+            blockers: [],
+            relaxationsApplied: []
         }
     }
 };
@@ -261,15 +280,18 @@ assert.equal(sessionTurns, 2);
 assert.ok(!secondEvents.some((event)=>event.kind === 'operation'), 'JSON-looking explanation text is not parsed into an operation');
 assert.ok(secondEvents[0].sequence > firstEvents.at(-1).sequence, 'SSE sequence is monotonic across turns');
 await serverHandle.close();
-let recoveredLastReceipt = false;
+const preRestartRuntime = new BookingCopilotTaskRuntime(ledger, {
+    idFactory: (prefix)=>`${prefix}-probe-${++nextId}`,
+    now: ()=>'2026-08-30T12:01:00.000Z'
+});
+const recovered = preRestartRuntime.resumeTask('task-http-1');
+assert.equal(recovered?.lastReceipt?.actionId, 'action-http-1', 'new server process seam restores task from last typed receipt');
+assert.equal(recovered?.phase, 'terminal', 'the completed task stays durably terminal across restart');
 const restarted = await startBookingCopilotServer({
     apiKey: API_KEY,
-    runtime: new BookingCopilotTaskRuntime(ledger, {
-        idFactory: (prefix)=>`${prefix}-restart-${++nextId}`,
-        now: ()=>'2026-08-30T12:01:00.000Z'
-    }),
+    runtime: preRestartRuntime,
     plannerFactory: (initialTask)=>{
-        recoveredLastReceipt = initialTask.lastReceipt?.actionId === 'action-http-1';
+        assert.equal(initialTask.taskId, 'task-http-2');
         return {
             async next () {
                 return [
@@ -298,13 +320,26 @@ const afterRestartResponse = await fetch(restartedEndpoint, {
     },
     body: JSON.stringify({
         ...userTurn,
-        workspace: receiptTurn.workspace
+        taskId: 'task-http-2',
+        turnId: 'http-restart-turn-1',
+        workspace: {
+            ...workspace,
+            contextRef: 'ctx-http-2'
+        }
     })
 });
 assert.equal(afterRestartResponse.status, 200);
-assert.equal(recoveredLastReceipt, true, 'new server process seam restores task from last typed receipt');
 const restartEvents = parseSse(await afterRestartResponse.text());
-assert.ok(restartEvents[0].sequence > secondEvents.at(-1).sequence, 'sequence resumes from durable ledger after server restart');
+assert.deepEqual(restartEvents.map((event)=>event.kind), [
+    'status',
+    'status',
+    'terminal'
+]);
+assert.deepEqual(restartEvents.map((event)=>event.sequence), [
+    1,
+    2,
+    3
+], 'the restarted process allocates fresh task-scoped sequences after recovering the ledger');
 await restarted.close();
 ledger.close();
 rmSync(stateRoot, {

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

@@ -3,7 +3,7 @@ import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { resolveBookingCopilotStartupConfig, startBookingCopilotFromEnvironment } from '../src/booking-surface/startup.js';
-import { BOOKING_READ_ACTION_KINDS_V2 } from '../src/booking-surface/contracts-v2.js';
+import { BOOKING_READ_ACTION_KINDS } from '../src/booking-surface/contracts.js';
 assert.throws(()=>resolveBookingCopilotStartupConfig({}), /booking_copilot_api_key_required/);
 assert.throws(()=>resolveBookingCopilotStartupConfig({
         GOTRY_BOOKING_COPILOT_API_KEY: 'bff-key',
@@ -26,8 +26,8 @@ const env = {
 };
 await assert.rejects(startBookingCopilotFromEnvironment({
     ...env,
-    GOTRY_BOOKING_COPILOT_V2_INGRESS_MODE: 'bff-ingress-binding'
-}, {}), /booking_copilot_v2_ingress_binding_required/, 'explicit ingress mode rejects startup when the trusted BFF seam is absent');
+    GOTRY_BOOKING_COPILOT_INGRESS_MODE: 'bff-ingress-binding'
+}, {}), /booking_copilot_ingress_binding_required/, 'explicit ingress mode rejects startup when the trusted BFF seam is absent');
 await assert.rejects(startBookingCopilotFromEnvironment(env, {
     ingressBinding: {
         bind: ()=>({
@@ -36,17 +36,17 @@ await assert.rejects(startBookingCopilotFromEnvironment(env, {
                 contextRef: 'partial-context',
                 surface: 'tenant',
                 allowedActions: [
-                    ...BOOKING_READ_ACTION_KINDS_V2
+                    ...BOOKING_READ_ACTION_KINDS
                 ]
             })
     }
-}), /booking_copilot_v2_ingress_binding_pair_required/, 'partial trusted BFF seam is rejected before startup');
+}), /booking_copilot_ingress_binding_pair_required/, 'partial trusted BFF seam is rejected before startup');
 await assert.rejects(startBookingCopilotFromEnvironment(env, {
     principal: {
         subject: 'partial-bff',
         scope: 'booking:read'
     }
-}), /booking_copilot_v2_ingress_binding_pair_required/, 'principal without a binding is rejected before startup');
+}), /booking_copilot_ingress_binding_pair_required/, 'principal without a binding is rejected before startup');
 let standaloneIngressMode = '';
 const standaloneStateRoot = mkdtempSync(join(tmpdir(), 'gotry-booking-startup-standalone-'));
 const standalone = await startBookingCopilotFromEnvironment({
@@ -71,21 +71,8 @@ const standalone = await startBookingCopilotFromEnvironment({
             },
             async close () {}
         }),
-    runtimeFactoryV2 () {
-        return {};
-    },
-    createPlannerV2: async ()=>({
-            plannerFactory () {
-                return {
-                    async next () {
-                        return [];
-                    }
-                };
-            },
-            async close () {}
-        }),
     async startServer (options) {
-        standaloneIngressMode = options.v2?.ingressMode ?? '';
+        standaloneIngressMode = options.ingressMode ?? '';
         return {
             server: {},
             port: 43122,
@@ -102,12 +89,11 @@ rmSync(standaloneStateRoot, {
 });
 const closeOrder = [];
 let plannerEnv;
-let plannerV2Env;
 let serverApiKey = '';
 let serverArtifactId = '';
 const trustedEnv = {
     ...env,
-    GOTRY_BOOKING_COPILOT_V2_INGRESS_MODE: 'bff-ingress-binding'
+    GOTRY_BOOKING_COPILOT_INGRESS_MODE: 'bff-ingress-binding'
 };
 const fakeLedger = {
     close () {
@@ -121,7 +107,7 @@ const trustedBinding = {
             contextRef: 'startup-context',
             surface: 'tenant',
             allowedActions: [
-                ...BOOKING_READ_ACTION_KINDS_V2
+                ...BOOKING_READ_ACTION_KINDS
             ]
         })
 };
@@ -147,24 +133,6 @@ const started = await startBookingCopilotFromEnvironment(trustedEnv, {
             }
         };
     },
-    runtimeFactoryV2 () {
-        return {};
-    },
-    async createPlannerV2 (options) {
-        plannerV2Env = options.env;
-        return {
-            plannerFactory () {
-                return {
-                    async next () {
-                        return [];
-                    }
-                };
-            },
-            async close () {
-                closeOrder.push('planner-v2');
-            }
-        };
-    },
     ingressBinding: trustedBinding,
     principal: {
         subject: 'startup-bff',
@@ -173,7 +141,7 @@ const started = await startBookingCopilotFromEnvironment(trustedEnv, {
     async startServer (options) {
         serverApiKey = options.apiKey;
         serverArtifactId = options.artifactId ?? '';
-        assert.equal(options.v2?.ingressMode, 'bff-ingress-binding');
+        assert.equal(options.ingressMode, 'bff-ingress-binding');
         return {
             server: {},
             port: 43123,
@@ -190,93 +158,16 @@ assert.equal(plannerEnv?.DEEPSEEK_API_KEY, 'model-only-key');
 assert.equal(plannerEnv?.GOTRY_BOOKING_COPILOT_API_KEY, undefined);
 assert.equal(plannerEnv?.PORTAL_TOKEN, undefined);
 assert.equal(plannerEnv?.HOTELBYTE_TOKEN, undefined);
-assert.equal(plannerV2Env?.DEEPSEEK_API_KEY, 'model-only-key');
 await started.close();
 assert.deepEqual(closeOrder, [
     'server',
     'planner',
-    'planner-v2',
     'ledger'
 ]);
 rmSync(stateRoot, {
     recursive: true,
     force: true
 });
-const v2StateRoot = mkdtempSync(join(tmpdir(), 'gotry-booking-startup-v2-'));
-let v2Passed = false;
-let v2PlannerEnv;
-const v2CloseOrder = [];
-const v2Started = await startBookingCopilotFromEnvironment({
-    ...trustedEnv,
-    GOTRY_BOOKING_COPILOT_STATE_ROOT: v2StateRoot
-}, {
-    ensureLedger () {
-        return {
-            close () {
-                v2CloseOrder.push('ledger');
-            }
-        };
-    },
-    runtimeFactory () {
-        return {};
-    },
-    createPlanner: async ()=>({
-            plannerFactory () {
-                return {
-                    async next () {
-                        return [];
-                    }
-                };
-            },
-            async close () {}
-        }),
-    runtimeFactoryV2 () {
-        return {};
-    },
-    async createPlannerV2 (options) {
-        v2PlannerEnv = options.env;
-        return {
-            plannerFactory () {
-                return {
-                    async next () {
-                        return [];
-                    }
-                };
-            },
-            async close () {
-                v2CloseOrder.push('planner-v2');
-            }
-        };
-    },
-    ingressBinding: trustedBinding,
-    principal: {
-        subject: 'startup-bff',
-        scope: 'booking:read'
-    },
-    async startServer (options) {
-        v2Passed = Boolean(options.v2 && options.runtime && options.plannerFactory);
-        return {
-            server: {},
-            port: 43124,
-            async close () {
-                v2CloseOrder.push('server');
-            }
-        };
-    }
-});
-assert.equal(v2Started.port, 43124);
-assert.equal(v2Passed, true, 'v2 startup constructs and passes the real v2 adapter seam');
-assert.equal(v2PlannerEnv?.DEEPSEEK_API_KEY, 'model-only-key');
-await v2Started.close();
-assert.deepEqual(v2CloseOrder, [
-    'server',
-    'planner-v2',
-    'ledger'
-]);
-rmSync(v2StateRoot, {
-    recursive: true,
-    force: true
-});
 console.log('BOOKING COPILOT STARTUP PROOF: env split/server+planner+ledger lifecycle OK');