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

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

@@ -0,0 +1,557 @@
+import assert from 'node:assert/strict';
+import { DSH_EMBEDDED_BOOKING_TOOL_NAMES, buildDshPlannerEnvironment, createDshEmbeddedBookingPlanner, createDshEmbeddedBookingPlannerV2 } from '../src/booking-surface/dsh-planner.js';
+const task = {
+    schemaVersion: 'booking.surface.v1',
+    taskId: 'task-dsh-1',
+    contextRef: 'ctx-dsh-1',
+    surface: 'tenant',
+    revision: 0,
+    allowedActions: [
+        'search.patch',
+        'search.run'
+    ],
+    userTurnCount: 1,
+    lastUserTurnDigest: 'request-digest',
+    phase: 'planning',
+    lastSequence: 0
+};
+const workspace = {
+    schemaVersion: 'booking.surface.v1',
+    contextRef: task.contextRef,
+    surface: 'tenant',
+    revision: 0,
+    locale: 'zh-CN',
+    currency: 'AED',
+    searchDraft: {},
+    results: {
+        status: 'idle'
+    },
+    visibleHotels: [],
+    loadedOffers: [],
+    shortlistedOfferRefs: [],
+    capabilities: {
+        surface: 'tenant',
+        allowedActions: [
+            'search.patch',
+            'search.run'
+        ]
+    }
+};
+const searchRun = {
+    schemaVersion: 'booking.surface.v1',
+    kind: 'search.run',
+    actionId: 'action-dsh-1',
+    contextRef: task.contextRef,
+    expectedRevision: 0,
+    reason: 'Run the authoritative workspace search.',
+    factRefs: [],
+    input: {}
+};
+const hotelSelect = {
+    ...searchRun,
+    kind: 'hotel.select',
+    actionId: 'action-dsh-select-1',
+    reason: 'Select the requested hotel.',
+    input: {
+        hotelRef: 'hotel-1'
+    }
+};
+const prompts = [];
+const sessionIds = [];
+let runIndex = 0;
+const runPort = {
+    async run (prompt, options) {
+        prompts.push(prompt);
+        sessionIds.push(options.sessionId);
+        runIndex += 1;
+        if (runIndex === 1) {
+            return {
+                finalResponse: '{"kind":"book","input":{}}',
+                events: [
+                    {
+                        type: 'tool/call',
+                        data: {
+                            name: 'booking_search_hotels',
+                            arguments: JSON.stringify({
+                                decision: {
+                                    kind: 'operation',
+                                    action: searchRun
+                                }
+                            })
+                        }
+                    }
+                ]
+            };
+        }
+        if (runIndex === 3) {
+            return {
+                finalResponse: '',
+                events: [
+                    {
+                        type: 'tool/call',
+                        data: {
+                            name: 'booking_refine_results',
+                            arguments: JSON.stringify({
+                                decision: {
+                                    kind: 'operation',
+                                    action: hotelSelect
+                                }
+                            })
+                        }
+                    }
+                ]
+            };
+        }
+        return {
+            finalResponse: '{"kind":"search.run","input":{}}',
+            events: [
+                {
+                    type: 'tool/call',
+                    data: {
+                        name: 'booking_search_hotels',
+                        arguments: JSON.stringify({
+                            decision: {
+                                kind: 'terminal',
+                                terminal: {
+                                    status: 'completed',
+                                    summary: 'Stopped at search results.',
+                                    factRefs: []
+                                }
+                            }
+                        })
+                    }
+                }
+            ]
+        };
+    },
+    async close () {}
+};
+const adapter = await createDshEmbeddedBookingPlanner({
+    runPort
+});
+const session = adapter.plannerFactory(task);
+const first = await session.next({
+    task,
+    turn: {
+        schemaVersion: 'booking.surface.v1',
+        kind: 'user.turn',
+        taskId: task.taskId,
+        workspace: {
+            ...workspace,
+            capabilities: {
+                ...workspace.capabilities,
+                allowedActions: [
+                    ...workspace.capabilities.allowedActions
+                ]
+            }
+        },
+        request: {
+            text: '执行当前搜索'
+        }
+    }
+});
+assert.deepEqual(first, [
+    {
+        kind: 'operation',
+        action: searchRun
+    }
+], 'typed dsh tool call becomes one operation');
+const receipt = {
+    schemaVersion: 'booking.surface.v1',
+    kind: 'action.receipt',
+    actionId: searchRun.actionId,
+    contextRef: task.contextRef,
+    status: 'applied',
+    revision: 1,
+    observation: {
+        kind: 'search.state',
+        searchSessionRef: 'search-dsh-1',
+        resultCount: 4
+    },
+    resultContract: {
+        outcome: 'complete',
+        hardCriteriaMet: true,
+        factRefs: [],
+        gapCodes: []
+    }
+};
+const continuedTask = {
+    ...task,
+    revision: 1,
+    lastReceipt: receipt
+};
+const second = await session.next({
+    task: continuedTask,
+    turn: {
+        schemaVersion: 'booking.surface.v1',
+        kind: 'action.receipt.continuation',
+        taskId: task.taskId,
+        workspace: {
+            ...workspace,
+            revision: 1,
+            capabilities: {
+                ...workspace.capabilities,
+                allowedActions: [
+                    ...workspace.capabilities.allowedActions
+                ]
+            }
+        },
+        receipt
+    }
+});
+assert.deepEqual(second, [
+    {
+        kind: 'terminal',
+        terminal: {
+            status: 'completed',
+            summary: 'Stopped at search results.',
+            factRefs: []
+        }
+    }
+]);
+assert.equal(sessionIds[0], sessionIds[1], 'one task keeps one dsh session across receipt continuation');
+assert.match(prompts[1], /action-dsh-1/, 'receipt continuation reaches the same task-scoped planner session');
+const paymentTask = {
+    ...task,
+    taskId: 'task-payment-1',
+    surface: 'payment_link',
+    allowedActions: [
+        'hotel.select'
+    ],
+    revision: 0
+};
+const paymentSession = adapter.plannerFactory(paymentTask);
+const selected = await paymentSession.next({
+    task: paymentTask,
+    turn: {
+        schemaVersion: 'booking.surface.v1',
+        kind: 'user.turn',
+        taskId: paymentTask.taskId,
+        workspace: {
+            ...workspace,
+            surface: 'payment_link',
+            capabilities: {
+                surface: 'payment_link',
+                allowedActions: [
+                    'hotel.select'
+                ]
+            }
+        },
+        request: {
+            text: '选择酒店'
+        }
+    }
+});
+assert.deepEqual(selected, [
+    {
+        kind: 'operation',
+        action: hotelSelect
+    }
+], 'refine-results can emit typed hotel.select on payment_link');
+assert.deepEqual(DSH_EMBEDDED_BOOKING_TOOL_NAMES, [
+    'booking_search_hotels',
+    'booking_refine_results',
+    'booking_find_room_offers',
+    'booking_compare_offers',
+    'booking_prepare_booking',
+    'booking_observe_booking'
+]);
+assert.ok(!DSH_EMBEDDED_BOOKING_TOOL_NAMES.some((name)=>/book$|trade|payment/i.test(name)), 'profile has no Book/payment tool');
+const childEnv = buildDshPlannerEnvironment({
+    PATH: '/usr/bin',
+    LANG: 'en_US.UTF-8',
+    LLM_API_KEY: 'model-key',
+    LLM_BASE_URL: 'http://model.invalid/v1',
+    PORTAL_TOKEN: 'forbidden',
+    HOTELBYTE_TOKEN: 'forbidden',
+    GOTRY_BOOKING_COPILOT_API_KEY: 'bff-only'
+});
+assert.equal(childEnv.DEEPSEEK_API_KEY, 'model-key');
+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 = {
+    async run () {
+        return {
+            finalResponse: JSON.stringify({
+                kind: 'operation',
+                action: searchRun
+            }),
+            events: []
+        };
+    },
+    async close () {}
+};
+const proseOnly = await createDshEmbeddedBookingPlanner({
+    runPort: proseOnlyPort
+});
+const proseDecisions = await proseOnly.plannerFactory(task).next({
+    task,
+    turn: {
+        schemaVersion: 'booking.surface.v1',
+        kind: 'user.turn',
+        taskId: task.taskId,
+        workspace: {
+            ...workspace,
+            capabilities: {
+                ...workspace.capabilities,
+                allowedActions: [
+                    ...workspace.capabilities.allowedActions
+                ]
+            }
+        },
+        request: {
+            text: 'JSON prose must stay prose'
+        }
+    }
+});
+assert.equal(proseDecisions[0]?.kind, 'error', 'JSON-looking assistant prose is never executable');
+const forbiddenPort = {
+    async run () {
+        return {
+            finalResponse: '',
+            events: [
+                {
+                    type: 'tool/call',
+                    data: {
+                        name: 'gotry_book',
+                        arguments: JSON.stringify({
+                            decision: {
+                                kind: 'operation',
+                                action: {
+                                    ...searchRun,
+                                    kind: 'book'
+                                }
+                            }
+                        })
+                    }
+                }
+            ]
+        };
+    },
+    async close () {}
+};
+const forbidden = await createDshEmbeddedBookingPlanner({
+    runPort: forbiddenPort
+});
+await assert.rejects(forbidden.plannerFactory(task).next({
+    task,
+    turn: {
+        schemaVersion: 'booking.surface.v1',
+        kind: 'user.turn',
+        taskId: task.taskId,
+        workspace: {
+            ...workspace,
+            capabilities: {
+                ...workspace.capabilities,
+                allowedActions: [
+                    ...workspace.capabilities.allowedActions
+                ]
+            }
+        },
+        request: {
+            text: '帮我下单'
+        }
+    }
+}), /planner_forbidden_tool/);
+const v2Task = {
+    schemaVersion: 'booking.surface.v2',
+    taskId: 'task-dsh-v2',
+    contextRef: 'ctx-dsh-v2',
+    surface: 'tenant',
+    revision: 0,
+    allowedActions: [
+        'search.run'
+    ],
+    userTurnCount: 1,
+    operationCount: 0,
+    phase: 'planning',
+    lastSequence: 0,
+    availability: {
+        initialized: true,
+        recoveryStarted: true,
+        availabilityPhase: 'terminal',
+        activeHotelOrdinal: 0,
+        hotelRefs: [],
+        hotels: {},
+        attempts: [],
+        queryReservations: [],
+        terminal: {
+            code: 'availability_exhausted_complete',
+            hotelRefs: [],
+            reason: 'no_current_offers',
+            evidence: 'conclusive'
+        }
+    }
+};
+const v2Workspace = {
+    schemaVersion: 'booking.surface.v2',
+    contextRef: v2Task.contextRef,
+    surface: 'tenant',
+    revision: 0,
+    locale: 'en-US',
+    currency: 'AED',
+    searchDraft: {},
+    results: {
+        status: 'idle'
+    },
+    visibleHotels: [],
+    loadedOffers: [],
+    shortlistedOfferRefs: [],
+    capabilities: {
+        surface: 'tenant',
+        allowedActions: [
+            'search.run'
+        ]
+    }
+};
+let v2Runs = 0;
+const v2Port = {
+    async run () {
+        v2Runs++;
+        return v2Runs === 1 ? {
+            finalResponse: '',
+            events: [
+                {
+                    type: 'tool/call',
+                    data: {
+                        name: 'booking_search_hotels',
+                        arguments: JSON.stringify({
+                            decision: {
+                                kind: 'operation',
+                                action: {
+                                    ...searchRun,
+                                    schemaVersion: 'booking.surface.v2',
+                                    contextRef: v2Task.contextRef,
+                                    actionId: 'action-dsh-v2'
+                                }
+                            }
+                        })
+                    }
+                }
+            ]
+        } : {
+            finalResponse: '',
+            events: [
+                {
+                    type: 'tool/call',
+                    data: {
+                        name: 'booking_search_hotels',
+                        arguments: JSON.stringify({
+                            decision: {
+                                kind: 'terminal',
+                                terminal: {
+                                    status: 'stopped',
+                                    summary: 'receipt continuation handled',
+                                    factRefs: []
+                                }
+                            }
+                        })
+                    }
+                }
+            ]
+        };
+    },
+    async close () {}
+};
+const v2Adapter = await createDshEmbeddedBookingPlannerV2({
+    runPort: v2Port
+});
+const v2Decisions = await v2Adapter.plannerFactory(v2Task).next({
+    task: v2Task,
+    turn: {
+        schemaVersion: 'booking.surface.v2',
+        kind: 'user.turn',
+        taskId: v2Task.taskId,
+        turnId: 'dsh-v2-turn-1',
+        workspace: v2Workspace,
+        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',
+    kind: 'action.receipt.continuation',
+    taskId: v2Task.taskId,
+    workspace: {
+        ...v2Workspace,
+        revision: 1
+    },
+    receipt: {
+        schemaVersion: 'booking.surface.v2',
+        kind: 'action.receipt',
+        actionId: 'action-dsh-v2',
+        contextRef: v2Task.contextRef,
+        status: 'applied',
+        revision: 1,
+        observation: {
+            kind: 'search.state',
+            resultCount: 1
+        },
+        resultContract: {
+            outcome: 'complete',
+            hardCriteriaMet: true,
+            factRefs: [],
+            gapCodes: [],
+            blockers: [],
+            relaxationsApplied: []
+        }
+    }
+};
+const v2ContinuationDecision = await v2Adapter.plannerFactory(v2Task).next({
+    task: {
+        ...v2Task,
+        revision: 1,
+        lastReceipt: v2Continuation.receipt
+    },
+    turn: v2Continuation
+});
+assert.deepEqual(v2ContinuationDecision, [
+    {
+        kind: 'terminal',
+        terminal: {
+            status: 'stopped',
+            summary: 'receipt continuation handled',
+            factRefs: []
+        }
+    }
+], 'real DSH v2 planner handles receipt continuation through the typed seam');
+await assert.rejects(v2Adapter.plannerFactory(v2Task).next({
+    task: v2Task,
+    turn: {
+        schemaVersion: 'booking.surface.v2',
+        kind: 'user.turn.ingress',
+        requestKey: 'browser-request',
+        surfaceHint: 'tenant',
+        workspace: {
+            schemaVersion: 'booking.surface.v2',
+            revision: 0,
+            locale: 'en-US',
+            currency: 'AED',
+            searchDraft: {},
+            results: {
+                status: 'idle'
+            },
+            visibleHotels: [],
+            loadedOffers: [],
+            shortlistedOfferRefs: []
+        },
+        request: {
+            text: 'browser ingress must be BFF-bound'
+        }
+    }
+}), /planner_identity_required/);
+await Promise.all([
+    adapter.close(),
+    proseOnly.close(),
+    forbidden.close(),
+    v2Adapter.close()
+]);
+console.log('BOOKING COPILOT DSH PLANNER PROOF: task session/typed tool decisions/no Book/no prose parser/no portal token OK');
+
+
+//# sourceURL=ts/scripts/booking-copilot-dsh-planner-proof-tests.ts

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

@@ -0,0 +1,140 @@
+import assert from 'node:assert/strict';
+import { Ajv2020 } from 'ajv/dist/2020.js';
+import { apply, embeddedBookingToolDefinitions } from '../src/booking-surface/dsh-plugin.js';
+const registered = [];
+apply({
+    tools: {
+        register (tool) {
+            registered.push(tool);
+        }
+    }
+});
+assert.equal(registered.length, 6);
+assert.deepEqual(registered.map((tool)=>tool.name), [
+    'booking_search_hotels',
+    'booking_refine_results',
+    'booking_find_room_offers',
+    'booking_compare_offers',
+    'booking_prepare_booking',
+    'booking_observe_booking'
+]);
+assert.deepEqual(registered, embeddedBookingToolDefinitions);
+assert.ok(!registered.some((tool)=>/gotry_book|trade|payment/i.test(String(tool.name))));
+assert.ok(registered.every((tool)=>{
+    const parameters = tool.parameters;
+    return parameters.additionalProperties === false && Object.keys(parameters.properties ?? {}).join(',') === 'decision';
+}), 'every model-facing tool accepts only one typed decision envelope');
+const prepare = registered.find((tool)=>tool.name === 'booking_prepare_booking');
+const prepareParameters = prepare.parameters;
+const operationBranches = prepareParameters.properties.decision.oneOf[0]?.properties?.action?.oneOf ?? [];
+assert.equal(operationBranches.length, 2, 'prepare-booking exposes offer.check + checkout.prepare only');
+assert.ok(!JSON.stringify(prepare.parameters).includes('book"'), 'schema has no Book discriminator');
+const search = registered.find((tool)=>tool.name === 'booking_search_hotels');
+const validateSearchTool = new Ajv2020({
+    allErrors: true,
+    strict: true
+}).compile(search.parameters);
+const validSearchDecision = {
+    decision: {
+        kind: 'operation',
+        action: {
+            schemaVersion: 'booking.surface.v1',
+            kind: 'search.patch',
+            actionId: 'action-model-1',
+            contextRef: 'ctx-model-1',
+            expectedRevision: 0,
+            reason: 'Apply the requested budget.',
+            factRefs: [],
+            input: {
+                patch: {
+                    budget: {
+                        strength: 'must',
+                        value: {
+                            max: {
+                                amount: '1000',
+                                currency: 'AED',
+                                sourceFactRef: 'fact-budget-1'
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+};
+assert.equal(validateSearchTool(validSearchDecision), true, JSON.stringify(validateSearchTool.errors));
+assert.equal(validateSearchTool({
+    decision: {
+        kind: 'operation',
+        action: {
+            schemaVersion: 'booking.surface.v2',
+            kind: 'search.run',
+            actionId: 'action-model-v2',
+            contextRef: 'ctx-model-1',
+            expectedRevision: 0,
+            reason: 'Run the authoritative workspace search.',
+            factRefs: [],
+            input: {}
+        }
+    }
+}), true, JSON.stringify(validateSearchTool.errors));
+assert.equal(validateSearchTool({
+    ...validSearchDecision,
+    decision: {
+        ...validSearchDecision.decision,
+        action: {
+            ...validSearchDecision.decision.action,
+            input: {
+                patch: {
+                    unknownCriterion: {
+                        strength: 'must',
+                        value: true
+                    }
+                }
+            }
+        }
+    }
+}), false, 'model-facing tool schema closes nested search criteria');
+assert.equal(validateSearchTool({
+    ...validSearchDecision,
+    decision: {
+        ...validSearchDecision.decision,
+        action: {
+            ...validSearchDecision.decision.action,
+            input: {
+                patch: {
+                    budget: {
+                        strength: 'must',
+                        value: {
+                            max: {
+                                amount: 1000,
+                                currency: 'AED',
+                                sourceFactRef: 'fact-budget-1'
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}), false, 'model-facing Money.amount rejects numbers');
+assert.equal(validateSearchTool({
+    ...validSearchDecision,
+    decision: {
+        ...validSearchDecision.decision,
+        action: {
+            ...validSearchDecision.decision.action,
+            input: {
+                patch: {
+                    holder: {
+                        email: 'x@example.com'
+                    }
+                }
+            }
+        }
+    }
+}), false, 'model-facing tool schema rejects nested holder data');
+console.log('BOOKING COPILOT DSH PLUGIN PROOF: exact six typed tools/no Book OK');
+
+
+//# sourceURL=ts/scripts/booking-copilot-dsh-plugin-proof-tests.ts