@danceiny/gotry 0.0.1-rc.21 → 0.0.1-rc.24

package/dist/src/booking-surface/server.js

@@ -1,9 +1,74 @@
+/**
+ * BFF-only HTTP/SSE seam for the embedded Booking Copilot.
+ *
+ * The browser never calls this server directly. A same-origin HotelByte BFF
+ * authenticates the actor, mints contextRef and sends a strict planner turn
+ * with a deployment-level Bearer key. No portal token field exists here.
+ */
 import { timingSafeEqual } from 'node:crypto';
 import { createServer } from 'node:http';
-import { BOOKING_COPILOT_ACCEPTED_TURN_KINDS, BOOKING_COPILOT_INGRESS_MODES, BOOKING_READ_ACTION_KINDS, BOOKING_SURFACE_ALLOWED_ACTIONS, BOOKING_SURFACE_SCHEMA_SHA256, BOOKING_SURFACE_SCHEMA_SHA256_HEADER, BOOKING_SURFACE_SCHEMA_VERSION, BOOKING_SURFACE_VERSION_HEADER } from './contracts.js';
-import { bookingDigest, BookingCopilotTaskRuntime } from './runtime.js';
+import { BOOKING_COPILOT_ACCEPTED_TURN_KINDS, BOOKING_COPILOT_INGRESS_MODES, BOOKING_READ_ACTION_KINDS, BOOKING_SURFACE_ALLOWED_ACTIONS, BOOKING_SURFACE_SCHEMA_SHA256, BOOKING_SURFACE_SCHEMA_SHA256_HEADER, BOOKING_SURFACE_SCHEMA_VERSION, BOOKING_SURFACE_VERSION_HEADER, } from './contracts.js';
+import { bookingDigest, } from './runtime.js';
 import { validateBookingSurface } from './validation.js';
