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

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

@@ -1,11 +1,39 @@
 import { timingSafeEqual } from 'node:crypto';
 import { createServer } from 'node:http';
-import { BOOKING_SURFACE_SCHEMA_SHA256, BOOKING_SURFACE_SCHEMA_SHA256_HEADER, BOOKING_SURFACE_SCHEMA_VERSION, BOOKING_SURFACE_VERSION_HEADER } from './contracts.js';
-import { BookingCopilotTaskRuntime } from './runtime.js';
-import { validateBookingCopilotTurnV1 } from './validation.js';
-import { handleBookingCopilotV2Request } from './server-v2.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, BookingCopilotTaskRuntime } from './runtime.js';
+import { validateBookingSurface } from './validation.js';
 import { normalizeBookingErrorCode, safeBookingErrorMessage } from './error-codes.js';
-import { BOOKING_COPILOT_V2_ACCEPTED_TURN_KINDS, BOOKING_COPILOT_V2_INGRESS_TURN_KIND, BOOKING_COPILOT_V2_INGRESS_MODES, BOOKING_SURFACE_SCHEMA_V2_SHA256, BOOKING_SURFACE_SCHEMA_VERSION_V2 } from './contracts-v2.js';
+const sessionsByComposition = new WeakMap();
+const decisionFlightsByComposition = new WeakMap();
+function sessionsFor(composition) {
+    let sessions = sessionsByComposition.get(composition);
+    if (!sessions) {
+        sessions = new Map();
+        sessionsByComposition.set(composition, sessions);
+    }
+    return sessions;
+}
+function decisionFlightsFor(composition) {
+    let flights = decisionFlightsByComposition.get(composition);
+    if (!flights) {
+        flights = new Map();
+        decisionFlightsByComposition.set(composition, flights);
+    }
+    return flights;
+}
+async function runDecisionSingleFlight(composition, key, work) {
+    const flights = decisionFlightsFor(composition);
+    const prior = flights.get(key);
+    if (prior) return prior;
+    const current = work();
+    flights.set(key, current);
+    try {
+        return await current;
+    } finally{
+        if (flights.get(key) === current) flights.delete(key);
+    }
+}
 function runtimeIdentity() {
     const report = process.report?.getReport?.();
     const header = report?.header;
@@ -45,38 +73,341 @@ function readBody(req, maxBodyBytes) {
         req.on('error', reject);
     });
 }
