@voyantjs/travel-composer 0.55.0

package/README.md

@@ -0,0 +1,38 @@
+# @voyantjs/travel-composer
+
+Deterministic composition layer for customer-facing trips that group multiple
+component bookings/orders into one itinerary, pricing, reserve, checkout, and
+support experience.
+
+This package is landing on the travel-composer integration branch. It currently
+includes the durable schema, Zod contracts, deterministic trip service,
+catalog component adapter, price aggregation, reserve workflow, checkout
+handoff, component-level cancellation preview/cancel operations, Cruise
+Extension representation helpers, Hono routes, and MCP tools. Checkout and
+cancellation are dependency-injected so app/runtime packages keep owning
+payment-provider, bank-transfer, storefront URL, supplier, and staff-remediation
+policy. See
+`docs/architecture/travel-composer-implementation-plan.md` for the full PR
+sequence and remaining slices.
+
+## Install
+
+```bash
+pnpm add @voyantjs/travel-composer
+```
+
+## Exports
+
+| Entry | Description |
+| --- | --- |
+| `.` | Module export |
+| `./schema` | Drizzle tables, added in the schema slice |
+| `./validation` | Zod contracts |
+| `./service` | Deterministic composer services |
+| `./mcp-tools` | AI-safe trip planning, revision, price, and reserve tools |
+| `./cruise-extension` | Cruise Extension link and selection helpers |
+| `./routes` | Hono route factory/module routes |
+
+## License
+
+Apache-2.0

package/dist/catalog-component-adapter.d.ts

@@ -0,0 +1,16 @@
+import { type BookingDraftV1, type TravelerEntryV1 } from "@voyantjs/catalog/booking-engine/contracts";
+import type { TripComponent } from "./schema.js";
+export interface CatalogComponentBookingDraftOverrides {
+    configure?: Partial<BookingDraftV1["configure"]>;
+    billing?: Partial<BookingDraftV1["billing"]>;
+    travelers?: TravelerEntryV1[];
+    accommodation?: BookingDraftV1["accommodation"];
+    addons?: BookingDraftV1["addons"];
+    payment?: Partial<BookingDraftV1["payment"]>;
+    promotionCode?: string;
+    internalNotes?: string;
+    customerNotes?: string;
+}
+export declare function isCatalogBackedTripComponent(component: Pick<TripComponent, "kind" | "entityModule" | "entityId" | "sourceKind">): boolean;
+export declare function toBookingDraftV1(component: Pick<TripComponent, "kind" | "entityModule" | "entityId" | "sourceKind" | "sourceConnectionId" | "sourceRef">, overrides?: CatalogComponentBookingDraftOverrides): BookingDraftV1;
+//# sourceMappingURL=catalog-component-adapter.d.ts.map

package/dist/catalog-component-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog-component-adapter.d.ts","sourceRoot":"","sources":["../src/catalog-component-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EAEnB,KAAK,eAAe,EACrB,MAAM,4CAA4C,CAAA;AAEnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAGhD,MAAM,WAAW,qCAAqC;IACpD,SAAS,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC,CAAA;IAChD,OAAO,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CAAA;IAC5C,SAAS,CAAC,EAAE,eAAe,EAAE,CAAA;IAC7B,aAAa,CAAC,EAAE,cAAc,CAAC,eAAe,CAAC,CAAA;IAC/C,MAAM,CAAC,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAA;IACjC,OAAO,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CAAA;IAC5C,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,cAAc,GAAG,UAAU,GAAG,YAAY,CAAC,GAClF,OAAO,CAOT;AAED,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,IAAI,CACb,aAAa,EACb,MAAM,GAAG,cAAc,GAAG,UAAU,GAAG,YAAY,GAAG,oBAAoB,GAAG,WAAW,CACzF,EACD,SAAS,GAAE,qCAA0C,GACpD,cAAc,CA4BhB"}

package/dist/catalog-component-adapter.js

