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

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

@@ -0,0 +1,302 @@
+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 { 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';
+function runtimeIdentity() {
+    const report = process.report?.getReport?.();
+    const header = report?.header;
+    const glibcVersion = header?.glibcVersionRuntime ?? '';
+    return {
+        nodeVersion: process.version,
+        nodeModulesAbi: process.versions.modules ?? '',
+        releaseTuple: `${process.platform}-${process.arch}-${glibcVersion ? 'glibc' : 'unknown'}`,
+        glibcVersion
+    };
+}
+function safeSecretEqual(actual, expected) {
+    const actualBytes = Buffer.from(actual);
+    const expectedBytes = Buffer.from(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.end(JSON.stringify(body));
+}
+function readBody(req, maxBodyBytes) {
+    return new Promise((resolve, reject)=>{
+        const chunks = [];
+        let size = 0;
+        let exceeded = false;
+        req.on('data', (chunk)=>{
+            size += chunk.length;
+            if (size > maxBodyBytes) {
+                exceeded = true;
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on('end', ()=>exceeded ? reject(new Error('payload_too_large')) : resolve(Buffer.concat(chunks).toString('utf8')));
+        req.on('error', reject);
+    });
+}
+function writeSse(res, event) {
+    res.write(`event: ${event.kind}\ndata: ${JSON.stringify(event)}\n\n`);
+}
+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.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'));
+    }
+    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'));
+    }
+    if (options.v2 && ingressMode === 'bff-ingress-binding' && !hasIngressBinding) {
+        return Promise.reject(new Error('booking_copilot_v2_ingress_binding_required'));
+    }
+    if (options.v2 && ingressMode === 'bff-bound-turn-only' && hasIngressBinding) {
+        return Promise.reject(new Error('booking_copilot_v2_ingress_mode_conflict'));
+    }
+    const v2 = options.v2 ? {
+        ...options.v2,
+        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)=>{
+        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) {
+            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);
+            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
+            ] : [
+                BOOKING_SURFACE_SCHEMA_VERSION,
+                BOOKING_SURFACE_SCHEMA_VERSION_V2
+            ];
+            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(','));
+            }
+            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: {
+                    code: 'booking_surface_schema_mismatch',
+                    expectedVersion: BOOKING_SURFACE_SCHEMA_VERSION,
+                    expectedSchemaSha256: BOOKING_SURFACE_SCHEMA_SHA256
+                }
+            });
+            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();
+        }
+    });
+    return new Promise((resolve, reject)=>{
+        server.once('error', reject);
+        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;
+            resolve({
+                server,
+                port,
+                close: ()=>new Promise((done, fail)=>server.close((error)=>error ? fail(error) : done()))
+            });
+        });
+    });
+}
+
+
+//# sourceURL=ts/src/booking-surface/server.ts

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

