@mastra/server 1.26.1-alpha.0 → 1.27.0-alpha.1

package/dist/{chunk-2Q5WIJZV.js → chunk-BXJTD5TI.js}

@@ -1040,7 +1040,7 @@ function imageSize(input) {
   throw new TypeError(`unsupported file type: ${type}`);
 }
 
-// ../memory/dist/chunk-OOA4C7IX.js
+// ../memory/dist/chunk-MPBMHIAQ.js
 var OM_DEBUG_LOG = process.env.OM_DEBUG ? join(process.cwd(), "om-debug.log") : null;
 function omDebug(msg) {
   if (!OM_DEBUG_LOG) return;
@@ -1397,6 +1397,67 @@ ${gap}
   result += withInlineDates.slice(lastIndex);
   return result;
 }
+var MIN_TEMPORAL_GAP_MS = 10 * 60 * 1e3;
+function formatTemporalGap(diffMs) {
+  if (diffMs < MIN_TEMPORAL_GAP_MS) return null;
+  const minute = 60 * 1e3;
+  const hour = 60 * minute;
+  const day = 24 * hour;
+  const week = 7 * day;
+  const month = 30 * day;
+  const year = 365 * day;
+  const formatUnit = (value, unit) => `${value} ${unit}${value === 1 ? "" : "s"}`;
+  if (diffMs < hour) {
+    const minutes = Math.max(1, Math.round(diffMs / minute));
+    return `${formatUnit(minutes, "minute")} later`;
+  }
+  const formatTwoUnits = (primaryMs, primaryUnit, secondaryMs, secondaryUnit) => {
+    const primary = Math.floor(diffMs / primaryMs);
+    const remainder = diffMs - primary * primaryMs;
+    const secondary = Math.floor(remainder / secondaryMs);
+    const parts = [formatUnit(primary, primaryUnit)];
+    if (secondary > 0) {
+      parts.push(formatUnit(secondary, secondaryUnit));
+    }
+    return `${parts.join(" ")} later`;
+  };
+  if (diffMs < day) {
+    return formatTwoUnits(hour, "hour", minute, "minute");
+  }
+  if (diffMs < week) {
+    return formatTwoUnits(day, "day", hour, "hour");
+  }
+  if (diffMs < month) {
+    return formatTwoUnits(week, "week", day, "day");
+  }
+  if (diffMs < year) {
+    return formatTwoUnits(month, "month", week, "week");
+  }
+  return formatTwoUnits(year, "year", month, "month");
+}
+function formatTemporalTimestamp(date) {
+  return date.toLocaleString("en-US", {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true,
+    timeZoneName: "short"
+  });
+}
+function getMessagePartTimestamp(msg, position) {
+  const timestamps = msg.content?.parts?.map((part) => "createdAt" in part ? part.createdAt : void 0).filter((timestamp) => typeof timestamp === "number");
+  if (timestamps && timestamps.length > 0) {
+    const index = position === "first" ? 0 : timestamps.length - 1;
+    const timestamp = timestamps[index];
+    if (timestamp !== void 0) return timestamp;
+  }
+  return new Date(msg.createdAt).getTime();
+}
+function isTemporalGapMarker(msg) {
+  return msg.id.startsWith("__temporal_");
+}
 function createObservationStartMarker(params) {
   return {
     type: "data-om-observation-start",
@@ -3435,6 +3496,13 @@ function stripEphemeralAnchorIds(observations) {
   }
   return observations.replace(/(^|\n)([^\S\n]*)\[(O\d+(?:-N\d+)?)\][^\S\n]*/g, "$1$2");
 }
+function safeSlice(str, end) {
+  if (end <= 0) return "";
+  if (end >= str.length) return str;
+  const code = str.charCodeAt(end - 1);
+  const safeEnd = code >= 55296 && code <= 56319 ? end - 1 : end;
+  return str.slice(0, safeEnd);
+}
 var ENCRYPTED_CONTENT_KEY = "encryptedContent";
 var ENCRYPTED_CONTENT_REDACTION_THRESHOLD = 256;
 var DEFAULT_OBSERVER_TOOL_RESULT_MAX_TOKENS = 1e4;
@@ -3500,7 +3568,7 @@ function truncateStringByTokens(text, maxTokens) {
     return text;
   }
   const buildCandidate = (sliceEnd) => {
-    const visible = text.slice(0, sliceEnd);
+    const visible = safeSlice(text, sliceEnd);
     return `${visible}
 ... [truncated ~${totalTokens - estimateTokenCount(visible)} tokens]`;
   };
@@ -4052,8 +4120,11 @@ function formatObserverAttachmentPlaceholder(part, counter) {
   return label ? `[${attachmentType} #${attachmentId}: ${label}]` : `[${attachmentType} #${attachmentId}]`;
 }
 function formatObserverPartLine(title, body, time, previousTime) {
-  const timeLabel = time && time !== previousTime ? ` (${time})` : "";
-  return `${title}${timeLabel}: ${body}`;
+  const timeLabel = time && time !== previousTime ? `(${time})` : "";
+  if (!title) {
+    return timeLabel ? `${timeLabel}: ${body}` : body;
+  }
+  return `${title}${timeLabel ? ` ${timeLabel}` : ""}: ${body}`;
 }
 function normalizeObserverCreatedAt(createdAt) {
   if (createdAt instanceof Date) {
@@ -4089,6 +4160,16 @@ function formatObserverLines(lines, context = {}) {
     context: { previousDate, previousTime }
   };
 }
+function getTemporalGapMarkerText(msg) {
+  const metadata = typeof msg.content === "object" && msg.content && "metadata" in msg.content ? msg.content.metadata : void 0;
+  if (metadata?.reminderType === "temporal-gap" && typeof metadata.gapText === "string") {
+    return metadata.gapText;
+  }
+  if (typeof metadata?.systemReminder === "object" && metadata.systemReminder && "type" in metadata.systemReminder && metadata.systemReminder.type === "temporal-gap" && "gapText" in metadata.systemReminder && typeof metadata.systemReminder.gapText === "string") {
+    return metadata.systemReminder.gapText;
+  }
+  return void 0;
+}
 function formatObserverMessage(msg, counter, options) {
   const maxLen = options?.maxPartLength;
   const maxToolResultTokens = options?.maxToolResultTokens ?? DEFAULT_OBSERVER_TOOL_RESULT_MAX_TOKENS;
@@ -4096,6 +4177,7 @@ function formatObserverMessage(msg, counter, options) {
   const attachments = [];
   const messageCreatedAt = normalizeObserverCreatedAt(msg.createdAt);
   let lines = [];
+  const temporalGapText = isTemporalGapMarker(msg) ? getTemporalGapMarkerText(msg) : void 0;
   const pushLine = (title, body, createdAt) => {
     if (!body) {
       return;
@@ -4108,7 +4190,9 @@ function formatObserverMessage(msg, counter, options) {
       body
     });
   };
-  if (typeof msg.content === "string") {
+  if (temporalGapText) {
+    pushLine("", temporalGapText, messageCreatedAt);
+  } else if (typeof msg.content === "string") {
     pushLine(role, maybeTruncate(msg.content, maxLen), messageCreatedAt);
   } else if (msg.content?.parts && Array.isArray(msg.content.parts) && msg.content.parts.length > 0) {
     msg.content.parts.forEach((part) => {
@@ -4209,8 +4293,8 @@ function buildObserverHistoryMessage(messages, options) {
 }
 function maybeTruncate(str, maxLen) {
   if (!maxLen || str.length <= maxLen) return str;
-  const truncated = str.slice(0, maxLen);
-  const remaining = str.length - maxLen;
+  const truncated = safeSlice(str, maxLen);
+  const remaining = str.length - truncated.length;
   return `${truncated}
 ... [truncated ${remaining} characters]`;
 }
@@ -4514,7 +4598,7 @@ function sanitizeObservationLines(observations) {
   let changed = false;
   for (let i = 0; i < lines.length; i++) {
     if (lines[i].length > MAX_OBSERVATION_LINE_CHARS) {
-      lines[i] = lines[i].slice(0, MAX_OBSERVATION_LINE_CHARS) + " \u2026 [truncated]";
+      lines[i] = safeSlice(lines[i], MAX_OBSERVATION_LINE_CHARS) + " \u2026 [truncated]";
       changed = true;
     }
   }
@@ -9845,6 +9929,106 @@ ${grouped}` : grouped;
     });
   }
 };
+var TEMPORAL_GAP_REMINDER_TYPE = "temporal-gap";
+function getTemporalGapReminderText(gapText, timestamp) {
+  return `${gapText} \u2014 ${formatTemporalTimestamp(new Date(timestamp))}`;
+}
+function getTemporalGapReminderMetadata(message, gapText, gapMs, timestamp) {
+  const formattedTimestamp = formatTemporalTimestamp(new Date(timestamp));
+  return {
+    reminderType: TEMPORAL_GAP_REMINDER_TYPE,
+    gapText,
+    gapMs,
+    timestamp: formattedTimestamp,
+    timestampMs: timestamp,
+    precedesMessageId: message.id,
+    systemReminder: {
+      type: TEMPORAL_GAP_REMINDER_TYPE,
+      message: getTemporalGapReminderText(gapText, timestamp),
+      gapText,
+      gapMs,
+      timestamp: formattedTimestamp,
+      timestampMs: timestamp,
+      precedesMessageId: message.id
+    }
+  };
+}
+function isTemporalGapMarkerForMessage(message, targetMessageId) {
+  if (!isTemporalGapMarker(message)) {
+    return false;
+  }
+  const metadata = message.content.metadata;
+  if (metadata?.precedesMessageId === targetMessageId) {
+    return true;
+  }
+  return metadata?.systemReminder?.type === TEMPORAL_GAP_REMINDER_TYPE && metadata.systemReminder.precedesMessageId === targetMessageId;
+}
+function createTemporalGapMarker(message, gapText, gapMs, timestamp) {
+  const metadata = getTemporalGapReminderMetadata(message, gapText, gapMs, timestamp);
+  return {
+    id: `__temporal_gap_${crypto.randomUUID()}`,
+    role: "user",
+    createdAt: new Date(timestamp - 1),
+    threadId: message.threadId,
+    resourceId: message.resourceId,
+    content: {
+      format: 2,
+      parts: [
+        {
+          type: "text",
+          text: `<system-reminder type="${TEMPORAL_GAP_REMINDER_TYPE}" precedesMessageId="${message.id}">${getTemporalGapReminderText(gapText, timestamp)}</system-reminder>`
+        }
+      ],
+      metadata
+    }
+  };
+}
+async function insertTemporalGapMarkers({
+  messageList,
+  writer
+}) {
+  const inputMessages = messageList.get.input.db().filter((message) => Boolean(message));
+  const latestInputMessage = inputMessages.at(-1);
+  if (!latestInputMessage || isTemporalGapMarker(latestInputMessage)) {
+    return;
+  }
+  const allMessages = messageList.get.all.db().filter((message) => Boolean(message));
+  const latestInputIndex = allMessages.findIndex((message) => message.id === latestInputMessage.id);
+  if (latestInputIndex <= 0) {
+    return;
+  }
+  if (allMessages.some((message) => isTemporalGapMarkerForMessage(message, latestInputMessage.id))) {
+    return;
+  }
+  let previousNonMarker;
+  for (let index = latestInputIndex - 1; index >= 0; index--) {
+    const candidate = allMessages[index];
+    if (candidate && !isTemporalGapMarker(candidate)) {
+      previousNonMarker = candidate;
+      break;
+    }
+  }
+  if (!previousNonMarker) {
+    return;
+  }
+  const timestamp = getMessagePartTimestamp(latestInputMessage, "first");
+  const gapMs = timestamp - getMessagePartTimestamp(previousNonMarker, "last");
+  const gapText = formatTemporalGap(gapMs);
+  if (!gapText) {
+    return;
+  }
+  const reminderMetadata = getTemporalGapReminderMetadata(latestInputMessage, gapText, gapMs, timestamp);
+  await writer?.custom({
+    type: "data-system-reminder",
+    data: {
+      message: getTemporalGapReminderText(gapText, timestamp),
+      ...reminderMetadata
+    },
+    transient: true
+  });
+  const marker = createTemporalGapMarker(latestInputMessage, gapText, gapMs, timestamp);
+  messageList.add(marker, "input");
+}
 function getOmObservabilityContext(args) {
   if (!args.tracing || !args.tracingContext || !args.loggerVNext || !args.metrics) {
     return void 0;
@@ -9867,11 +10051,14 @@ var ObservationalMemoryProcessor = class {
   engine;
   /** Memory instance for loading context. */
   memory;
+  /** Whether temporal-gap reminder markers should be inserted. */
+  temporalMarkers;
   /** Active turn — created on first processInputStep, ended on processOutputResult. */
   turn;
-  constructor(engine, memory) {
+  constructor(engine, memory, options) {
     this.engine = engine;
     this.memory = memory;
+    this.temporalMarkers = options?.temporalMarkers ?? false;
   }
   // ─── Processor lifecycle hooks ──────────────────────────────────────────
   async processInputStep(args) {
@@ -9930,6 +10117,9 @@ var ObservationalMemoryProcessor = class {
         this.turn.writer = writer;
         this.turn.requestContext = requestContext;
         await this.turn.start(this.memory);
+        if (stepNumber === 0 && this.temporalMarkers) {
+          await insertTemporalGapMarkers({ messageList, writer });
+        }
         state.__omTurn = this.turn;
       }
       const observabilityContext = getOmObservabilityContext(args);
@@ -10067,5 +10257,5 @@ function getObservationsAsOf(activeObservations, asOf) {
 }
 
 export { ModelByInputTokens, OBSERVER_SYSTEM_PROMPT, ObservationalMemory, ObservationalMemoryProcessor, TokenCounter, buildObserverPrompt, buildObserverSystemPrompt, combineObservationGroupRanges, deriveObservationGroupProvenance, e, estimateTokenCount, extractCurrentTask, formatMessagesForObserver, formatToolResultForObserver, getObservationsAsOf, hasCurrentTaskSection, injectAnchorIds, optimizeObservationsForContext, parseAnchorId, parseObservationGroups, parseObserverOutput, reconcileObservationGroupsFromReflection, renderObservationGroupsForReflection, resolveToolResultValue, stripEphemeralAnchorIds, stripObservationGroups, truncateStringByTokens, wrapInObservationGroup };
-//# sourceMappingURL=chunk-2Q5WIJZV.js.map
-//# sourceMappingURL=chunk-2Q5WIJZV.js.map
+//# sourceMappingURL=chunk-BXJTD5TI.js.map
+//# sourceMappingURL=chunk-BXJTD5TI.js.map