@deepagents/context 0.34.0 → 0.36.0

package/dist/index.js

@@ -83,22 +83,6 @@ function assistantText(content, options) {
     parts: [{ type: "text", text: content }]
   });
 }
-var LAZY_ID = Symbol.for("@deepagents/context:lazy-id");
-function isLazyFragment(fragment2) {
-  return LAZY_ID in fragment2;
-}
-function lastAssistantMessage(content) {
-  return {
-    name: "assistant",
-    type: "message",
-    persist: true,
-    data: "content",
-    [LAZY_ID]: {
-      type: "last-assistant",
-      content
-    }
-  };
-}
 
 // packages/context/src/lib/guardrail.ts
 function pass(part) {
@@ -149,13 +133,19 @@ var Agent = class _Agent {
     return generateText({
       abortSignal: config?.abortSignal,
       providerOptions: this.#options.providerOptions,
+      experimental_telemetry: this.#options.experimental_telemetry,
       model: this.#options.model,
       system: systemPrompt,
-      messages: await convertToModelMessages(messages),
-      stopWhen: stepCountIs(25),
+      messages: await convertToModelMessages(messages, {
+        ignoreIncompleteToolCalls: true
+      }),
+      stopWhen: stepCountIs(200),
       tools: this.#options.tools,
       experimental_context: contextVariables,
-      experimental_repairToolCall: createRepairToolCall(this.#options.model),
+      experimental_repairToolCall: createRepairToolCall(
+        this.#options.model,
+        config?.abortSignal
+      ),
       toolChoice: this.#options.toolChoice,
       onStepFinish: (step) => {
         const toolCall = step.toolCalls.at(-1);
@@ -216,11 +206,17 @@ var Agent = class _Agent {
     return streamText({
       abortSignal: config?.abortSignal,
       providerOptions: this.#options.providerOptions,
+      experimental_telemetry: this.#options.experimental_telemetry,
       model,
       system: systemPrompt,
-      messages: await convertToModelMessages(messages),
-      experimental_repairToolCall: createRepairToolCall(model),
-      stopWhen: stepCountIs(50),
+      messages: await convertToModelMessages(messages, {
+        ignoreIncompleteToolCalls: true
+      }),
+      experimental_repairToolCall: createRepairToolCall(
+        model,
+        config?.abortSignal
+      ),
+      stopWhen: stepCountIs(200),
       experimental_transform: config?.transform ?? smoothStream(),
       tools: this.#options.tools,
       experimental_context: contextVariables,
@@ -239,8 +235,8 @@ var Agent = class _Agent {
    * Wrap a StreamTextResult with guardrail protection on toUIMessageStream().
    *
    * When a guardrail fails:
-   * 1. Accumulated text + feedback is appended as the assistant's self-correction
-   * 2. The feedback is written to the output stream (user sees the correction)
+   * 1. The feedback is written to the output stream (user sees the correction)
+   * 2. A finish-step is emitted, triggering onStepFinish to persist the self-correction
    * 3. A new stream is started and the model continues from the correction
    */
   #wrapWithGuardrails(result, contextVariables, config) {
@@ -251,8 +247,18 @@ var Agent = class _Agent {
     }
     const originalToUIMessageStream = result.toUIMessageStream.bind(result);
     result.toUIMessageStream = (options) => {
+      const assistantMsgId = options?.generateMessageId?.();
+      let stepSaved = null;
       return createUIMessageStream({
-        generateId: generateId2,
+        generateId: assistantMsgId ? () => assistantMsgId : generateId2,
+        onStepFinish: async ({ responseMessage }) => {
+          if (!stepSaved) return;
+          const normalizedMessage = assistantMsgId ? { ...responseMessage, id: assistantMsgId } : responseMessage;
+          context.set(assistant(normalizedMessage));
+          await context.save({ branch: false });
+          stepSaved.resolve();
+          stepSaved = null;
+        },
         execute: async ({ writer }) => {
           let currentResult = result;
           let attempt = 0;
@@ -267,7 +273,6 @@ var Agent = class _Agent {
               return;
             }
             attempt++;
-            let accumulatedText = "";
             let guardrailFailed = false;
             let failureFeedback = "";
             const uiStream = currentResult === result ? originalToUIMessageStream(options) : currentResult.toUIMessageStream(options);
@@ -297,9 +302,6 @@ var Agent = class _Agent {
                 writer.write({ type: "finish" });
                 return;
               }
-              if (checkResult.part.type === "text-delta") {
-                accumulatedText += checkResult.part.delta;
-              }
               writer.write(part);
             }
             if (!guardrailFailed) {
@@ -316,9 +318,9 @@ var Agent = class _Agent {
               return;
             }
             writeText(writer, failureFeedback);
-            const selfCorrectionText = accumulatedText + " " + failureFeedback;
-            context.set(lastAssistantMessage(selfCorrectionText));
-            await context.save({ branch: false });
+            stepSaved = Promise.withResolvers();
+            writer.write({ type: "finish-step" });
+            await stepSaved.promise;
             currentResult = await this.#createRawStream(
               contextVariables,
               config
@@ -358,11 +360,17 @@ function structuredOutput(options) {
       const result = await generateText({
         abortSignal: config?.abortSignal,
         providerOptions: options.providerOptions,
+        experimental_telemetry: options.experimental_telemetry,
         model: options.model,
         system: systemPrompt,
-        messages: await convertToModelMessages(messages),
-        stopWhen: stepCountIs(25),
-        experimental_repairToolCall: createRepairToolCall(options.model),
+        messages: await convertToModelMessages(messages, {
+          ignoreIncompleteToolCalls: true
+        }),
+        stopWhen: stepCountIs(200),
+        experimental_repairToolCall: createRepairToolCall(
+          options.model,
+          config?.abortSignal
+        ),
         experimental_context: contextVariables,
         output: Output.object({ schema: options.schema }),
         tools: options.tools
@@ -382,11 +390,17 @@ function structuredOutput(options) {
       return streamText({
         abortSignal: config?.abortSignal,
         providerOptions: options.providerOptions,
+        experimental_telemetry: options.experimental_telemetry,
         model: options.model,
         system: systemPrompt,
-        experimental_repairToolCall: createRepairToolCall(options.model),
-        messages: await convertToModelMessages(messages),
-        stopWhen: stepCountIs(50),
+        experimental_repairToolCall: createRepairToolCall(
+          options.model,
+          config?.abortSignal
+        ),
+        messages: await convertToModelMessages(messages, {
+          ignoreIncompleteToolCalls: true
+        }),
+        stopWhen: stepCountIs(200),
         experimental_transform: config?.transform ?? smoothStream(),
         experimental_context: contextVariables,
         output: Output.object({ schema: options.schema }),
@@ -593,422 +607,77 @@ async function estimate(modelId, renderer, ...fragments) {
 // packages/context/src/lib/fragments/message/user.ts
 import { generateId as generateId3 } from "ai";
 
-// packages/context/src/lib/text.ts
-import { isTextUIPart } from "ai";
-function getTextParts(message2) {
-  return message2.parts.filter(isTextUIPart).map((part) => part.text);
-}
-function extractPlainText(message2) {
-  return getTextParts(message2).join(" ");
-}
-
-// packages/context/src/lib/fragments/message/user.ts
-function everyNTurns(n) {
-  return ({ turn }) => turn % n === 0;
-}
-function once() {
-  return ({ turn }) => turn === 1;
-}
-function firstN(n) {
-  return ({ turn }) => turn <= n;
-}
-function afterTurn(n) {
-  return ({ turn }) => turn > n;
-}
-function and(...predicates) {
-  return (ctx) => predicates.every((p) => p(ctx));
-}
-function or(...predicates) {
-  return (ctx) => predicates.some((p) => p(ctx));
-}
-function not(predicate) {
-  return (ctx) => !predicate(ctx);
-}
-function contentIncludes(keywords) {
-  const lower = keywords.map((k) => k.toLowerCase());
-  return (ctx) => {
-    const text = ctx.content.toLowerCase();
-    return lower.some((kw) => text.includes(kw));
-  };
-}
-function contentPattern(pattern) {
-  return (ctx) => {
-    pattern.lastIndex = 0;
-    return pattern.test(ctx.content);
-  };
-}
-function toDateParts(date, tz) {
-  const parts = new Intl.DateTimeFormat("en-CA", {
-    timeZone: tz,
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    hour: "2-digit",
-    hourCycle: "h23"
-  }).formatToParts(date);
-  const get = (type) => parts.find((p) => p.type === type).value;
-  return {
-    year: get("year"),
-    month: get("month"),
-    day: get("day"),
-    hour: get("hour")
-  };
-}
-function temporalChanged(ctx, tz, getKey) {
-  if (ctx.lastMessageAt === void 0) return true;
-  const nowParts = toDateParts(/* @__PURE__ */ new Date(), tz);
-  const prevParts = toDateParts(new Date(ctx.lastMessageAt), tz);
-  return getKey(nowParts) !== getKey(prevParts);
-}
-function getSeason(month) {
-  if (month >= 2 && month <= 4) return "Spring";
-  if (month >= 5 && month <= 7) return "Summer";
-  if (month >= 8 && month <= 10) return "Fall";
-  return "Winter";
-}
-function isoWeekKey(parts) {
-  const d = new Date(
-    Date.UTC(
-      parseInt(parts.year),
-      parseInt(parts.month) - 1,
-      parseInt(parts.day)
-    )
-  );
-  d.setUTCDate(d.getUTCDate() + 4 - (d.getUTCDay() || 7));
-  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
-  const weekNo = Math.ceil(
-    ((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7
-  );
-  return `${d.getUTCFullYear()}-W${String(weekNo).padStart(2, "0")}`;
-}
-function dayChanged(tz = "UTC") {
-  return (ctx) => temporalChanged(ctx, tz, (p) => `${p.year}-${p.month}-${p.day}`);
-}
-function hourChanged(tz = "UTC") {
-  return (ctx) => temporalChanged(ctx, tz, (p) => `${p.year}-${p.month}-${p.day}-${p.hour}`);
-}
-function monthChanged(tz = "UTC") {
-  return (ctx) => temporalChanged(ctx, tz, (p) => `${p.year}-${p.month}`);
-}
-function yearChanged(tz = "UTC") {
-  return (ctx) => temporalChanged(ctx, tz, (p) => p.year);
-}
-function seasonChanged(tz = "UTC") {
-  return (ctx) => temporalChanged(ctx, tz, (p) => getSeason(parseInt(p.month) - 1));
-}
-function weekChanged(tz = "UTC") {
-  return (ctx) => temporalChanged(ctx, tz, isoWeekKey);
-}
-function isConditionalReminder(fragment2) {
-  return fragment2.name === "reminder" && !!fragment2.metadata?.reminder;
-}
-function getConditionalReminder(fragment2) {
-  return fragment2.metadata.reminder;
-}
-var SYSTEM_REMINDER_OPEN_TAG = "<system-reminder>";
-var SYSTEM_REMINDER_CLOSE_TAG = "</system-reminder>";
-function getReminderRanges(metadata) {
-  return metadata?.reminders ?? [];
-}
-function stripTextByRanges(text, ranges) {
-  if (ranges.length === 0) {
-    return text;
+// packages/context/src/lib/renderers/abstract.renderer.ts
+import pluralize from "pluralize";
+import { titlecase } from "stringcase";
+var ContextRenderer = class {
+  options;
+  constructor(options = {}) {
+    this.options = options;
   }
-  const normalized = ranges.map((range) => ({
-    start: Math.max(0, Math.min(text.length, range.start)),
-    end: Math.max(0, Math.min(text.length, range.end))
-  })).filter((range) => range.end > range.start).sort((a, b) => a.start - b.start);
-  if (normalized.length === 0) {
-    return text;
+  /**
+   * Check if data is a primitive (string, number, boolean).
+   */
+  isPrimitive(data) {
+    return typeof data === "string" || typeof data === "number" || typeof data === "boolean";
   }
-  let cursor = 0;
-  let output = "";
-  for (const range of normalized) {
-    if (range.start < cursor) {
-      if (range.end > cursor) {
-        cursor = range.end;
+  /**
+   * Group fragments by name for groupFragments option.
+   */
+  groupByName(fragments) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const fragment2 of fragments) {
+      const existing = groups.get(fragment2.name) ?? [];
+      existing.push(fragment2);
+      groups.set(fragment2.name, existing);
+    }
+    return groups;
+  }
+  /**
+   * Remove null/undefined from fragments and fragment data recursively.
+   * This protects renderers from nullish values and ensures they are ignored
+   * consistently across all output formats.
+   */
+  sanitizeFragments(fragments) {
+    const sanitized = [];
+    for (const fragment2 of fragments) {
+      const cleaned = this.sanitizeFragment(fragment2, /* @__PURE__ */ new WeakSet());
+      if (cleaned) {
+        sanitized.push(cleaned);
       }
-      continue;
     }
-    output += text.slice(cursor, range.start);
-    cursor = range.end;
+    return sanitized;
   }
-  output += text.slice(cursor);
-  return output.trimEnd();
-}
-function stripReminders(message2) {
-  const reminderRanges = getReminderRanges(
-    isRecord(message2.metadata) ? message2.metadata : void 0
-  );
-  const rangesByPartIndex = /* @__PURE__ */ new Map();
-  for (const range of reminderRanges) {
-    const partRanges = rangesByPartIndex.get(range.partIndex) ?? [];
-    partRanges.push({ start: range.start, end: range.end });
-    rangesByPartIndex.set(range.partIndex, partRanges);
+  sanitizeFragment(fragment2, seen) {
+    const data = this.sanitizeData(getFragmentData(fragment2), seen);
+    if (data == null) {
+      return null;
+    }
+    return {
+      ...fragment2,
+      data
+    };
   }
-  const strippedParts = message2.parts.flatMap((part, partIndex) => {
-    const clonedPart = { ...part };
-    const ranges = rangesByPartIndex.get(partIndex);
-    if (clonedPart.type !== "text" || ranges === void 0) {
-      return [clonedPart];
+  sanitizeData(data, seen) {
+    if (data == null) {
+      return void 0;
     }
-    const strippedText = stripTextByRanges(clonedPart.text, ranges);
-    if (strippedText.length === 0) {
-      return [];
+    if (isFragment(data)) {
+      return this.sanitizeFragment(data, seen) ?? void 0;
     }
-    return [{ ...clonedPart, text: strippedText }];
-  });
-  const nextMessage = {
-    ...message2,
-    parts: strippedParts
-  };
-  if (isRecord(message2.metadata)) {
-    const metadata = { ...message2.metadata };
-    delete metadata.reminders;
-    if (Object.keys(metadata).length > 0) {
-      nextMessage.metadata = metadata;
-    } else {
-      delete nextMessage.metadata;
-    }
-  }
-  return nextMessage;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function assertReminderText(text) {
-  if (text.trim().length === 0) {
-    throw new Error("Reminder text must not be empty");
-  }
-}
-function formatTaggedReminder(text) {
-  return `${SYSTEM_REMINDER_OPEN_TAG}${text}${SYSTEM_REMINDER_CLOSE_TAG}`;
-}
-function findLastTextPartIndex(message2) {
-  for (let i = message2.parts.length - 1; i >= 0; i--) {
-    if (message2.parts[i].type === "text") {
-      return i;
-    }
-  }
-  return void 0;
-}
-function ensureTextPart(message2) {
-  const existingIndex = findLastTextPartIndex(message2);
-  if (existingIndex !== void 0) {
-    return existingIndex;
-  }
-  const reminderPart = {
-    type: "text",
-    text: ""
-  };
-  message2.parts.push(reminderPart);
-  return message2.parts.length - 1;
-}
-function applyInlineReminder(message2, value) {
-  const partIndex = ensureTextPart(message2);
-  const textPart = message2.parts[partIndex];
-  if (textPart.type !== "text") {
-    throw new Error("Failed to resolve text part for inline reminder");
-  }
-  const reminderText = formatTaggedReminder(value);
-  const start = textPart.text.length;
-  const updatedText = `${textPart.text}${reminderText}`;
-  message2.parts[partIndex] = { ...textPart, text: updatedText };
-  return {
-    id: generateId3(),
-    text: value,
-    partIndex,
-    start,
-    end: start + reminderText.length,
-    mode: "inline"
-  };
-}
-function applyPartReminder(message2, value) {
-  const part = { type: "text", text: value };
-  message2.parts.push(part);
-  const partIndex = message2.parts.length - 1;
-  return {
-    id: generateId3(),
-    text: value,
-    partIndex,
-    start: 0,
-    end: value.length,
-    mode: "part"
-  };
-}
-function resolveReminderText(item, ctx) {
-  return resolveReminder(item, ctx)?.text ?? "";
-}
-function normalizeReminderResolution(value) {
-  if (typeof value === "string") {
-    return value.trim().length === 0 ? null : { text: value };
-  }
-  if (value.text.trim().length === 0) {
-    return null;
-  }
-  return value;
-}
-function resolveReminder(item, ctx) {
-  const resolvedText = typeof item.text === "function" ? item.text(ctx) : item.text;
-  const resolved = normalizeReminderResolution(resolvedText);
-  if (!resolved) {
-    return null;
-  }
-  const metadata = item.metadata || resolved.metadata ? {
-    ...item.metadata ?? {},
-    ...resolved.metadata ?? {}
-  } : void 0;
-  return metadata ? { ...resolved, metadata } : resolved;
-}
-function mergeMessageMetadata(message2, addedMetadata) {
-  if (Object.keys(addedMetadata).length === 0) {
-    return;
-  }
-  const metadata = isRecord(message2.metadata) ? { ...message2.metadata } : {};
-  message2.metadata = { ...metadata, ...addedMetadata };
-}
-function applyReminderToMessage(message2, item, ctx) {
-  const resolved = resolveReminder(item, ctx);
-  if (!resolved) {
-    return null;
-  }
-  if (resolved.metadata) {
-    mergeMessageMetadata(message2, resolved.metadata);
-  }
-  return item.asPart ? applyPartReminder(message2, resolved.text) : applyInlineReminder(message2, resolved.text);
-}
-function mergeReminderMetadata(message2, addedReminders) {
-  if (addedReminders.length === 0) return;
-  const metadata = isRecord(message2.metadata) ? { ...message2.metadata } : {};
-  const existing = Array.isArray(metadata.reminders) ? metadata.reminders : [];
-  metadata.reminders = [...existing, ...addedReminders];
-  message2.metadata = metadata;
-}
-function reminder(text, options) {
-  if (typeof text === "string") {
-    assertReminderText(text);
-  }
-  if (options && "when" in options && options.when) {
-    return {
-      name: "reminder",
-      metadata: {
-        reminder: {
-          text,
-          when: options.when,
-          asPart: options.asPart ?? false
-        }
-      }
-    };
-  }
-  return {
-    text,
-    asPart: options?.asPart ?? false
-  };
-}
-function user(content, ...reminders) {
-  const message2 = typeof content === "string" ? {
-    id: generateId3(),
-    role: "user",
-    parts: [{ type: "text", text: content }]
-  } : { ...content, role: "user", parts: [...content.parts] };
-  if (reminders.length > 0) {
-    const plainText = extractPlainText(message2);
-    const added = [];
-    for (const item of reminders) {
-      const meta = applyReminderToMessage(message2, item, {
-        content: plainText
-      });
-      if (meta) added.push(meta);
-    }
-    mergeReminderMetadata(message2, added);
-  }
-  return {
-    id: message2.id,
-    name: "user",
-    type: "message",
-    persist: true,
-    codec: {
-      decode() {
-        return message2;
-      },
-      encode() {
-        return message2;
-      }
-    }
-  };
-}
-
-// packages/context/src/lib/renderers/abstract.renderer.ts
-import pluralize from "pluralize";
-import { titlecase } from "stringcase";
-var ContextRenderer = class {
-  options;
-  constructor(options = {}) {
-    this.options = options;
-  }
-  /**
-   * Check if data is a primitive (string, number, boolean).
-   */
-  isPrimitive(data) {
-    return typeof data === "string" || typeof data === "number" || typeof data === "boolean";
-  }
-  /**
-   * Group fragments by name for groupFragments option.
-   */
-  groupByName(fragments) {
-    const groups = /* @__PURE__ */ new Map();
-    for (const fragment2 of fragments) {
-      const existing = groups.get(fragment2.name) ?? [];
-      existing.push(fragment2);
-      groups.set(fragment2.name, existing);
-    }
-    return groups;
-  }
-  /**
-   * Remove null/undefined from fragments and fragment data recursively.
-   * This protects renderers from nullish values and ensures they are ignored
-   * consistently across all output formats.
-   */
-  sanitizeFragments(fragments) {
-    const sanitized = [];
-    for (const fragment2 of fragments) {
-      const cleaned = this.sanitizeFragment(fragment2, /* @__PURE__ */ new WeakSet());
-      if (cleaned) {
-        sanitized.push(cleaned);
-      }
-    }
-    return sanitized;
-  }
-  sanitizeFragment(fragment2, seen) {
-    const data = this.sanitizeData(getFragmentData(fragment2), seen);
-    if (data == null) {
-      return null;
-    }
-    return {
-      ...fragment2,
-      data
-    };
-  }
-  sanitizeData(data, seen) {
-    if (data == null) {
-      return void 0;
-    }
-    if (isFragment(data)) {
-      return this.sanitizeFragment(data, seen) ?? void 0;
-    }
-    if (Array.isArray(data)) {
-      if (seen.has(data)) {
-        return void 0;
-      }
-      seen.add(data);
-      const cleaned = [];
-      for (const item of data) {
-        const sanitizedItem = this.sanitizeData(item, seen);
-        if (sanitizedItem != null) {
-          cleaned.push(sanitizedItem);
-        }
-      }
-      return cleaned;
+    if (Array.isArray(data)) {
+      if (seen.has(data)) {
+        return void 0;
+      }
+      seen.add(data);
+      const cleaned = [];
+      for (const item of data) {
+        const sanitizedItem = this.sanitizeData(item, seen);
+        if (sanitizedItem != null) {
+          cleaned.push(sanitizedItem);
+        }
+      }
+      return cleaned;
     }
     if (isFragmentObject(data)) {
       if (seen.has(data)) {
@@ -1814,27 +1483,391 @@ ${entries}`;
   }
 };
 
-// packages/context/src/lib/store/store.ts
-var ContextStore = class {
-};
+// packages/context/src/lib/text.ts
+import { isTextUIPart } from "ai";
+function getTextParts(message2) {
+  return message2.parts.filter(isTextUIPart).map((part) => part.text);
+}
+function extractPlainText(message2) {
+  return getTextParts(message2).join(" ");
+}
 
-// packages/context/src/lib/engine.ts
-function estimateMessageContent(data) {
-  return typeof data === "string" ? data : JSON.stringify(data);
+// packages/context/src/lib/fragments/message/user.ts
+function everyNTurns(n) {
+  return ({ turn }) => turn % n === 0;
 }
-function isLanguageModelUsage(value) {
-  return typeof value === "object" && value !== null && "totalTokens" in value;
+function once() {
+  return ({ turn }) => turn === 1;
 }
-var ContextEngine = class {
-  /** Non-message fragments (role, hints, etc.) - not persisted in graph */
-  #fragments = [];
-  /** Pending message fragments to be added to graph */
-  #pendingMessages = [];
-  #store;
-  #chatId;
-  #userId;
-  #branchName;
-  #branch = null;
+function firstN(n) {
+  return ({ turn }) => turn <= n;
+}
+function afterTurn(n) {
+  return ({ turn }) => turn > n;
+}
+function and(...predicates) {
+  return async (ctx) => {
+    for (const it of predicates) {
+      if (!await it(ctx)) return false;
+    }
+    return true;
+  };
+}
+function or(...predicates) {
+  return async (ctx) => {
+    for (const it of predicates) {
+      if (await it(ctx)) return true;
+    }
+    return false;
+  };
+}
+function not(predicate) {
+  return async (ctx) => !await predicate(ctx);
+}
+function contentIncludes(keywords) {
+  const lower = keywords.map((k) => k.toLowerCase());
+  return (ctx) => {
+    const text = ctx.content.toLowerCase();
+    return lower.some((kw) => text.includes(kw));
+  };
+}
+function contentPattern(pattern) {
+  return (ctx) => {
+    pattern.lastIndex = 0;
+    return pattern.test(ctx.content);
+  };
+}
+function toDateParts(date, tz) {
+  const parts = new Intl.DateTimeFormat("en-CA", {
+    timeZone: tz,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    hourCycle: "h23"
+  }).formatToParts(date);
+  const get = (type) => parts.find((p) => p.type === type).value;
+  return {
+    year: get("year"),
+    month: get("month"),
+    day: get("day"),
+    hour: get("hour")
+  };
+}
+function temporalChanged(ctx, tz, getKey) {
+  if (ctx.lastMessageAt === void 0) return true;
+  const nowParts = toDateParts(/* @__PURE__ */ new Date(), tz);
+  const prevParts = toDateParts(new Date(ctx.lastMessageAt), tz);
+  return getKey(nowParts) !== getKey(prevParts);
+}
+function getSeason(month) {
+  if (month >= 2 && month <= 4) return "Spring";
+  if (month >= 5 && month <= 7) return "Summer";
+  if (month >= 8 && month <= 10) return "Fall";
+  return "Winter";
+}
+function isoWeekKey(parts) {
+  const d = new Date(
+    Date.UTC(
+      parseInt(parts.year),
+      parseInt(parts.month) - 1,
+      parseInt(parts.day)
+    )
+  );
+  d.setUTCDate(d.getUTCDate() + 4 - (d.getUTCDay() || 7));
+  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+  const weekNo = Math.ceil(
+    ((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7
+  );
+  return `${d.getUTCFullYear()}-W${String(weekNo).padStart(2, "0")}`;
+}
+function dayChanged(tz = "UTC") {
+  return (ctx) => temporalChanged(ctx, tz, (p) => `${p.year}-${p.month}-${p.day}`);
+}
+function hourChanged(tz = "UTC") {
+  return (ctx) => temporalChanged(ctx, tz, (p) => `${p.year}-${p.month}-${p.day}-${p.hour}`);
+}
+function monthChanged(tz = "UTC") {
+  return (ctx) => temporalChanged(ctx, tz, (p) => `${p.year}-${p.month}`);
+}
+function yearChanged(tz = "UTC") {
+  return (ctx) => temporalChanged(ctx, tz, (p) => p.year);
+}
+function seasonChanged(tz = "UTC") {
+  return (ctx) => temporalChanged(ctx, tz, (p) => getSeason(parseInt(p.month) - 1));
+}
+function weekChanged(tz = "UTC") {
+  return (ctx) => temporalChanged(ctx, tz, isoWeekKey);
+}
+function isConditionalReminder(fragment2) {
+  return fragment2.name === "reminder" && !!fragment2.metadata?.reminder;
+}
+function getConditionalReminder(fragment2) {
+  return fragment2.metadata.reminder;
+}
+var SYSTEM_REMINDER_OPEN_TAG = "<system-reminder>";
+var SYSTEM_REMINDER_CLOSE_TAG = "</system-reminder>";
+function getReminderRanges(metadata) {
+  return metadata?.reminders ?? [];
+}
+function stripTextByRanges(text, ranges) {
+  if (ranges.length === 0) {
+    return text;
+  }
+  const normalized = ranges.map((range) => ({
+    start: Math.max(0, Math.min(text.length, range.start)),
+    end: Math.max(0, Math.min(text.length, range.end))
+  })).filter((range) => range.end > range.start).sort((a, b) => a.start - b.start);
+  if (normalized.length === 0) {
+    return text;
+  }
+  let cursor = 0;
+  let output = "";
+  for (const range of normalized) {
+    if (range.start < cursor) {
+      if (range.end > cursor) {
+        cursor = range.end;
+      }
+      continue;
+    }
+    output += text.slice(cursor, range.start);
+    cursor = range.end;
+  }
+  output += text.slice(cursor);
+  return output.trimEnd();
+}
+function stripReminders(message2) {
+  const reminderRanges = getReminderRanges(
+    isRecord(message2.metadata) ? message2.metadata : void 0
+  );
+  const rangesByPartIndex = /* @__PURE__ */ new Map();
+  for (const range of reminderRanges) {
+    const partRanges = rangesByPartIndex.get(range.partIndex) ?? [];
+    partRanges.push({ start: range.start, end: range.end });
+    rangesByPartIndex.set(range.partIndex, partRanges);
+  }
+  const strippedParts = message2.parts.flatMap((part, partIndex) => {
+    const clonedPart = { ...part };
+    const ranges = rangesByPartIndex.get(partIndex);
+    if (clonedPart.type !== "text" || ranges === void 0) {
+      return [clonedPart];
+    }
+    const strippedText = stripTextByRanges(clonedPart.text, ranges);
+    if (strippedText.length === 0) {
+      return [];
+    }
+    return [{ ...clonedPart, text: strippedText }];
+  });
+  const nextMessage = {
+    ...message2,
+    parts: strippedParts
+  };
+  if (isRecord(message2.metadata)) {
+    const metadata = { ...message2.metadata };
+    delete metadata.reminders;
+    if (Object.keys(metadata).length > 0) {
+      nextMessage.metadata = metadata;
+    } else {
+      delete nextMessage.metadata;
+    }
+  }
+  return nextMessage;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertReminderText(text) {
+  if (text.trim().length === 0) {
+    throw new Error("Reminder text must not be empty");
+  }
+}
+function formatTaggedReminder(text) {
+  return `${SYSTEM_REMINDER_OPEN_TAG}${text}${SYSTEM_REMINDER_CLOSE_TAG}`;
+}
+function findLastTextPartIndex(message2) {
+  for (let i = message2.parts.length - 1; i >= 0; i--) {
+    if (message2.parts[i].type === "text") {
+      return i;
+    }
+  }
+  return void 0;
+}
+function ensureTextPart(message2) {
+  const existingIndex = findLastTextPartIndex(message2);
+  if (existingIndex !== void 0) {
+    return existingIndex;
+  }
+  const reminderPart = {
+    type: "text",
+    text: ""
+  };
+  message2.parts.push(reminderPart);
+  return message2.parts.length - 1;
+}
+function applyInlineReminder(message2, value) {
+  const partIndex = ensureTextPart(message2);
+  const textPart = message2.parts[partIndex];
+  if (textPart.type !== "text") {
+    throw new Error("Failed to resolve text part for inline reminder");
+  }
+  const reminderText = formatTaggedReminder(value);
+  const start = textPart.text.length;
+  const updatedText = `${textPart.text}${reminderText}`;
+  message2.parts[partIndex] = { ...textPart, text: updatedText };
+  return {
+    id: generateId3(),
+    text: value,
+    partIndex,
+    start,
+    end: start + reminderText.length,
+    mode: "inline"
+  };
+}
+function applyPartReminder(message2, value) {
+  const part = { type: "text", text: value };
+  message2.parts.push(part);
+  const partIndex = message2.parts.length - 1;
+  return {
+    id: generateId3(),
+    text: value,
+    partIndex,
+    start: 0,
+    end: value.length,
+    mode: "part"
+  };
+}
+function resolveReminderText(item, ctx) {
+  return resolveReminder(item, ctx)?.text ?? "";
+}
+function normalizeReminderResolution(value) {
+  if (typeof value === "string") {
+    return value.trim().length === 0 ? null : { text: value };
+  }
+  if (value.text.trim().length === 0) {
+    return null;
+  }
+  return value;
+}
+function resolveReminder(item, ctx) {
+  const resolvedText = typeof item.text === "function" ? item.text(ctx) : item.text;
+  const resolved = normalizeReminderResolution(resolvedText);
+  if (!resolved) {
+    return null;
+  }
+  const metadata = item.metadata || resolved.metadata ? {
+    ...item.metadata ?? {},
+    ...resolved.metadata ?? {}
+  } : void 0;
+  return metadata ? { ...resolved, metadata } : resolved;
+}
+async function resolveReminderAsync(item, ctx) {
+  const text = await (typeof item.text === "function" ? item.text(ctx) : item.text);
+  const resolved = normalizeReminderResolution(text);
+  if (!resolved) return null;
+  const metadata = item.metadata || resolved.metadata ? { ...item.metadata ?? {}, ...resolved.metadata ?? {} } : void 0;
+  return metadata ? { ...resolved, metadata } : resolved;
+}
+function mergeMessageMetadata(message2, addedMetadata) {
+  if (Object.keys(addedMetadata).length === 0) {
+    return;
+  }
+  const metadata = isRecord(message2.metadata) ? { ...message2.metadata } : {};
+  message2.metadata = { ...metadata, ...addedMetadata };
+}
+function applyReminderToMessage(message2, item, ctx) {
+  const resolved = resolveReminder(item, ctx);
+  if (!resolved) {
+    return null;
+  }
+  if (resolved.metadata) {
+    mergeMessageMetadata(message2, resolved.metadata);
+  }
+  return item.asPart ? applyPartReminder(message2, resolved.text) : applyInlineReminder(message2, resolved.text);
+}
+function mergeReminderMetadata(message2, addedReminders) {
+  if (addedReminders.length === 0) return;
+  const metadata = isRecord(message2.metadata) ? { ...message2.metadata } : {};
+  const existing = Array.isArray(metadata.reminders) ? metadata.reminders : [];
+  metadata.reminders = [...existing, ...addedReminders];
+  message2.metadata = metadata;
+}
+function reminder(textOrFragment, options) {
+  const text = isFragment(textOrFragment) ? new XmlRenderer().render([textOrFragment]) : textOrFragment;
+  if (typeof text === "string") {
+    assertReminderText(text);
+  }
+  if (options && "when" in options && options.when) {
+    return {
+      name: "reminder",
+      data: null,
+      metadata: {
+        reminder: {
+          text,
+          when: options.when,
+          asPart: options.asPart ?? false
+        }
+      }
+    };
+  }
+  return {
+    text,
+    asPart: options?.asPart ?? false
+  };
+}
+function user(content, ...reminders) {
+  const message2 = typeof content === "string" ? {
+    id: generateId3(),
+    role: "user",
+    parts: [{ type: "text", text: content }]
+  } : { ...content, role: "user", parts: [...content.parts] };
+  if (reminders.length > 0) {
+    const plainText = extractPlainText(message2);
+    const added = [];
+    for (const item of reminders) {
+      const meta = applyReminderToMessage(message2, item, {
+        content: plainText
+      });
+      if (meta) added.push(meta);
+    }
+    mergeReminderMetadata(message2, added);
+  }
+  return {
+    id: message2.id,
+    name: "user",
+    type: "message",
+    persist: true,
+    codec: {
+      decode() {
+        return message2;
+      },
+      encode() {
+        return message2;
+      }
+    }
+  };
+}
+
+// packages/context/src/lib/store/store.ts
+var ContextStore = class {
+};
+
+// packages/context/src/lib/engine.ts
+function estimateMessageContent(data) {
+  return typeof data === "string" ? data : JSON.stringify(data);
+}
+function isLanguageModelUsage(value) {
+  return typeof value === "object" && value !== null && "totalTokens" in value;
+}
+var ContextEngine = class {
+  /** Non-message fragments (role, hints, etc.) - not persisted in graph */
+  #fragments = [];
+  /** Pending message fragments to be added to graph */
+  #pendingMessages = [];
+  #store;
+  #chatId;
+  #userId;
+  #branchName;
+  #branch = null;
   #chatData = null;
   #initialized = false;
   /** Initial metadata to merge on first initialization */
@@ -1972,7 +2005,7 @@ var ContextEngine = class {
     let messageCount = 0;
     let lastMessageAt;
     let lastMessage;
-    let lastAssistantMessage2;
+    let lastAssistantMessage;
     if (this.#branch?.headMessageId) {
       const chain = await this.#store.getMessageChain(
         this.#branch.headMessageId
@@ -1980,7 +2013,7 @@ var ContextEngine = class {
       for (const msg of chain) {
         messageCount++;
         if (msg.name === "assistant") {
-          lastAssistantMessage2 = msg.data;
+          lastAssistantMessage = msg.data;
         }
         if (msg.name !== "user") {
           continue;
@@ -1999,7 +2032,7 @@ var ContextEngine = class {
       messageCount,
       lastMessageAt,
       lastMessage,
-      lastAssistantMessage: lastAssistantMessage2
+      lastAssistantMessage
     };
   }
   async getTurnCount() {
@@ -2061,17 +2094,9 @@ var ContextEngine = class {
         messages.push(msg.data);
       }
     }
-    for (let i = 0; i < this.#pendingMessages.length; i++) {
-      const fragment2 = this.#pendingMessages[i];
-      if (isLazyFragment(fragment2)) {
-        this.#pendingMessages[i] = await this.#resolveLazyFragment(fragment2);
-      }
-    }
     for (const fragment2 of this.#pendingMessages) {
       if (!fragment2.codec) {
-        throw new Error(
-          `Fragment "${fragment2.name}" is missing codec. Lazy fragments must be resolved before encode.`
-        );
+        throw new Error(`Fragment "${fragment2.name}" is missing codec.`);
       }
       messages.push(fragment2.codec.encode());
     }
@@ -2100,12 +2125,6 @@ var ContextEngine = class {
       return { headMessageId: this.#branch?.headMessageId ?? void 0 };
     }
     const shouldBranch = options?.branch ?? true;
-    for (let i = 0; i < this.#pendingMessages.length; i++) {
-      const fragment2 = this.#pendingMessages[i];
-      if (isLazyFragment(fragment2)) {
-        this.#pendingMessages[i] = await this.#resolveLazyFragment(fragment2);
-      }
-    }
     if (shouldBranch) {
       for (const fragment2 of this.#pendingMessages) {
         if (fragment2.id) {
@@ -2135,7 +2154,7 @@ var ContextEngine = class {
             messageCount,
             lastMessageAt,
             lastMessage,
-            lastAssistantMessage: lastAssistantMessage2
+            lastAssistantMessage
           } = await this.#getChainContext();
           const original = lastUserFragment.codec.encode();
           const plainText = extractPlainText(original);
@@ -2152,19 +2171,23 @@ var ContextEngine = class {
             branch: this.#branchName,
             elapsed,
             messageCount,
-            lastAssistantMessage: lastAssistantMessage2
+            lastAssistantMessage
           };
-          const firedReminders = conditionalReminders.map(getConditionalReminder).filter((config) => config.when(whenCtx));
+          const configs = conditionalReminders.map(getConditionalReminder);
+          const whenResults = await Promise.all(
+            configs.map((it) => it.when(whenCtx))
+          );
+          const firedReminders = configs.filter((_, i) => whenResults[i]);
           if (firedReminders.length > 0) {
-            const reminders = firedReminders.flatMap((rem) => {
-              const resolved = resolveReminder(rem, whenCtx);
-              if (!resolved) {
-                return [];
-              }
+            const resolvedOrNull = await Promise.all(
+              firedReminders.map((it) => resolveReminderAsync(it, whenCtx))
+            );
+            const reminders = resolvedOrNull.flatMap((resolved, i) => {
+              if (!resolved) return [];
               return [
                 {
                   text: resolved.text,
-                  asPart: rem.asPart,
+                  asPart: firedReminders[i].asPart,
                   metadata: resolved.metadata
                 }
               ];
@@ -2180,9 +2203,7 @@ var ContextEngine = class {
     const now = Date.now();
     for (const fragment2 of this.#pendingMessages) {
       if (!fragment2.codec) {
-        throw new Error(
-          `Fragment "${fragment2.name}" is missing codec. Lazy fragments must be resolved before encode.`
-        );
+        throw new Error(`Fragment "${fragment2.name}" is missing codec.`);
       }
       const msgId = fragment2.id ?? crypto.randomUUID();
       let msgParentId = parentId;
@@ -2209,39 +2230,6 @@ var ContextEngine = class {
     this.#pendingMessages = [];
     return { headMessageId: this.#activeBranch.headMessageId ?? void 0 };
   }
-  /**
-   * Resolve a lazy fragment by finding the appropriate ID.
-   */
-  async #resolveLazyFragment(fragment2) {
-    const lazy = fragment2[LAZY_ID];
-    if (lazy.type === "last-assistant") {
-      const lastId = await this.#getLastAssistantId();
-      return assistantText(lazy.content, { id: lastId ?? crypto.randomUUID() });
-    }
-    throw new Error(`Unknown lazy fragment type: ${lazy.type}`);
-  }
-  /**
-   * Find the most recent assistant message ID (pending or persisted).
-   */
-  async #getLastAssistantId() {
-    for (let i = this.#pendingMessages.length - 1; i >= 0; i--) {
-      const msg = this.#pendingMessages[i];
-      if (msg.name === "assistant" && !isLazyFragment(msg)) {
-        return msg.id;
-      }
-    }
-    if (this.#branch?.headMessageId) {
-      const chain = await this.#store.getMessageChain(
-        this.#branch.headMessageId
-      );
-      for (let i = chain.length - 1; i >= 0; i--) {
-        if (chain[i].name === "assistant") {
-          return chain[i].id;
-        }
-      }
-    }
-    return void 0;
-  }
   /**
    * Estimate token count and cost for the full context.
    *
@@ -7934,7 +7922,6 @@ export {
   DockerfileBuildError,
   DockerfileStrategy,
   InMemoryContextStore,
-  LAZY_ID,
   MarkdownRenderer,
   ModelsRegistry,
   MountPathError,
@@ -8002,10 +7989,8 @@ export {
   isDockerfileOptions,
   isFragment,
   isFragmentObject,
-  isLazyFragment,
   isMessageFragment,
   isRecord,
-  lastAssistantMessage,
   loadSkillMetadata,
   localeReminder,
   mergeMessageMetadata,
@@ -8032,6 +8017,7 @@ export {
   render,
   resetAdaptivePolling,
   resolveReminder,
+  resolveReminderAsync,
   resolveReminderText,
   role,
   runGuardrailChain,