-function writeSse(res, event) {
+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]);
+}
+function exactKeys(value, allowed) {
+    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;
+    const matrix = SURFACE_ACTION_MATRIX[surface];
+    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);
+}
+function validIngressBinding(binding, ingress) {
+    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;
+    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;
+}
+function fallbackErrorEvent(task, code) {
+    return {
+        schemaVersion: BOOKING_SURFACE_SCHEMA_VERSION,
+        eventId: `error-${task.taskId}-${task.lastSequence + 1}`,
+        taskId: task.taskId,
+        contextRef: task.contextRef,
+        sequence: task.lastSequence + 1,
+        emittedAt: new Date().toISOString(),
+        kind: 'error',
+        error: {
+            code: normalizeBookingErrorCode(code),
+            message: safeBookingErrorMessage(normalizeBookingErrorCode(code)),
+            retryable: false
+        }
+    };
+}
+function writeTypedError(res, composition, task, error, requestKey, includeSubmitted = false) {
+    const code = normalizeBookingErrorCode(error);
+    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
+            }
+        };
+        if (requestKey) {
+            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  {
+        write(res, fallbackErrorEvent(task, code));
+    }
+}
+async function handleBookingCopilotRequest(req, res, composition, maxBodyBytes) {
+    let turn;
+    let browserRequestKey;
+    let requestBinding;
+    try {
+        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
+                }
+            });
+            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
+                        ]
+                    }
+                });
+                return;
+            }
+            const binding = await composition.ingressBinding.bind(ingress, composition.principal);
+            if (!validIngressBinding(binding, ingress)) {
+                sendJson(res, 502, {
+                    error: {
+                        code: 'invalid_ingress_binding'
+                    }
+                });
+                return;
+            }
+            if (!validIngressApprovalAuthority(ingress, binding)) {
+                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
+                } : {}
+            };
+            const boundValid = validateBookingSurface(turn);
+            if (!boundValid.ok) {
+                sendJson(res, 502, {
+                    error: {
+                        code: 'invalid_ingress_binding',
+                        details: boundValid.errors
+                    }
+                });
+                return;
+            }
+        } else {
+            turn = parsed;
+            if (!validBoundWorkspaceAuthority(turn.workspace)) {
+                sendJson(res, 403, {
+                    error: {
+                        code: 'invalid_bound_turn_authority'
+                    }
+                });
+                return;
+            }
+        }
+    } catch (error) {
+        const code = normalizeBookingErrorCode(error);
+        sendJson(res, code === 'PAYLOAD_TOO_LARGE' ? 413 : 400, {
+            error: {
+                code
+            }
+        });
+        return;
+    }
+    let task;
+    let fresh = false;
+    let replayKey;
+    let replayEvents = null;
+    let activeDecisionKey;
+    try {
+        fresh = turn.kind === 'action.receipt.continuation' ? false : !turn.taskId || composition.runtime.resumeTask(turn.taskId) === null;
+        if (turn.kind === 'action.receipt.continuation') {
+            replayKey = `receipt:${turn.receipt.actionId}:${composition.runtime.receiptDigest(turn.receipt)}`;
+            task = composition.runtime.continueWithReceipt(turn);
+            if (task.awaitingApproval) {
+                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 {
+            const existing = turn.taskId ? composition.runtime.resumeTask(turn.taskId) : null;
+            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);
+                task = existing;
+                replayKey = stableReplayKey;
+                replayEvents = stableReplay;
+            } 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);
+                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');
+                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');
+                task = existing;
+            } 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}`;
+                    replayEvents = composition.runtime.readDecisionBatch(task.taskId, replayKey);
+                }
+            }
+        }
+    } catch (error) {
+        sendJson(res, 409, {
+            error: {
+                code: normalizeBookingErrorCode(error)
+            }
+        });
+        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
+    });
+    try {
+        if (replayEvents) {
+            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 ()=>{
+                if (turn.kind === 'action.receipt.continuation' && task.awaitingApproval) {
+                    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
+                        }
+                    }
+                ];
+                return composition.runtime.applyDecisionBatch(task.taskId, requestKey, plannerDecisions, fresh);
+            });
+            for (const event of decisionEvents)write(res, event);
+        }
+    } catch (error) {
+        writeTypedError(res, composition, task, error, activeDecisionKey, fresh);
+    } finally{
+        res.end();
+    }
+}
 export function startBookingCopilotServer(options) {
     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'));
     }
-    const hasIngressBinding = Boolean(options.v2?.ingressBinding);
-    const hasPrincipal = Boolean(options.v2?.principal);
-    if (options.v2 && hasIngressBinding !== hasPrincipal) {
-        return Promise.reject(new Error('booking_copilot_v2_ingress_binding_pair_required'));
+    if (!options.runtime || !options.plannerFactory) {
+        return Promise.reject(new Error('booking_copilot_runtime_and_planner_required'));
+    }
+    const hasIngressBinding = Boolean(options.ingressBinding);
+    const hasPrincipal = Boolean(options.principal);
+    if (hasIngressBinding !== hasPrincipal) {
+        return Promise.reject(new Error('booking_copilot_ingress_binding_pair_required'));
     }
-    if (options.v2 && hasIngressBinding && (typeof options.v2.ingressBinding?.bind !== 'function' || typeof options.v2.principal?.subject !== 'string' || options.v2.principal.subject.length === 0 || options.v2.principal.subject.length > 256 || typeof options.v2.principal?.scope !== 'string' || options.v2.principal.scope.length === 0 || options.v2.principal.scope.length > 256)) {
-        return Promise.reject(new Error('booking_copilot_v2_ingress_binding_invalid'));
+    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.v2 ? options.v2.ingressMode ?? (hasIngressBinding ? 'bff-ingress-binding' : 'bff-bound-turn-only') : undefined;
-    if (options.v2 && !BOOKING_COPILOT_V2_INGRESS_MODES.includes(ingressMode)) {
-        return Promise.reject(new Error('booking_copilot_v2_ingress_mode_invalid'));
+    const ingressMode = options.ingressMode ?? (hasIngressBinding ? 'bff-ingress-binding' : 'bff-bound-turn-only');
+    if (!BOOKING_COPILOT_INGRESS_MODES.includes(ingressMode)) {
+        return Promise.reject(new Error('booking_copilot_ingress_mode_invalid'));
     }
-    if (options.v2 && ingressMode === 'bff-ingress-binding' && !hasIngressBinding) {
-        return Promise.reject(new Error('booking_copilot_v2_ingress_binding_required'));
+    if (ingressMode === 'bff-ingress-binding' && !hasIngressBinding) {
+        return Promise.reject(new Error('booking_copilot_ingress_binding_required'));
     }
-    if (options.v2 && ingressMode === 'bff-bound-turn-only' && hasIngressBinding) {
-        return Promise.reject(new Error('booking_copilot_v2_ingress_mode_conflict'));
+    if (ingressMode === 'bff-bound-turn-only' && hasIngressBinding) {
+        return Promise.reject(new Error('booking_copilot_ingress_mode_conflict'));
     }
-    const v2 = options.v2 ? {
-        ...options.v2,
+    const composition = {
+        runtime: options.runtime,
+        plannerFactory: options.plannerFactory,
+        ...hasIngressBinding ? {
+            ingressBinding: options.ingressBinding,
+            principal: options.principal
+        } : {},
         ingressMode
-    } : undefined;
-    const v2Only = Boolean(v2 && !options.runtime && !options.plannerFactory);
-    const sessions = new Map();
+    };
     const maxBodyBytes = options.maxBodyBytes ?? 1_000_000;
     const runningIdentity = runtimeIdentity();
     const server = createServer(async (req, res)=>{
@@ -99,56 +430,33 @@ export function startBookingCopilotServer(options) {
             return;
         }
         if (isProbe) {
-            const activeV2Only = Boolean(v2 && !options.runtime && !options.plannerFactory);
-            res.setHeader(BOOKING_SURFACE_VERSION_HEADER, activeV2Only ? BOOKING_SURFACE_SCHEMA_VERSION_V2 : BOOKING_SURFACE_SCHEMA_VERSION);
-            res.setHeader(BOOKING_SURFACE_SCHEMA_SHA256_HEADER, activeV2Only ? BOOKING_SURFACE_SCHEMA_V2_SHA256 : BOOKING_SURFACE_SCHEMA_SHA256);
+            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 healthBody = {
-                schemaVersion: activeV2Only ? BOOKING_SURFACE_SCHEMA_VERSION_V2 : BOOKING_SURFACE_SCHEMA_VERSION,
-                schemaSha256: activeV2Only ? BOOKING_SURFACE_SCHEMA_V2_SHA256 : BOOKING_SURFACE_SCHEMA_SHA256,
-                status: 'ready'
-            };
-            if (activeV2Only || v2) healthBody.supportedSchemaVersions = activeV2Only ? [
-                BOOKING_SURFACE_SCHEMA_VERSION_V2
+            const acceptedTurnKinds = ingressMode === 'bff-ingress-binding' ? [
+                ...BOOKING_COPILOT_ACCEPTED_TURN_KINDS,
+                'user.turn.ingress'
             ] : [
-                BOOKING_SURFACE_SCHEMA_VERSION,
-                BOOKING_SURFACE_SCHEMA_VERSION_V2
+                ...BOOKING_COPILOT_ACCEPTED_TURN_KINDS
             ];
-            if (v2) {
-                const acceptedTurnKinds = v2.ingressMode === 'bff-ingress-binding' ? [
-                    ...BOOKING_COPILOT_V2_ACCEPTED_TURN_KINDS,
-                    BOOKING_COPILOT_V2_INGRESS_TURN_KIND
-                ] : [
-                    ...BOOKING_COPILOT_V2_ACCEPTED_TURN_KINDS
-                ];
-                healthBody.ingressMode = v2.ingressMode;
-                healthBody.acceptedTurnKinds = acceptedTurnKinds;
-                res.setHeader('X-GoTry-Ingress-Mode', v2.ingressMode);
-                res.setHeader('X-GoTry-Accepted-Turn-Kinds', acceptedTurnKinds.join(','));
-            }
+            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_V2) {
-            if (!v2 || schemaHash !== BOOKING_SURFACE_SCHEMA_V2_SHA256) {
-                sendJson(res, 409, {
-                    error: {
-                        code: 'booking_surface_schema_mismatch',
-                        expectedVersion: BOOKING_SURFACE_SCHEMA_VERSION_V2,
-                        expectedSchemaSha256: BOOKING_SURFACE_SCHEMA_V2_SHA256
-                    }
-                });
-                return;
-            }
-            await handleBookingCopilotV2Request(req, res, v2, maxBodyBytes);
-            return;
-        }
         if (schemaVersion !== BOOKING_SURFACE_SCHEMA_VERSION || schemaHash !== BOOKING_SURFACE_SCHEMA_SHA256) {
             sendJson(res, 409, {
                 error: {
@@ -159,129 +467,7 @@ export function startBookingCopilotServer(options) {
             });
             return;
         }
-        if (!options.runtime || !options.plannerFactory) {
-            sendJson(res, 503, {
-                error: {
-                    code: 'booking_surface_v1_not_configured'
-                }
-            });
-            return;
-        }
-        let turn;
-        try {
-            const raw = await readBody(req, maxBodyBytes);
-            const parsed = JSON.parse(raw);
-            const validation = validateBookingCopilotTurnV1(parsed);
-            if (!validation.ok) {
-                sendJson(res, 400, {
-                    error: {
-                        code: 'invalid_booking_surface_turn',
-                        details: validation.errors
-                    }
-                });
-                return;
-            }
-            turn = parsed;
-        } catch (error) {
-            const code = normalizeBookingErrorCode(error);
-            sendJson(res, code === 'PAYLOAD_TOO_LARGE' ? 413 : 400, {
-                error: {
-                    code
-                }
-            });
-            return;
-        }
-        let task;
-        let isNewTask = false;
-        try {
-            const taskId = turn.taskId;
-            if (v2 && taskId && v2.runtime.resumeTask(taskId)) throw new Error('task_conflict:protocol_version');
-            if (turn.kind === 'user.turn') {
-                const suppliedTaskId = turn.taskId;
-                isNewTask = !suppliedTaskId || options.runtime.resumeTask(suppliedTaskId) === null;
-                task = options.runtime.startTask(turn);
-            } else {
-                task = options.runtime.continueWithReceipt(turn);
-            }
-        } catch (error) {
-            sendJson(res, 409, {
-                error: {
-                    code: normalizeBookingErrorCode(error)
-                }
-            });
-            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
-        });
-        try {
-            if (isNewTask) writeSse(res, options.runtime.emitEvent(task.taskId, {
-                kind: 'status',
-                status: 'submitted'
-            }));
-            writeSse(res, options.runtime.emitEvent(task.taskId, {
-                kind: 'status',
-                status: 'working'
-            }));
-            task = options.runtime.resumeTask(task.taskId) ?? task;
-            let session = sessions.get(task.taskId);
-            if (!session) {
-                session = options.plannerFactory(task);
-                sessions.set(task.taskId, session);
-            }
-            const decisions = await session.next({
-                turn,
-                task
-            });
-            if (decisions.length === 0) {
-                writeSse(res, options.runtime.emitEvent(task.taskId, {
-                    kind: 'error',
-                    error: {
-                        code: 'PLANNER_NO_DECISION',
-                        message: 'Planner returned no typed decision.',
-                        retryable: false
-                    }
-                }));
-            } else {
-                for (const decision of decisions){
-                    const event = decision.kind === 'operation' ? options.runtime.issueOperation(task.taskId, decision.action) : options.runtime.emitEvent(task.taskId, decision);
-                    writeSse(res, event);
-                }
-            }
-        } catch (error) {
-            try {
-                writeSse(res, options.runtime.emitEvent(task.taskId, {
-                    kind: 'error',
-                    error: {
-                        code: normalizeBookingErrorCode(error),
-                        message: safeBookingErrorMessage(normalizeBookingErrorCode(error)),
-                        retryable: false
-                    }
-                }));
-            } catch  {
-                writeSse(res, {
-                    schemaVersion: 'booking.surface.v1',
-                    eventId: `error-${task.taskId}-${task.lastSequence + 1}`,
-                    taskId: task.taskId,
-                    contextRef: task.contextRef,
-                    sequence: task.lastSequence + 1,
-                    emittedAt: new Date().toISOString(),
-                    kind: 'error',
-                    error: {
-                        code: normalizeBookingErrorCode(error),
-                        message: safeBookingErrorMessage(normalizeBookingErrorCode(error)),
-                        retryable: false
-                    }
-                });
-            }
-        } finally{
-            res.end();
-        }
+        await handleBookingCopilotRequest(req, res, composition, maxBodyBytes);
     });
     return new Promise((resolve, reject)=>{
         server.once('error', reject);