ti2-tourplan 1.0.138 → 1.0.139

package/index.test.js

@@ -339,6 +339,100 @@ describe('search tests', () => {
         expect(request.Remarks).toBe(`Passenger Notes: ${'A'.repeat(43)}`);
         expect(request.Remarks).toHaveLength(60);
       });
+
+      it.each([
+        ['an exact boundary reference', { reference: 'A'.repeat(60) }, 'A'.repeat(60)],
+        ['an overlong reference', { reference: 'B'.repeat(61) }, 'B'.repeat(60)],
+        ['a long itinerary description', {
+          reference: 'A detailed anniversary itinerary with transfers, hotels, touring, and extra arrangements',
+        }, 'A detailed anniversary itinerary with transfers, hotels, tou'],
+        ['the fallback reference', { reference: ' FALLBACK-REFERENCE ' }, 'FALLBACK-REFERENCE'],
+        ['the preferred agentRef', {
+          agentRef: ' AGENT-PICKED ',
+          reference: 'REFERENCE-IGNORED',
+        }, 'AGENT-PICKED'],
+        ['a value that expands during sanitization', { agentRef: 'Ä'.repeat(40) }, 'Ae'.repeat(30)],
+        ['invalid XML characters', { agentRef: '  REF\u0000WITH\u0001CONTROL  ' }, 'REFWITHCONTROL'],
+      ])('normalizes AgentRef from %s without changing the payload', async (
+        description,
+        sourceFields,
+        expected,
+      ) => {
+        mockCallTourplan.mockImplementationOnce(async () => ({
+          AddServiceReply: { BookingId: '12345', Ref: 'TESTREF', ServiceLineId: '10' },
+        }));
+        const payload = {
+          quoteName: `Agent reference test: ${description}`,
+          optionId: 'ABC123',
+          startDate: '2026-07-03',
+          paxConfigs: [{ roomType: 'Double', adults: 2 }],
+          notes: '',
+          ...sourceFields,
+        };
+        const originalPayload = { ...payload };
+
+        await app.addServiceToItinerary({ axios, token, payload });
+
+        const agentReference = mockCallTourplan.mock.calls[0][0].model.AddServiceRequest.AgentRef;
+        expect(agentReference).toBe(expected);
+        expect(Array.from(agentReference).length).toBeLessThanOrEqual(60);
+        expect(payload).toEqual(originalPayload);
+
+        const requestXml = js2xmlparser.parse(
+          'Request',
+          mockCallTourplan.mock.calls[0][0].model,
+          hostConnectXmlOptions,
+        );
+        expect(requestXml.indexOf('<SCUqty>')).toBeLessThan(requestXml.indexOf('<AgentRef>'));
+        expect(requestXml.indexOf('<AgentRef>')).toBeLessThan(requestXml.indexOf('<RoomConfigs>'));
+      });
+
+      it('omits AgentRef when the selected source sanitizes to empty', async () => {
+        mockCallTourplan.mockImplementationOnce(async () => ({
+          AddServiceReply: { BookingId: '12345', Ref: 'TESTREF', ServiceLineId: '10' },
+        }));
+
+        await app.addServiceToItinerary({
+          axios,
+          token,
+          payload: {
+            quoteName: 'Empty agent reference',
+            optionId: 'ABC123',
+            startDate: '2026-07-03',
+            agentRef: ' \u0001 ',
+            reference: 'REFERENCE-IGNORED',
+            paxConfigs: [{ roomType: 'Double', adults: 2 }],
+            notes: '',
+          },
+        });
+
+        expect(mockCallTourplan.mock.calls[0][0].model.AddServiceRequest.AgentRef).toBeUndefined();
+      });
+
+      it('normalizes a direct-line AgentRef override without changing XML element order', async () => {
+        mockCallTourplan.mockImplementationOnce(async () => ({
+          AddServiceReply: { BookingId: '12345', Ref: 'TESTREF', ServiceLineId: '10' },
+        }));
+
+        await app.addServiceToItinerary({
+          axios,
+          token,
+          payload: {
+            quoteName: 'Direct override agent reference',
+            optionId: 'ABC123',
+            startDate: '2026-07-03',
+            reference: 'REFERENCE-IGNORED',
+            paxConfigs: [{ roomType: 'Double', adults: 2 }],
+            notes: '',
+            directLinePayload: { AgentRef: 'D'.repeat(61) },
+          },
+        });
+
+        const model = mockCallTourplan.mock.calls[0][0].model;
+        expect(model.AddServiceRequest.AgentRef).toBe('D'.repeat(60));
+        const requestXml = js2xmlparser.parse('Request', model, hostConnectXmlOptions);
+        expect(requestXml.indexOf('<AgentRef>')).toBeLessThan(requestXml.indexOf('<RoomConfigs>'));
+      });
     });
 
     describe('cancelBooking', () => {

package/itinerary-add-service.js

@@ -2,6 +2,7 @@ const R = require('ramda');
 const {
   getRoomConfigs,
   escapeInvalidXmlChars,
+  normalizeAgentReference,
   CUSTOM_RATE_ID_NAME,
   CUSTOM_NO_RATE_NAME,
   hostConnectXmlOptions,
@@ -15,6 +16,13 @@ const SERVICE_CANNOT_BE_ADDED_ERROR_MESSAGE = 'Service cannot be added to quote
 const getBookingName = quoteName => escapeInvalidXmlChars(quoteName)
   .substring(0, MAX_BOOKING_NAME_LENGTH);
 
+const buildAgentReference = ({ agentRef, reference }) => {
+  const source = typeof agentRef === 'string' && agentRef.trim() !== ''
+    ? agentRef
+    : reference;
+  return normalizeAgentReference(source);
+};
+
 const addServiceToItinerary = async ({
   axios,
   token: {
@@ -30,6 +38,7 @@ const addServiceToItinerary = async ({
     quoteId,
     optionId,
     startDate,
+    agentRef,
     reference,
     /*
     paxConfigs: [{ roomType: 'DB', adults: 2 }, { roomType: 'TW', children: 2 }]
@@ -66,6 +75,20 @@ const addServiceToItinerary = async ({
       return acc;
     }, {});
 
+  const directLinePayloadHasAgentReference = directLinePayload &&
+    Object.prototype.hasOwnProperty.call(directLinePayload, 'AgentRef');
+  const customFieldsHaveAgentReference = Object.prototype.hasOwnProperty.call(
+    cfvPerService,
+    'AgentRef',
+  );
+  const payloadAgentReference = buildAgentReference({ agentRef, reference });
+  let agentReferenceSource = payloadAgentReference;
+  if (directLinePayloadHasAgentReference) agentReferenceSource = directLinePayload.AgentRef;
+  if (customFieldsHaveAgentReference) agentReferenceSource = cfvPerService.AgentRef;
+  const agentReference = normalizeAgentReference(agentReferenceSource);
+  const directLinePayloadWithoutAgentReference = R.omit(['AgentRef'], directLinePayload || {});
+  const customFieldsWithoutAgentReference = R.omit(['AgentRef'], cfvPerService);
+
   const directHeaderPayloadHasName = directHeaderPayload &&
     Object.prototype.hasOwnProperty.call(directHeaderPayload, 'Name');
   const bookingNameSource = directHeaderPayloadHasName ? directHeaderPayload.Name : quoteName;
@@ -178,10 +201,10 @@ const addServiceToItinerary = async ({
         if (Number.isNaN(num) || num < 1) return 1;
         return num;
       })(),
-      AgentRef: escapeInvalidXmlChars(reference),
+      ...(agentReference ? { AgentRef: agentReference } : {}),
       RoomConfigs: getRoomConfigs(paxConfigs),
-      ...(directLinePayload || {}),
-      ...(cfvPerService || {}),
+      ...directLinePayloadWithoutAgentReference,
+      ...customFieldsWithoutAgentReference,
     },
   };
   const replyObj = await callTourplan({

package/itinerary-search.js

@@ -1,6 +1,10 @@
 const R = require('ramda');
 const Promise = require('bluebird');
-const { escapeInvalidXmlChars, hostConnectXmlOptions } = require('./utils');
+const {
+  escapeInvalidXmlChars,
+  normalizeAgentReference,
+  hostConnectXmlOptions,
+} = require('./utils');
 const { translateItineraryBooking } = require('./resolvers/itinerary');
 
 /** Years to extend the travel window when start or end is missing. */
@@ -8,6 +12,16 @@ const TRAVEL_WINDOW_SPAN_YEARS = 2;
 const LIST_BOOKINGS_CONCURRENCY = 10;
 const MAX_AGENT_REFERENCE_IDS = 20;
 
+const buildAgentReferenceSearchVariants = value => {
+  const rawReference = value == null ? '' : String(value).trim();
+  if (!rawReference) return [];
+  const normalizedReference = normalizeAgentReference(rawReference);
+  if (!normalizedReference) return [];
+  return normalizedReference && normalizedReference !== rawReference
+    ? [rawReference, normalizedReference]
+    : [rawReference];
+};
+
 /**
  * Extract the date prefix from a string in the format YYYY-MM-DD.
  * @param {string} value - The string to extract the date prefix from.
@@ -187,7 +201,7 @@ const searchItineraries = async ({
     xmlOptions: hostConnectXmlOptions,
   });
 
-  let searchCriterias = [];
+  let searchCriteriaGroups = [];
   let applyBaseSearchFilters = false;
   let baseSearchFilters = null;
 
@@ -199,37 +213,40 @@ const searchItineraries = async ({
   if (hasAgentReferenceIds && rawAgentReferenceIds.length > MAX_AGENT_REFERENCE_IDS) {
     return { bookings: [] };
   }
-  const normalizedAgentReferenceIds = rawAgentReferenceIds
+  const agentReferenceSearchVariants = R.uniqBy(variants => variants[0], rawAgentReferenceIds
     .filter(ref => typeof ref === 'string' || (typeof ref === 'number' && Number.isFinite(ref)))
-    .map(ref => escapeInvalidXmlChars(String(ref).trim()))
-    .filter(Boolean);
-  const uniqueAgentReferenceIds = R.uniq(normalizedAgentReferenceIds);
-  if (hasAgentReferenceIds && !uniqueAgentReferenceIds.length) {
+    .map(buildAgentReferenceSearchVariants)
+    .filter(variants => variants.length > 0));
+  if (hasAgentReferenceIds && !agentReferenceSearchVariants.length) {
     return { bookings: [] };
   }
   const normalizedBookingReferenceIds = (
     Array.isArray(bookingReferenceIds) ? bookingReferenceIds : [bookingReferenceIds]
   ).filter(v => v != null).map(v => escapeInvalidXmlChars(String(v).trim())).filter(Boolean);
 
-  if (uniqueAgentReferenceIds.length) {
-    searchCriterias = uniqueAgentReferenceIds.map(ref => ({ AgentRef: ref }));
+  if (agentReferenceSearchVariants.length) {
+    searchCriteriaGroups = agentReferenceSearchVariants
+      .map(variants => variants.map(ref => ({ AgentRef: ref })));
   } else if (normalizedBookingReferenceIds.length) {
     // if bookingReferenceIds are provided other search criteria are ignored
-    searchCriterias = R.uniq(normalizedBookingReferenceIds).map(ref => ({ Ref: ref }));
+    searchCriteriaGroups = R.uniq(normalizedBookingReferenceIds).map(ref => [{ Ref: ref }]);
   } else if (bookingId) {
     // if bookingId is provided other search criteria are ignored
     // and we search for bookings by bookingId, ref & agentRef
-    searchCriterias = ['BookingId', 'Ref', 'AgentRef'].map(key => ({ [key]: escapeInvalidXmlChars(bookingId) }));
+    const bookingIdText = String(bookingId).trim();
+    const normalizedBookingId = escapeInvalidXmlChars(bookingIdText);
+    if (!normalizedBookingId) return { bookings: [] };
+    searchCriteriaGroups = [
+      [{ BookingId: normalizedBookingId }],
+      [{ Ref: normalizedBookingId }],
+      buildAgentReferenceSearchVariants(bookingIdText).map(ref => ({ AgentRef: ref })),
+    ];
   } else {
     applyBaseSearchFilters = true;
     if (name) {
-      searchCriterias.push({ NameContains: escapeInvalidXmlChars(name) });
+      searchCriteriaGroups.push([{ NameContains: escapeInvalidXmlChars(name) }]);
     }
   }
-  // Step2: Remove duplicate criteria so repeated refs don't trigger duplicate upstream calls.
-  // R.uniqWith(R.equals) uses deep structural equality, which is safer than
-  // R.uniqBy(JSON.stringify) whose output depends on property insertion order.
-  searchCriterias = R.uniqWith(R.equals, searchCriterias);
 
   // Step3: Build base search filters.
   if (applyBaseSearchFilters) {
@@ -251,57 +268,96 @@ const searchItineraries = async ({
   }
 
   // Step4: Fetch for bookings based on the search criterias.
-  const allSearches = (searchCriterias.length ? searchCriterias : [baseSearchFilters])
-    .map(keyObj => ({ keyObj }));
+  const allSearches = searchCriteriaGroups.length
+    ? searchCriteriaGroups
+    : [[baseSearchFilters]];
+  const listSearchPromises = new Map();
   const settledSearches = await Promise.map(
     allSearches,
-    async ({ keyObj }) => {
-      try {
-        let reply;
+    async keyObjs => {
+      const searchState = await Promise.reduce(keyObjs, async (state, keyObj) => {
+        if (state.match) return state;
         try {
-          reply = await callTourplan(getPayload('ListBookingsRequest', {
-            ...(baseSearchFilters ? { ...baseSearchFilters } : {}),
-            ...keyObj,
-          }));
-        /*
-          <Reply>
-            <ListBookingsReply>
-              <BookingHeaders>
-                <BookingHeader>
-                  <BookingId>320984</BookingId>
-                  <Ref>ALFI399113</Ref>
-                  <Name>Barbara Solomon x2 2554776</Name>
-                  <NameAlias/>
-                  <QB>B</QB>
-                  <Consult>TEST AGENT OWNER</Consult>
-                  <AgentRef>2554776</AgentRef>
-                  <TravelDate>2025-04-06</TravelDate>
-                  <EnteredDate>2025-01-30</EnteredDate>
-                  <BookingStatus>Quotation iCom CNX</BookingStatus>
-                  <BookingType>F</BookingType>
-                  <IsInternetBooking>Y</IsInternetBooking>
-                  <Currency>GBP</Currency>
-                  <TotalPrice>1016738</TotalPrice>
-                </BookingHeader>
-              </BookingHeaders>
-            </ListBookingsReply>
-          </Reply>
-        */
-        } catch (err) {
-          const errMsg = typeof err === 'string' ? err : (err && err.message) || String(err);
-          if (hasAgentReferenceIds) {
-            throw err instanceof Error ? err : Error(errMsg);
+          let reply;
+          try {
+            const requestInput = {
+              ...(baseSearchFilters ? { ...baseSearchFilters } : {}),
+              ...keyObj,
+            };
+            const requestKey = JSON.stringify(requestInput);
+            if (!listSearchPromises.has(requestKey)) {
+              listSearchPromises.set(
+                requestKey,
+                callTourplan(getPayload('ListBookingsRequest', requestInput)),
+              );
+            }
+            reply = await listSearchPromises.get(requestKey);
+          /*
+            <Reply>
+              <ListBookingsReply>
+                <BookingHeaders>
+                  <BookingHeader>
+                    <BookingId>320984</BookingId>
+                    <Ref>ALFI399113</Ref>
+                    <Name>Barbara Solomon x2 2554776</Name>
+                    <NameAlias/>
+                    <QB>B</QB>
+                    <Consult>TEST AGENT OWNER</Consult>
+                    <AgentRef>2554776</AgentRef>
+                    <TravelDate>2025-04-06</TravelDate>
+                    <EnteredDate>2025-01-30</EnteredDate>
+                    <BookingStatus>Quotation iCom CNX</BookingStatus>
+                    <BookingType>F</BookingType>
+                    <IsInternetBooking>Y</IsInternetBooking>
+                    <Currency>GBP</Currency>
+                    <TotalPrice>1016738</TotalPrice>
+                  </BookingHeader>
+                </BookingHeaders>
+              </ListBookingsReply>
+            </Reply>
+          */
+          } catch (err) {
+            const errMsg = typeof err === 'string' ? err : (err && err.message) || String(err);
+            if (hasAgentReferenceIds) {
+              throw err instanceof Error ? err : Error(errMsg);
+            }
+            if (errMsg.includes('Request failed with status code')) throw Error(errMsg);
+            // if it's not server error, we just considered as no booking is found
+            reply = { ListBookingsReply: { BookingHeaders: { BookingHeader: [] } } };
           }
-          if (errMsg.includes('Request failed with status code')) {
-            throw Error(errMsg);
+          const result = { status: 'fulfilled', value: reply };
+          const bookingHeaders = R.pathOr(
+            [],
+            ['ListBookingsReply', 'BookingHeaders', 'BookingHeader'],
+            reply,
+          );
+          if ((Array.isArray(bookingHeaders) && bookingHeaders.length) ||
+            (!Array.isArray(bookingHeaders) && bookingHeaders)) {
+            return { ...state, match: result };
           }
-          // if it's not server error, we just considered as no booking is found
-          reply = { ListBookingsReply: { BookingHeaders: { BookingHeader: [] } } };
+          return { ...state, emptyResult: result };
+        } catch (reason) {
+          const result = { status: 'rejected', reason };
+          if (Object.prototype.hasOwnProperty.call(keyObj, 'AgentRef')) {
+            const status = R.path(['response', 'status'], reason)
+              || R.path(['status'], reason)
+              || R.path(['code'], reason)
+              || 'unknown';
+            const agentReference = String(keyObj.AgentRef || '');
+            const errorMessage = reason instanceof Error ? reason.message : String(reason);
+            const redactedErrorMessage = agentReference
+              ? errorMessage.split(agentReference).join('[redacted]')
+              : errorMessage;
+            console.warn(
+              '[tourplan] AgentRef ListBookingsRequest failed status=%s error=%s',
+              status,
+              redactedErrorMessage,
+            );
+          }
+          return state.firstRejection ? state : { ...state, firstRejection: result };
         }
-        return { status: 'fulfilled', value: reply };
-      } catch (reason) {
-        return { status: 'rejected', reason };
-      }
+      }, { match: null, emptyResult: null, firstRejection: null });
+      return searchState.match || searchState.emptyResult || searchState.firstRejection;
     },
     { concurrency: LIST_BOOKINGS_CONCURRENCY },
   );
@@ -315,11 +371,13 @@ const searchItineraries = async ({
       replyObjs.push(result.value);
       return;
     }
-    const { keyObj } = allSearches[idx];
+    const keyObj = allSearches[idx][0];
     const { reason } = result;
     const errMsg = reason instanceof Error ? reason.message : String(reason);
     rejectedSearches.push(reason);
-    console.warn('[tourplan] ListBookingsRequest failed', keyObj, errMsg);
+    if (!Object.prototype.hasOwnProperty.call(keyObj, 'AgentRef')) {
+      console.warn('[tourplan] ListBookingsRequest failed', keyObj, errMsg);
+    }
   });
 
   if (!replyObjs.length && rejectedSearches.length) {

package/itinerary-search.test.js

@@ -109,6 +109,52 @@ describe('searchItineraries agentReferenceIds', () => {
     expect(result).toEqual({ bookings: [] });
   });
 
+  it('tries the raw AgentRef before the provider-safe value after a miss', async () => {
+    const rawAgentReference = 'X'.repeat(61);
+    const callTourplan = jest.fn(async ({ model }) => {
+      if (model.ListBookingsRequest) {
+        return {
+          ListBookingsReply: {
+            BookingHeaders: {
+              BookingHeader: model.ListBookingsRequest.AgentRef === 'X'.repeat(60)
+                ? [{ BookingId: '778' }]
+                : [],
+            },
+          },
+        };
+      }
+      return { GetBookingReply: { BookingId: '778' } };
+    });
+
+    const result = await runSearch({ agentReferenceIds: [rawAgentReference] }, callTourplan);
+
+    expect(listRequestsFrom(callTourplan).map(request => request.AgentRef)).toEqual([
+      rawAgentReference,
+      'X'.repeat(60),
+    ]);
+    expect(result.bookings.map(booking => booking.BookingId)).toEqual(['778']);
+  });
+
+  it('does not try the provider-safe AgentRef after the raw value matches', async () => {
+    const rawAgentReference = 'Müller – external booking';
+    const callTourplan = jest.fn(async ({ model }) => {
+      if (model.ListBookingsRequest) {
+        return {
+          ListBookingsReply: {
+            BookingHeaders: { BookingHeader: [{ BookingId: '779' }] },
+          },
+        };
+      }
+      return { GetBookingReply: { BookingId: '779' } };
+    });
+
+    const result = await runSearch({ agentReferenceIds: [rawAgentReference] }, callTourplan);
+
+    expect(listRequestsFrom(callTourplan).map(request => request.AgentRef))
+      .toEqual([rawAgentReference]);
+    expect(result.bookings.map(booking => booking.BookingId)).toEqual(['779']);
+  });
+
   it('normalizes array values and deduplicates AgentRef searches and booking results', async () => {
     const callTourplan = jest.fn(async ({ model }) => {
       const listRequest = model.ListBookingsRequest;
@@ -160,12 +206,29 @@ describe('searchItineraries agentReferenceIds', () => {
     expect(getBookingIds).toEqual(['601', '602']);
   });
 
+  it('deduplicates provider-safe AgentRef variants across inputs', async () => {
+    const rawAgentReference = 'A'.repeat(61);
+    const callTourplan = jest.fn(async () => ({
+      ListBookingsReply: { BookingHeaders: { BookingHeader: [] } },
+    }));
+
+    const result = await runSearch({
+      agentReferenceIds: [rawAgentReference, 'A'.repeat(60)],
+    }, callTourplan);
+
+    expect(listRequestsFrom(callTourplan).map(request => request.AgentRef)).toEqual([
+      rawAgentReference,
+      'A'.repeat(60),
+    ]);
+    expect(result).toEqual({ bookings: [] });
+  });
+
   it('keeps successful AgentRef results when another fan-out request fails', async () => {
     const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
     const callTourplan = jest.fn(async ({ model }) => {
       const listRequest = model.ListBookingsRequest;
       if (listRequest && listRequest.AgentRef === 'FAIL') {
-        throw new Error('Request failed with status code 500: failed AgentRef');
+        throw new Error('Request failed with status code 500 for FAIL');
       }
       if (listRequest && listRequest.AgentRef === 'GOOD') {
         return {
@@ -182,10 +245,11 @@ describe('searchItineraries agentReferenceIds', () => {
 
       expect(result.bookings.map(booking => booking.BookingId)).toEqual(['801']);
       expect(warnSpy).toHaveBeenCalledWith(
-        '[tourplan] ListBookingsRequest failed',
-        { AgentRef: 'FAIL' },
-        'Request failed with status code 500: failed AgentRef',
+        '[tourplan] AgentRef ListBookingsRequest failed status=%s error=%s',
+        'unknown',
+        'Request failed with status code 500 for [redacted]',
       );
+      expect(JSON.stringify(warnSpy.mock.calls)).not.toContain('FAIL');
     } finally {
       warnSpy.mockRestore();
     }
@@ -254,10 +318,11 @@ describe('searchItineraries agentReferenceIds', () => {
         .toEqual([...agentReferenceIds].sort());
       expect(result.bookings.map(booking => booking.BookingId)).toEqual(['901']);
       expect(warnSpy).toHaveBeenCalledWith(
-        '[tourplan] ListBookingsRequest failed',
-        { AgentRef: 'REF-7' },
+        '[tourplan] AgentRef ListBookingsRequest failed status=%s error=%s',
+        'unknown',
         'Request failed with status code 500: failed AgentRef',
       );
+      expect(JSON.stringify(warnSpy.mock.calls)).not.toContain('REF-7');
     } finally {
       pendingListRequests.splice(0).forEach(({ settle }) => settle());
       warnSpy.mockRestore();
@@ -305,6 +370,7 @@ describe('searchItineraries agentReferenceIds', () => {
   it.each([
     ['an empty list', []],
     ['blank and absent entries', [' ', null, undefined]],
+    ['values removed by XML sanitization', ['\u0001']],
     ['malformed entries', [{}, true, false, NaN, Infinity]],
     ['an explicit undefined scalar', undefined],
   ])('returns empty without a HostConnect request for %s', async (description, agentReferenceIds) => {
@@ -321,6 +387,15 @@ describe('searchItineraries agentReferenceIds', () => {
     expect(callTourplan).not.toHaveBeenCalled();
   });
 
+  it('returns empty without a HostConnect request for a blank bookingId', async () => {
+    const callTourplan = jest.fn();
+
+    const result = await runSearch({ bookingId: '   ' }, callTourplan);
+
+    expect(result).toEqual({ bookings: [] });
+    expect(callTourplan).not.toHaveBeenCalled();
+  });
+
   it.each([
     ['bookingReferenceIds', { bookingReferenceIds: ['LEGACY-REF'] }, 1],
     ['bookingId', { bookingId: '12345' }, 3],
@@ -344,6 +419,30 @@ describe('searchItineraries agentReferenceIds', () => {
     expect(result).toEqual({ bookings: [] });
     expect(callTourplan).toHaveBeenCalledTimes(expectedRequests);
   });
+
+  it('uses raw and provider-safe AgentRef variants for a bookingId fallback', async () => {
+    const rawBookingId = 'Z'.repeat(61);
+    const callTourplan = jest.fn(async ({ model }) => {
+      if (model.ListBookingsRequest) {
+        const { AgentRef } = model.ListBookingsRequest;
+        return {
+          ListBookingsReply: {
+            BookingHeaders: {
+              BookingHeader: AgentRef === 'Z'.repeat(60) ? [{ BookingId: '880' }] : [],
+            },
+          },
+        };
+      }
+      return { GetBookingReply: { BookingId: '880' } };
+    });
+
+    const result = await runSearch({ bookingId: rawBookingId }, callTourplan);
+
+    expect(listRequestsFrom(callTourplan)
+      .filter(request => Object.prototype.hasOwnProperty.call(request, 'AgentRef'))
+      .map(request => request.AgentRef)).toEqual([rawBookingId, 'Z'.repeat(60)]);
+    expect(result.bookings.map(booking => booking.BookingId)).toEqual(['880']);
+  });
 });
 
 // ---------------------------------------------------------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ti2-tourplan",
-  "version": "1.0.138",
+  "version": "1.0.139",
   "description": "Tourplan's TI2 Plugin",
   "main": "index.js",
   "scripts": {

package/utils.js

@@ -11,6 +11,7 @@ const passengerTypeMap = {
 
 // Constants not exported
 const BAD_XML_CHARS = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007f-\u0084\u0086-\u009f\uD800-\uDFFF\uFDD0-\uFDFF\uFFFF\uC008\uFEFF\u00DF]/g; // eslint-disable-line no-control-regex
+const MAX_AGENT_REFERENCE_LENGTH = 60;
 
 const hostConnectXmlOptions = {
   prettyPrinting: { enabled: false },
@@ -71,6 +72,16 @@ const escapeInvalidXmlChars = str => {
     .replace(BAD_XML_CHARS, '');
 };
 
+const normalizeAgentReference = value => {
+  if (value == null || value === '') return '';
+  const normalized = String(value).trim();
+  if (!normalized) return '';
+  return Array.from(escapeInvalidXmlChars(normalized))
+    .slice(0, MAX_AGENT_REFERENCE_LENGTH)
+    .join('')
+    .trim();
+};
+
 const isEnabled = value => {
   if (value === true || value === 1) return true;
   const normalized = String(value == null ? '' : value).trim().toLowerCase();
@@ -208,6 +219,7 @@ const getRoomConfigs = (paxConfigs, noPaxList) => {
 
 module.exports = {
   escapeInvalidXmlChars,
+  normalizeAgentReference,
   getRoomConfigs,
   wildcardMatch,
   CUSTOM_RATE_ID_NAME,

package/utils.test.js

@@ -2,6 +2,7 @@
 
 const {
   escapeInvalidXmlChars,
+  normalizeAgentReference,
   getOptionInfoTag,
   getRoomConfigs,
 } = require('./utils');
@@ -142,6 +143,21 @@ describe('escapeInvalidXmlChars', () => {
   });
 });
 
+describe('normalizeAgentReference', () => {
+  it('trims and caps the sanitized value at 60 characters', () => {
+    expect(normalizeAgentReference(`  ${'A'.repeat(61)}  `)).toBe('A'.repeat(60));
+    expect(normalizeAgentReference('Ä'.repeat(40))).toBe('Ae'.repeat(30));
+  });
+
+  it('removes invalid XML characters before applying the cap', () => {
+    expect(normalizeAgentReference(`${'A'.repeat(59)}\u0000BC`)).toBe(`${'A'.repeat(59)}B`);
+  });
+
+  it('returns an empty value when sanitization removes the selected source', () => {
+    expect(normalizeAgentReference(' \u0001 ')).toBe('');
+  });
+});
+
 describe('getOptionInfoTag', () => {
   it('uses includeRates for product-search tags when checkType is omitted', () => {
     expect(getOptionInfoTag()).toBe('G');