@@ -0,0 +1,159 @@
+import { mkdirSync } from 'node:fs';
+import { isAbsolute, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ensureLedger } from '../state-ledger.js';
+import { buildDshPlannerEnvironment, createDshEmbeddedBookingPlanner, createDshEmbeddedBookingPlannerV2 } from './dsh-planner.js';
+import { BookingCopilotTaskRuntime } from './runtime.js';
+import { BookingCopilotTaskRuntimeV2 } from './runtime-v2.js';
+import { BOOKING_COPILOT_V2_INGRESS_MODES } from './contracts-v2.js';
+import { startBookingCopilotServer } from './server.js';
+const DEFAULT_DEPENDENCIES = {
+    ensureLedger,
+    runtimeFactory: (ledger)=>new BookingCopilotTaskRuntime(ledger),
+    createPlanner: createDshEmbeddedBookingPlanner,
+    runtimeFactoryV2: (ledger)=>new BookingCopilotTaskRuntimeV2(ledger),
+    createPlannerV2: createDshEmbeddedBookingPlannerV2,
+    startServer: startBookingCopilotServer
+};
+function parsePort(raw) {
+    if (raw === undefined || raw === '') return 3_082;
+    const value = Number(raw);
+    if (!Number.isSafeInteger(value) || value < 0 || value > 65_535) throw new Error('booking_copilot_invalid_port');
+    return value;
+}
+export function resolveBookingCopilotStartupConfig(env = process.env) {
+    const apiKey = env.GOTRY_BOOKING_COPILOT_API_KEY ?? '';
+    if (!apiKey) throw new Error('booking_copilot_api_key_required');
+    const stateRoot = env.GOTRY_BOOKING_COPILOT_STATE_ROOT ?? '';
+    if (!stateRoot) throw new Error('booking_copilot_state_root_required');
+    if (!isAbsolute(stateRoot)) throw new Error('booking_copilot_state_root_must_be_absolute');
+    const artifactId = env.GOTRY_BOOKING_COPILOT_ARTIFACT_ID || undefined;
+    if (artifactId !== undefined && !/^[0-9a-f]{40}$/.test(artifactId)) {
+        throw new Error('booking_copilot_artifact_id_invalid');
+    }
+    const rawIngressMode = env.GOTRY_BOOKING_COPILOT_V2_INGRESS_MODE;
+    const ingressMode = rawIngressMode === undefined || rawIngressMode === '' ? 'bff-bound-turn-only' : rawIngressMode;
+    if (!BOOKING_COPILOT_V2_INGRESS_MODES.includes(ingressMode)) {
+        throw new Error('booking_copilot_v2_ingress_mode_invalid');
+    }
+    return {
+        apiKey,
+        stateRoot,
+        host: env.GOTRY_BOOKING_COPILOT_HOST || '127.0.0.1',
+        port: parsePort(env.GOTRY_BOOKING_COPILOT_PORT),
+        artifactId,
+        ingressMode: ingressMode
+    };
+}
+async function closeAll(server, planner, plannerV2, ledger) {
+    const failures = [];
+    for (const close of [
+        server ? ()=>server.close() : undefined,
+        planner ? ()=>planner.close() : undefined,
+        plannerV2 ? ()=>plannerV2.close() : undefined,
+        ledger ? ()=>Promise.resolve(ledger.close()) : undefined
+    ]){
+        if (!close) continue;
+        try {
+            await close();
+        } catch (error) {
+            failures.push(error);
+        }
+    }
+    if (failures.length === 1) throw failures[0];
+    if (failures.length > 1) throw new AggregateError(failures, 'booking_copilot_shutdown_failed');
+}
+export async function startBookingCopilotFromEnvironment(env = process.env, dependencies = DEFAULT_DEPENDENCIES) {
+    const config = resolveBookingCopilotStartupConfig(env);
+    const activeDependencies = dependencies;
+    const hasIngressBinding = Boolean(activeDependencies.ingressBinding);
+    const hasPrincipal = Boolean(activeDependencies.principal);
+    if (hasIngressBinding !== hasPrincipal) throw new Error('booking_copilot_v2_ingress_binding_pair_required');
+    const ingressPair = hasIngressBinding && hasPrincipal;
+    if (ingressPair && env.GOTRY_BOOKING_COPILOT_V2_INGRESS_MODE !== undefined && config.ingressMode === 'bff-bound-turn-only') {
+        throw new Error('booking_copilot_v2_ingress_mode_conflict');
+    }
+    if (!ingressPair && config.ingressMode === 'bff-ingress-binding') throw new Error('booking_copilot_v2_ingress_binding_required');
+    if (ingressPair && (typeof activeDependencies.ingressBinding?.bind !== 'function' || typeof activeDependencies.principal?.subject !== 'string' || activeDependencies.principal.subject.length === 0 || activeDependencies.principal.subject.length > 256 || typeof activeDependencies.principal?.scope !== 'string' || activeDependencies.principal.scope.length === 0 || activeDependencies.principal.scope.length > 256)) {
+        throw new Error('booking_copilot_v2_ingress_binding_invalid');
+    }
+    const activeIngressMode = ingressPair ? 'bff-ingress-binding' : 'bff-bound-turn-only';
+    mkdirSync(config.stateRoot, {
+        recursive: true
+    });
+    let ledger;
+    let planner;
+    let plannerV2;
+    let server;
+    try {
+        ledger = dependencies.ensureLedger(config.stateRoot);
+        const plannerOptions = {
+            stateRoot: config.stateRoot,
+            env: buildDshPlannerEnvironment(env)
+        };
+        if (!activeDependencies.runtimeFactoryV2 || !activeDependencies.createPlannerV2) throw new Error('booking_copilot_v2_startup_dependency_missing');
+        const runtime = activeDependencies.runtimeFactory(ledger);
+        planner = await activeDependencies.createPlanner(plannerOptions);
+        const runtimeV2 = activeDependencies.runtimeFactoryV2(ledger);
+        plannerV2 = await activeDependencies.createPlannerV2(plannerOptions);
+        server = await activeDependencies.startServer({
+            apiKey: config.apiKey,
+            runtime,
+            plannerFactory: planner.plannerFactory,
+            v2: {
+                runtime: runtimeV2,
+                plannerFactory: plannerV2.plannerFactory,
+                ingressBinding: activeDependencies.ingressBinding,
+                principal: activeDependencies.principal,
+                ingressMode: activeIngressMode
+            },
+            host: config.host,
+            port: config.port,
+            artifactId: config.artifactId
+        });
+    } catch (error) {
+        try {
+            await closeAll(server, planner, plannerV2, ledger);
+        } catch (cleanupError) {
+            throw new AggregateError([
+                error,
+                cleanupError
+            ], 'booking_copilot_startup_and_cleanup_failed');
+        }
+        throw error;
+    }
+    let closed = false;
+    return {
+        port: server.port,
+        async close () {
+            if (closed) return;
+            closed = true;
+            await closeAll(server, planner, plannerV2, ledger);
+        }
+    };
+}
+async function runCli() {
+    const handle = await startBookingCopilotFromEnvironment();
+    process.stderr.write(`[gotry-booking-copilot] listening on http://127.0.0.1:${handle.port}/a2a/booking-copilot/turn\n`);
+    let stopping = false;
+    const stop = ()=>{
+        if (stopping) return;
+        stopping = true;
+        void handle.close().then(()=>process.exit(0), (error)=>{
+            process.stderr.write(`[gotry-booking-copilot] shutdown failed: ${error instanceof Error ? error.message : String(error)}\n`);
+            process.exit(1);
+        });
+    };
+    process.once('SIGINT', stop);
+    process.once('SIGTERM', stop);
+}
+const invokedPath = process.argv[1] ? resolve(process.argv[1]) : '';
+if (invokedPath === fileURLToPath(import.meta.url)) {
+    runCli().catch((error)=>{
+        process.stderr.write(`[gotry-booking-copilot] startup failed: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exit(1);
+    });
+}
+
+
+//# sourceURL=ts/src/booking-surface/startup.ts