@deepagents/context 0.26.0 → 0.28.0

package/dist/browser.js

@@ -1,167 +1,7 @@
-// packages/context/src/lib/estimate.ts
-import { encode } from "gpt-tokenizer";
-var defaultTokenizer = {
-  encode(text) {
-    return encode(text);
-  },
-  count(text) {
-    return encode(text).length;
-  }
-};
-var ModelsRegistry = class {
-  #cache = /* @__PURE__ */ new Map();
-  #loaded = false;
-  #tokenizers = /* @__PURE__ */ new Map();
-  #defaultTokenizer = defaultTokenizer;
-  /**
-   * Load models data from models.dev API
-   */
-  async load() {
-    if (this.#loaded) return;
-    const response = await fetch("https://models.dev/api.json");
-    if (!response.ok) {
-      throw new Error(`Failed to fetch models: ${response.statusText}`);
-    }
-    const data = await response.json();
-    for (const [providerId, provider] of Object.entries(data)) {
-      for (const [modelId, model] of Object.entries(provider.models)) {
-        const info = {
-          id: model.id,
-          name: model.name,
-          family: model.family,
-          cost: model.cost,
-          limit: model.limit,
-          provider: providerId
-        };
-        this.#cache.set(`${providerId}:${modelId}`, info);
-      }
-    }
-    this.#loaded = true;
-  }
-  /**
-   * Get model info by ID
-   * @param modelId - Model ID (e.g., "openai:gpt-4o")
-   */
-  get(modelId) {
-    return this.#cache.get(modelId);
-  }
-  /**
-   * Check if a model exists in the registry
-   */
-  has(modelId) {
-    return this.#cache.has(modelId);
-  }
-  /**
-   * List all available model IDs
-   */
-  list() {
-    return [...this.#cache.keys()];
-  }
-  /**
-   * Register a custom tokenizer for specific model families
-   * @param family - Model family name (e.g., "llama", "claude")
-   * @param tokenizer - Tokenizer implementation
-   */
-  registerTokenizer(family, tokenizer) {
-    this.#tokenizers.set(family, tokenizer);
-  }
-  /**
-   * Set the default tokenizer used when no family-specific tokenizer is registered
-   */
-  setDefaultTokenizer(tokenizer) {
-    this.#defaultTokenizer = tokenizer;
-  }
-  /**
-   * Get the appropriate tokenizer for a model
-   */
-  getTokenizer(modelId) {
-    const model = this.get(modelId);
-    if (model) {
-      const familyTokenizer = this.#tokenizers.get(model.family);
-      if (familyTokenizer) {
-        return familyTokenizer;
-      }
-    }
-    return this.#defaultTokenizer;
-  }
-  /**
-   * Estimate token count and cost for given text and model
-   * @param modelId - Model ID to use for pricing (e.g., "openai:gpt-4o")
-   * @param input - Input text (prompt)
-   */
-  estimate(modelId, input) {
-    const model = this.get(modelId);
-    if (!model) {
-      throw new Error(
-        `Model "${modelId}" not found. Call load() first or check model ID.`
-      );
-    }
-    const tokenizer = this.getTokenizer(modelId);
-    const tokens = tokenizer.count(input);
-    const cost = tokens / 1e6 * model.cost.input;
-    return {
-      model: model.id,
-      provider: model.provider,
-      tokens,
-      cost,
-      limits: {
-        context: model.limit.context,
-        output: model.limit.output,
-        exceedsContext: tokens > model.limit.context
-      },
-      fragments: []
-    };
-  }
-};
-var _registry = null;
-function getModelsRegistry() {
-  if (!_registry) {
-    _registry = new ModelsRegistry();
-  }
-  return _registry;
-}
-async function estimate(modelId, renderer, ...fragments) {
-  const registry = getModelsRegistry();
-  await registry.load();
-  const input = renderer.render(fragments);
-  const model = registry.get(modelId);
-  if (!model) {
-    throw new Error(
-      `Model "${modelId}" not found. Call load() first or check model ID.`
-    );
-  }
-  const tokenizer = registry.getTokenizer(modelId);
-  const totalTokens = tokenizer.count(input);
-  const totalCost = totalTokens / 1e6 * model.cost.input;
-  const fragmentEstimates = fragments.map((fragment2) => {
-    const rendered = renderer.render([fragment2]);
-    const tokens = tokenizer.count(rendered);
-    const cost = tokens / 1e6 * model.cost.input;
-    return {
-      id: fragment2.id,
-      name: fragment2.name,
-      tokens,
-      cost
-    };
-  });
-  return {
-    model: model.id,
-    provider: model.provider,
-    tokens: totalTokens,
-    cost: totalCost,
-    limits: {
-      context: model.limit.context,
-      output: model.limit.output,
-      exceedsContext: totalTokens > model.limit.context
-    },
-    fragments: fragmentEstimates
-  };
-}
-
 // packages/context/src/lib/fragments.ts
 import { generateId } from "ai";
 function isFragment(data) {
-  return typeof data === "object" && data !== null && "name" in data && "data" in data && typeof data.name === "string";
+  return typeof data === "object" && data !== null && "name" in data && ("data" in data || "codec" in data) && typeof data.name === "string";
 }
 function isFragmentObject(data) {
   return typeof data === "object" && data !== null && !Array.isArray(data) && !isFragment(data);
@@ -169,6 +9,15 @@ function isFragmentObject(data) {
 function isMessageFragment(fragment2) {
   return fragment2.type === "message";
 }
+function getFragmentData(fragment2) {
+  if (fragment2.codec) {
+    return fragment2.codec.decode();
+  }
+  if ("data" in fragment2) {
+    return fragment2.data;
+  }
+  throw new Error(`Fragment "${fragment2.name}" is missing data and codec`);
+}
 function fragment(name, ...children) {
   return {
     name,
@@ -179,7 +28,6 @@ function assistant(message2) {
   return {
     id: message2.id,
     name: "assistant",
-    data: "content",
     type: "message",
     persist: true,
     codec: {
@@ -201,7 +49,6 @@ function message(content) {
   return {
     id: message2.id,
     name: message2.role,
-    data: "content",
     type: "message",
     persist: true,
     codec: {
@@ -239,17 +86,60 @@ function lastAssistantMessage(content) {
   };
 }
 
+// packages/context/src/lib/codec/serialized-codec.ts
+function encodeSerializedValue(value) {
+  if (isFragment(value)) {
+    if (isMessageFragment(value)) {
+      throw new Error(
+        "Message fragments are not supported by serialized fragment conversion"
+      );
+    }
+    if (!value.codec) {
+      throw new Error(`Fragment "${value.name}" is missing codec`);
+    }
+    return value.codec.encode();
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => encodeSerializedValue(item));
+  }
+  if (isFragmentObject(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [
+        key,
+        encodeSerializedValue(entry)
+      ])
+    );
+  }
+  return value;
+}
+
 // packages/context/src/lib/fragments/domain.ts
 function term(name, definition) {
   return {
     name: "term",
-    data: { name, definition }
+    data: { name, definition },
+    codec: {
+      encode() {
+        return { type: "term", name, definition };
+      },
+      decode() {
+        return { name, definition };
+      }
+    }
   };
 }
 function hint(text) {
   return {
     name: "hint",
-    data: text
+    data: text,
+    codec: {
+      encode() {
+        return { type: "hint", text };
+      },
+      decode() {
+        return text;
+      }
+    }
   };
 }
 function guardrail(input) {
@@ -259,6 +149,23 @@ function guardrail(input) {
       rule: input.rule,
       ...input.reason && { reason: input.reason },
       ...input.action && { action: input.action }
+    },
+    codec: {
+      encode() {
+        return {
+          type: "guardrail",
+          rule: input.rule,
+          ...input.reason && { reason: input.reason },
+          ...input.action && { action: input.action }
+        };
+      },
+      decode() {
+        return {
+          rule: input.rule,
+          ...input.reason && { reason: input.reason },
+          ...input.action && { action: input.action }
+        };
+      }
     }
   };
 }
@@ -269,6 +176,23 @@ function explain(input) {
       concept: input.concept,
       explanation: input.explanation,
       ...input.therefore && { therefore: input.therefore }
+    },
+    codec: {
+      encode() {
+        return {
+          type: "explain",
+          concept: input.concept,
+          explanation: input.explanation,
+          ...input.therefore && { therefore: input.therefore }
+        };
+      },
+      decode() {
+        return {
+          concept: input.concept,
+          explanation: input.explanation,
+          ...input.therefore && { therefore: input.therefore }
+        };
+      }
     }
   };
 }
@@ -279,6 +203,23 @@ function example(input) {
       question: input.question,
       answer: input.answer,
       ...input.note && { note: input.note }
+    },
+    codec: {
+      encode() {
+        return {
+          type: "example",
+          question: input.question,
+          answer: input.answer,
+          ...input.note && { note: input.note }
+        };
+      },
+      decode() {
+        return {
+          question: input.question,
+          answer: input.answer,
+          ...input.note && { note: input.note }
+        };
+      }
     }
   };
 }
@@ -289,6 +230,23 @@ function clarification(input) {
       when: input.when,
       ask: input.ask,
       reason: input.reason
+    },
+    codec: {
+      encode() {
+        return {
+          type: "clarification",
+          when: input.when,
+          ask: input.ask,
+          reason: input.reason
+        };
+      },
+      decode() {
+        return {
+          when: input.when,
+          ask: input.ask,
+          reason: input.reason
+        };
+      }
     }
   };
 }
@@ -300,6 +258,25 @@ function workflow(input) {
       steps: input.steps,
       ...input.triggers?.length && { triggers: input.triggers },
       ...input.notes && { notes: input.notes }
+    },
+    codec: {
+      encode() {
+        return {
+          type: "workflow",
+          task: input.task,
+          steps: input.steps,
+          ...input.triggers?.length && { triggers: input.triggers },
+          ...input.notes && { notes: input.notes }
+        };
+      },
+      decode() {
+        return {
+          task: input.task,
+          steps: input.steps,
+          ...input.triggers?.length && { triggers: input.triggers },
+          ...input.notes && { notes: input.notes }
+        };
+      }
     }
   };
 }