@@ -0,0 +1,34 @@
+import { bookingDraftV1, } from "@voyantjs/catalog/booking-engine/contracts";
+import { TravelComposerInvariantError } from "./service.js";
+export function isCatalogBackedTripComponent(component) {
+    return Boolean(component.kind === "catalog_booking" &&
+        component.entityModule &&
+        component.entityId &&
+        component.sourceKind);
+}
+export function toBookingDraftV1(component, overrides = {}) {
+    if (!isCatalogBackedTripComponent(component)) {
+        throw new TravelComposerInvariantError("Trip component cannot be mapped to a booking draft without catalog entity refs");
+    }
+    return bookingDraftV1.parse({
+        entity: {
+            module: component.entityModule,
+            id: component.entityId,
+            sourceKind: component.sourceKind,
+            sourceConnectionId: component.sourceConnectionId ?? undefined,
+            sourceRef: component.sourceRef ?? undefined,
+        },
+        configure: {
+            pax: {},
+            ...overrides.configure,
+        },
+        billing: overrides.billing,
+        travelers: overrides.travelers,
+        accommodation: overrides.accommodation,
+        addons: overrides.addons,
+        payment: overrides.payment,
+        promotionCode: overrides.promotionCode,
+        internalNotes: overrides.internalNotes,
+        customerNotes: overrides.customerNotes,
+    });
+}

package/dist/cruise-extension.d.ts