-import { normalizeBookingErrorCode, safeBookingErrorMessage } from './error-codes.js';
+import { extractBookingDispatchReason, normalizeBookingErrorCode, safeBookingErrorMessage } from './error-codes.js';
+/**
+ * 单请求处理闭包(startBookingCopilotServer 的 createServer 回调原样摘出):
+ * 探活(/healthz /status)+ 唯一 turn 路由 + 鉴权 + schema 头校验。
+ * gotry-backend 的 booking-copilot 模块复用同一闭包,保证两条挂载路径行为逐字一致。
+ */
+export function bookingCopilotTrafficHandler(deps) {
+    const { apiKey, composition, maxBodyBytes, artifactId, ingressMode, runningIdentity } = deps;
+    return async (req, res) => {
+        const isProbe = req.method === 'GET' && (req.url === '/healthz' || req.url === '/status');
+        if (!isProbe && (req.method !== 'POST' || req.url !== '/a2a/booking-copilot/turn')) {
+            sendJson(res, 404, { error: { code: 'not_found' } });
+            return;
+        }
+        const auth = String(req.headers.authorization ?? '');
+        if (!safeSecretEqual(auth, `Bearer ${apiKey}`)) {
+            sendJson(res, 401, { error: { code: 'unauthorized' } });
+            return;
+        }
+        if (isProbe) {
+            res.setHeader(BOOKING_SURFACE_VERSION_HEADER, BOOKING_SURFACE_SCHEMA_VERSION);
+            res.setHeader(BOOKING_SURFACE_SCHEMA_SHA256_HEADER, BOOKING_SURFACE_SCHEMA_SHA256);
+            if (artifactId)
+                res.setHeader('X-GoTry-Artifact-ID', artifactId);
+            res.setHeader('X-GoTry-Node-Version', runningIdentity.nodeVersion);
+            res.setHeader('X-GoTry-Node-Modules-ABI', runningIdentity.nodeModulesAbi);
+            res.setHeader('X-GoTry-Release-Tuple', runningIdentity.releaseTuple);
+            if (runningIdentity.glibcVersion)
+                res.setHeader('X-GoTry-Glibc-Version', runningIdentity.glibcVersion);
+            const acceptedTurnKinds = ingressMode === 'bff-ingress-binding'
+                ? [...BOOKING_COPILOT_ACCEPTED_TURN_KINDS, 'user.turn.ingress']
+                : [...BOOKING_COPILOT_ACCEPTED_TURN_KINDS];
+            const healthBody = {
+                schemaVersion: BOOKING_SURFACE_SCHEMA_VERSION,
+                schemaSha256: BOOKING_SURFACE_SCHEMA_SHA256,
+                status: 'ready',
+                ingressMode,
+                acceptedTurnKinds,
+            };
+            res.setHeader('X-GoTry-Ingress-Mode', ingressMode);
+            res.setHeader('X-GoTry-Accepted-Turn-Kinds', acceptedTurnKinds.join(','));
+            sendJson(res, 200, healthBody);
+            return;
+        }
+        const schemaVersion = String(req.headers[BOOKING_SURFACE_VERSION_HEADER] ?? '');
+        const schemaHash = String(req.headers[BOOKING_SURFACE_SCHEMA_SHA256_HEADER] ?? '');
+        if (schemaVersion !== BOOKING_SURFACE_SCHEMA_VERSION || schemaHash !== BOOKING_SURFACE_SCHEMA_SHA256) {
+            sendJson(res, 409, {
+                error: {
+                    code: 'booking_surface_schema_mismatch',
+                    expectedVersion: BOOKING_SURFACE_SCHEMA_VERSION,
+                    expectedSchemaSha256: BOOKING_SURFACE_SCHEMA_SHA256,
+                },
+            });
+            return;
+        }
+        await handleBookingCopilotRequest(req, res, composition, maxBodyBytes);
+    };
+}
 const sessionsByComposition = new WeakMap();
 const decisionFlightsByComposition = new WeakMap();
 function sessionsFor(composition) {
@@ -25,16 +90,19 @@ function decisionFlightsFor(composition) {
 async function runDecisionSingleFlight(composition, key, work) {
     const flights = decisionFlightsFor(composition);
     const prior = flights.get(key);
-    if (prior) return prior;
+    if (prior)
+        return prior;
     const current = work();
     flights.set(key, current);
     try {
         return await current;
-    } finally{
-        if (flights.get(key) === current) flights.delete(key);
+    }
+    finally {
+        if (flights.get(key) === current)
+            flights.delete(key);
     }
 }
-function runtimeIdentity() {
+export function runtimeIdentity() {
     const report = process.report?.getReport?.();
     const header = report?.header;
     const glibcVersion = header?.glibcVersionRuntime ?? '';
@@ -42,7 +110,7 @@ function runtimeIdentity() {
         nodeVersion: process.version,
         nodeModulesAbi: process.versions.modules ?? '',
         releaseTuple: `${process.platform}-${process.arch}-${glibcVersion ? 'glibc' : 'unknown'}`,
-        glibcVersion
+        glibcVersion,
     };
 }
 function safeSecretEqual(actual, expected) {
@@ -51,17 +119,15 @@ function safeSecretEqual(actual, expected) {
     return actualBytes.length === expectedBytes.length && timingSafeEqual(actualBytes, expectedBytes);
 }
 function sendJson(res, status, body) {
-    res.writeHead(status, {
-        'content-type': 'application/json; charset=utf-8'
-    });
+    res.writeHead(status, { 'content-type': 'application/json; charset=utf-8' });
     res.end(JSON.stringify(body));
 }
 function readBody(req, maxBodyBytes) {
-    return new Promise((resolve, reject)=>{
+    return new Promise((resolve, reject) => {
         const chunks = [];
         let size = 0;
         let exceeded = false;
-        req.on('data', (chunk)=>{
+        req.on('data', (chunk) => {
             size += chunk.length;
             if (size > maxBodyBytes) {
                 exceeded = true;
@@ -69,7 +135,7 @@ function readBody(req, maxBodyBytes) {
             }
             chunks.push(chunk);
         });
-        req.on('end', ()=>exceeded ? reject(new Error('payload_too_large')) : resolve(Buffer.concat(chunks).toString('utf8')));
+        req.on('end', () => exceeded ? reject(new Error('payload_too_large')) : resolve(Buffer.concat(chunks).toString('utf8')));
         req.on('error', reject);
     });
 }
@@ -77,42 +143,43 @@ function write(res, event) {
     res.write(`event: ${event.kind}\ndata: ${JSON.stringify(event)}\n\n`);
 }
 function sameCapabilities(a, b) {
-    return a.length === b.length && [
-        ...a
-    ].sort().every((kind, index)=>kind === [
-            ...b
-        ].sort()[index]);
+    return a.length === b.length && [...a].sort().every((kind, index) => kind === [...b].sort()[index]);
 }
 function exactKeys(value, allowed) {
-    return Object.keys(value).length === allowed.length && Object.keys(value).every((key)=>allowed.includes(key));
+    return Object.keys(value).length === allowed.length && Object.keys(value).every((key) => allowed.includes(key));
 }
 const SURFACE_ACTION_MATRIX = BOOKING_SURFACE_ALLOWED_ACTIONS;
 function validSurfaceActions(surface, allowed) {
-    if (typeof surface !== 'string' || !Object.prototype.hasOwnProperty.call(SURFACE_ACTION_MATRIX, surface)) return false;
-    if (!Array.isArray(allowed) || allowed.length < 1 || new Set(allowed).size !== allowed.length) return false;
+    if (typeof surface !== 'string' || !Object.prototype.hasOwnProperty.call(SURFACE_ACTION_MATRIX, surface))
+        return false;
+    if (!Array.isArray(allowed) || allowed.length < 1 || new Set(allowed).size !== allowed.length)
+        return false;
     const matrix = SURFACE_ACTION_MATRIX[surface];
-    return allowed.every((action)=>typeof action === 'string' && matrix.includes(action) && BOOKING_READ_ACTION_KINDS.includes(action));
+    return allowed.every((action) => typeof action === 'string'
+        && matrix.includes(action)
+        && BOOKING_READ_ACTION_KINDS.includes(action));
 }
 function validBoundWorkspaceAuthority(workspace) {
-    return workspace.capabilities.surface === workspace.surface && validSurfaceActions(workspace.surface, workspace.capabilities.allowedActions);
+    return workspace.capabilities.surface === workspace.surface
+        && validSurfaceActions(workspace.surface, workspace.capabilities.allowedActions);
 }
 function validIngressBinding(binding, ingress) {
-    if (!binding || typeof binding !== 'object' || Array.isArray(binding)) return false;
+    if (!binding || typeof binding !== 'object' || Array.isArray(binding))
+        return false;
     const candidate = binding;
-    if (!exactKeys(candidate, [
-        'taskId',
-        'turnId',
-        'contextRef',
-        'surface',
-        'allowedActions'
-    ])) return false;
-    if (typeof candidate.taskId !== 'string' || typeof candidate.turnId !== 'string' || typeof candidate.contextRef !== 'string') return false;
-    if (typeof candidate.surface !== 'string' || candidate.surface !== ingress.surfaceHint || !Object.prototype.hasOwnProperty.call(SURFACE_ACTION_MATRIX, candidate.surface)) return false;
+    if (!exactKeys(candidate, ['taskId', 'turnId', 'contextRef', 'surface', 'allowedActions']))
+        return false;
+    if (typeof candidate.taskId !== 'string' || typeof candidate.turnId !== 'string' || typeof candidate.contextRef !== 'string')
+        return false;
+    if (typeof candidate.surface !== 'string' || candidate.surface !== ingress.surfaceHint || !Object.prototype.hasOwnProperty.call(SURFACE_ACTION_MATRIX, candidate.surface))
+        return false;
     return validSurfaceActions(candidate.surface, candidate.allowedActions);
 }
 function validIngressApprovalAuthority(ingress, binding) {
-    if (!ingress.request.approval) return true;
-    return ingress.request.approval.taskId === binding.taskId && ingress.request.approval.contextRef === binding.contextRef;
+    if (!ingress.request.approval)
+        return true;
+    return ingress.request.approval.taskId === binding.taskId
+        && ingress.request.approval.contextRef === binding.contextRef;
 }
 function fallbackErrorEvent(task, code) {
     return {
@@ -123,37 +190,31 @@ function fallbackErrorEvent(task, code) {
         sequence: task.lastSequence + 1,
         emittedAt: new Date().toISOString(),
         kind: 'error',
-        error: {
-            code: normalizeBookingErrorCode(code),
-            message: safeBookingErrorMessage(normalizeBookingErrorCode(code)),
-            retryable: false
-        }
+        error: { code: normalizeBookingErrorCode(code), message: safeBookingErrorMessage(normalizeBookingErrorCode(code)), retryable: false },
     };
 }
 function writeTypedError(res, composition, task, error, requestKey, includeSubmitted = false) {
     const code = normalizeBookingErrorCode(error);
+    // Operator-side diagnosability only: the raw boundary error stays on the
+    // server stderr/journal; clients keep receiving the safe typed vocabulary.
     console.error(`[booking-copilot] planner boundary error (${code}):`, error instanceof Error ? error.stack || error.message : error);
     try {
-        const decision = {
-            kind: 'error',
-            error: {
-                code,
-                message: safeBookingErrorMessage(code),
-                retryable: false
-            }
-        };
+        const decision = { kind: 'error', error: { code, message: safeBookingErrorMessage(code), retryable: false } };
         if (requestKey) {
-            const events = composition.runtime.applyDecisionBatch(task.taskId, requestKey, [
-                decision
-            ], includeSubmitted);
-            for (const event of events)write(res, event);
+            const events = composition.runtime.applyDecisionBatch(task.taskId, requestKey, [decision], includeSubmitted);
+            for (const event of events)
+                write(res, event);
             return;
         }
         write(res, composition.runtime.emitEvent(task.taskId, decision));
-    } catch  {
+    }
+    catch {
+        // The stream is already committed. Emit a schema-valid, non-durable
+        // typed envelope instead of silently returning an empty HTTP 200 stream.
         write(res, fallbackErrorEvent(task, code));
     }
 }
+/** Handles one already-authenticated request inside the sole HTTP listener. */
 async function handleBookingCopilotRequest(req, res, composition, maxBodyBytes) {
     let turn;
     let browserRequestKey;
@@ -162,108 +223,53 @@ async function handleBookingCopilotRequest(req, res, composition, maxBodyBytes)
         const parsed = JSON.parse(await readBody(req, maxBodyBytes));
         const valid = validateBookingSurface(parsed);
         if (!valid.ok) {
-            sendJson(res, 400, {
-                error: {
-                    code: 'invalid_booking_surface_turn',
-                    details: valid.errors
-                }
-            });
+            sendJson(res, 400, { error: { code: 'invalid_booking_surface_turn', details: valid.errors } });
             return;
         }
         if (parsed.kind === 'user.turn.ingress') {
             const ingress = parsed;
             browserRequestKey = ingress.requestKey;
             if (composition.ingressMode !== 'bff-ingress-binding' || !composition.ingressBinding || !composition.principal) {
-                sendJson(res, 503, {
-                    error: {
-                        code: 'trusted_ingress_binding_required',
-                        mode: composition.ingressMode ?? 'bff-bound-turn-only',
-                        acceptedTurnKinds: [
-                            ...BOOKING_COPILOT_ACCEPTED_TURN_KINDS
-                        ]
-                    }
-                });
+                sendJson(res, 503, { error: { code: 'trusted_ingress_binding_required', mode: composition.ingressMode ?? 'bff-bound-turn-only', acceptedTurnKinds: [...BOOKING_COPILOT_ACCEPTED_TURN_KINDS] } });
                 return;
             }
             const binding = await composition.ingressBinding.bind(ingress, composition.principal);
             if (!validIngressBinding(binding, ingress)) {
-                sendJson(res, 502, {
-                    error: {
-                        code: 'invalid_ingress_binding'
-                    }
-                });
+                sendJson(res, 502, { error: { code: 'invalid_ingress_binding' } });
                 return;
             }
             if (!validIngressApprovalAuthority(ingress, binding)) {
-                sendJson(res, 400, {
-                    error: {
-                        code: 'invalid_ingress_approval_authority'
-                    }
-                });
+                sendJson(res, 400, { error: { code: 'invalid_ingress_approval_authority' } });
                 return;
             }
             const boundWorkspace = {
                 ...ingress.workspace,
                 contextRef: binding.contextRef,
                 surface: binding.surface,
-                capabilities: {
-                    surface: binding.surface,
-                    allowedActions: [
-                        ...binding.allowedActions
-                    ]
-                }
-            };
-            const boundRequest = ingress.request.approval ? {
-                text: ingress.request.text,
-                approval: {
-                    ...ingress.request.approval
-                }
-            } : {
-                text: ingress.request.text
-            };
-            turn = {
-                schemaVersion: BOOKING_SURFACE_SCHEMA_VERSION,
-                kind: 'user.turn',
-                taskId: binding.taskId,
-                turnId: binding.turnId,
-                workspace: boundWorkspace,
-                request: boundRequest
-            };
-            requestBinding = {
-                requestKey: ingress.requestKey,
-                principal: composition.principal,
-                ...ingress.taskHandle ? {
-                    taskHandle: ingress.taskHandle
-                } : {}
+                capabilities: { surface: binding.surface, allowedActions: [...binding.allowedActions] },
             };
+            const boundRequest = ingress.request.approval
+                ? { text: ingress.request.text, approval: { ...ingress.request.approval } }
+                : { text: ingress.request.text };
+            turn = { schemaVersion: BOOKING_SURFACE_SCHEMA_VERSION, kind: 'user.turn', taskId: binding.taskId, turnId: binding.turnId, workspace: boundWorkspace, request: boundRequest };
+            requestBinding = { requestKey: ingress.requestKey, principal: composition.principal, ...(ingress.taskHandle ? { taskHandle: ingress.taskHandle } : {}) };
             const boundValid = validateBookingSurface(turn);
             if (!boundValid.ok) {
-                sendJson(res, 502, {
-                    error: {
-                        code: 'invalid_ingress_binding',
-                        details: boundValid.errors
-                    }
-                });
+                sendJson(res, 502, { error: { code: 'invalid_ingress_binding', details: boundValid.errors } });
                 return;
             }
-        } else {
+        }
+        else {
             turn = parsed;
             if (!validBoundWorkspaceAuthority(turn.workspace)) {
-                sendJson(res, 403, {
-                    error: {
-                        code: 'invalid_bound_turn_authority'
-                    }
-                });
+                sendJson(res, 403, { error: { code: 'invalid_bound_turn_authority' } });
                 return;
             }
         }
-    } catch (error) {
+    }
+    catch (error) {
         const code = normalizeBookingErrorCode(error);
-        sendJson(res, code === 'PAYLOAD_TOO_LARGE' ? 413 : 400, {
-            error: {
-                code
-            }
-        });
+        sendJson(res, code === 'PAYLOAD_TOO_LARGE' ? 413 : 400, { error: { code } });
         return;
     }
     let task;
@@ -280,32 +286,47 @@ async function handleBookingCopilotRequest(req, res, composition, maxBodyBytes)
                 replayKey = composition.runtime.approvalPresentationRequestKey(turn.taskId);
             }
             replayEvents = composition.runtime.readDecisionBatch(turn.taskId, replayKey);
-            if (!replayEvents && task.phase === 'terminal') replayEvents = composition.runtime.terminalDecisionBatch(turn.taskId, replayKey);
-        } else {
+            if (!replayEvents && task.phase === 'terminal')
+                replayEvents = composition.runtime.terminalDecisionBatch(turn.taskId, replayKey);
+        }
+        else {
             const existing = turn.taskId ? composition.runtime.resumeTask(turn.taskId) : null;
-            if (requestBinding && turn.kind === 'user.turn') composition.runtime.assertRequestBinding(browserRequestKey, turn, requestBinding);
+            if (requestBinding && turn.kind === 'user.turn')
+                composition.runtime.assertRequestBinding(browserRequestKey, turn, requestBinding);
             const requestReplayKey = existing && browserRequestKey ? `ingress:${existing.taskId}:${browserRequestKey}` : undefined;
             const directReplayKey = existing && turn.kind === 'user.turn' && turn.turnId ? `turn:${existing.taskId}:${turn.turnId}` : undefined;
             const stableReplayKey = requestReplayKey ?? directReplayKey;
             const stableReplay = stableReplayKey ? composition.runtime.readDecisionBatch(existing.taskId, stableReplayKey) : null;
             if (stableReplay) {
-                if (existing && turn.kind === 'user.turn' && directReplayKey) composition.runtime.assertTurnBinding(existing.taskId, turn);
+                if (existing && turn.kind === 'user.turn' && directReplayKey)
+                    composition.runtime.assertTurnBinding(existing.taskId, turn);
                 task = existing;
                 replayKey = stableReplayKey;
                 replayEvents = stableReplay;
-            } else if (existing?.phase === 'terminal' || existing?.phase === 'error') {
+            }
+            else if (existing?.phase === 'terminal' || existing?.phase === 'error') {
                 throw new Error('task_terminal');
-            } else if (existing?.phase === 'waiting_receipt') {
-                if (turn.kind === 'user.turn' && turn.request.approval) composition.runtime.assertApprovalNotConsumed(existing.taskId, turn.request.approval);
+            }
+            else if (existing?.phase === 'waiting_receipt') {
+                if (turn.kind === 'user.turn' && turn.request.approval)
+                    composition.runtime.assertApprovalNotConsumed(existing.taskId, turn.request.approval);
                 const workspace = turn.workspace;
-                if (workspace.contextRef !== existing.contextRef || workspace.surface !== existing.surface || workspace.revision !== existing.revision || workspace.capabilities.surface !== existing.surface || !sameCapabilities(workspace.capabilities.allowedActions, existing.allowedActions)) throw new Error('task_conflict:workspace_mismatch');
-                if (!turn.turnId || existing.lastTurnId !== turn.turnId) throw new Error('receipt_required');
+                if (workspace.contextRef !== existing.contextRef || workspace.surface !== existing.surface || workspace.revision !== existing.revision || workspace.capabilities.surface !== existing.surface || !sameCapabilities(workspace.capabilities.allowedActions, existing.allowedActions))
+                    throw new Error('task_conflict:workspace_mismatch');
+                // A waiting task can only be replayed with the caller's stable turn
+                // identity. Without it, an identical sentence is not distinguishable
+                // from a new user turn and must not receive an old operation batch.
+                if (!turn.turnId || existing.lastTurnId !== turn.turnId)
+                    throw new Error('receipt_required');
                 replayKey = browserRequestKey ? `ingress:${existing.taskId}:${browserRequestKey}` : `turn:${existing.taskId}:${existing.lastTurnId ?? existing.userTurnCount}`;
                 replayEvents = composition.runtime.readDecisionBatch(existing.taskId, replayKey);
-                if (!replayEvents) throw new Error('receipt_required');
+                if (!replayEvents)
+                    throw new Error('receipt_required');
                 task = existing;
-            } else {
-                if (existing && turn.kind === 'user.turn' && turn.request.approval) composition.runtime.assertApprovalNotConsumed(existing.taskId, turn.request.approval);
+            }
+            else {
+                if (existing && turn.kind === 'user.turn' && turn.request.approval)
+                    composition.runtime.assertApprovalNotConsumed(existing.taskId, turn.request.approval);
                 task = composition.runtime.startTask(turn, requestBinding);
                 if (turn.kind === 'user.turn' && turn.taskId) {
                     replayKey = browserRequestKey ? `ingress:${task.taskId}:${browserRequestKey}` : `turn:${task.taskId}:${turn.turnId ?? task.userTurnCount}`;
@@ -313,68 +334,49 @@ async function handleBookingCopilotRequest(req, res, composition, maxBodyBytes)
                 }
             }
         }
-    } catch (error) {
-        sendJson(res, 409, {
-            error: {
-                code: normalizeBookingErrorCode(error)
-            }
-        });
+    }
+    catch (error) {
+        const code = normalizeBookingErrorCode(error);
+        console.error(JSON.stringify({ code, reason: extractBookingDispatchReason(error) }));
+        sendJson(res, 409, { error: { code } });
         return;
     }
-    res.writeHead(200, {
-        'content-type': 'text/event-stream; charset=utf-8',
-        'cache-control': 'no-cache, no-transform',
-        connection: 'keep-alive',
-        'x-content-type-options': 'nosniff',
-        [BOOKING_SURFACE_VERSION_HEADER]: BOOKING_SURFACE_SCHEMA_VERSION,
-        [BOOKING_SURFACE_SCHEMA_SHA256_HEADER]: BOOKING_SURFACE_SCHEMA_SHA256
-    });
+    res.writeHead(200, { 'content-type': 'text/event-stream; charset=utf-8', 'cache-control': 'no-cache, no-transform', connection: 'keep-alive', 'x-content-type-options': 'nosniff', [BOOKING_SURFACE_VERSION_HEADER]: BOOKING_SURFACE_SCHEMA_VERSION, [BOOKING_SURFACE_SCHEMA_SHA256_HEADER]: BOOKING_SURFACE_SCHEMA_SHA256 });
     try {
         if (replayEvents) {
-            for (const event of replayEvents)write(res, event);
-        } else {
+            for (const event of replayEvents)
+                write(res, event);
+        }
+        else {
             const requestKey = replayKey ?? `turn:${task.taskId}:${task.userTurnCount}`;
             activeDecisionKey = requestKey;
             const approval = turn.kind === 'user.turn' ? turn.request.approval : undefined;
-            const flightKey = JSON.stringify([
-                task.taskId,
-                approval ? `approval:${bookingDigest(approval)}` : requestKey
-            ]);
-            const decisionEvents = await runDecisionSingleFlight(composition, flightKey, async ()=>{
+            const flightKey = JSON.stringify([task.taskId, approval ? `approval:${bookingDigest(approval)}` : requestKey]);
+            const decisionEvents = await runDecisionSingleFlight(composition, flightKey, async () => {
                 if (turn.kind === 'action.receipt.continuation' && task.awaitingApproval) {
-                    return composition.runtime.applyDecisionBatch(task.taskId, requestKey, [
-                        composition.runtime.approvalQuestion(task.taskId)
-                    ], false);
+                    return composition.runtime.applyDecisionBatch(task.taskId, requestKey, [composition.runtime.approvalQuestion(task.taskId)], false);
                 }
                 const sessions = sessionsFor(composition);
                 const session = sessions.get(task.taskId) ?? composition.plannerFactory(task);
                 sessions.set(task.taskId, session);
-                const decisions = await session.next({
-                    turn,
-                    task: composition.runtime.resumeTask(task.taskId) ?? task
-                });
-                const plannerDecisions = decisions.length ? decisions : [
-                    {
-                        kind: 'error',
-                        error: {
-                            code: 'PLANNER_NO_DECISION',
-                            message: 'Planner returned no typed decision.',
-                            retryable: false
-                        }
-                    }
-                ];
+                const decisions = await session.next({ turn, task: composition.runtime.resumeTask(task.taskId) ?? task });
+                const plannerDecisions = decisions.length ? decisions : [{ kind: 'error', error: { code: 'PLANNER_NO_DECISION', message: 'Planner returned no typed decision.', retryable: false } }];
                 return composition.runtime.applyDecisionBatch(task.taskId, requestKey, plannerDecisions, fresh);
             });
-            for (const event of decisionEvents)write(res, event);
+            for (const event of decisionEvents)
+                write(res, event);
         }
-    } catch (error) {
+    }
+    catch (error) {
         writeTypedError(res, composition, task, error, activeDecisionKey, fresh);
-    } finally{
+    }
+    finally {
         res.end();
     }
 }
 export function startBookingCopilotServer(options) {
-    if (!options.apiKey) return Promise.reject(new Error('booking_copilot_api_key_required'));
+    if (!options.apiKey)
+        return Promise.reject(new Error('booking_copilot_api_key_required'));
     if (options.artifactId !== undefined && !/^[0-9a-f]{40}$/.test(options.artifactId)) {
         return Promise.reject(new Error('booking_copilot_artifact_id_invalid'));
     }
@@ -386,7 +388,9 @@ export function startBookingCopilotServer(options) {
     if (hasIngressBinding !== hasPrincipal) {
         return Promise.reject(new Error('booking_copilot_ingress_binding_pair_required'));
     }
-    if (hasIngressBinding && (typeof options.ingressBinding?.bind !== 'function' || typeof options.principal?.subject !== 'string' || options.principal.subject.length === 0 || options.principal.subject.length > 256 || typeof options.principal?.scope !== 'string' || options.principal.scope.length === 0 || options.principal.scope.length > 256)) {
+    if (hasIngressBinding && (typeof options.ingressBinding?.bind !== 'function'
+        || typeof options.principal?.subject !== 'string' || options.principal.subject.length === 0 || options.principal.subject.length > 256
+        || typeof options.principal?.scope !== 'string' || options.principal.scope.length === 0 || options.principal.scope.length > 256)) {
         return Promise.reject(new Error('booking_copilot_ingress_binding_invalid'));
     }
     const ingressMode = options.ingressMode ?? (hasIngressBinding ? 'bff-ingress-binding' : 'bff-bound-turn-only');
@@ -402,87 +406,32 @@ export function startBookingCopilotServer(options) {
     const composition = {
         runtime: options.runtime,
         plannerFactory: options.plannerFactory,
-        ...hasIngressBinding ? {
-            ingressBinding: options.ingressBinding,
-            principal: options.principal
-        } : {},
-        ingressMode
+        ...(hasIngressBinding ? { ingressBinding: options.ingressBinding, principal: options.principal } : {}),
+        ingressMode,
     };
     const maxBodyBytes = options.maxBodyBytes ?? 1_000_000;
     const runningIdentity = runtimeIdentity();
-    const server = createServer(async (req, res)=>{
-        const isProbe = req.method === 'GET' && (req.url === '/healthz' || req.url === '/status');
-        if (!isProbe && (req.method !== 'POST' || req.url !== '/a2a/booking-copilot/turn')) {
-            sendJson(res, 404, {
-                error: {
-                    code: 'not_found'
-                }
-            });
-            return;
-        }
-        const auth = String(req.headers.authorization ?? '');
-        if (!safeSecretEqual(auth, `Bearer ${options.apiKey}`)) {
-            sendJson(res, 401, {
-                error: {
-                    code: 'unauthorized'
-                }
-            });
-            return;
-        }
-        if (isProbe) {
-            res.setHeader(BOOKING_SURFACE_VERSION_HEADER, BOOKING_SURFACE_SCHEMA_VERSION);
-            res.setHeader(BOOKING_SURFACE_SCHEMA_SHA256_HEADER, BOOKING_SURFACE_SCHEMA_SHA256);
-            if (options.artifactId) res.setHeader('X-GoTry-Artifact-ID', options.artifactId);
-            res.setHeader('X-GoTry-Node-Version', runningIdentity.nodeVersion);
-            res.setHeader('X-GoTry-Node-Modules-ABI', runningIdentity.nodeModulesAbi);
-            res.setHeader('X-GoTry-Release-Tuple', runningIdentity.releaseTuple);
-            if (runningIdentity.glibcVersion) res.setHeader('X-GoTry-Glibc-Version', runningIdentity.glibcVersion);
-            const acceptedTurnKinds = ingressMode === 'bff-ingress-binding' ? [
-                ...BOOKING_COPILOT_ACCEPTED_TURN_KINDS,
-                'user.turn.ingress'
-            ] : [
-                ...BOOKING_COPILOT_ACCEPTED_TURN_KINDS
-            ];
-            const healthBody = {
-                schemaVersion: BOOKING_SURFACE_SCHEMA_VERSION,
-                schemaSha256: BOOKING_SURFACE_SCHEMA_SHA256,
-                status: 'ready',
-                ingressMode,
-                acceptedTurnKinds
-            };
-            res.setHeader('X-GoTry-Ingress-Mode', ingressMode);
-            res.setHeader('X-GoTry-Accepted-Turn-Kinds', acceptedTurnKinds.join(','));
-            sendJson(res, 200, healthBody);
-            return;
-        }
-        const schemaVersion = String(req.headers[BOOKING_SURFACE_VERSION_HEADER] ?? '');
-        const schemaHash = String(req.headers[BOOKING_SURFACE_SCHEMA_SHA256_HEADER] ?? '');
-        if (schemaVersion !== BOOKING_SURFACE_SCHEMA_VERSION || schemaHash !== BOOKING_SURFACE_SCHEMA_SHA256) {
-            sendJson(res, 409, {
-                error: {
-                    code: 'booking_surface_schema_mismatch',
-                    expectedVersion: BOOKING_SURFACE_SCHEMA_VERSION,
-                    expectedSchemaSha256: BOOKING_SURFACE_SCHEMA_SHA256
-                }
-            });
-            return;
-        }
-        await handleBookingCopilotRequest(req, res, composition, maxBodyBytes);
+    const server = createServer((req, res) => {
+        void bookingCopilotTrafficHandler({
+            apiKey: options.apiKey,
+            composition,
+            maxBodyBytes,
+            ...(options.artifactId !== undefined ? { artifactId: options.artifactId } : {}),
+            ingressMode,
+            runningIdentity,
+        })(req, res);
     });
-    return new Promise((resolve, reject)=>{
+    return new Promise((resolve, reject) => {
         server.once('error', reject);
-        server.listen(options.port ?? 0, options.host ?? '127.0.0.1', ()=>{
+        server.listen(options.port ?? 0, options.host ?? '127.0.0.1', () => {
             server.off('error', reject);
             const address = server.address();
-            const port = typeof address === 'object' && address ? address.port : options.port ?? 0;
+            const port = typeof address === 'object' && address ? address.port : (options.port ?? 0);
             resolve({
                 server,
                 port,
-                close: ()=>new Promise((done, fail)=>server.close((error)=>error ? fail(error) : done()))
+                close: () => new Promise((done, fail) => server.close((error) => error ? fail(error) : done())),
             });
         });
     });
 }
-
-
-//# sourceURL=ts/src/booking-surface/server.ts