@@ -309,6 +286,21 @@ function quirk(input) {
     data: {
       issue: input.issue,
       workaround: input.workaround
+    },
+    codec: {
+      encode() {
+        return {
+          type: "quirk",
+          issue: input.issue,
+          workaround: input.workaround
+        };
+      },
+      decode() {
+        return {
+          issue: input.issue,
+          workaround: input.workaround
+        };
+      }
     }
   };
 }
@@ -319,6 +311,23 @@ function styleGuide(input) {
       prefer: input.prefer,
       ...input.never && { never: input.never },
       ...input.always && { always: input.always }
+    },
+    codec: {
+      encode() {
+        return {
+          type: "styleGuide",
+          prefer: input.prefer,
+          ...input.never && { never: input.never },
+          ...input.always && { always: input.always }
+        };
+      },
+      decode() {
+        return {
+          prefer: input.prefer,
+          ...input.never && { never: input.never },
+          ...input.always && { always: input.always }
+        };
+      }
     }
   };
 }
@@ -331,43 +340,562 @@ function analogy(input) {
       ...input.insight && { insight: input.insight },
       ...input.therefore && { therefore: input.therefore },
       ...input.pitfall && { pitfall: input.pitfall }
+    },
+    codec: {
+      encode() {
+        return {
+          type: "analogy",
+          concepts: input.concepts,
+          relationship: input.relationship,
+          ...input.insight && { insight: input.insight },
+          ...input.therefore && { therefore: input.therefore },
+          ...input.pitfall && { pitfall: input.pitfall }
+        };
+      },
+      decode() {
+        return {
+          concepts: input.concepts,
+          relationship: input.relationship,
+          ...input.insight && { insight: input.insight },
+          ...input.therefore && { therefore: input.therefore },
+          ...input.pitfall && { pitfall: input.pitfall }
+        };
+      }
+    }
+  };
+}
+function glossary(entries) {
+  return {
+    name: "glossary",
+    data: Object.entries(entries).map(([term2, expression]) => ({
+      term: term2,
+      expression
+    })),
+    codec: {
+      encode() {
+        return { type: "glossary", entries };
+      },
+      decode() {
+        return Object.entries(entries).map(([term2, expression]) => ({
+          term: term2,
+          expression
+        }));
+      }
+    }
+  };
+}
+function role(content) {
+  return {
+    name: "role",
+    data: content,
+    codec: {
+      encode() {
+        return { type: "role", content };
+      },
+      decode() {
+        return content;
+      }
+    }
+  };
+}
+function principle(input) {
+  return {
+    name: "principle",
+    data: {
+      title: input.title,
+      description: input.description,
+      ...input.policies?.length && { policies: input.policies }
+    },
+    codec: {
+      encode() {
+        return {
+          type: "principle",
+          title: input.title,
+          description: input.description,
+          ...input.policies?.length && {
+            policies: input.policies.map((item) => encodeSerializedValue(item))
+          }
+        };
+      },
+      decode() {
+        return {
+          title: input.title,
+          description: input.description,
+          ...input.policies?.length && { policies: input.policies }
+        };
+      }
+    }
+  };
+}
+function policy(input) {
+  return {
+    name: "policy",
+    data: {
+      rule: input.rule,
+      ...input.before && { before: input.before },
+      ...input.reason && { reason: input.reason },
+      ...input.policies?.length && { policies: input.policies }
+    },
+    codec: {
+      encode() {
+        return {
+          type: "policy",
+          rule: input.rule,
+          ...input.before && { before: input.before },
+          ...input.reason && { reason: input.reason },
+          ...input.policies?.length && {
+            policies: input.policies.map((item) => encodeSerializedValue(item))
+          }
+        };
+      },
+      decode() {
+        return {
+          rule: input.rule,
+          ...input.before && { before: input.before },
+          ...input.reason && { reason: input.reason },
+          ...input.policies?.length && { policies: input.policies }
+        };
+      }
+    }
+  };
+}
+
+// packages/context/src/lib/fragments/user.ts
+function identity(input) {
+  return {
+    name: "identity",
+    data: {
+      ...input.name && { name: input.name },
+      ...input.role && { role: input.role }
+    },
+    codec: {
+      encode() {
+        return {
+          type: "identity",
+          ...input.name && { name: input.name },
+          ...input.role && { role: input.role }
+        };
+      },
+      decode() {
+        return {
+          ...input.name && { name: input.name },
+          ...input.role && { role: input.role }
+        };
+      }
+    }
+  };
+}
+function persona(input) {
+  return {
+    name: "persona",
+    data: {
+      name: input.name,
+      ...input.role && { role: input.role },
+      ...input.objective && { objective: input.objective },
+      ...input.tone && { tone: input.tone }
+    },
+    codec: {
+      encode() {
+        return {
+          type: "persona",
+          name: input.name,
+          ...input.role && { role: input.role },
+          ...input.objective && { objective: input.objective },
+          ...input.tone && { tone: input.tone }
+        };
+      },
+      decode() {
+        return {
+          name: input.name,
+          ...input.role && { role: input.role },
+          ...input.objective && { objective: input.objective },
+          ...input.tone && { tone: input.tone }
+        };
+      }
+    }
+  };
+}
+function alias(term2, meaning) {
+  return {
+    name: "alias",
+    data: { term: term2, meaning },
+    codec: {
+      encode() {
+        return { type: "alias", term: term2, meaning };
+      },
+      decode() {
+        return { term: term2, meaning };
+      }
+    }
+  };
+}
+function preference(aspect, value) {
+  return {
+    name: "preference",
+    data: { aspect, value },
+    codec: {
+      encode() {
+        return { type: "preference", aspect, value };
+      },
+      decode() {
+        return { aspect, value };
+      }
+    }
+  };
+}
+function correction(subject, clarification2) {
+  return {
+    name: "correction",
+    data: { subject, clarification: clarification2 },
+    codec: {
+      encode() {
+        return { type: "correction", subject, clarification: clarification2 };
+      },
+      decode() {
+        return { subject, clarification: clarification2 };
+      }
+    }
+  };
+}
+
+// packages/context/src/lib/codec/serialized-fragments.ts
+function isSerializedFragmentLike(value) {
+  return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
+function toFragmentData(value, options) {
+  if (isSerializedFragmentLike(value)) {
+    return toFragment(value, options);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => toFragmentData(item, options));
+  }
+  if (isFragmentObject(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [
+        key,
+        toFragmentData(entry, options)
+      ])
+    );
+  }
+  return value;
+}
+var builtInSerializedRegistry = {
+  term: {
+    toFragment: (input) => term(input.name, input.definition)
+  },
+  hint: {
+    toFragment: (input) => hint(input.text)
+  },
+  guardrail: {
+    toFragment: (input) => guardrail({
+      rule: input.rule,
+      reason: input.reason,
+      action: input.action
+    })
+  },
+  explain: {
+    toFragment: (input) => explain({
+      concept: input.concept,
+      explanation: input.explanation,
+      therefore: input.therefore
+    })
+  },
+  example: {
+    toFragment: (input) => example({
+      question: input.question,
+      answer: input.answer,
+      note: input.note
+    })
+  },
+  clarification: {
+    toFragment: (input) => clarification({
+      when: input.when,
+      ask: input.ask,
+      reason: input.reason
+    })
+  },
+  workflow: {
+    toFragment: (input) => workflow({
+      task: input.task,
+      steps: input.steps,
+      triggers: input.triggers,
+      notes: input.notes
+    })
+  },
+  quirk: {
+    toFragment: (input) => quirk({
+      issue: input.issue,
+      workaround: input.workaround
+    })
+  },
+  styleGuide: {
+    toFragment: (input) => styleGuide({
+      prefer: input.prefer,
+      never: input.never,
+      always: input.always
+    })
+  },
+  analogy: {
+    toFragment: (input) => analogy({
+      concepts: input.concepts,
+      relationship: input.relationship,
+      insight: input.insight,
+      therefore: input.therefore,
+      pitfall: input.pitfall
+    })
+  },
+  glossary: {
+    toFragment: (input) => glossary(input.entries)
+  },
+  role: {
+    toFragment: (input) => role(input.content)
+  },
+  principle: {
+    toFragment: (input, options) => principle({
+      title: input.title,
+      description: input.description,
+      policies: input.policies?.map((item) => toFragmentData(item, options))
+    })
+  },
+  policy: {
+    toFragment: (input, options) => policy({
+      rule: input.rule,
+      before: input.before,
+      reason: input.reason,
+      policies: input.policies?.map((item) => toFragmentData(item, options))
+    })
+  },
+  identity: {
+    toFragment: (input) => identity({
+      name: input.name,
+      role: input.role
+    })
+  },
+  persona: {
+    toFragment: (input) => persona({
+      name: input.name,
+      role: input.role,
+      objective: input.objective,
+      tone: input.tone
+    })
+  },
+  alias: {
+    toFragment: (input) => alias(input.term, input.meaning)
+  },
+  preference: {
+    toFragment: (input) => preference(input.aspect, input.value)
+  },
+  correction: {
+    toFragment: (input) => correction(input.subject, input.clarification)
+  }
+};
+var messageLikeTypes = /* @__PURE__ */ new Set(["user", "assistant", "message"]);
+function findCustomSerializedFragment(fragment2, options) {
+  if (!options?.registry) {
+    return void 0;
+  }
+  for (const entry of Object.values(options.registry)) {
+    const serialized = entry.fromFragment?.(fragment2, options);
+    if (serialized !== void 0) {
+      return serialized;
     }
-  };
+  }
+  return void 0;
 }
