@voyant-travel/trips 0.110.2

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

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-registry.d.ts","sourceRoot":"","sources":["../src/mcp-registry.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,OAAO,KAAK,EAAE,cAAc,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAGzF,MAAM,WAAW,eAAe;IAC9B,iEAAiE;IACjE,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAA;IAChC,4DAA4D;IAC5D,QAAQ,CAAC,KAAK,EAAE,IAAI,EAAE,iBAAiB,CAAC,KAAK,EAAE,aAAa,CAAC,GAAG,IAAI,CAAA;IACpE,2EAA2E;IAC3E,IAAI,IAAI,gBAAgB,EAAE,CAAA;IAC1B,+EAA+E;IAC/E,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,aAAa,CAAC,CAAA;IACjE,wEAAwE;IAExE,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,CAAC,GAAG,EAAE,aAAa,CAAC,GAAG,SAAS,CAAA;CACrE;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB;;;;OAIG;IACH,kBAAkB,EAAE;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAA;CAC5D;AAED,MAAM,WAAW,4BAA4B;IAC3C,OAAO,EAAE,cAAc,CAAA;CACxB;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,4BAA4B,GAAG,eAAe,CAuD5F;AAUD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,CASzE;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC,EAC9B,kBAAkB,CAAC,EAAE,MAAM,EAAE,GAC5B,IAAI,CASN;AAID,YAAY,EAAE,CAAC,EAAE,CAAA"}

package/dist/mcp-registry.js

@@ -0,0 +1,88 @@
+/**
+ * Transport-agnostic registry for trips agent tools.
+ */
+import { McpToolError } from "./mcp-contract.js";
+export function createMcpToolRegistry(options) {
+    // biome-ignore lint/suspicious/noExplicitAny: heterogeneous tool args -- owner: trips; existing suppression is intentional pending typed cleanup.
+    const tools = new Map();
+    return {
+        get context() {
+            return options.context;
+        },
+        register(tool) {
+            if (tools.has(tool.name)) {
+                throw new Error(`MCP tool "${tool.name}" is already registered`);
+            }
+            tools.set(tool.name, tool);
+        },
+        list() {
+            return Array.from(tools.values()).map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                inputSchemaPreview: {
+                    type: "object",
+                    description: "Use the package's zod-to-json-schema adapter to serialize for the MCP SDK.",
+                },
+            }));
+        },
+        get(name) {
+            return tools.get(name);
+        },
+        async dispatchTool(name, args) {
+            const tool = tools.get(name);
+            if (!tool) {
+                return errorResult(`MCP tool "${name}" is not registered. Known tools: ${Array.from(tools.keys()).join(", ") || "(none)"}`, "NOT_FOUND");
+            }
+            let parsed;
+            try {
+                parsed = tool.inputSchema.parse(args);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return errorResult(`Invalid input for tool "${name}": ${message}`, "INVALID_INPUT");
+            }
+            try {
+                return await tool.handler(parsed, options.context);
+            }
+            catch (err) {
+                if (err instanceof McpToolError) {
+                    return errorResult(err.message, err.code, err.meta);
+                }
+                const message = err instanceof Error ? err.message : String(err);
+                return errorResult(`Tool "${name}" failed: ${message}`, "PROVIDER_ERROR");
+            }
+        },
+    };
+}
+function errorResult(message, code, meta) {
+    return {
+        isError: true,
+        content: [{ type: "text", text: `[${code}] ${message}` }],
+        structuredContent: { error: { code, message, ...(meta ?? {}) } },
+    };
+}
+/**
+ * Helper for tools to assert that a required service was injected
+ * into the context. Throws `MISSING_SERVICE` if not, which the dispatcher
+ * translates into a structured error.
+ */
+export function requireService(service, name) {
+    if (!service) {
+        throw new McpToolError(`MCP tool requires the "${name}" service to be wired into the context, but it was not provided. Configure the registry services or omit tools that depend on it.`, "MISSING_SERVICE", { service: name });
+    }
+    return service;
+}
+/**
+ * Helper for tools that need to enforce per-actor authorization. Customer/
+ * partner/supplier actors are pinned to their own audience pool — staff
+ * actors may federate across pools.
+ */
+export function enforceAudienceAuthorization(actor, requestedAudiences) {
+    if (!requestedAudiences || requestedAudiences.length === 0)
+        return;
+    if (actor === "staff")
+        return;
+    if (requestedAudiences.length === 1 && requestedAudiences[0] === actor)
+        return;
+    throw new McpToolError(`Actor "${actor}" is not authorized to query audiences ${JSON.stringify(requestedAudiences)}. Non-staff actors may only query their own audience pool.`, "AUTHORIZATION_DENIED", { actor, requestedAudiences });
+}

package/dist/mcp-tools.d.ts

@@ -0,0 +1,157 @@
+import { z } from "zod";
+import type { McpToolDefinition, McpToolResult } from "./mcp-contract.js";
+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 TripsMcpServices {
+    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 tripsMcpTools: 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,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAkB,iBAAiB,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAEzF,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,gBAAgB;IAC/B,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,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAKhB,CAAA"}

package/dist/mcp-tools.js

@@ -0,0 +1,109 @@
+import { z } from "zod";
+import { McpToolError } from "./mcp-contract.js";
+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 = requireTrips(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 = requireTrips(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("Trips MCP service removeComponent is not configured.", "MISSING_SERVICE", { service: "trips.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 trips. Returns aggregate totals, " +
+        "component statuses, warnings, failures, and quote expiry data.",
+    inputSchema: priceTripSchema,
+    async handler(args, rawContext) {
+        const context = rawContext;
+        const composer = requireTrips(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 trips services. " +
+        "Partial failures return explicit compensation and staff-remediation state.",
+    inputSchema: reserveTripSchema,
+    async handler(args, rawContext) {
+        const context = rawContext;
+        const composer = requireTrips(context);
+        const result = await composer.reserveTrip(args);
+        return tripResult("Reserved trip", result);
+    },
+};
+export const tripsMcpTools = [
+    createTripTool,
+    reviseTripTool,
+    priceTripTool,
+    reserveTripTool,
+];
+function requireTrips(context) {
+    if (!context.trips) {
+        throw new McpToolError("MCP tool requires trips services to be wired into the context.", "MISSING_SERVICE", { service: "trips" });
+    }
+    return context.trips;
+}
+function tripResult(message, structuredContent) {
+    return {
+        content: [{ type: "text", text: message }],
+        structuredContent: structuredContent,
+    };
+}