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

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

@@ -1,7 +1,17 @@
 import assert from 'node:assert/strict';
-import { DSH_EMBEDDED_BOOKING_TOOL_NAMES, buildDshPlannerEnvironment, createDshEmbeddedBookingPlanner, createDshEmbeddedBookingPlannerV2 } from '../src/booking-surface/dsh-planner.js';
+import { DSH_EMBEDDED_BOOKING_TOOL_NAMES, buildDshPlannerEnvironment, createDshEmbeddedBookingPlanner } from '../src/booking-surface/dsh-planner.js';
+const availability = {
+    initialized: true,
+    recoveryStarted: false,
+    availabilityPhase: 'need_offers',
+    activeHotelOrdinal: 0,
+    hotelRefs: [],
+    hotels: {},
+    attempts: [],
+    queryReservations: []
+};
 const task = {
-    schemaVersion: 'booking.surface.v1',
+    schemaVersion: 'booking.surface',
     taskId: 'task-dsh-1',
     contextRef: 'ctx-dsh-1',
     surface: 'tenant',
@@ -11,12 +21,14 @@ const task = {
         'search.run'
     ],
     userTurnCount: 1,
-    lastUserTurnDigest: 'request-digest',
+    lastTurnId: 'dsh-turn-1',
+    operationCount: 0,
     phase: 'planning',
-    lastSequence: 0
+    lastSequence: 0,
+    availability
 };
 const workspace = {
-    schemaVersion: 'booking.surface.v1',
+    schemaVersion: 'booking.surface',
     contextRef: task.contextRef,
     surface: 'tenant',
     revision: 0,
@@ -38,7 +50,7 @@ const workspace = {
     }
 };
 const searchRun = {
-    schemaVersion: 'booking.surface.v1',
+    schemaVersion: 'booking.surface',
     kind: 'search.run',
     actionId: 'action-dsh-1',
     contextRef: task.contextRef,
@@ -133,9 +145,10 @@ const session = adapter.plannerFactory(task);
 const first = await session.next({
     task,
     turn: {
-        schemaVersion: 'booking.surface.v1',
+        schemaVersion: 'booking.surface',
         kind: 'user.turn',
         taskId: task.taskId,
+        turnId: 'dsh-turn-1',
         workspace: {
             ...workspace,
             capabilities: {
@@ -157,7 +170,7 @@ assert.deepEqual(first, [
     }
 ], 'typed dsh tool call becomes one operation');
 const receipt = {
-    schemaVersion: 'booking.surface.v1',
+    schemaVersion: 'booking.surface',
     kind: 'action.receipt',
     actionId: searchRun.actionId,
     contextRef: task.contextRef,
@@ -172,7 +185,9 @@ const receipt = {
         outcome: 'complete',
         hardCriteriaMet: true,
         factRefs: [],
-        gapCodes: []
+        gapCodes: [],
+        blockers: [],
+        relaxationsApplied: []
     }
 };
 const continuedTask = {
@@ -183,7 +198,7 @@ const continuedTask = {
 const second = await session.next({
     task: continuedTask,
     turn: {
-        schemaVersion: 'booking.surface.v1',
+        schemaVersion: 'booking.surface',
         kind: 'action.receipt.continuation',
         taskId: task.taskId,
         workspace: {
@@ -224,9 +239,10 @@ const paymentSession = adapter.plannerFactory(paymentTask);
 const selected = await paymentSession.next({
     task: paymentTask,
     turn: {
-        schemaVersion: 'booking.surface.v1',
+        schemaVersion: 'booking.surface',
         kind: 'user.turn',
         taskId: paymentTask.taskId,
+        turnId: 'payment-turn-1',
         workspace: {
             ...workspace,
             surface: 'payment_link',
@@ -271,7 +287,7 @@ assert.equal(childEnv.DEEPSEEK_BASE_URL, 'http://model.invalid/v1');
 assert.equal(childEnv.PORTAL_TOKEN, undefined);
 assert.equal(childEnv.HOTELBYTE_TOKEN, undefined);
 assert.equal(childEnv.GOTRY_BOOKING_COPILOT_API_KEY, undefined);
-const proseOnlyPort = {
+const textChannelPort = {
     async run () {
         return {
             finalResponse: JSON.stringify({
@@ -283,15 +299,16 @@ const proseOnlyPort = {
     },
     async close () {}
 };
-const proseOnly = await createDshEmbeddedBookingPlanner({
-    runPort: proseOnlyPort
+const textChannel = await createDshEmbeddedBookingPlanner({
+    runPort: textChannelPort
 });
-const proseDecisions = await proseOnly.plannerFactory(task).next({
+const textDecisions = await textChannel.plannerFactory(task).next({
     task,
     turn: {
-        schemaVersion: 'booking.surface.v1',
+        schemaVersion: 'booking.surface',
         kind: 'user.turn',
         taskId: task.taskId,
+        turnId: 'dsh-turn-3',
         workspace: {
             ...workspace,
             capabilities: {
@@ -306,7 +323,292 @@ const proseDecisions = await proseOnly.plannerFactory(task).next({
         }
     }
 });
-assert.equal(proseDecisions[0]?.kind, 'error', 'JSON-looking assistant prose is never executable');
+assert.equal(textDecisions[0]?.kind, 'operation', 'text-channel typed decisions execute through the same authority path');
+assert.deepEqual(textDecisions[0].action, {
+    ...searchRun,
+    expectedRevision: 0
+});
+const sanitizedRefPort = {
+    async run () {
+        return {
+            finalResponse: '',
+            events: [
+                {
+                    type: 'tool/call',
+                    data: {
+                        name: 'booking_search_hotels',
+                        arguments: JSON.stringify({
+                            decision: {
+                                kind: 'operation',
+                                action: {
+                                    ...searchRun,
+                                    factRefs: [
+                                        'draft:destination=Dubai'
+                                    ]
+                                }
+                            }
+                        })
+                    }
+                }
+            ]
+        };
+    },
+    async close () {}
+};
+const sanitizedRef = await createDshEmbeddedBookingPlanner({
+    runPort: sanitizedRefPort
+});
+const sanitizedDecisions = await sanitizedRef.plannerFactory(task).next({
+    task,
+    turn: {
+        schemaVersion: 'booking.surface',
+        kind: 'user.turn',
+        taskId: task.taskId,
+        turnId: 'dsh-turn-6b',
+        workspace,
+        request: {
+            text: 'Find hotels'
+        }
+    }
+});
+assert.equal(sanitizedDecisions[0]?.kind, 'operation', 'sanitizer maps off-charset characters deterministically');
+assert.deepEqual(sanitizedDecisions[0].action?.factRefs, [
+    'draft:destination.Dubai'
+]);
+await sanitizedRef.close();
+const unauthorisedPort = {
+    async run () {
+        return {
+            finalResponse: JSON.stringify({
+                kind: 'operation',
+                action: hotelSelect
+            }),
+            events: []
+        };
+    },
+    async close () {}
+};
+const unauthorised = await createDshEmbeddedBookingPlanner({
+    runPort: unauthorisedPort
+});
+const unauthorisedDecisions = await unauthorised.plannerFactory(task).next({
+    task,
+    turn: {
+        schemaVersion: 'booking.surface',
+        kind: 'user.turn',
+        taskId: task.taskId,
+        turnId: 'dsh-turn-4',
+        workspace: {
+            ...workspace,
+            capabilities: {
+                ...workspace.capabilities,
+                allowedActions: [
+                    ...workspace.capabilities.allowedActions
+                ]
+            }
+        },
+        request: {
+            text: 'Select a hotel'
+        }
+    }
+});
+assert.equal(unauthorisedDecisions[0]?.kind, 'error', 'text-channel decisions outside allowedActions stay non-executable');
+const fragmentRefPort = {
+    async run () {
+        return {
+            finalResponse: '',
+            events: [
+                {
+                    type: 'tool/call',
+                    data: {
+                        name: 'booking_search_hotels',
+                        arguments: JSON.stringify({
+                            decision: {
+                                kind: 'operation',
+                                action: {
+                                    ...searchRun,
+                                    factRefs: [
+                                        `fact://turn_${task.lastTurnId}/request`
+                                    ]
+                                }
+                            }
+                        })
+                    }
+                }
+            ]
+        };
+    },
+    async close () {}
+};
+const fragmentRef = await createDshEmbeddedBookingPlanner({
+    runPort: fragmentRefPort
+});
+const fragmentDecisions = await fragmentRef.plannerFactory(task).next({
+    task,
+    turn: {
+        schemaVersion: 'booking.surface',
+        kind: 'user.turn',
+        taskId: task.taskId,
+        turnId: 'dsh-turn-7',
+        workspace,
+        request: {
+            text: 'Find hotels'
+        }
+    }
+});
+assert.equal(fragmentDecisions[0]?.kind, 'operation', 'JSON-pointer fragment factRefs repair into the safe charset');
+assert.deepEqual(fragmentDecisions[0].action?.factRefs, [
+    `fact:..turn_${task.lastTurnId}.request`
+]);
+await fragmentRef.close();
+const truncatedPort = {
+    async run () {
+        const truncated = JSON.stringify({
+            decision: {
+                action: {
+                    ...searchRun,
+                    factRefs: [
+                        'turn_cap-request'
+                    ]
+                },
+                kind: 'operation'
+            }
+        }).replace(/}+$/, '');
+        return {
+            finalResponse: truncated,
+            events: []
+        };
+    },
+    async close () {}
+};
+const truncatedRecovery = await createDshEmbeddedBookingPlanner({
+    runPort: truncatedPort
+});
+const truncatedDecisions = await truncatedRecovery.plannerFactory(task).next({
+    task,
+    turn: {
+        schemaVersion: 'booking.surface',
+        kind: 'user.turn',
+        taskId: task.taskId,
+        turnId: 'dsh-turn-8',
+        workspace,
+        request: {
+            text: 'Find hotels'
+        }
+    }
+});
+assert.equal(truncatedDecisions[0]?.kind, 'operation', 'truncated-but-reconstructable finalResponse recovers through the authority path');
+await truncatedRecovery.close();
+const unsafeRefPort = {
+    async run () {
+        return {
+            finalResponse: '',
+            events: [
+                {
+                    type: 'tool/call',
+                    data: {
+                        name: 'booking_search_hotels',
+                        arguments: JSON.stringify({
+                            decision: {
+                                kind: 'operation',
+                                action: {
+                                    ...searchRun,
+                                    factRefs: [
+                                        42
+                                    ]
+                                }
+                            }
+                        })
+                    }
+                }
+            ]
+        };
+    },
+    async close () {}
+};
+const unsafeRef = await createDshEmbeddedBookingPlanner({
+    runPort: unsafeRefPort
+});
+await assert.rejects(unsafeRef.plannerFactory(task).next({
+    task,
+    turn: {
+        schemaVersion: 'booking.surface',
+        kind: 'user.turn',
+        taskId: task.taskId,
+        turnId: 'dsh-turn-6',
+        workspace,
+        request: {
+            text: 'Find hotels'
+        }
+    }
+}), /planner_invalid_action/, 'non-string factRef entries retry as parse-class failures, not ledger-boundary crashes');
+await unsafeRef.close();
+const foreignOfferWorkspace = {
+    ...workspace,
+    loadedOffers: [
+        {
+            offerRef: "offer-ui-1",
+            offerVersionRef: "offerv-ui-1",
+            hotelRef: "hotel-ui-9",
+            evidenceLevel: "rate_loaded",
+            factRefs: []
+        }
+    ]
+};
+const uiOffersPort = {
+    async run (prompt) {
+        assert.ok(prompt.includes("hotel-ui-9"), "workspace loadedOffers reach the planner payload");
+        return {
+            finalResponse: "",
+            events: []
+        };
+    },
+    async close () {}
+};
+const uiOffers = await createDshEmbeddedBookingPlanner({
+    runPort: uiOffersPort
+});
+const uiOffersDecisions = await uiOffers.plannerFactory(task).next({
+    task,
+    turn: {
+        schemaVersion: "booking.surface",
+        kind: "user.turn",
+        taskId: task.taskId,
+        turnId: "dsh-turn-ui",
+        workspace: foreignOfferWorkspace,
+        request: {
+            text: "Prepare the loaded offer"
+        }
+    }
+});
+assert.equal(uiOffersDecisions[0]?.kind, "error", "foreign loadedOffers reach the payload without crashing the projection");
+await uiOffers.close();
+const plainProsePort = {
+    async run () {
+        return {
+            finalResponse: 'I would search hotels in Dubai for you.',
+            events: []
+        };
+    },
+    async close () {}
+};
+const plainProse = await createDshEmbeddedBookingPlanner({
+    runPort: plainProsePort
+});
+const plainProseDecisions = await plainProse.plannerFactory(task).next({
+    task,
+    turn: {
+        schemaVersion: 'booking.surface',
+        kind: 'user.turn',
+        taskId: task.taskId,
+        turnId: 'dsh-turn-5',
+        workspace,
+        request: {
+            text: 'Find hotels'
+        }
+    }
+});
+assert.equal(plainProseDecisions[0]?.kind, 'error', 'prose without a typed decision envelope is never executable');
 const forbiddenPort = {
     async run () {
         return {
@@ -338,9 +640,10 @@ const forbidden = await createDshEmbeddedBookingPlanner({
 await assert.rejects(forbidden.plannerFactory(task).next({
     task,
     turn: {
-        schemaVersion: 'booking.surface.v1',
+        schemaVersion: 'booking.surface',
         kind: 'user.turn',
         taskId: task.taskId,
+        turnId: 'dsh-turn-4',
         workspace: {
             ...workspace,
             capabilities: {
@@ -355,10 +658,10 @@ await assert.rejects(forbidden.plannerFactory(task).next({
         }
     }
 }), /planner_forbidden_tool/);
-const v2Task = {
-    schemaVersion: 'booking.surface.v2',
-    taskId: 'task-dsh-v2',
-    contextRef: 'ctx-dsh-v2',
+const terminalTask = {
+    schemaVersion: 'booking.surface',
+    taskId: 'task-dsh-terminal',
+    contextRef: 'ctx-dsh-terminal',
     surface: 'tenant',
     revision: 0,
     allowedActions: [
@@ -385,9 +688,9 @@ const v2Task = {
         }
     }
 };
-const v2Workspace = {
-    schemaVersion: 'booking.surface.v2',
-    contextRef: v2Task.contextRef,
+const terminalWorkspace = {
+    schemaVersion: 'booking.surface',
+    contextRef: terminalTask.contextRef,
     surface: 'tenant',
     revision: 0,
     locale: 'en-US',
@@ -406,11 +709,11 @@ const v2Workspace = {
         ]
     }
 };
-let v2Runs = 0;
-const v2Port = {
+let terminalRuns = 0;
+const terminalPort = {
     async run () {
-        v2Runs++;
-        return v2Runs === 1 ? {
+        terminalRuns++;
+        return terminalRuns === 1 ? {
             finalResponse: '',
             events: [
                 {
@@ -422,9 +725,9 @@ const v2Port = {
                                 kind: 'operation',
                                 action: {
                                     ...searchRun,
-                                    schemaVersion: 'booking.surface.v2',
-                                    contextRef: v2Task.contextRef,
-                                    actionId: 'action-dsh-v2'
+                                    schemaVersion: 'booking.surface',
+                                    contextRef: terminalTask.contextRef,
+                                    actionId: 'action-dsh-terminal'
                                 }
                             }
                         })
@@ -455,37 +758,37 @@ const v2Port = {
     },
     async close () {}
 };
-const v2Adapter = await createDshEmbeddedBookingPlannerV2({
-    runPort: v2Port
+const terminalAdapter = await createDshEmbeddedBookingPlanner({
+    runPort: terminalPort
 });
-const v2Decisions = await v2Adapter.plannerFactory(v2Task).next({
-    task: v2Task,
+const terminalDecisions = await terminalAdapter.plannerFactory(terminalTask).next({
+    task: terminalTask,
     turn: {
-        schemaVersion: 'booking.surface.v2',
+        schemaVersion: 'booking.surface',
         kind: 'user.turn',
-        taskId: v2Task.taskId,
-        turnId: 'dsh-v2-turn-1',
-        workspace: v2Workspace,
+        taskId: terminalTask.taskId,
+        turnId: 'dsh-terminal-turn-1',
+        workspace: terminalWorkspace,
         request: {
             text: 'find hotels'
         }
     }
 });
-assert.equal(v2Decisions[0]?.kind, 'operation', 'real DSH adapter accepts canonical v2 typed action');
-assert.equal(v2Decisions[0]?.kind === 'operation' ? v2Decisions[0].action.schemaVersion : '', 'booking.surface.v2');
-const v2Continuation = {
-    schemaVersion: 'booking.surface.v2',
+assert.equal(terminalDecisions[0]?.kind, 'operation', 'real DSH adapter accepts the canonical typed action');
+assert.equal(terminalDecisions[0]?.kind === 'operation' ? terminalDecisions[0].action.schemaVersion : '', 'booking.surface');
+const terminalContinuation = {
+    schemaVersion: 'booking.surface',
     kind: 'action.receipt.continuation',
-    taskId: v2Task.taskId,
+    taskId: terminalTask.taskId,
     workspace: {
-        ...v2Workspace,
+        ...terminalWorkspace,
         revision: 1
     },
     receipt: {
-        schemaVersion: 'booking.surface.v2',
+        schemaVersion: 'booking.surface',
         kind: 'action.receipt',
-        actionId: 'action-dsh-v2',
-        contextRef: v2Task.contextRef,
+        actionId: 'action-dsh-terminal',
+        contextRef: terminalTask.contextRef,
         status: 'applied',
         revision: 1,
         observation: {
@@ -502,15 +805,15 @@ const v2Continuation = {
         }
     }
 };
-const v2ContinuationDecision = await v2Adapter.plannerFactory(v2Task).next({
+const terminalContinuationDecision = await terminalAdapter.plannerFactory(terminalTask).next({
     task: {
-        ...v2Task,
+        ...terminalTask,
         revision: 1,
-        lastReceipt: v2Continuation.receipt
+        lastReceipt: terminalContinuation.receipt
     },
-    turn: v2Continuation
+    turn: terminalContinuation
 });
-assert.deepEqual(v2ContinuationDecision, [
+assert.deepEqual(terminalContinuationDecision, [
     {
         kind: 'terminal',
         terminal: {
@@ -519,16 +822,16 @@ assert.deepEqual(v2ContinuationDecision, [
             factRefs: []
         }
     }
-], 'real DSH v2 planner handles receipt continuation through the typed seam');
-await assert.rejects(v2Adapter.plannerFactory(v2Task).next({
-    task: v2Task,
+], 'real DSH planner handles receipt continuation through the typed seam');
+await assert.rejects(terminalAdapter.plannerFactory(terminalTask).next({
+    task: terminalTask,
     turn: {
-        schemaVersion: 'booking.surface.v2',
+        schemaVersion: 'booking.surface',
         kind: 'user.turn.ingress',
         requestKey: 'browser-request',
         surfaceHint: 'tenant',
         workspace: {
-            schemaVersion: 'booking.surface.v2',
+            schemaVersion: 'booking.surface',
             revision: 0,
             locale: 'en-US',
             currency: 'AED',
@@ -547,9 +850,15 @@ await assert.rejects(v2Adapter.plannerFactory(v2Task).next({
 }), /planner_identity_required/);
 await Promise.all([
     adapter.close(),
-    proseOnly.close(),
+    textChannel.close(),
+    unauthorised.close(),
+    fragmentRef.close(),
+    truncatedRecovery.close(),
+    sanitizedRef.close(),
+    unsafeRef.close(),
+    uiOffers.close(),
     forbidden.close(),
-    v2Adapter.close()
+    terminalAdapter.close()
 ]);
 console.log('BOOKING COPILOT DSH PLANNER PROOF: task session/typed tool decisions/no Book/no prose parser/no portal token OK');
 

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

@@ -38,7 +38,7 @@ const validSearchDecision = {
     decision: {
         kind: 'operation',
         action: {
-            schemaVersion: 'booking.surface.v1',
+            schemaVersion: 'booking.surface',
             kind: 'search.patch',
             actionId: 'action-model-1',
             contextRef: 'ctx-model-1',
@@ -67,7 +67,7 @@ assert.equal(validateSearchTool({
     decision: {
         kind: 'operation',
         action: {
-            schemaVersion: 'booking.surface.v2',
+            schemaVersion: 'booking.surface',
             kind: 'search.run',
             actionId: 'action-model-v2',
             contextRef: 'ctx-model-1',

package/dist/scripts/booking-copilot-event-sequence-concurrency-proof-tests.js

@@ -8,7 +8,7 @@ import { ensureLedger } from '../src/state-ledger.js';
 import { BookingCopilotTaskRuntime } from '../src/booking-surface/runtime.js';
 const taskId = 'task-event-sequence-atomicity';
 const workspace = {
-    schemaVersion: 'booking.surface.v1',
+    schemaVersion: 'booking.surface',
     contextRef: 'ctx-event-sequence-atomicity',
     surface: 'tenant',
     revision: 0,
@@ -29,9 +29,10 @@ const workspace = {
     }
 };
 const turn = {
-    schemaVersion: 'booking.surface.v1',
+    schemaVersion: 'booking.surface',
     kind: 'user.turn',
     taskId,
+    turnId: 'seq-anchor-turn',
     workspace,
     request: {
         text: 'opaque user turn'
@@ -121,7 +122,10 @@ if (child) {
         return state;
     };
     try {
-        if (mode === 'user-turn') runtime.startTask(turn);
+        if (mode === 'user-turn') runtime.startTask({
+            ...turn,
+            turnId: `seq-${variant}-turn`
+        });
         const event = runtime.emitEvent(taskId, {
             kind: 'status',
             status: 'working'