-function glossary(entries) {
-  return {
-    name: "glossary",
-    data: Object.entries(entries).map(([term2, expression]) => ({
-      term: term2,
-      expression
-    }))
-  };
+function toFragment(input, options) {
+  if (messageLikeTypes.has(input.type)) {
+    throw new Error(
+      "Message fragments are not supported by serialized fragment conversion"
+    );
+  }
+  const entry = options?.registry?.[input.type] ?? builtInSerializedRegistry[input.type];
+  if (!entry) {
+    throw new Error(`Unsupported serialized fragment type: ${input.type}`);
+  }
+  return entry.toFragment(input, options);
 }
-function role(content) {
-  return {
-    name: "role",
-    data: content
-  };
+function fromFragment(fragment2, options) {
+  if (isMessageFragment(fragment2)) {
+    throw new Error(
+      "Message fragments are not supported by serialized fragment conversion"
+    );
+  }
+  const customSerialized = findCustomSerializedFragment(fragment2, options);
+  if (customSerialized !== void 0) {
+    return customSerialized;
+  }
+  if (fragment2.codec) {
+    const encoded = fragment2.codec.encode();
+    if (!isSerializedFragmentLike(encoded)) {
+      throw new Error(
+        `Fragment "${fragment2.name}" codec must encode to a serialized fragment object`
+      );
+    }
+    return encoded;
+  }
+  if (!builtInSerializedRegistry[fragment2.name]) {
+    throw new Error(`Unsupported fragment name: ${fragment2.name}`);
+  }
+  throw new Error(`Fragment "${fragment2.name}" is missing codec`);
 }
-function principle(input) {
-  return {
-    name: "principle",
-    data: {
-      title: input.title,
-      description: input.description,
-      ...input.policies?.length && { policies: input.policies }
+
+// packages/context/src/lib/estimate.ts
+import { encode } from "gpt-tokenizer";
+var defaultTokenizer = {
+  encode(text) {
+    return encode(text);
+  },
+  count(text) {
+    return encode(text).length;
+  }
+};
+var ModelsRegistry = class {
+  #cache = /* @__PURE__ */ new Map();
+  #loaded = false;
+  #tokenizers = /* @__PURE__ */ new Map();
+  #defaultTokenizer = defaultTokenizer;
+  /**
+   * Load models data from models.dev API
+   */
+  async load() {
+    if (this.#loaded) return;
+    const response = await fetch("https://models.dev/api.json");
+    if (!response.ok) {
+      throw new Error(`Failed to fetch models: ${response.statusText}`);
     }
-  };
+    const data = await response.json();
+    for (const [providerId, provider] of Object.entries(data)) {
+      for (const [modelId, model] of Object.entries(provider.models)) {
+        const info = {
+          id: model.id,
+          name: model.name,
+          family: model.family,
+          cost: model.cost,
+          limit: model.limit,
+          provider: providerId
+        };
+        this.#cache.set(`${providerId}:${modelId}`, info);
+      }
+    }
+    this.#loaded = true;
+  }
+  /**
+   * Get model info by ID
+   * @param modelId - Model ID (e.g., "openai:gpt-4o")
+   */
+  get(modelId) {
+    return this.#cache.get(modelId);
+  }
+  /**
+   * Check if a model exists in the registry
+   */
+  has(modelId) {
+    return this.#cache.has(modelId);
+  }
+  /**
+   * List all available model IDs
+   */
+  list() {
+    return [...this.#cache.keys()];
+  }
+  /**
+   * Register a custom tokenizer for specific model families
+   * @param family - Model family name (e.g., "llama", "claude")
+   * @param tokenizer - Tokenizer implementation
+   */
+  registerTokenizer(family, tokenizer) {
+    this.#tokenizers.set(family, tokenizer);
+  }
+  /**
+   * Set the default tokenizer used when no family-specific tokenizer is registered
+   */
+  setDefaultTokenizer(tokenizer) {
+    this.#defaultTokenizer = tokenizer;
+  }
+  /**
+   * Get the appropriate tokenizer for a model
+   */
+  getTokenizer(modelId) {
+    const model = this.get(modelId);
+    if (model) {
+      const familyTokenizer = this.#tokenizers.get(model.family);
+      if (familyTokenizer) {
+        return familyTokenizer;
+      }
+    }
+    return this.#defaultTokenizer;
+  }
+  /**
+   * Estimate token count and cost for given text and model
+   * @param modelId - Model ID to use for pricing (e.g., "openai:gpt-4o")
+   * @param input - Input text (prompt)
+   */
+  estimate(modelId, input) {
+    const model = this.get(modelId);
+    if (!model) {
+      throw new Error(
+        `Model "${modelId}" not found. Call load() first or check model ID.`
+      );
+    }
+    const tokenizer = this.getTokenizer(modelId);
+    const tokens = tokenizer.count(input);
+    const cost = tokens / 1e6 * model.cost.input;
+    return {
+      model: model.id,
+      provider: model.provider,
+      tokens,
+      cost,
+      limits: {
+        context: model.limit.context,
+        output: model.limit.output,
+        exceedsContext: tokens > model.limit.context
+      },
+      fragments: []
+    };
+  }
+};
+var _registry = null;
+function getModelsRegistry() {
+  if (!_registry) {
+    _registry = new ModelsRegistry();
+  }
+  return _registry;
 }
-function policy(input) {
+async function estimate(modelId, renderer, ...fragments) {
+  const registry = getModelsRegistry();
+  await registry.load();
+  const input = renderer.render(fragments);
+  const model = registry.get(modelId);
+  if (!model) {
+    throw new Error(
+      `Model "${modelId}" not found. Call load() first or check model ID.`
+    );
+  }
+  const tokenizer = registry.getTokenizer(modelId);
+  const totalTokens = tokenizer.count(input);
+  const totalCost = totalTokens / 1e6 * model.cost.input;
+  const fragmentEstimates = fragments.map((fragment2) => {
+    const rendered = renderer.render([fragment2]);
+    const tokens = tokenizer.count(rendered);
+    const cost = tokens / 1e6 * model.cost.input;
+    return {
+      id: fragment2.id,
+      name: fragment2.name,
+      tokens,
+      cost
+    };
+  });
   return {
-    name: "policy",
-    data: {
-      rule: input.rule,
-      ...input.before && { before: input.before },
-      ...input.reason && { reason: input.reason },
-      ...input.policies?.length && { policies: input.policies }
-    }
+    model: model.id,
+    provider: model.provider,
+    tokens: totalTokens,
+    cost: totalCost,
+    limits: {
+      context: model.limit.context,
+      output: model.limit.output,
+      exceedsContext: totalTokens > model.limit.context
+    },
+    fragments: fragmentEstimates
   };
 }
 
@@ -507,26 +1035,51 @@ function applyPartReminder(message2, value) {
     mode: "part"
   };
 }
+function hasSchedule(reminder2) {
+  return reminder2.everyNTurns !== void 0 || reminder2.once !== void 0 || reminder2.firstN !== void 0 || reminder2.afterTurn !== void 0 || reminder2.when !== void 0;
+}
+function shouldIncludeReminder(reminder2, turn) {
+  if (reminder2.once && turn !== 1) return false;
+  if (reminder2.firstN !== void 0 && turn > reminder2.firstN) return false;
+  if (reminder2.afterTurn !== void 0 && turn <= reminder2.afterTurn)
+    return false;
+  if (reminder2.everyNTurns !== void 0 && turn % reminder2.everyNTurns !== 0)
+    return false;
+  if (reminder2.when && !reminder2.when(turn)) return false;
+  return true;
+}
 function reminder(text, options) {
   if (typeof text === "string") {
     assertReminderText(text);
   }
   return {
     text,
-    asPart: options?.asPart ?? false
+    asPart: options?.asPart ?? false,
+    ...options?.everyNTurns !== void 0 && {
+      everyNTurns: options.everyNTurns
+    },
+    ...options?.once !== void 0 && { once: options.once },
+    ...options?.firstN !== void 0 && { firstN: options.firstN },
+    ...options?.afterTurn !== void 0 && { afterTurn: options.afterTurn },
+    ...options?.when !== void 0 && { when: options.when }
   };
 }
+function resolveReminderText(item, ctx) {
+  return typeof item.text === "function" ? item.text(ctx) : item.text;
+}
 function user(content, ...reminders) {
   const message2 = typeof content === "string" ? {
     id: generateId2(),
     role: "user",
     parts: [{ type: "text", text: content }]
   } : { ...content, role: "user", parts: [...content.parts] };
-  if (reminders.length > 0) {
+  const immediateReminders = reminders.filter((r) => !hasSchedule(r));
+  const scheduledReminders = reminders.filter((r) => hasSchedule(r));
+  if (immediateReminders.length > 0) {
     const addedReminders = [];
     const plainText = extractPlainText(message2);
-    for (const item of reminders) {
-      const resolvedText = typeof item.text === "function" ? item.text(plainText) : item.text;
+    for (const item of immediateReminders) {
+      const resolvedText = resolveReminderText(item, { content: plainText });
       if (resolvedText.trim().length === 0) {
         continue;
       }
@@ -541,10 +1094,10 @@ function user(content, ...reminders) {
       message2.metadata = metadata;
     }
   }
+  const fragmentMetadata = scheduledReminders.length > 0 ? { scheduledReminders } : void 0;
   return {
     id: message2.id,
     name: "user",
-    data: "content",
     type: "message",
     persist: true,
     codec: {
@@ -554,53 +1107,8 @@ function user(content, ...reminders) {
       encode() {
         return message2;
       }
-    }
-  };
-}
-
-// packages/context/src/lib/fragments/user.ts
-function identity(input) {
-  return {
-    name: "identity",
-    data: {
-      ...input.name && { name: input.name },
-      ...input.role && { role: input.role }
-    }
-  };
-}
-function persona(input) {
-  return {
-    name: "persona",
-    data: {
-      name: input.name,
-      ...input.role && { role: input.role },
-      ...input.objective && { objective: input.objective },
-      ...input.tone && { tone: input.tone }
-    }
-  };
-}
-function alias(term2, meaning) {
-  return {
-    name: "alias",
-    data: { term: term2, meaning }
-  };
-}
-function preference(aspect, value) {
-  return {
-    name: "preference",
-    data: { aspect, value }
-  };
-}
-function userContext(description) {
-  return {
-    name: "userContext",
-    data: description
-  };
-}
-function correction(subject, clarification2) {
-  return {
-    name: "correction",
-    data: { subject, clarification: clarification2 }
+    },
+    metadata: fragmentMetadata
   };
 }
 
@@ -668,7 +1176,7 @@ var ContextRenderer = class {
     return sanitized;
   }
   sanitizeFragment(fragment2, seen) {
-    const data = this.sanitizeData(fragment2.data, seen);
+    const data = this.sanitizeData(getFragmentData(fragment2), seen);
     if (data == null) {
       return null;
     }
@@ -745,12 +1253,13 @@ var XmlRenderer = class extends ContextRenderer {
     return sanitized.map((f) => this.#renderTopLevel(f)).filter(Boolean).join("\n");
   }
   #renderTopLevel(fragment2) {
-    if (this.isPrimitive(fragment2.data)) {
-      return this.#leafRoot(fragment2.name, String(fragment2.data));
+    const data = getFragmentData(fragment2);
+    if (this.isPrimitive(data)) {
+      return this.#leafRoot(fragment2.name, String(data));
     }
-    if (Array.isArray(fragment2.data)) {
-      if (fragment2.data.length === 1) {
-        const single = fragment2.data[0];
+    if (Array.isArray(data)) {
+      if (data.length === 1) {
+        const single = data[0];
         if (this.isPrimitive(single)) {
           return this.#leafRoot(fragment2.name, String(single));
         }
@@ -768,19 +1277,15 @@ var XmlRenderer = class extends ContextRenderer {
           );
         }
       }
-      return this.#renderArray(fragment2.name, fragment2.data, 0);
+      return this.#renderArray(fragment2.name, data, 0);
     }
-    if (isFragment(fragment2.data)) {
-      return this.#renderFragmentContentsUnderParent(
-        fragment2.name,
-        fragment2.data,
-        0
-      );
+    if (isFragment(data)) {
+      return this.#renderFragmentContentsUnderParent(fragment2.name, data, 0);
     }
-    if (isFragmentObject(fragment2.data)) {
+    if (isFragmentObject(data)) {
       return this.#wrap(
         fragment2.name,
-        this.renderEntries(fragment2.data, { depth: 1, path: [] })
+        this.renderEntries(data, { depth: 1, path: [] })
       );
     }
     return "";
@@ -912,23 +1417,23 @@ ${this.#indent(safe, 2)}
     return `<${tag}>${safe}</${tag}>`;
   }
   renderFragment(fragment2, ctx) {
-    const { name, data } = fragment2;
+    const data = getFragmentData(fragment2);
     if (this.isPrimitive(data)) {
-      return this.#leaf(name, String(data), ctx.depth);
+      return this.#leaf(fragment2.name, String(data), ctx.depth);
     }
     if (isFragment(data)) {
       const child = this.renderFragment(data, { ...ctx, depth: ctx.depth + 1 });
-      return this.#wrapIndented(name, [child], ctx.depth);
+      return this.#wrapIndented(fragment2.name, [child], ctx.depth);
     }
     if (Array.isArray(data)) {
-      return this.#renderArrayIndented(name, data, ctx.depth);
+      return this.#renderArrayIndented(fragment2.name, data, ctx.depth);
     }
     if (isFragmentObject(data)) {
       const children = this.renderEntries(data, {
         ...ctx,
         depth: ctx.depth + 1
       });
-      return this.#wrapIndented(name, children, ctx.depth);
+      return this.#wrapIndented(fragment2.name, children, ctx.depth);
     }
     return "";
   }
@@ -1045,21 +1550,22 @@ var MarkdownRenderer = class extends ContextRenderer {
   render(fragments) {
     return this.sanitizeFragments(fragments).map((f) => {
       const title = `## ${titlecase(f.name)}`;
-      if (this.isPrimitive(f.data)) {
+      const data = getFragmentData(f);
+      if (this.isPrimitive(data)) {
         return `${title}
-${String(f.data)}`;
+${String(data)}`;
       }
-      if (Array.isArray(f.data)) {
+      if (Array.isArray(data)) {
         return `${title}
-${this.#renderArray(f.data, 0)}`;
+${this.#renderArray(data, 0)}`;
       }
-      if (isFragment(f.data)) {
+      if (isFragment(data)) {
         return `${title}
-${this.renderFragment(f.data, { depth: 0, path: [] })}`;
+${this.renderFragment(data, { depth: 0, path: [] })}`;
       }
-      if (isFragmentObject(f.data)) {
+      if (isFragmentObject(data)) {
         return `${title}
-${this.renderEntries(f.data, { depth: 0, path: [] }).join("\n")}`;
+${this.renderEntries(data, { depth: 0, path: [] }).join("\n")}`;
       }
       return `${title}
 `;
@@ -1109,10 +1615,10 @@ ${this.renderEntries(f.data, { depth: 0, path: [] }).join("\n")}`;
     return `${this.#pad(depth)}- ${String(item)}`;
   }
   renderFragment(fragment2, ctx) {
-    const { name, data } = fragment2;
-    const header = `${this.#pad(ctx.depth)}- **${name}**:`;
+    const data = getFragmentData(fragment2);
+    const header = `${this.#pad(ctx.depth)}- **${fragment2.name}**:`;
     if (this.isPrimitive(data)) {
-      return `${this.#pad(ctx.depth)}- **${name}**: ${String(data)}`;
+      return `${this.#pad(ctx.depth)}- **${fragment2.name}**: ${String(data)}`;
     }
     if (isFragment(data)) {
       const child = this.renderFragment(data, { ...ctx, depth: ctx.depth + 1 });
@@ -1151,21 +1657,22 @@ ${this.renderEntries(f.data, { depth: 0, path: [] }).join("\n")}`;
 var TomlRenderer = class extends ContextRenderer {
   render(fragments) {
     const rendered = [];
-    for (const f of this.sanitizeFragments(fragments)) {
-      if (this.isPrimitive(f.data)) {
-        rendered.push(`${f.name} = ${this.#formatValue(f.data)}`);
-      } else if (Array.isArray(f.data)) {
-        rendered.push(this.#renderTopLevelArray(f.name, f.data));
-      } else if (isFragment(f.data)) {
+    for (const it of this.sanitizeFragments(fragments)) {
+      const data = getFragmentData(it);
+      if (this.isPrimitive(data)) {
+        rendered.push(`${it.name} = ${this.#formatValue(data)}`);
+      } else if (Array.isArray(data)) {
+        rendered.push(this.#renderTopLevelArray(it.name, data));
+      } else if (isFragment(data)) {
         rendered.push(
           [
-            `[${f.name}]`,
-            this.renderFragment(f.data, { depth: 0, path: [f.name] })
+            `[${it.name}]`,
+            this.renderFragment(data, { depth: 0, path: [it.name] })
           ].join("\n")
         );
-      } else if (isFragmentObject(f.data)) {
-        const entries = this.#renderObjectEntries(f.data, [f.name]);
-        rendered.push([`[${f.name}]`, ...entries].join("\n"));
+      } else if (isFragmentObject(data)) {
+        const entries = this.#renderObjectEntries(data, [it.name]);
+        rendered.push([`[${it.name}]`, ...entries].join("\n"));
       }
     }
     return rendered.join("\n\n");
@@ -1235,10 +1742,10 @@ var TomlRenderer = class extends ContextRenderer {
     }).filter(Boolean);
   }
   renderFragment(fragment2, ctx) {
-    const { name, data } = fragment2;
-    const newPath = [...ctx.path, name];
+    const data = getFragmentData(fragment2);
+    const newPath = [...ctx.path, fragment2.name];
     if (this.isPrimitive(data)) {
-      return `${name} = ${this.#formatValue(data)}`;
+      return `${fragment2.name} = ${this.#formatValue(data)}`;
     }
     if (isFragment(data)) {
       return [
@@ -1260,7 +1767,7 @@ var TomlRenderer = class extends ContextRenderer {
         return parts.join("\n");
       }
       const values = nonFragmentItems.map((item) => this.#formatValue(item));
-      return `${name} = [${values.join(", ")}]`;
+      return `${fragment2.name} = [${values.join(", ")}]`;
     }
     if (isFragmentObject(data)) {
       const entries = this.#renderObjectEntries(data, newPath);
@@ -1290,27 +1797,27 @@ var ToonRenderer = class extends ContextRenderer {
     return sanitized.map((f) => this.#renderTopLevel(f)).filter(Boolean).join("\n");
   }
   #renderTopLevel(fragment2) {
-    const { name, data } = fragment2;
+    const data = getFragmentData(fragment2);
     if (this.isPrimitive(data)) {
-      return `${name}: ${this.#formatValue(data)}`;
+      return `${fragment2.name}: ${this.#formatValue(data)}`;
     }
     if (Array.isArray(data)) {
-      return this.#renderArrayField(name, data, 0);
+      return this.#renderArrayField(fragment2.name, data, 0);
     }
     if (isFragment(data)) {
       const child = this.renderFragment(data, { depth: 1, path: [] });
-      return `${name}:
+      return `${fragment2.name}:
 ${child}`;
     }
     if (isFragmentObject(data)) {
       const entries = this.#renderObjectEntries(data, 1);
       if (!entries) {
-        return `${name}:`;
+        return `${fragment2.name}:`;
       }
-      return `${name}:
+      return `${fragment2.name}:
 ${entries}`;
     }
-    return `${name}:`;
+    return `${fragment2.name}:`;
   }
   #renderArrayField(key, items, depth) {
     const filtered = items.filter((item) => item != null);
@@ -1385,8 +1892,9 @@ ${entries}`;
         depth: depth + 1,
         path: []
       });
-      if (this.isPrimitive(item.data)) {
-        return `${this.#pad(depth)}- ${item.name}: ${this.#formatValue(item.data)}`;
+      const itemData = getFragmentData(item);
+      if (this.isPrimitive(itemData)) {
+        return `${this.#pad(depth)}- ${item.name}: ${this.#formatValue(itemData)}`;
       }
       return `${this.#pad(depth)}- ${item.name}:
 ${rendered.split("\n").slice(1).join("\n")}`;
@@ -1429,30 +1937,30 @@ ${nested}`);
     return lines.join("\n");
   }
   renderFragment(fragment2, ctx) {
-    const { name, data } = fragment2;
+    const data = getFragmentData(fragment2);
     if (this.isPrimitive(data)) {
-      return `${this.#pad(ctx.depth)}${name}: ${this.#formatValue(data)}`;
+      return `${this.#pad(ctx.depth)}${fragment2.name}: ${this.#formatValue(data)}`;
     }
     if (isFragment(data)) {
       const child = this.renderFragment(data, {
         ...ctx,
         depth: ctx.depth + 1
       });
-      return `${this.#pad(ctx.depth)}${name}:
+      return `${this.#pad(ctx.depth)}${fragment2.name}:
 ${child}`;
     }
     if (Array.isArray(data)) {
-      return this.#renderArrayField(name, data, ctx.depth);
+      return this.#renderArrayField(fragment2.name, data, ctx.depth);
     }
     if (isFragmentObject(data)) {
       const entries = this.#renderObjectEntries(data, ctx.depth + 1);
       if (!entries) {
-        return `${this.#pad(ctx.depth)}${name}:`;
+        return `${this.#pad(ctx.depth)}${fragment2.name}:`;
       }
-      return `${this.#pad(ctx.depth)}${name}:
+      return `${this.#pad(ctx.depth)}${fragment2.name}:
 ${entries}`;
     }
-    return `${this.#pad(ctx.depth)}${name}:`;
+    return `${this.#pad(ctx.depth)}${fragment2.name}:`;
   }
   renderPrimitive(key, value, ctx) {
     return `${this.#pad(ctx.depth)}${key}: ${this.#formatValue(value)}`;
@@ -1668,6 +2176,8 @@ export {
   XmlRenderer,
   alias,
   analogy,
+  applyInlineReminder,
+  applyPartReminder,
   assistant,
   assistantText,
   clarification,
@@ -1678,10 +2188,13 @@ export {
   explain,
   fail,
   fragment,
+  fromFragment,
+  getFragmentData,
   getModelsRegistry,
   getReminderRanges,
   glossary,
   guardrail,
+  hasSchedule,
   hint,
   identity,
   isFragment,
@@ -1699,16 +2212,18 @@ export {
   quirk,
   reminder,
   render,
+  resolveReminderText,
   role,
   runGuardrailChain,
+  shouldIncludeReminder,
   soul,
   stop,
   stripReminders,
   stripTextByRanges,
   styleGuide,
   term,
+  toFragment,
   user,
-  userContext,
   visualizeGraph,
   workflow
 };