@deepagents/context 0.6.0 → 0.8.0

package/dist/index.js

@@ -0,0 +1,1766 @@
+// packages/context/src/lib/context.ts
+function isFragment(data) {
+  return typeof data === "object" && data !== null && "name" in data && "data" in data && typeof data.name === "string";
+}
+function isFragmentObject(data) {
+  return typeof data === "object" && data !== null && !Array.isArray(data) && !isFragment(data);
+}
+function isMessageFragment(fragment2) {
+  return fragment2.type === "message";
+}
+
+// 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
+      }
+    };
+  }
+};
+var _registry = null;
+function getModelsRegistry() {
+  if (!_registry) {
+    _registry = new ModelsRegistry();
+  }
+  return _registry;
+}
+
+// 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;
+  }
+  /**
+   * Template method - dispatches value to appropriate handler.
+   */
+  renderValue(key, value, ctx) {
+    if (value == null) {
+      return "";
+    }
+    if (isFragment(value)) {
+      return this.renderFragment(value, ctx);
+    }
+    if (Array.isArray(value)) {
+      return this.renderArray(key, value, ctx);
+    }
+    if (isFragmentObject(value)) {
+      return this.renderObject(key, value, ctx);
+    }
+    return this.renderPrimitive(key, String(value), ctx);
+  }
+  /**
+   * Render all entries of an object.
+   */
+  renderEntries(data, ctx) {
+    return Object.entries(data).map(([key, value]) => this.renderValue(key, value, ctx)).filter(Boolean);
+  }
+};
+var XmlRenderer = class extends ContextRenderer {
+  render(fragments) {
+    return fragments.map((f) => this.#renderTopLevel(f)).filter(Boolean).join("\n");
+  }
+  #renderTopLevel(fragment2) {
+    if (this.isPrimitive(fragment2.data)) {
+      return this.#leafRoot(fragment2.name, String(fragment2.data));
+    }
+    if (Array.isArray(fragment2.data)) {
+      return this.#renderArray(fragment2.name, fragment2.data, 0);
+    }
+    if (isFragment(fragment2.data)) {
+      const child = this.renderFragment(fragment2.data, { depth: 1, path: [] });
+      return this.#wrap(fragment2.name, [child]);
+    }
+    return this.#wrap(
+      fragment2.name,
+      this.renderEntries(fragment2.data, { depth: 1, path: [] })
+    );
+  }
+  #renderArray(name, items, depth) {
+    const fragmentItems = items.filter(isFragment);
+    const nonFragmentItems = items.filter((item) => !isFragment(item));
+    const children = [];
+    for (const item of nonFragmentItems) {
+      if (item != null) {
+        children.push(
+          this.#leaf(pluralize.singular(name), String(item), depth + 1)
+        );
+      }
+    }
+    if (this.options.groupFragments && fragmentItems.length > 0) {
+      const groups = this.groupByName(fragmentItems);
+      for (const [groupName, groupFragments] of groups) {
+        const groupChildren = groupFragments.map(
+          (frag) => this.renderFragment(frag, { depth: depth + 2, path: [] })
+        );
+        const pluralName = pluralize.plural(groupName);
+        children.push(this.#wrapIndented(pluralName, groupChildren, depth + 1));
+      }
+    } else {
+      for (const frag of fragmentItems) {
+        children.push(
+          this.renderFragment(frag, { depth: depth + 1, path: [] })
+        );
+      }
+    }
+    return this.#wrap(name, children);
+  }
+  #leafRoot(tag, value) {
+    const safe = this.#escape(value);
+    if (safe.includes("\n")) {
+      return `<${tag}>
+${this.#indent(safe, 2)}
+</${tag}>`;
+    }
+    return `<${tag}>${safe}</${tag}>`;
+  }
+  renderFragment(fragment2, ctx) {
+    const { name, data } = fragment2;
+    if (this.isPrimitive(data)) {
+      return this.#leaf(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);
+    }
+    if (Array.isArray(data)) {
+      return this.#renderArrayIndented(name, data, ctx.depth);
+    }
+    const children = this.renderEntries(data, { ...ctx, depth: ctx.depth + 1 });
+    return this.#wrapIndented(name, children, ctx.depth);
+  }
+  #renderArrayIndented(name, items, depth) {
+    const fragmentItems = items.filter(isFragment);
+    const nonFragmentItems = items.filter((item) => !isFragment(item));
+    const children = [];
+    for (const item of nonFragmentItems) {
+      if (item != null) {
+        children.push(
+          this.#leaf(pluralize.singular(name), String(item), depth + 1)
+        );
+      }
+    }
+    if (this.options.groupFragments && fragmentItems.length > 0) {
+      const groups = this.groupByName(fragmentItems);
+      for (const [groupName, groupFragments] of groups) {
+        const groupChildren = groupFragments.map(
+          (frag) => this.renderFragment(frag, { depth: depth + 2, path: [] })
+        );
+        const pluralName = pluralize.plural(groupName);
+        children.push(this.#wrapIndented(pluralName, groupChildren, depth + 1));
+      }
+    } else {
+      for (const frag of fragmentItems) {
+        children.push(
+          this.renderFragment(frag, { depth: depth + 1, path: [] })
+        );
+      }
+    }
+    return this.#wrapIndented(name, children, depth);
+  }
+  renderPrimitive(key, value, ctx) {
+    return this.#leaf(key, value, ctx.depth);
+  }
+  renderArray(key, items, ctx) {
+    if (!items.length) {
+      return "";
+    }
+    const itemTag = pluralize.singular(key);
+    const children = items.filter((item) => item != null).map((item) => this.#leaf(itemTag, String(item), ctx.depth + 1));
+    return this.#wrapIndented(key, children, ctx.depth);
+  }
+  renderObject(key, obj, ctx) {
+    const children = this.renderEntries(obj, { ...ctx, depth: ctx.depth + 1 });
+    return this.#wrapIndented(key, children, ctx.depth);
+  }
+  #escape(value) {
+    if (value == null) {
+      return "";
+    }
+    return value.replaceAll(/&/g, "&amp;").replaceAll(/</g, "&lt;").replaceAll(/>/g, "&gt;").replaceAll(/"/g, "&quot;").replaceAll(/'/g, "&apos;");
+  }
+  #indent(text, spaces) {
+    if (!text.trim()) {
+      return "";
+    }
+    const padding = " ".repeat(spaces);
+    return text.split("\n").map((line) => line.length ? padding + line : padding).join("\n");
+  }
+  #leaf(tag, value, depth) {
+    const safe = this.#escape(value);
+    const pad = "  ".repeat(depth);
+    if (safe.includes("\n")) {
+      return `${pad}<${tag}>
+${this.#indent(safe, (depth + 1) * 2)}
+${pad}</${tag}>`;
+    }
+    return `${pad}<${tag}>${safe}</${tag}>`;
+  }
+  #wrap(tag, children) {
+    const content = children.filter(Boolean).join("\n");
+    if (!content) {
+      return "";
+    }
+    return `<${tag}>
+${content}
+</${tag}>`;
+  }
+  #wrapIndented(tag, children, depth) {
+    const content = children.filter(Boolean).join("\n");
+    if (!content) {
+      return "";
+    }
+    const pad = "  ".repeat(depth);
+    return `${pad}<${tag}>
+${content}
+${pad}</${tag}>`;
+  }
+};
+var MarkdownRenderer = class extends ContextRenderer {
+  render(fragments) {
+    return fragments.map((f) => {
+      const title = `## ${titlecase(f.name)}`;
+      if (this.isPrimitive(f.data)) {
+        return `${title}
+${String(f.data)}`;
+      }
+      if (Array.isArray(f.data)) {
+        return `${title}
+${this.#renderArray(f.data, 0)}`;
+      }
+      if (isFragment(f.data)) {
+        return `${title}
+${this.renderFragment(f.data, { depth: 0, path: [] })}`;
+      }
+      return `${title}
+${this.renderEntries(f.data, { depth: 0, path: [] }).join("\n")}`;
+    }).join("\n\n");
+  }
+  #renderArray(items, depth) {
+    const fragmentItems = items.filter(isFragment);
+    const nonFragmentItems = items.filter((item) => !isFragment(item));
+    const lines = [];
+    for (const item of nonFragmentItems) {
+      if (item != null) {
+        lines.push(`${this.#pad(depth)}- ${String(item)}`);
+      }
+    }
+    if (this.options.groupFragments && fragmentItems.length > 0) {
+      const groups = this.groupByName(fragmentItems);
+      for (const [groupName, groupFragments] of groups) {
+        const pluralName = pluralize.plural(groupName);
+        lines.push(`${this.#pad(depth)}- **${titlecase(pluralName)}**:`);
+        for (const frag of groupFragments) {
+          lines.push(this.renderFragment(frag, { depth: depth + 1, path: [] }));
+        }
+      }
+    } else {
+      for (const frag of fragmentItems) {
+        lines.push(this.renderFragment(frag, { depth, path: [] }));
+      }
+    }
+    return lines.join("\n");
+  }
+  #pad(depth) {
+    return "  ".repeat(depth);
+  }
+  #leaf(key, value, depth) {
+    return `${this.#pad(depth)}- **${key}**: ${value}`;
+  }
+  #arrayItem(item, depth) {
+    if (isFragment(item)) {
+      return this.renderFragment(item, { depth, path: [] });
+    }
+    if (isFragmentObject(item)) {
+      return this.renderEntries(item, {
+        depth,
+        path: []
+      }).join("\n");
+    }
+    return `${this.#pad(depth)}- ${String(item)}`;
+  }
+  renderFragment(fragment2, ctx) {
+    const { name, data } = fragment2;
+    const header = `${this.#pad(ctx.depth)}- **${name}**:`;
+    if (this.isPrimitive(data)) {
+      return `${this.#pad(ctx.depth)}- **${name}**: ${String(data)}`;
+    }
+    if (isFragment(data)) {
+      const child = this.renderFragment(data, { ...ctx, depth: ctx.depth + 1 });
+      return [header, child].join("\n");
+    }
+    if (Array.isArray(data)) {
+      const children2 = data.filter((item) => item != null).map((item) => this.#arrayItem(item, ctx.depth + 1));
+      return [header, ...children2].join("\n");
+    }
+    const children = this.renderEntries(data, {
+      ...ctx,
+      depth: ctx.depth + 1
+    }).join("\n");
+    return [header, children].join("\n");
+  }
+  renderPrimitive(key, value, ctx) {
+    return this.#leaf(key, value, ctx.depth);
+  }
+  renderArray(key, items, ctx) {
+    const header = `${this.#pad(ctx.depth)}- **${key}**:`;
+    const children = items.filter((item) => item != null).map((item) => this.#arrayItem(item, ctx.depth + 1));
+    return [header, ...children].join("\n");
+  }
+  renderObject(key, obj, ctx) {
+    const header = `${this.#pad(ctx.depth)}- **${key}**:`;
+    const children = this.renderEntries(obj, {
+      ...ctx,
+      depth: ctx.depth + 1
+    }).join("\n");
+    return [header, children].join("\n");
+  }
+};
+var TomlRenderer = class extends ContextRenderer {
+  render(fragments) {
+    return fragments.map((f) => {
+      if (this.isPrimitive(f.data)) {
+        return `${f.name} = ${this.#formatValue(f.data)}`;
+      }
+      if (Array.isArray(f.data)) {
+        return this.#renderTopLevelArray(f.name, f.data);
+      }
+      if (isFragment(f.data)) {
+        return [
+          `[${f.name}]`,
+          this.renderFragment(f.data, { depth: 0, path: [f.name] })
+        ].join("\n");
+      }
+      const entries = this.#renderObjectEntries(f.data, [f.name]);
+      return [`[${f.name}]`, ...entries].join("\n");
+    }).join("\n\n");
+  }
+  #renderTopLevelArray(name, items) {
+    const fragmentItems = items.filter(isFragment);
+    const nonFragmentItems = items.filter(
+      (item) => !isFragment(item) && item != null
+    );
+    if (fragmentItems.length > 0) {
+      const parts = [`[${name}]`];
+      for (const frag of fragmentItems) {
+        parts.push(this.renderFragment(frag, { depth: 0, path: [name] }));
+      }
+      return parts.join("\n");
+    }
+    const values = nonFragmentItems.map((item) => this.#formatValue(item));
+    return `${name} = [${values.join(", ")}]`;
+  }
+  /**
+   * Override renderValue to preserve type information for TOML formatting.
+   */
+  renderValue(key, value, ctx) {
+    if (value == null) {
+      return "";
+    }
+    if (isFragment(value)) {
+      return this.renderFragment(value, ctx);
+    }
+    if (Array.isArray(value)) {
+      return this.renderArray(key, value, ctx);
+    }
+    if (isFragmentObject(value)) {
+      return this.renderObject(key, value, ctx);
+    }
+    return `${key} = ${this.#formatValue(value)}`;
+  }
+  renderPrimitive(key, value, _ctx) {
+    return `${key} = ${this.#formatValue(value)}`;
+  }
+  renderArray(key, items, _ctx) {
+    const values = items.filter((item) => item != null).map((item) => this.#formatValue(item));
+    return `${key} = [${values.join(", ")}]`;
+  }
+  renderObject(key, obj, ctx) {
+    const newPath = [...ctx.path, key];
+    const entries = this.#renderObjectEntries(obj, newPath);
+    return ["", `[${newPath.join(".")}]`, ...entries].join("\n");
+  }
+  #renderObjectEntries(obj, path) {
+    return Object.entries(obj).map(([key, value]) => {
+      if (value == null) {
+        return "";
+      }
+      if (isFragmentObject(value)) {
+        const newPath = [...path, key];
+        const entries = this.#renderObjectEntries(value, newPath);
+        return ["", `[${newPath.join(".")}]`, ...entries].join("\n");
+      }
+      if (Array.isArray(value)) {
+        const values = value.filter((item) => item != null).map((item) => this.#formatValue(item));
+        return `${key} = [${values.join(", ")}]`;
+      }
+      return `${key} = ${this.#formatValue(value)}`;
+    }).filter(Boolean);
+  }
+  renderFragment(fragment2, ctx) {
+    const { name, data } = fragment2;
+    const newPath = [...ctx.path, name];
+    if (this.isPrimitive(data)) {
+      return `${name} = ${this.#formatValue(data)}`;
+    }
+    if (isFragment(data)) {
+      return [
+        "",
+        `[${newPath.join(".")}]`,
+        this.renderFragment(data, { ...ctx, path: newPath })
+      ].join("\n");
+    }
+    if (Array.isArray(data)) {
+      const fragmentItems = data.filter(isFragment);
+      const nonFragmentItems = data.filter(
+        (item) => !isFragment(item) && item != null
+      );
+      if (fragmentItems.length > 0) {
+        const parts = ["", `[${newPath.join(".")}]`];
+        for (const frag of fragmentItems) {
+          parts.push(this.renderFragment(frag, { ...ctx, path: newPath }));
+        }
+        return parts.join("\n");
+      }
+      const values = nonFragmentItems.map((item) => this.#formatValue(item));
+      return `${name} = [${values.join(", ")}]`;
+    }
+    const entries = this.#renderObjectEntries(data, newPath);
+    return ["", `[${newPath.join(".")}]`, ...entries].join("\n");
+  }
+  #escape(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  }
+  #formatValue(value) {
+    if (typeof value === "string") {
+      return `"${this.#escape(value)}"`;
+    }
+    if (typeof value === "boolean" || typeof value === "number") {
+      return String(value);
+    }
+    if (typeof value === "object" && value !== null) {
+      return JSON.stringify(value);
+    }
+    return `"${String(value)}"`;
+  }
+};
+var ToonRenderer = class extends ContextRenderer {
+  render(fragments) {
+    return fragments.map((f) => this.#renderTopLevel(f)).filter(Boolean).join("\n");
+  }
+  #renderTopLevel(fragment2) {
+    const { name, data } = fragment2;
+    if (this.isPrimitive(data)) {
+      return `${name}: ${this.#formatValue(data)}`;
+    }
+    if (Array.isArray(data)) {
+      return this.#renderArrayField(name, data, 0);
+    }
+    if (isFragment(data)) {
+      const child = this.renderFragment(data, { depth: 1, path: [] });
+      return `${name}:
+${child}`;
+    }
+    if (isFragmentObject(data)) {
+      const entries = this.#renderObjectEntries(data, 1);
+      if (!entries) {
+        return `${name}:`;
+      }
+      return `${name}:
+${entries}`;
+    }
+    return `${name}:`;
+  }
+  #renderArrayField(key, items, depth) {
+    const filtered = items.filter((item) => item != null);
+    if (filtered.length === 0) {
+      return `${this.#pad(depth)}${key}[0]:`;
+    }
+    const fragmentItems = filtered.filter(isFragment);
+    if (fragmentItems.length > 0) {
+      return this.#renderMixedArray(key, filtered, depth);
+    }
+    if (filtered.every((item) => this.#isPrimitiveValue(item))) {
+      return this.#renderPrimitiveArray(key, filtered, depth);
+    }
+    if (this.#isTabularArray(filtered)) {
+      return this.#renderTabularArray(key, filtered, depth);
+    }
+    return this.#renderMixedArray(key, filtered, depth);
+  }
+  #isPrimitiveValue(value) {
+    return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+  }
+  #isTabularArray(items) {
+    if (items.length === 0) return false;
+    const objects = items.filter(isFragmentObject);
+    if (objects.length !== items.length) return false;
+    const firstKeys = Object.keys(objects[0]).sort().join(",");
+    for (const obj of objects) {
+      if (Object.keys(obj).sort().join(",") !== firstKeys) {
+        return false;
+      }
+      for (const value of Object.values(obj)) {
+        if (!this.#isPrimitiveValue(value) && value !== null) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  #renderPrimitiveArray(key, items, depth) {
+    const values = items.map((item) => this.#formatValue(item)).join(",");
+    return `${this.#pad(depth)}${key}[${items.length}]: ${values}`;
+  }
+  #renderTabularArray(key, items, depth) {
+    if (items.length === 0) {
+      return `${this.#pad(depth)}${key}[0]:`;
+    }
+    const fields = Object.keys(items[0]);
+    const header = `${this.#pad(depth)}${key}[${items.length}]{${fields.join(",")}}:`;
+    const rows = items.map((obj) => {
+      const values = fields.map((f) => this.#formatValue(obj[f]));
+      return `${this.#pad(depth + 1)}${values.join(",")}`;
+    });
+    return [header, ...rows].join("\n");
+  }
+  #renderMixedArray(key, items, depth) {
+    const header = `${this.#pad(depth)}${key}[${items.length}]:`;
+    const lines = items.map((item) => this.#renderListItem(item, depth + 1));
+    return [header, ...lines].join("\n");
+  }
+  #renderListItem(item, depth) {
+    if (this.#isPrimitiveValue(item)) {
+      return `${this.#pad(depth)}- ${this.#formatValue(item)}`;
+    }
+    if (isFragment(item)) {
+      const rendered = this.renderFragment(item, {
+        depth: depth + 1,
+        path: []
+      });
+      if (this.isPrimitive(item.data)) {
+        return `${this.#pad(depth)}- ${item.name}: ${this.#formatValue(item.data)}`;
+      }
+      return `${this.#pad(depth)}- ${item.name}:
+${rendered.split("\n").slice(1).join("\n")}`;
+    }
+    if (Array.isArray(item)) {
+      const content = this.#renderArrayField("", item, depth + 1);
+      return `${this.#pad(depth)}-${content.trimStart()}`;
+    }
+    if (isFragmentObject(item)) {
+      const entries = this.#renderObjectEntries(item, depth + 1);
+      if (!entries) {
+        return `${this.#pad(depth)}-`;
+      }
+      const lines = entries.split("\n");
+      const first = lines[0].trimStart();
+      const rest = lines.slice(1).join("\n");
+      return rest ? `${this.#pad(depth)}- ${first}
+${rest}` : `${this.#pad(depth)}- ${first}`;
+    }
+    return `${this.#pad(depth)}- ${this.#formatValue(item)}`;
+  }
+  #renderObjectEntries(obj, depth) {
+    const lines = [];
+    for (const [key, value] of Object.entries(obj)) {
+      if (value == null) continue;
+      if (this.#isPrimitiveValue(value)) {
+        lines.push(`${this.#pad(depth)}${key}: ${this.#formatValue(value)}`);
+      } else if (Array.isArray(value)) {
+        lines.push(this.#renderArrayField(key, value, depth));
+      } else if (isFragmentObject(value)) {
+        const nested = this.#renderObjectEntries(value, depth + 1);
+        if (nested) {
+          lines.push(`${this.#pad(depth)}${key}:
+${nested}`);
+        } else {
+          lines.push(`${this.#pad(depth)}${key}:`);
+        }
+      }
+    }
+    return lines.join("\n");
+  }
+  renderFragment(fragment2, ctx) {
+    const { name, data } = fragment2;
+    if (this.isPrimitive(data)) {
+      return `${this.#pad(ctx.depth)}${name}: ${this.#formatValue(data)}`;
+    }
+    if (isFragment(data)) {
+      const child = this.renderFragment(data, {
+        ...ctx,
+        depth: ctx.depth + 1
+      });
+      return `${this.#pad(ctx.depth)}${name}:
+${child}`;
+    }
+    if (Array.isArray(data)) {
+      return this.#renderArrayField(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)}${name}:
+${entries}`;
+    }
+    return `${this.#pad(ctx.depth)}${name}:`;
+  }
+  renderPrimitive(key, value, ctx) {
+    return `${this.#pad(ctx.depth)}${key}: ${this.#formatValue(value)}`;
+  }
+  renderArray(key, items, ctx) {
+    return this.#renderArrayField(key, items, ctx.depth);
+  }
+  renderObject(key, obj, ctx) {
+    const entries = this.#renderObjectEntries(obj, ctx.depth + 1);
+    if (!entries) {
+      return `${this.#pad(ctx.depth)}${key}:`;
+    }
+    return `${this.#pad(ctx.depth)}${key}:
+${entries}`;
+  }
+  #pad(depth) {
+    return "  ".repeat(depth);
+  }
+  #needsQuoting(value) {
+    if (value === "") return true;
+    if (value !== value.trim()) return true;
+    if (["true", "false", "null"].includes(value.toLowerCase())) return true;
+    if (/^-?\d+(?:\.\d+)?(?:e[+-]?\d+)?$/i.test(value)) return true;
+    if (/[:\\"'[\]{}|,\t\n\r]/.test(value)) return true;
+    if (value.startsWith("-")) return true;
+    return false;
+  }
+  #escape(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+  }
+  #canonicalizeNumber(n) {
+    if (!Number.isFinite(n)) return "null";
+    if (Object.is(n, -0)) return "0";
+    return String(n);
+  }
+  #formatValue(value) {
+    if (value === null) return "null";
+    if (typeof value === "boolean") return String(value);
+    if (typeof value === "number") return this.#canonicalizeNumber(value);
+    if (typeof value === "string") {
+      if (this.#needsQuoting(value)) {
+        return `"${this.#escape(value)}"`;
+      }
+      return value;
+    }
+    return `"${this.#escape(JSON.stringify(value))}"`;
+  }
+};
+
+// packages/context/src/lib/store/store.ts
+var ContextStore = class {
+};
+
+// packages/context/src/lib/store/sqlite.store.ts
+import { DatabaseSync } from "node:sqlite";
+var STORE_DDL = `
+-- Chats table
+CREATE TABLE IF NOT EXISTS chats (
+  id TEXT PRIMARY KEY,
+  title TEXT,
+  metadata TEXT,
+  createdAt INTEGER NOT NULL,
+  updatedAt INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_chats_updatedAt ON chats(updatedAt);
+
+-- Messages table (nodes in the DAG)
+CREATE TABLE IF NOT EXISTS messages (
+  id TEXT PRIMARY KEY,
+  chatId TEXT NOT NULL,
+  parentId TEXT,
+  name TEXT NOT NULL,
+  type TEXT,
+  data TEXT NOT NULL,
+  persist INTEGER NOT NULL DEFAULT 1,
+  createdAt INTEGER NOT NULL,
+  FOREIGN KEY (chatId) REFERENCES chats(id) ON DELETE CASCADE,
+  FOREIGN KEY (parentId) REFERENCES messages(id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_messages_chatId ON messages(chatId);
+CREATE INDEX IF NOT EXISTS idx_messages_parentId ON messages(parentId);
+
+-- Branches table (pointers to head messages)
+CREATE TABLE IF NOT EXISTS branches (
+  id TEXT PRIMARY KEY,
+  chatId TEXT NOT NULL,
+  name TEXT NOT NULL,
+  headMessageId TEXT,
+  isActive INTEGER NOT NULL DEFAULT 0,
+  createdAt INTEGER NOT NULL,
+  FOREIGN KEY (chatId) REFERENCES chats(id) ON DELETE CASCADE,
+  FOREIGN KEY (headMessageId) REFERENCES messages(id),
+  UNIQUE(chatId, name)
+);
+
+CREATE INDEX IF NOT EXISTS idx_branches_chatId ON branches(chatId);
+
+-- Checkpoints table (pointers to message nodes)
+CREATE TABLE IF NOT EXISTS checkpoints (
+  id TEXT PRIMARY KEY,
+  chatId TEXT NOT NULL,
+  name TEXT NOT NULL,
+  messageId TEXT NOT NULL,
+  createdAt INTEGER NOT NULL,
+  FOREIGN KEY (chatId) REFERENCES chats(id) ON DELETE CASCADE,
+  FOREIGN KEY (messageId) REFERENCES messages(id),
+  UNIQUE(chatId, name)
+);
+
+CREATE INDEX IF NOT EXISTS idx_checkpoints_chatId ON checkpoints(chatId);
+
+-- FTS5 virtual table for full-text search
+-- Using external content mode (content='') so we manage sync manually
+CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
+  messageId,
+  chatId,
+  name,
+  content,
+  content='',
+  tokenize='porter unicode61'
+);
+`;
+var SqliteContextStore = class extends ContextStore {
+  #db;
+  constructor(path) {
+    super();
+    this.#db = new DatabaseSync(path);
+    this.#db.exec("PRAGMA foreign_keys = ON");
+    this.#db.exec(STORE_DDL);
+  }
+  // ==========================================================================
+  // Chat Operations
+  // ==========================================================================
+  async createChat(chat) {
+    this.#db.prepare(
+      `INSERT INTO chats (id, title, metadata, createdAt, updatedAt)
+         VALUES (?, ?, ?, ?, ?)`
+    ).run(
+      chat.id,
+      chat.title ?? null,
+      chat.metadata ? JSON.stringify(chat.metadata) : null,
+      chat.createdAt,
+      chat.updatedAt
+    );
+  }
+  async getChat(chatId) {
+    const row = this.#db.prepare("SELECT * FROM chats WHERE id = ?").get(chatId);
+    if (!row) {
+      return void 0;
+    }
+    return {
+      id: row.id,
+      title: row.title ?? void 0,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    };
+  }
+  async updateChat(chatId, updates) {
+    const setClauses = [];
+    const params = [];
+    if (updates.title !== void 0) {
+      setClauses.push("title = ?");
+      params.push(updates.title ?? null);
+    }
+    if (updates.metadata !== void 0) {
+      setClauses.push("metadata = ?");
+      params.push(JSON.stringify(updates.metadata));
+    }
+    if (updates.updatedAt !== void 0) {
+      setClauses.push("updatedAt = ?");
+      params.push(updates.updatedAt);
+    }
+    if (setClauses.length === 0) {
+      return;
+    }
+    params.push(chatId);
+    this.#db.prepare(`UPDATE chats SET ${setClauses.join(", ")} WHERE id = ?`).run(...params);
+  }
+  async listChats() {
+    const rows = this.#db.prepare(
+      `SELECT
+          c.id,
+          c.title,
+          c.createdAt,
+          c.updatedAt,
+          COUNT(DISTINCT m.id) as messageCount,
+          COUNT(DISTINCT b.id) as branchCount
+        FROM chats c
+        LEFT JOIN messages m ON m.chatId = c.id
+        LEFT JOIN branches b ON b.chatId = c.id
+        GROUP BY c.id
+        ORDER BY c.updatedAt DESC`
+    ).all();
+    return rows.map((row) => ({
+      id: row.id,
+      title: row.title ?? void 0,
+      messageCount: row.messageCount,
+      branchCount: row.branchCount,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    }));
+  }
+  // ==========================================================================
+  // Message Operations (Graph Nodes)
+  // ==========================================================================
+  async addMessage(message) {
+    this.#db.prepare(
+      `INSERT INTO messages (id, chatId, parentId, name, type, data, persist, createdAt)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      message.id,
+      message.chatId,
+      message.parentId,
+      message.name,
+      message.type ?? null,
+      JSON.stringify(message.data),
+      message.persist ? 1 : 0,
+      message.createdAt
+    );
+    const content = typeof message.data === "string" ? message.data : JSON.stringify(message.data);
+    this.#db.prepare(
+      `INSERT INTO messages_fts(messageId, chatId, name, content)
+         VALUES (?, ?, ?, ?)`
+    ).run(message.id, message.chatId, message.name, content);
+  }
+  async getMessage(messageId) {
+    const row = this.#db.prepare("SELECT * FROM messages WHERE id = ?").get(messageId);
+    if (!row) {
+      return void 0;
+    }
+    return {
+      id: row.id,
+      chatId: row.chatId,
+      parentId: row.parentId,
+      name: row.name,
+      type: row.type ?? void 0,
+      data: JSON.parse(row.data),
+      persist: row.persist === 1,
+      createdAt: row.createdAt
+    };
+  }
+  async getMessageChain(headId) {
+    const rows = this.#db.prepare(
+      `WITH RECURSIVE chain AS (
+          SELECT *, 0 as depth FROM messages WHERE id = ?
+          UNION ALL
+          SELECT m.*, c.depth + 1 FROM messages m
+          INNER JOIN chain c ON m.id = c.parentId
+        )
+        SELECT * FROM chain
+        ORDER BY depth DESC`
+    ).all(headId);
+    return rows.map((row) => ({
+      id: row.id,
+      chatId: row.chatId,
+      parentId: row.parentId,
+      name: row.name,
+      type: row.type ?? void 0,
+      data: JSON.parse(row.data),
+      persist: row.persist === 1,
+      createdAt: row.createdAt
+    }));
+  }
+  async hasChildren(messageId) {
+    const row = this.#db.prepare(
+      "SELECT EXISTS(SELECT 1 FROM messages WHERE parentId = ?) as hasChildren"
+    ).get(messageId);
+    return row.hasChildren === 1;
+  }
+  // ==========================================================================
+  // Branch Operations
+  // ==========================================================================
+  async createBranch(branch) {
+    this.#db.prepare(
+      `INSERT INTO branches (id, chatId, name, headMessageId, isActive, createdAt)
+         VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(
+      branch.id,
+      branch.chatId,
+      branch.name,
+      branch.headMessageId,
+      branch.isActive ? 1 : 0,
+      branch.createdAt
+    );
+  }
+  async getBranch(chatId, name) {
+    const row = this.#db.prepare("SELECT * FROM branches WHERE chatId = ? AND name = ?").get(chatId, name);
+    if (!row) {
+      return void 0;
+    }
+    return {
+      id: row.id,
+      chatId: row.chatId,
+      name: row.name,
+      headMessageId: row.headMessageId,
+      isActive: row.isActive === 1,
+      createdAt: row.createdAt
+    };
+  }
+  async getActiveBranch(chatId) {
+    const row = this.#db.prepare("SELECT * FROM branches WHERE chatId = ? AND isActive = 1").get(chatId);
+    if (!row) {
+      return void 0;
+    }
+    return {
+      id: row.id,
+      chatId: row.chatId,
+      name: row.name,
+      headMessageId: row.headMessageId,
+      isActive: true,
+      createdAt: row.createdAt
+    };
+  }
+  async setActiveBranch(chatId, branchId) {
+    this.#db.prepare("UPDATE branches SET isActive = 0 WHERE chatId = ?").run(chatId);
+    this.#db.prepare("UPDATE branches SET isActive = 1 WHERE id = ?").run(branchId);
+  }
+  async updateBranchHead(branchId, messageId) {
+    this.#db.prepare("UPDATE branches SET headMessageId = ? WHERE id = ?").run(messageId, branchId);
+  }
+  async listBranches(chatId) {
+    const branches = this.#db.prepare(
+      `SELECT
+          b.id,
+          b.name,
+          b.headMessageId,
+          b.isActive,
+          b.createdAt
+        FROM branches b
+        WHERE b.chatId = ?
+        ORDER BY b.createdAt ASC`
+    ).all(chatId);
+    const result = [];
+    for (const branch of branches) {
+      let messageCount = 0;
+      if (branch.headMessageId) {
+        const countRow = this.#db.prepare(
+          `WITH RECURSIVE chain AS (
+              SELECT id, parentId FROM messages WHERE id = ?
+              UNION ALL
+              SELECT m.id, m.parentId FROM messages m
+              INNER JOIN chain c ON m.id = c.parentId
+            )
+            SELECT COUNT(*) as count FROM chain`
+        ).get(branch.headMessageId);
+        messageCount = countRow.count;
+      }
+      result.push({
+        id: branch.id,
+        name: branch.name,
+        headMessageId: branch.headMessageId,
+        isActive: branch.isActive === 1,
+        messageCount,
+        createdAt: branch.createdAt
+      });
+    }
+    return result;
+  }
+  // ==========================================================================
+  // Checkpoint Operations
+  // ==========================================================================
+  async createCheckpoint(checkpoint) {
+    this.#db.prepare(
+      `INSERT INTO checkpoints (id, chatId, name, messageId, createdAt)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(chatId, name) DO UPDATE SET
+           messageId = excluded.messageId,
+           createdAt = excluded.createdAt`
+    ).run(
+      checkpoint.id,
+      checkpoint.chatId,
+      checkpoint.name,
+      checkpoint.messageId,
+      checkpoint.createdAt
+    );
+  }
+  async getCheckpoint(chatId, name) {
+    const row = this.#db.prepare("SELECT * FROM checkpoints WHERE chatId = ? AND name = ?").get(chatId, name);
+    if (!row) {
+      return void 0;
+    }
+    return {
+      id: row.id,
+      chatId: row.chatId,
+      name: row.name,
+      messageId: row.messageId,
+      createdAt: row.createdAt
+    };
+  }
+  async listCheckpoints(chatId) {
+    const rows = this.#db.prepare(
+      `SELECT id, name, messageId, createdAt
+         FROM checkpoints
+         WHERE chatId = ?
+         ORDER BY createdAt DESC`
+    ).all(chatId);
+    return rows.map((row) => ({
+      id: row.id,
+      name: row.name,
+      messageId: row.messageId,
+      createdAt: row.createdAt
+    }));
+  }
+  async deleteCheckpoint(chatId, name) {
+    this.#db.prepare("DELETE FROM checkpoints WHERE chatId = ? AND name = ?").run(chatId, name);
+  }
+  // ==========================================================================
+  // Search Operations
+  // ==========================================================================
+  async searchMessages(chatId, query, options) {
+    const limit = options?.limit ?? 20;
+    const roles = options?.roles;
+    let sql = `
+      SELECT
+        m.id,
+        m.chatId,
+        m.parentId,
+        m.name,
+        m.type,
+        m.data,
+        m.persist,
+        m.createdAt,
+        fts.rank,
+        snippet(messages_fts, 3, '<mark>', '</mark>', '...', 32) as snippet
+      FROM messages_fts fts
+      JOIN messages m ON m.id = fts.messageId
+      WHERE messages_fts MATCH ?
+        AND fts.chatId = ?
+    `;
+    const params = [query, chatId];
+    if (roles && roles.length > 0) {
+      const placeholders = roles.map(() => "?").join(", ");
+      sql += ` AND fts.name IN (${placeholders})`;
+      params.push(...roles);
+    }
+    sql += " ORDER BY fts.rank LIMIT ?";
+    params.push(limit);
+    const rows = this.#db.prepare(sql).all(...params);
+    return rows.map((row) => ({
+      message: {
+        id: row.id,
+        chatId: row.chatId,
+        parentId: row.parentId,
+        name: row.name,
+        type: row.type ?? void 0,
+        data: JSON.parse(row.data),
+        persist: row.persist === 1,
+        createdAt: row.createdAt
+      },
+      rank: row.rank,
+      snippet: row.snippet
+    }));
+  }
+  // ==========================================================================
+  // Visualization Operations
+  // ==========================================================================
+  async getGraph(chatId) {
+    const messageRows = this.#db.prepare(
+      `SELECT id, parentId, name, data, createdAt
+         FROM messages
+         WHERE chatId = ?
+         ORDER BY createdAt ASC`
+    ).all(chatId);
+    const nodes = messageRows.map((row) => {
+      const data = JSON.parse(row.data);
+      const content = typeof data === "string" ? data : JSON.stringify(data);
+      return {
+        id: row.id,
+        parentId: row.parentId,
+        role: row.name,
+        content: content.length > 50 ? content.slice(0, 50) + "..." : content,
+        createdAt: row.createdAt
+      };
+    });
+    const branchRows = this.#db.prepare(
+      `SELECT name, headMessageId, isActive
+         FROM branches
+         WHERE chatId = ?
+         ORDER BY createdAt ASC`
+    ).all(chatId);
+    const branches = branchRows.map((row) => ({
+      name: row.name,
+      headMessageId: row.headMessageId,
+      isActive: row.isActive === 1
+    }));
+    const checkpointRows = this.#db.prepare(
+      `SELECT name, messageId
+         FROM checkpoints
+         WHERE chatId = ?
+         ORDER BY createdAt ASC`
+    ).all(chatId);
+    const checkpoints = checkpointRows.map((row) => ({
+      name: row.name,
+      messageId: row.messageId
+    }));
+    return {
+      chatId,
+      nodes,
+      branches,
+      checkpoints
+    };
+  }
+};
+
+// packages/context/src/lib/store/memory.store.ts
+var InMemoryContextStore = class extends SqliteContextStore {
+  constructor() {
+    super(":memory:");
+  }
+};
+
+// packages/context/src/lib/visualize.ts
+function visualizeGraph(data) {
+  if (data.nodes.length === 0) {
+    return `[chat: ${data.chatId}]
+
+(empty)`;
+  }
+  const childrenByParentId = /* @__PURE__ */ new Map();
+  const branchHeads = /* @__PURE__ */ new Map();
+  const checkpointsByMessageId = /* @__PURE__ */ new Map();
+  for (const node of data.nodes) {
+    const children = childrenByParentId.get(node.parentId) ?? [];
+    children.push(node);
+    childrenByParentId.set(node.parentId, children);
+  }
+  for (const branch of data.branches) {
+    if (branch.headMessageId) {
+      const heads = branchHeads.get(branch.headMessageId) ?? [];
+      heads.push(branch.isActive ? `${branch.name} *` : branch.name);
+      branchHeads.set(branch.headMessageId, heads);
+    }
+  }
+  for (const checkpoint of data.checkpoints) {
+    const cps = checkpointsByMessageId.get(checkpoint.messageId) ?? [];
+    cps.push(checkpoint.name);
+    checkpointsByMessageId.set(checkpoint.messageId, cps);
+  }
+  const roots = childrenByParentId.get(null) ?? [];
+  const lines = [`[chat: ${data.chatId}]`, ""];
+  function renderNode(node, prefix, isLast, isRoot) {
+    const connector = isRoot ? "" : isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const contentPreview = node.content.replace(/\n/g, " ");
+    let line = `${prefix}${connector}${node.id.slice(0, 8)} (${node.role}): "${contentPreview}"`;
+    const branches = branchHeads.get(node.id);
+    if (branches) {
+      line += ` <- [${branches.join(", ")}]`;
+    }
+    const checkpoints = checkpointsByMessageId.get(node.id);
+    if (checkpoints) {
+      line += ` {${checkpoints.join(", ")}}`;
+    }
+    lines.push(line);
+    const children = childrenByParentId.get(node.id) ?? [];
+    const childPrefix = isRoot ? "" : prefix + (isLast ? "    " : "\u2502   ");
+    for (let i = 0; i < children.length; i++) {
+      renderNode(children[i], childPrefix, i === children.length - 1, false);
+    }
+  }
+  for (let i = 0; i < roots.length; i++) {
+    renderNode(roots[i], "", i === roots.length - 1, true);
+  }
+  lines.push("");
+  lines.push("Legend: * = active branch, {...} = checkpoint");
+  return lines.join("\n");
+}
+
+// packages/context/src/index.ts
+var ContextEngine = class {
+  /** Non-message fragments (role, hints, etc.) - not persisted in graph */
+  #contextFragments = [];
+  /** Pending message fragments to be added to graph */
+  #pendingMessages = [];
+  #store;
+  #chatId;
+  #branchName;
+  #branch = null;
+  #chatData = null;
+  #initialized = false;
+  constructor(options) {
+    if (!options.chatId) {
+      throw new Error("chatId is required");
+    }
+    this.#store = options.store;
+    this.#chatId = options.chatId;
+    this.#branchName = options.branch ?? "main";
+  }
+  /**
+   * Initialize the chat and branch if they don't exist.
+   */
+  async #ensureInitialized() {
+    if (this.#initialized) {
+      return;
+    }
+    const existingChat = await this.#store.getChat(this.#chatId);
+    if (existingChat) {
+      this.#chatData = existingChat;
+    } else {
+      const now = Date.now();
+      this.#chatData = {
+        id: this.#chatId,
+        createdAt: now,
+        updatedAt: now
+      };
+      await this.#store.createChat(this.#chatData);
+    }
+    const existingBranch = await this.#store.getBranch(
+      this.#chatId,
+      this.#branchName
+    );
+    if (existingBranch) {
+      this.#branch = existingBranch;
+    } else {
+      this.#branch = {
+        id: crypto.randomUUID(),
+        chatId: this.#chatId,
+        name: this.#branchName,
+        headMessageId: null,
+        isActive: true,
+        createdAt: Date.now()
+      };
+      await this.#store.createBranch(this.#branch);
+    }
+    this.#initialized = true;
+  }
+  /**
+   * Get the current chat ID.
+   */
+  get chatId() {
+    return this.#chatId;
+  }
+  /**
+   * Get the current branch name.
+   */
+  get branch() {
+    return this.#branchName;
+  }
+  /**
+   * Get metadata for the current chat.
+   * Returns null if the chat hasn't been initialized yet.
+   */
+  get chat() {
+    if (!this.#chatData) {
+      return null;
+    }
+    return {
+      id: this.#chatData.id,
+      createdAt: this.#chatData.createdAt,
+      updatedAt: this.#chatData.updatedAt,
+      title: this.#chatData.title,
+      metadata: this.#chatData.metadata
+    };
+  }
+  /**
+   * Add fragments to the context.
+   *
+   * - Message fragments (user/assistant) are queued for persistence
+   * - Non-message fragments (role/hint) are kept in memory for system prompt
+   */
+  set(...fragments) {
+    for (const fragment2 of fragments) {
+      if (isMessageFragment(fragment2)) {
+        this.#pendingMessages.push(fragment2);
+      } else {
+        this.#contextFragments.push(fragment2);
+      }
+    }
+    return this;
+  }
+  /**
+   * Render all fragments using the provided renderer.
+   * @internal Use resolve() instead for public API.
+   */
+  render(renderer) {
+    return renderer.render(this.#contextFragments);
+  }
+  /**
+   * Resolve context into AI SDK-ready format.
+   *
+   * - Initializes chat and branch if needed
+   * - Loads message history from the graph (walking parent chain)
+   * - Separates context fragments for system prompt
+   * - Combines with pending messages
+   *
+   * @example
+   * ```ts
+   * const context = new ContextEngine({ store, chatId: 'chat-1' })
+   *   .set(role('You are helpful'), user('Hello'));
+   *
+   * const { systemPrompt, messages } = await context.resolve();
+   * await generateText({ system: systemPrompt, messages });
+   * ```
+   */
+  async resolve(options = {}) {
+    await this.#ensureInitialized();
+    const renderer = options.renderer ?? new XmlRenderer();
+    const systemPrompt = renderer.render(this.#contextFragments);
+    const persistedMessages = [];
+    if (this.#branch?.headMessageId) {
+      const chain = await this.#store.getMessageChain(
+        this.#branch.headMessageId
+      );
+      persistedMessages.push(...chain);
+    }
+    const messages = persistedMessages.map((msg) => ({
+      role: msg.name,
+      content: String(msg.data)
+    }));
+    for (const fragment2 of this.#pendingMessages) {
+      messages.push({
+        role: fragment2.name,
+        content: String(fragment2.data)
+      });
+    }
+    return { systemPrompt, messages };
+  }
+  /**
+   * Save pending messages to the graph.
+   *
+   * Each message is added as a node with parentId pointing to the previous message.
+   * The branch head is updated to point to the last message.
+   *
+   * @example
+   * ```ts
+   * context.set(user('Hello'));
+   * // AI responds...
+   * context.set(assistant('Hi there!'));
+   * await context.save(); // Persist to graph
+   * ```
+   */
+  async save() {
+    await this.#ensureInitialized();
+    if (this.#pendingMessages.length === 0) {
+      return;
+    }
+    let parentId = this.#branch.headMessageId;
+    const now = Date.now();
+    for (const fragment2 of this.#pendingMessages) {
+      const messageData = {
+        id: fragment2.id ?? crypto.randomUUID(),
+        chatId: this.#chatId,
+        parentId,
+        name: fragment2.name,
+        type: fragment2.type,
+        data: fragment2.data,
+        persist: fragment2.persist ?? true,
+        createdAt: now
+      };
+      await this.#store.addMessage(messageData);
+      parentId = messageData.id;
+    }
+    await this.#store.updateBranchHead(this.#branch.id, parentId);
+    this.#branch.headMessageId = parentId;
+    await this.#store.updateChat(this.#chatId, { updatedAt: now });
+    if (this.#chatData) {
+      this.#chatData.updatedAt = now;
+    }
+    this.#pendingMessages = [];
+  }
+  /**
+   * Estimate token count and cost for the current context.
+   *
+   * @param modelId - Model ID (e.g., "openai:gpt-4o", "anthropic:claude-3-5-sonnet")
+   * @param options - Optional settings
+   * @returns Estimate result with token counts and costs
+   */
+  async estimate(modelId, options = {}) {
+    const renderer = options.renderer ?? new XmlRenderer();
+    const renderedContext = this.render(renderer);
+    const registry = getModelsRegistry();
+    await registry.load();
+    return registry.estimate(modelId, renderedContext);
+  }
+  /**
+   * Rewind to a specific message by ID.
+   *
+   * Creates a new branch from that message, preserving the original branch.
+   * The new branch becomes active.
+   *
+   * @param messageId - The message ID to rewind to
+   * @returns The new branch info
+   *
+   * @example
+   * ```ts
+   * context.set(user('What is 2 + 2?', { id: 'q1' }));
+   * context.set(assistant('The answer is 5.', { id: 'wrong' })); // Oops!
+   * await context.save();
+   *
+   * // Rewind to the question, creates new branch
+   * const newBranch = await context.rewind('q1');
+   *
+   * // Now add correct answer on new branch
+   * context.set(assistant('The answer is 4.'));
+   * await context.save();
+   * ```
+   */
+  async rewind(messageId) {
+    await this.#ensureInitialized();
+    const message = await this.#store.getMessage(messageId);
+    if (!message) {
+      throw new Error(`Message "${messageId}" not found`);
+    }
+    if (message.chatId !== this.#chatId) {
+      throw new Error(`Message "${messageId}" belongs to a different chat`);
+    }
+    const branches = await this.#store.listBranches(this.#chatId);
+    const newBranchName = `${this.#branchName}-v${branches.length + 1}`;
+    const newBranch = {
+      id: crypto.randomUUID(),
+      chatId: this.#chatId,
+      name: newBranchName,
+      headMessageId: messageId,
+      isActive: false,
+      createdAt: Date.now()
+    };
+    await this.#store.createBranch(newBranch);
+    await this.#store.setActiveBranch(this.#chatId, newBranch.id);
+    this.#branch = { ...newBranch, isActive: true };
+    this.#branchName = newBranchName;
+    this.#pendingMessages = [];
+    const chain = await this.#store.getMessageChain(messageId);
+    return {
+      id: newBranch.id,
+      name: newBranch.name,
+      headMessageId: newBranch.headMessageId,
+      isActive: true,
+      messageCount: chain.length,
+      createdAt: newBranch.createdAt
+    };
+  }
+  /**
+   * Create a checkpoint at the current position.
+   *
+   * A checkpoint is a named pointer to the current branch head.
+   * Use restore() to return to this point later.
+   *
+   * @param name - Name for the checkpoint
+   * @returns The checkpoint info
+   *
+   * @example
+   * ```ts
+   * context.set(user('I want to learn a new skill.'));
+   * context.set(assistant('Would you like coding or cooking?'));
+   * await context.save();
+   *
+   * // Save checkpoint before user's choice
+   * const cp = await context.checkpoint('before-choice');
+   * ```
+   */
+  async checkpoint(name) {
+    await this.#ensureInitialized();
+    if (!this.#branch?.headMessageId) {
+      throw new Error("Cannot create checkpoint: no messages in conversation");
+    }
+    const checkpoint = {
+      id: crypto.randomUUID(),
+      chatId: this.#chatId,
+      name,
+      messageId: this.#branch.headMessageId,
+      createdAt: Date.now()
+    };
+    await this.#store.createCheckpoint(checkpoint);
+    return {
+      id: checkpoint.id,
+      name: checkpoint.name,
+      messageId: checkpoint.messageId,
+      createdAt: checkpoint.createdAt
+    };
+  }
+  /**
+   * Restore to a checkpoint by creating a new branch from that point.
+   *
+   * @param name - Name of the checkpoint to restore
+   * @returns The new branch info
+   *
+   * @example
+   * ```ts
+   * // User chose cooking, but wants to try coding path
+   * await context.restore('before-choice');
+   *
+   * context.set(user('I want to learn coding.'));
+   * context.set(assistant('Python is a great starting language!'));
+   * await context.save();
+   * ```
+   */
+  async restore(name) {
+    await this.#ensureInitialized();
+    const checkpoint = await this.#store.getCheckpoint(this.#chatId, name);
+    if (!checkpoint) {
+      throw new Error(
+        `Checkpoint "${name}" not found in chat "${this.#chatId}"`
+      );
+    }
+    return this.rewind(checkpoint.messageId);
+  }
+  /**
+   * Switch to a different branch by name.
+   *
+   * @param name - Branch name to switch to
+   *
+   * @example
+   * ```ts
+   * // List branches (via store)
+   * const branches = await store.listBranches(context.chatId);
+   * console.log(branches); // [{name: 'main', ...}, {name: 'main-v2', ...}]
+   *
+   * // Switch to original branch
+   * await context.switchBranch('main');
+   * ```
+   */
+  async switchBranch(name) {
+    await this.#ensureInitialized();
+    const branch = await this.#store.getBranch(this.#chatId, name);
+    if (!branch) {
+      throw new Error(`Branch "${name}" not found in chat "${this.#chatId}"`);
+    }
+    await this.#store.setActiveBranch(this.#chatId, branch.id);
+    this.#branch = { ...branch, isActive: true };
+    this.#branchName = name;
+    this.#pendingMessages = [];
+  }
+  /**
+   * Update metadata for the current chat.
+   *
+   * @param updates - Partial metadata to merge (title, metadata)
+   *
+   * @example
+   * ```ts
+   * await context.updateChat({
+   *   title: 'Coding Help Session',
+   *   metadata: { tags: ['python', 'debugging'] }
+   * });
+   * ```
+   */
+  async updateChat(updates) {
+    await this.#ensureInitialized();
+    const now = Date.now();
+    const storeUpdates = {
+      updatedAt: now
+    };
+    if (updates.title !== void 0) {
+      storeUpdates.title = updates.title;
+    }
+    if (updates.metadata !== void 0) {
+      storeUpdates.metadata = {
+        ...this.#chatData?.metadata,
+        ...updates.metadata
+      };
+    }
+    await this.#store.updateChat(this.#chatId, storeUpdates);
+    if (this.#chatData) {
+      if (storeUpdates.title !== void 0) {
+        this.#chatData.title = storeUpdates.title;
+      }
+      if (storeUpdates.metadata !== void 0) {
+        this.#chatData.metadata = storeUpdates.metadata;
+      }
+      this.#chatData.updatedAt = now;
+    }
+  }
+  /**
+   * Consolidate context fragments (no-op for now).
+   *
+   * This is a placeholder for future functionality that merges context fragments
+   * using specific rules. Currently, it does nothing.
+   *
+   * @experimental
+   */
+  consolidate() {
+    return void 0;
+  }
+};
+function hint(text) {
+  return {
+    name: "hint",
+    data: text
+  };
+}
+function fragment(name, ...children) {
+  return {
+    name,
+    data: children
+  };
+}
+function role(content) {
+  return {
+    name: "role",
+    data: content
+  };
+}
+function user(content, options) {
+  return {
+    id: options?.id ?? crypto.randomUUID(),
+    name: "user",
+    data: content,
+    type: "message",
+    persist: true
+  };
+}
+function assistant(content, options) {
+  return {
+    id: options?.id ?? crypto.randomUUID(),
+    name: "assistant",
+    data: content,
+    type: "message",
+    persist: true
+  };
+}
+export {
+  ContextEngine,
+  ContextStore,
+  InMemoryContextStore,
+  MarkdownRenderer,
+  ModelsRegistry,
+  SqliteContextStore,
+  TomlRenderer,
+  ToonRenderer,
+  XmlRenderer,
+  assistant,
+  defaultTokenizer,
+  fragment,
+  getModelsRegistry,
+  hint,
+  isMessageFragment,
+  role,
+  user,
+  visualizeGraph
+};
+//# sourceMappingURL=index.js.map