@@ -0,0 +1,48 @@
+import type { CreateTripComponentInput } from "./validation.js";
+export declare const CRUISE_EXTENSION_METADATA_KIND = "cruise_extension";
+export type CruiseExtensionTargetKind = "cruise" | "cruise_sailing";
+export type CruiseExtensionPlacement = "pre" | "post" | "either";
+export type CruiseExtensionLifecycle = "dependent_extra" | "independent_component";
+export interface CruiseExtensionLinkInput {
+    extensionProductId: string;
+    targetKind: CruiseExtensionTargetKind;
+    targetId: string;
+    linkKey?: string;
+}
+export interface CruiseExtensionLinkCommand {
+    linkKey: string;
+    leftId: string;
+    rightId: string;
+}
+export interface CruiseExtensionSelection {
+    extensionProductId: string;
+    targetKind: CruiseExtensionTargetKind;
+    targetId: string;
+    placement: CruiseExtensionPlacement;
+    lifecycle: CruiseExtensionLifecycle;
+    quantity?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface CruiseExtensionExtra {
+    kind: typeof CRUISE_EXTENSION_METADATA_KIND;
+    productId: string;
+    targetKind: CruiseExtensionTargetKind;
+    targetId: string;
+    placement: CruiseExtensionPlacement;
+    quantity: number;
+    metadata: Record<string, unknown>;
+}
+export type CruiseExtensionRepresentation = {
+    mode: "nested_extra";
+    extra: CruiseExtensionExtra;
+} | {
+    mode: "sibling_component";
+    component: CreateTripComponentInput;
+};
+export declare function cruiseExtensionLinkKey(targetKind: CruiseExtensionTargetKind): string;
+export declare function createCruiseExtensionLinkCommand(input: CruiseExtensionLinkInput): CruiseExtensionLinkCommand;
+export declare function createCruiseExtensionExtra(selection: CruiseExtensionSelection): CruiseExtensionExtra;
+export declare function createCruiseExtensionComponent(envelopeId: string, selection: CruiseExtensionSelection, sequence?: number): CreateTripComponentInput;
+export declare function representCruiseExtensionSelection(envelopeId: string, selection: CruiseExtensionSelection, sequence?: number): CruiseExtensionRepresentation;
+export declare function groupCruiseExtensionLinksByProduct(links: CruiseExtensionLinkInput[]): Map<string, CruiseExtensionLinkInput[]>;
+//# sourceMappingURL=cruise-extension.d.ts.map

package/dist/cruise-extension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cruise-extension.d.ts","sourceRoot":"","sources":["../src/cruise-extension.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAA;AAE/D,eAAO,MAAM,8BAA8B,qBAAqB,CAAA;AAEhE,MAAM,MAAM,yBAAyB,GAAG,QAAQ,GAAG,gBAAgB,CAAA;AACnE,MAAM,MAAM,wBAAwB,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,CAAA;AAChE,MAAM,MAAM,wBAAwB,GAAG,iBAAiB,GAAG,uBAAuB,CAAA;AAElF,MAAM,WAAW,wBAAwB;IACvC,kBAAkB,EAAE,MAAM,CAAA;IAC1B,UAAU,EAAE,yBAAyB,CAAA;IACrC,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,wBAAwB;IACvC,kBAAkB,EAAE,MAAM,CAAA;IAC1B,UAAU,EAAE,yBAAyB,CAAA;IACrC,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,wBAAwB,CAAA;IACnC,SAAS,EAAE,wBAAwB,CAAA;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,OAAO,8BAA8B,CAAA;IAC3C,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,yBAAyB,CAAA;IACrC,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,wBAAwB,CAAA;IACnC,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAClC;AAED,MAAM,MAAM,6BAA6B,GACrC;IACE,IAAI,EAAE,cAAc,CAAA;IACpB,KAAK,EAAE,oBAAoB,CAAA;CAC5B,GACD;IACE,IAAI,EAAE,mBAAmB,CAAA;IACzB,SAAS,EAAE,wBAAwB,CAAA;CACpC,CAAA;AAEL,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,yBAAyB,GAAG,MAAM,CAIpF;AAED,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,wBAAwB,GAC9B,0BAA0B,CAM5B;AAED,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,wBAAwB,GAClC,oBAAoB,CAUtB;AAED,wBAAgB,8BAA8B,CAC5C,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,wBAAwB,EACnC,QAAQ,SAAI,GACX,wBAAwB,CAoB1B;AAED,wBAAgB,iCAAiC,CAC/C,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,wBAAwB,EACnC,QAAQ,SAAI,GACX,6BAA6B,CAY/B;AAED,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,wBAAwB,EAAE,GAChC,GAAG,CAAC,MAAM,EAAE,wBAAwB,EAAE,CAAC,CAQzC"}

package/dist/cruise-extension.js

@@ -0,0 +1,66 @@
+export const CRUISE_EXTENSION_METADATA_KIND = "cruise_extension";
+export function cruiseExtensionLinkKey(targetKind) {
+    return targetKind === "cruise"
+        ? "cruiseProductExtensionLink"
+        : "cruiseSailingProductExtensionLink";
+}
+export function createCruiseExtensionLinkCommand(input) {
+    return {
+        linkKey: input.linkKey ?? cruiseExtensionLinkKey(input.targetKind),
+        leftId: input.targetId,
+        rightId: input.extensionProductId,
+    };
+}
+export function createCruiseExtensionExtra(selection) {
+    return {
+        kind: CRUISE_EXTENSION_METADATA_KIND,
+        productId: selection.extensionProductId,
+        targetKind: selection.targetKind,
+        targetId: selection.targetId,
+        placement: selection.placement,
+        quantity: selection.quantity ?? 1,
+        metadata: selection.metadata ?? {},
+    };
+}
+export function createCruiseExtensionComponent(envelopeId, selection, sequence = 0) {
+    return {
+        envelopeId,
+        sequence,
+        kind: "catalog_booking",
+        catalogRef: {
+            entityModule: "products",
+            entityId: selection.extensionProductId,
+            sourceKind: "owned",
+        },
+        metadata: {
+            kind: CRUISE_EXTENSION_METADATA_KIND,
+            targetKind: selection.targetKind,
+            targetId: selection.targetId,
+            placement: selection.placement,
+            lifecycle: selection.lifecycle,
+            quantity: selection.quantity ?? 1,
+            ...(selection.metadata ?? {}),
+        },
+    };
+}
+export function representCruiseExtensionSelection(envelopeId, selection, sequence = 0) {
+    if (selection.lifecycle === "dependent_extra") {
+        return {
+            mode: "nested_extra",
+            extra: createCruiseExtensionExtra(selection),
+        };
+    }
+    return {
+        mode: "sibling_component",
+        component: createCruiseExtensionComponent(envelopeId, selection, sequence),
+    };
+}
+export function groupCruiseExtensionLinksByProduct(links) {
+    const grouped = new Map();
+    for (const link of links) {
+        const existing = grouped.get(link.extensionProductId) ?? [];
+        existing.push(link);
+        grouped.set(link.extensionProductId, existing);
+    }
+    return grouped;
+}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+import type { Module } from "@voyantjs/core";
+import type { HonoModule } from "@voyantjs/hono/module";
+import { type TravelComposerRoutesOptions } from "./routes.js";
+export { type CatalogComponentBookingDraftOverrides, isCatalogBackedTripComponent, toBookingDraftV1, } from "./catalog-component-adapter.js";
+export { CRUISE_EXTENSION_METADATA_KIND, type CruiseExtensionExtra, type CruiseExtensionLifecycle, type CruiseExtensionLinkCommand, type CruiseExtensionLinkInput, type CruiseExtensionPlacement, type CruiseExtensionRepresentation, type CruiseExtensionSelection, type CruiseExtensionTargetKind, createCruiseExtensionComponent, createCruiseExtensionExtra, createCruiseExtensionLinkCommand, cruiseExtensionLinkKey, groupCruiseExtensionLinksByProduct, representCruiseExtensionSelection, } from "./cruise-extension.js";
+export type { TravelComposerRoutes, TravelComposerRoutesOptions } from "./routes.js";
+export { createTravelComposerRoutes } from "./routes.js";
+export declare const travelComposerModule: Module;
+export declare const travelComposerHonoModule: HonoModule;
+export interface TravelComposerHonoModuleOptions extends TravelComposerRoutesOptions {
+    publicRoutes?: boolean;
+}
+export declare function createTravelComposerHonoModule(options?: TravelComposerHonoModuleOptions): HonoModule;
+export { type CreateTripArgs, createTripTool, type PriceTripArgs, priceTripTool, type ReserveTripArgs, type ReviseTripArgs, reserveTripTool, reviseTripTool, type TravelComposerMcpServices, travelComposerMcpTools, } from "./mcp-tools.js";
+export { travelComposerRoutes } from "./routes.js";
+export type { NewTripComponent, NewTripComponentEvent, NewTripEnvelope, TripComponent, TripComponentEvent, TripComponentPricingSnapshot, TripComponentTaxLineSnapshot, TripEnvelope, TripEnvelopePricingSnapshot, } from "./schema.js";
+export { tripComponentEvents, tripComponentEventTypeEnum, tripComponentKindEnum, tripComponentStatusEnum, tripComponents, tripEnvelopeStatusEnum, tripEnvelopes, } from "./schema.js";
+export { aggregateComponentPricing, applyQuoteToComponent, assertTripComponentCanBeReserved, assertTripComponentCanBeUpdated, assertTripComponentCanReceiveRefs, assertTripComponentCanStartCheckout, type CancelComponentInput, type CancelComponentResult, type CancelTripComponentsDeps, type CancelTripComponentsResult, type CatalogComponentQuoteInput, type CheckoutHandoffKind, type CompleteTripCheckoutInput, type CompleteTripCheckoutResult, type ComponentCancellationAction, type ComponentCancellationPreview, type ComponentCancellationPreviewInput, type ComponentCheckoutInput, type ComponentCheckoutResult, checkoutResultToComponentPatch, completeTripCheckout, hasCommittedComponentReference, type PreviewTripCancellationDeps, type PriceTripDeps, type PriceTripResult, pricingSnapshotFromBreakdown, type ReleaseReservedComponentInput, type ReleaseReservedComponentResult, type ReserveComponentInput, type ReserveComponentPreflightResult, type ReserveComponentPreflightStatus, type ReserveComponentResult, type ReserveTripDeps, type ReserveTripResult, reserveResultToComponentPatch, type StartCheckoutDeps, type StartCheckoutResult, type StartCheckoutTarget, type StartedTripComponentCheckout, shouldReplayCheckout, shouldReplayReserve, TravelComposerInvariantError, type Trip, type TripCancellationPreviewResult, type TripCheckoutInput, type TripCheckoutResult, type TripListResult, taxLinesFromBreakdown, travelComposerService, } from "./service.js";
+export { assertTripTravelerPartyComplete, validateTripTravelerParty, } from "./traveler-party-validation.js";
+export { type CancelTripComponentsInput, type CreateTripComponentBodyInput, type CreateTripComponentInput, type CreateTripEnvelopeInput, cancelTripComponentsSchema, catalogComponentReferenceSchema, committedComponentReferenceSchema, createTripComponentBodySchema, createTripComponentSchema, createTripEnvelopeSchema, isAllowedTripComponentStatusTransition, isTerminalTripComponentStatus, type ListTripsQuery, listTripsQuerySchema, type PreviewTripCancellationInput, type PriceTripInput, previewTripCancellationSchema, priceTripSchema, type ReserveTripInput, reorderTripComponentsSchema, reserveTripSchema, type StartTripCheckoutInput, startTripCheckoutSchema, type TravelComposerHealthCheck, type TravelComposerStatus, type TripComponentEventType, type TripComponentKind, type TripComponentStatus, type TripEnvelopeStatus, type TripsListSortDir, type TripsListSortField, travelComposerHealthCheckSchema, travelComposerStatusSchema, tripComponentEventTypeSchema, tripComponentKindSchema, tripComponentPricingSnapshotSchema, tripComponentStatusSchema, tripComponentStatusTransitionSchema, tripComponentTaxLineSchema, tripEnvelopePricingSnapshotSchema, tripEnvelopeStatusSchema, tripsListSortDirSchema, tripsListSortFieldSchema, type UpdateTripComponentInput, updateTripComponentRefsSchema, updateTripComponentSchema, updateTripEnvelopeSchema, } from "./validation.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,29 @@
+import { createTravelComposerRoutes, travelComposerRoutes, } from "./routes.js";
+export { isCatalogBackedTripComponent, toBookingDraftV1, } from "./catalog-component-adapter.js";
+export { CRUISE_EXTENSION_METADATA_KIND, createCruiseExtensionComponent, createCruiseExtensionExtra, createCruiseExtensionLinkCommand, cruiseExtensionLinkKey, groupCruiseExtensionLinksByProduct, representCruiseExtensionSelection, } from "./cruise-extension.js";
+export { createTravelComposerRoutes } from "./routes.js";
+export const travelComposerModule = {
+    name: "travel-composer",
+};
+export const travelComposerHonoModule = {
+    module: travelComposerModule,
+    adminRoutes: travelComposerRoutes,
+};
+export function createTravelComposerHonoModule(options = {}) {
+    const { publicRoutes = false, ...routeOptions } = options;
+    const routes = createTravelComposerRoutes({ ...routeOptions, surface: "admin" });
+    const honoModule = {
+        module: travelComposerModule,
+        adminRoutes: routes,
+    };
+    if (publicRoutes) {
+        honoModule.publicRoutes = createTravelComposerRoutes({ ...routeOptions, surface: "public" });
+    }
+    return honoModule;
+}
+export { createTripTool, priceTripTool, reserveTripTool, reviseTripTool, travelComposerMcpTools, } from "./mcp-tools.js";
+export { travelComposerRoutes } from "./routes.js";
+export { tripComponentEvents, tripComponentEventTypeEnum, tripComponentKindEnum, tripComponentStatusEnum, tripComponents, tripEnvelopeStatusEnum, tripEnvelopes, } from "./schema.js";
+export { aggregateComponentPricing, applyQuoteToComponent, assertTripComponentCanBeReserved, assertTripComponentCanBeUpdated, assertTripComponentCanReceiveRefs, assertTripComponentCanStartCheckout, checkoutResultToComponentPatch, completeTripCheckout, hasCommittedComponentReference, pricingSnapshotFromBreakdown, reserveResultToComponentPatch, shouldReplayCheckout, shouldReplayReserve, TravelComposerInvariantError, taxLinesFromBreakdown, travelComposerService, } from "./service.js";
+export { assertTripTravelerPartyComplete, validateTripTravelerParty, } from "./traveler-party-validation.js";
+export { cancelTripComponentsSchema, catalogComponentReferenceSchema, committedComponentReferenceSchema, createTripComponentBodySchema, createTripComponentSchema, createTripEnvelopeSchema, isAllowedTripComponentStatusTransition, isTerminalTripComponentStatus, listTripsQuerySchema, previewTripCancellationSchema, priceTripSchema, reorderTripComponentsSchema, reserveTripSchema, startTripCheckoutSchema, travelComposerHealthCheckSchema, travelComposerStatusSchema, tripComponentEventTypeSchema, tripComponentKindSchema, tripComponentPricingSnapshotSchema, tripComponentStatusSchema, tripComponentStatusTransitionSchema, tripComponentTaxLineSchema, tripEnvelopePricingSnapshotSchema, tripEnvelopeStatusSchema, tripsListSortDirSchema, tripsListSortFieldSchema, updateTripComponentRefsSchema, updateTripComponentSchema, updateTripEnvelopeSchema, } from "./validation.js";

package/dist/mcp-tools.d.ts

@@ -0,0 +1,157 @@
+import type { McpToolDefinition, McpToolResult } from "@voyantjs/catalog-mcp";
+import { z } from "zod";
+import type { TripComponent } from "./schema.js";
+import type { PriceTripResult, ReserveTripResult, Trip } from "./service.js";
+import { type createTripComponentSchema, createTripEnvelopeSchema, priceTripSchema, reserveTripSchema } from "./validation.js";
+export interface TravelComposerMcpServices {
+    createTrip(input: z.infer<typeof createTripEnvelopeSchema>): Promise<Trip>;
+    addComponent(input: z.infer<typeof createTripComponentSchema>): Promise<TripComponent>;
+    removeComponent?(componentId: string): Promise<TripComponent | null>;
+    priceTrip(input: z.infer<typeof priceTripSchema>): Promise<PriceTripResult>;
+    reserveTrip(input: z.infer<typeof reserveTripSchema>): Promise<ReserveTripResult>;
+}
+declare const createTripArgs: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    travelerParty: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    constraints: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdBy: z.ZodOptional<z.ZodString>;
+    components: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        sequence: z.ZodDefault<z.ZodNumber>;
+        kind: z.ZodEnum<{
+            catalog_booking: "catalog_booking";
+            manual_placeholder: "manual_placeholder";
+            flight_placeholder: "flight_placeholder";
+            flight_order: "flight_order";
+            external_order: "external_order";
+        }>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        catalogRef: z.ZodOptional<z.ZodObject<{
+            entityModule: z.ZodString;
+            entityId: z.ZodString;
+            sourceKind: z.ZodString;
+            sourceConnectionId: z.ZodOptional<z.ZodString>;
+            sourceRef: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        estimatedPricing: z.ZodOptional<z.ZodObject<{
+            currency: z.ZodString;
+            subtotalAmountCents: z.ZodNumber;
+            taxAmountCents: z.ZodNumber;
+            totalAmountCents: z.ZodNumber;
+            priceExpiresAt: z.ZodOptional<z.ZodString>;
+            warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strict>>>;
+}, z.core.$strip>;
+export type CreateTripArgs = z.infer<typeof createTripArgs>;
+export declare const createTripTool: McpToolDefinition<CreateTripArgs, McpToolResult>;
+declare const reviseTripArgs: z.ZodObject<{
+    envelopeId: z.ZodString;
+    addComponents: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        sequence: z.ZodDefault<z.ZodNumber>;
+        kind: z.ZodEnum<{
+            catalog_booking: "catalog_booking";
+            manual_placeholder: "manual_placeholder";
+            flight_placeholder: "flight_placeholder";
+            flight_order: "flight_order";
+            external_order: "external_order";
+        }>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        catalogRef: z.ZodOptional<z.ZodObject<{
+            entityModule: z.ZodString;
+            entityId: z.ZodString;
+            sourceKind: z.ZodString;
+            sourceConnectionId: z.ZodOptional<z.ZodString>;
+            sourceRef: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        estimatedPricing: z.ZodOptional<z.ZodObject<{
+            currency: z.ZodString;
+            subtotalAmountCents: z.ZodNumber;
+            taxAmountCents: z.ZodNumber;
+            totalAmountCents: z.ZodNumber;
+            priceExpiresAt: z.ZodOptional<z.ZodString>;
+            warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strict>>>;
+    removeComponentIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type ReviseTripArgs = z.infer<typeof reviseTripArgs>;
+export declare const reviseTripTool: McpToolDefinition<ReviseTripArgs, McpToolResult>;
+export type PriceTripArgs = z.infer<typeof priceTripSchema>;
+export declare const priceTripTool: McpToolDefinition<PriceTripArgs, McpToolResult>;
+export type ReserveTripArgs = z.infer<typeof reserveTripSchema>;
+export declare const reserveTripTool: McpToolDefinition<ReserveTripArgs, McpToolResult>;
+export declare const travelComposerMcpTools: readonly [McpToolDefinition<{
+    travelerParty: Record<string, unknown>;
+    constraints: Record<string, unknown>;
+    components: {
+        sequence: number;
+        kind: "catalog_booking" | "manual_placeholder" | "flight_placeholder" | "flight_order" | "external_order";
+        metadata: Record<string, unknown>;
+        description?: string | undefined;
+        catalogRef?: {
+            entityModule: string;
+            entityId: string;
+            sourceKind: string;
+            sourceConnectionId?: string | undefined;
+            sourceRef?: string | undefined;
+        } | undefined;
+        estimatedPricing?: {
+            currency: string;
+            subtotalAmountCents: number;
+            taxAmountCents: number;
+            totalAmountCents: number;
+            priceExpiresAt?: string | undefined;
+            warnings?: string[] | undefined;
+        } | undefined;
+    }[];
+    title?: string | undefined;
+    description?: string | undefined;
+    createdBy?: string | undefined;
+}, McpToolResult>, McpToolDefinition<{
+    envelopeId: string;
+    addComponents: {
+        sequence: number;
+        kind: "catalog_booking" | "manual_placeholder" | "flight_placeholder" | "flight_order" | "external_order";
+        metadata: Record<string, unknown>;
+        description?: string | undefined;
+        catalogRef?: {
+            entityModule: string;
+            entityId: string;
+            sourceKind: string;
+            sourceConnectionId?: string | undefined;
+            sourceRef?: string | undefined;
+        } | undefined;
+        estimatedPricing?: {
+            currency: string;
+            subtotalAmountCents: number;
+            taxAmountCents: number;
+            totalAmountCents: number;
+            priceExpiresAt?: string | undefined;
+            warnings?: string[] | undefined;
+        } | undefined;
+    }[];
+    removeComponentIds: string[];
+}, McpToolResult>, McpToolDefinition<{
+    envelopeId: string;
+    scope: {
+        locale: string;
+        audience: "staff" | "customer" | "partner" | "supplier";
+        market: string;
+        currency?: string | undefined;
+    };
+    ttlMs?: number | undefined;
+}, McpToolResult>, McpToolDefinition<{
+    envelopeId: string;
+    idempotencyKey?: string | undefined;
+    refreshScope?: {
+        locale: string;
+        audience: "staff" | "customer" | "partner" | "supplier";
+        market: string;
+        currency?: string | undefined;
+    } | undefined;
+}, McpToolResult>];
+export {};
+//# sourceMappingURL=mcp-tools.d.ts.map

package/dist/mcp-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-tools.d.ts","sourceRoot":"","sources":["../src/mcp-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,iBAAiB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAE7F,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAChD,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AAC5E,OAAO,EAEL,KAAK,yBAAyB,EAC9B,wBAAwB,EACxB,eAAe,EACf,iBAAiB,EAClB,MAAM,iBAAiB,CAAA;AAExB,MAAM,WAAW,yBAAyB;IACxC,UAAU,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1E,YAAY,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,CAAA;IACtF,eAAe,CAAC,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAAA;IACpE,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC,CAAA;IAC3E,WAAW,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAA;CAClF;AAMD,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAElB,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D,eAAO,MAAM,cAAc,EAAE,iBAAiB,CAAC,cAAc,EAAE,aAAa,CAgC3E,CAAA;AAED,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIlB,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D,eAAO,MAAM,cAAc,EAAE,iBAAiB,CAAC,cAAc,EAAE,aAAa,CAmC3E,CAAA;AAED,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE3D,eAAO,MAAM,aAAa,EAAE,iBAAiB,CAAC,aAAa,EAAE,aAAa,CAYzE,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE/D,eAAO,MAAM,eAAe,EAAE,iBAAiB,CAAC,eAAe,EAAE,aAAa,CAY7E,CAAA;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAKzB,CAAA"}

package/dist/mcp-tools.js

@@ -0,0 +1,109 @@
+import { McpToolError } from "@voyantjs/catalog-mcp";
+import { z } from "zod";
+import { createTripComponentBodySchema, createTripEnvelopeSchema, priceTripSchema, reserveTripSchema, } from "./validation.js";
+const createTripArgs = createTripEnvelopeSchema.extend({
+    components: z.array(createTripComponentBodySchema).default([]),
+});
+export const createTripTool = {
+    name: "create_trip",
+    description: "Create a deterministic trip envelope and optional components for a composed itinerary. " +
+        "Use this before pricing or reserving a cross-vertical trip.",
+    inputSchema: createTripArgs,
+    async handler(args, rawContext) {
+        const context = rawContext;
+        const composer = requireTravelComposer(context);
+        const trip = await composer.createTrip({
+            title: args.title,
+            description: args.description,
+            travelerParty: args.travelerParty,
+            constraints: args.constraints,
+            createdBy: args.createdBy,
+        });
+        const components = [];
+        for (const component of args.components) {
+            components.push(await composer.addComponent({
+                ...component,
+                envelopeId: trip.envelope.id,
+            }));
+        }
+        return tripResult("Created trip", {
+            envelope: trip.envelope,
+            components,
+        });
+    },
+};
+const reviseTripArgs = z.object({
+    envelopeId: z.string().min(1),
+    addComponents: z.array(createTripComponentBodySchema).default([]),
+    removeComponentIds: z.array(z.string().min(1)).default([]),
+});
+export const reviseTripTool = {
+    name: "revise_trip",
+    description: "Revise a deterministic trip envelope by adding components or removing uncommitted components. " +
+        "This does not mutate committed bookings directly.",
+    inputSchema: reviseTripArgs,
+    async handler(args, rawContext) {
+        const context = rawContext;
+        const composer = requireTravelComposer(context);
+        const added = [];
+        const removed = [];
+        for (const component of args.addComponents) {
+            added.push(await composer.addComponent({ ...component, envelopeId: args.envelopeId }));
+        }
+        if (args.removeComponentIds.length > 0 && !composer.removeComponent) {
+            throw new McpToolError("Travel composer MCP service removeComponent is not configured.", "MISSING_SERVICE", { service: "travelComposer.removeComponent" });
+        }
+        for (const componentId of args.removeComponentIds) {
+            const result = await composer.removeComponent?.(componentId);
+            if (result)
+                removed.push(result);
+        }
+        return tripResult("Revised trip", {
+            envelopeId: args.envelopeId,
+            added,
+            removed,
+        });
+    },
+};
+export const priceTripTool = {
+    name: "price_trip",
+    description: "Price a deterministic trip through the travel composer. Returns aggregate totals, " +
+        "component statuses, warnings, failures, and quote expiry data.",
+    inputSchema: priceTripSchema,
+    async handler(args, rawContext) {
+        const context = rawContext;
+        const composer = requireTravelComposer(context);
+        const result = await composer.priceTrip(args);
+        return tripResult("Priced trip", result);
+    },
+};
+export const reserveTripTool = {
+    name: "reserve_trip",
+    description: "Reserve a priced trip through deterministic travel composer services. " +
+        "Partial failures return explicit compensation and staff-remediation state.",
+    inputSchema: reserveTripSchema,
+    async handler(args, rawContext) {
+        const context = rawContext;
+        const composer = requireTravelComposer(context);
+        const result = await composer.reserveTrip(args);
+        return tripResult("Reserved trip", result);
+    },
+};
+export const travelComposerMcpTools = [
+    createTripTool,
+    reviseTripTool,
+    priceTripTool,
+    reserveTripTool,
+];
+function requireTravelComposer(context) {
+    if (!context.travelComposer) {
+        throw new McpToolError("MCP tool requires travel composer services to be wired into the context.", "MISSING_SERVICE", { service: "travelComposer" });
+    }
+    return context.travelComposer;
+}
+function tripResult(message, structuredContent) {
+    return {
+        content: [{ type: "text", text: message }],
+        structuredContent: structuredContent,
+    };
+}