@deepagents/text2sql 0.13.1 → 0.15.1

package/dist/lib/synthesis/index.js

@@ -165,1968 +165,22 @@ import {
 } from "ai";
 
 // packages/text2sql/src/lib/synthesis/extractors/base-contextual-extractor.ts
-import { groq as groq2 } from "@ai-sdk/groq";
-import {
-  getToolOrDynamicToolName,
-  isTextUIPart,
-  isToolOrDynamicToolUIPart
-} from "ai";
-import dedent from "dedent";
-import z from "zod";
-
-// packages/context/dist/index.js
-import { mergeWith } from "lodash-es";
-import { encode } from "gpt-tokenizer";
-import { generateId } from "ai";
-import pluralize from "pluralize";
-import { titlecase } from "stringcase";
-import chalk from "chalk";
-import { defineCommand } from "just-bash";
-import spawn from "nano-spawn";
-import "bash-tool";
-import spawn2 from "nano-spawn";
-import {
-  createBashTool
-} from "bash-tool";
-import YAML from "yaml";
-import { DatabaseSync } from "node:sqlite";
-import { groq } from "@ai-sdk/groq";
-import {
-  NoSuchToolError,
-  Output,
-  convertToModelMessages,
-  createUIMessageStream,
-  generateId as generateId2,
-  generateText,
-  smoothStream,
-  stepCountIs,
-  streamText
-} from "ai";
-import chalk2 from "chalk";
-import "zod";
-import "@deepagents/agent";
-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 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";
-}
-function fragment(name, ...children) {
-  return {
-    name,
-    data: children
-  };
-}
-function user(content) {
-  const message2 = typeof content === "string" ? {
-    id: generateId(),
-    role: "user",
-    parts: [{ type: "text", text: content }]
-  } : content;
-  return {
-    id: message2.id,
-    name: "user",
-    data: "content",
-    type: "message",
-    persist: true,
-    codec: {
-      decode() {
-        return message2;
-      },
-      encode() {
-        return message2;
-      }
-    }
-  };
-}
-function assistant(message2) {
-  return {
-    id: message2.id,
-    name: "assistant",
-    data: "content",
-    type: "message",
-    persist: true,
-    codec: {
-      decode() {
-        return message2;
-      },
-      encode() {
-        return message2;
-      }
-    }
-  };
-}
-function message(content) {
-  const message2 = typeof content === "string" ? {
-    id: generateId(),
-    role: "user",
-    parts: [{ type: "text", text: content }]
-  } : content;
-  return {
-    id: message2.id,
-    name: message2.role,
-    data: "content",
-    type: "message",
-    persist: true,
-    codec: {
-      decode() {
-        return message2;
-      },
-      encode() {
-        return message2;
-      }
-    }
-  };
-}
-function assistantText(content, options) {
-  const id = options?.id ?? crypto.randomUUID();
-  return assistant({
-    id,
-    role: "assistant",
-    parts: [{ type: "text", text: content }]
-  });
-}
-var LAZY_ID = Symbol("lazy-id");
-function isLazyFragment(fragment2) {
-  return LAZY_ID in fragment2;
-}
-var ContextRenderer = class {
-  options;
-  constructor(options = {}) {
-    this.options = options;
-  }
-  /**
-   * Check if data is a primitive (string, number, boolean).
-   */
-  isPrimitive(data) {
-    return typeof data === "string" || typeof data === "number" || typeof data === "boolean";
-  }
-  /**
-   * Group fragments by name for groupFragments option.
-   */
-  groupByName(fragments) {
-    const groups = /* @__PURE__ */ new Map();
-    for (const fragment2 of fragments) {
-      const existing = groups.get(fragment2.name) ?? [];
-      existing.push(fragment2);
-      groups.set(fragment2.name, existing);
-    }
-    return groups;
-  }
-  /**
-   * Remove null/undefined from fragments and fragment data recursively.
-   * This protects renderers from nullish values and ensures they are ignored
-   * consistently across all output formats.
-   */
-  sanitizeFragments(fragments) {
-    const sanitized = [];
-    for (const fragment2 of fragments) {
-      const cleaned = this.sanitizeFragment(fragment2, /* @__PURE__ */ new WeakSet());
-      if (cleaned) {
-        sanitized.push(cleaned);
-      }
-    }
-    return sanitized;
-  }
-  sanitizeFragment(fragment2, seen) {
-    const data = this.sanitizeData(fragment2.data, seen);
-    if (data == null) {
-      return null;
-    }
-    return {
-      ...fragment2,
-      data
-    };
-  }
-  sanitizeData(data, seen) {
-    if (data == null) {
-      return void 0;
-    }
-    if (isFragment(data)) {
-      return this.sanitizeFragment(data, seen) ?? void 0;
-    }
-    if (Array.isArray(data)) {
-      if (seen.has(data)) {
-        return void 0;
-      }
-      seen.add(data);
-      const cleaned = [];
-      for (const item of data) {
-        const sanitizedItem = this.sanitizeData(item, seen);
-        if (sanitizedItem != null) {
-          cleaned.push(sanitizedItem);
-        }
-      }
-      return cleaned;
-    }
-    if (isFragmentObject(data)) {
-      if (seen.has(data)) {
-        return void 0;
-      }
-      seen.add(data);
-      const cleaned = {};
-      for (const [key, value] of Object.entries(data)) {
-        const sanitizedValue = this.sanitizeData(value, seen);
-        if (sanitizedValue != null) {
-          cleaned[key] = sanitizedValue;
-        }
-      }
-      return cleaned;
-    }
-    return data;
-  }
-  /**
-   * 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) {
-    const sanitized = this.sanitizeFragments(fragments);
-    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));
-    }
-    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]);
-    }
-    if (isFragmentObject(fragment2.data)) {
-      return this.#wrap(
-        fragment2.name,
-        this.renderEntries(fragment2.data, { depth: 1, path: [] })
-      );
-    }
-    return "";
-  }
-  #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) {
-        if (isFragmentObject(item)) {
-          children.push(
-            this.#wrapIndented(
-              pluralize.singular(name),
-              this.renderEntries(item, { depth: depth + 2, path: [] }),
-              depth + 1
-            )
-          );
-        } else {
-          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);
-    }
-    if (isFragmentObject(data)) {
-      const children = this.renderEntries(data, {
-        ...ctx,
-        depth: ctx.depth + 1
-      });
-      return this.#wrapIndented(name, children, ctx.depth);
-    }
-    return "";
-  }
-  #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) {
-        if (isFragmentObject(item)) {
-          children.push(
-            this.#wrapIndented(
-              pluralize.singular(name),
-              this.renderEntries(item, { depth: depth + 2, path: [] }),
-              depth + 1
-            )
-          );
-        } else {
-          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) => {
-      if (isFragment(item)) {
-        return this.renderFragment(item, { ...ctx, depth: ctx.depth + 1 });
-      }
-      if (isFragmentObject(item)) {
-        return this.#wrapIndented(
-          itemTag,
-          this.renderEntries(item, { ...ctx, depth: ctx.depth + 2 }),
-          ctx.depth + 1
-        );
-      }
-      return 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 ContextStore = class {
-};
-var ContextEngine = class {
-  /** Non-message fragments (role, hints, etc.) - not persisted in graph */
-  #fragments = [];
-  /** Pending message fragments to be added to graph */
-  #pendingMessages = [];
-  #store;
-  #chatId;
-  #userId;
-  #branchName;
-  #branch = null;
-  #chatData = null;
-  #initialized = false;
-  /** Initial metadata to merge on first initialization */
-  #initialMetadata;
-  constructor(options) {
-    if (!options.chatId) {
-      throw new Error("chatId is required");
-    }
-    if (!options.userId) {
-      throw new Error("userId is required");
-    }
-    this.#store = options.store;
-    this.#chatId = options.chatId;
-    this.#userId = options.userId;
-    this.#branchName = "main";
-    this.#initialMetadata = options.metadata;
-  }
-  /**
-   * Initialize the chat and branch if they don't exist.
-   */
-  async #ensureInitialized() {
-    if (this.#initialized) {
-      return;
-    }
-    this.#chatData = await this.#store.upsertChat({
-      id: this.#chatId,
-      userId: this.#userId
-    });
-    if (this.#initialMetadata) {
-      this.#chatData = await this.#store.updateChat(this.#chatId, {
-        metadata: {
-          ...this.#chatData.metadata,
-          ...this.#initialMetadata
-        }
-      });
-      this.#initialMetadata = void 0;
-    }
-    this.#branch = await this.#store.getActiveBranch(this.#chatId);
-    this.#initialized = true;
-  }
-  /**
-   * Create a new branch from a specific message.
-   * Shared logic between rewind() and btw().
-   */
-  async #createBranchFrom(messageId, switchTo) {
-    const branches = await this.#store.listBranches(this.#chatId);
-    const samePrefix = branches.filter(
-      (b) => b.name === this.#branchName || b.name.startsWith(`${this.#branchName}-v`)
-    );
-    const newBranchName = `${this.#branchName}-v${samePrefix.length + 1}`;
-    const newBranch = {
-      id: crypto.randomUUID(),
-      chatId: this.#chatId,
-      name: newBranchName,
-      headMessageId: messageId,
-      isActive: false,
-      createdAt: Date.now()
-    };
-    await this.#store.createBranch(newBranch);
-    if (switchTo) {
-      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: switchTo,
-      messageCount: chain.length,
-      createdAt: newBranch.createdAt
-    };
-  }
-  /**
-   * 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,
-      userId: this.#chatData.userId,
-      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.#fragments.push(fragment2);
-      }
-    }
-    return this;
-  }
-  // Unset a fragment by ID (not implemented yet)
-  unset(fragmentId) {
-  }
-  /**
-   * Render all fragments using the provided renderer.
-   * @internal Use resolve() instead for public API.
-   */
-  render(renderer) {
-    return renderer.render(this.#fragments);
-  }
-  /**
-   * 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', userId: 'user-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 systemPrompt = options.renderer.render(this.#fragments);
-    const messages = [];
-    if (this.#branch?.headMessageId) {
-      const chain = await this.#store.getMessageChain(
-        this.#branch.headMessageId
-      );
-      for (const msg of chain) {
-        messages.push(message(msg.data).codec?.decode());
-      }
-    }
-    for (const fragment2 of this.#pendingMessages) {
-      const decoded = fragment2.codec.decode();
-      messages.push(decoded);
-    }
-    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;
-    }
-    for (let i = 0; i < this.#pendingMessages.length; i++) {
-      const fragment2 = this.#pendingMessages[i];
-      if (isLazyFragment(fragment2)) {
-        this.#pendingMessages[i] = await this.#resolveLazyFragment(fragment2);
-      }
-    }
-    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.codec.encode(),
-        createdAt: now
-      };
-      await this.#store.addMessage(messageData);
-      parentId = messageData.id;
-    }
-    await this.#store.updateBranchHead(this.#branch.id, parentId);
-    this.#branch.headMessageId = parentId;
-    this.#pendingMessages = [];
-  }
-  /**
-   * Resolve a lazy fragment by finding the appropriate ID.
-   */
-  async #resolveLazyFragment(fragment2) {
-    const lazy = fragment2[LAZY_ID];
-    if (lazy.type === "last-assistant") {
-      const lastId = await this.#getLastAssistantId();
-      return assistantText(lazy.content, { id: lastId ?? crypto.randomUUID() });
-    }
-    throw new Error(`Unknown lazy fragment type: ${lazy.type}`);
-  }
-  /**
-   * Find the most recent assistant message ID (pending or persisted).
-   */
-  async #getLastAssistantId() {
-    for (let i = this.#pendingMessages.length - 1; i >= 0; i--) {
-      const msg = this.#pendingMessages[i];
-      if (msg.name === "assistant" && !isLazyFragment(msg)) {
-        return msg.id;
-      }
-    }
-    if (this.#branch?.headMessageId) {
-      const chain = await this.#store.getMessageChain(
-        this.#branch.headMessageId
-      );
-      for (let i = chain.length - 1; i >= 0; i--) {
-        if (chain[i].name === "assistant") {
-          return chain[i].id;
-        }
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Estimate token count and cost for the full context.
-   *
-   * Includes:
-   * - System prompt fragments (role, hints, etc.)
-   * - Persisted chat messages (from store)
-   * - Pending messages (not yet saved)
-   *
-   * @param modelId - Model ID (e.g., "openai:gpt-4o", "anthropic:claude-3-5-sonnet")
-   * @param options - Optional settings
-   * @returns Estimate result with token counts, costs, and per-fragment breakdown
-   */
-  async estimate(modelId, options = {}) {
-    await this.#ensureInitialized();
-    const renderer = options.renderer ?? new XmlRenderer();
-    const registry = getModelsRegistry();
-    await registry.load();
-    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 fragmentEstimates = [];
-    for (const fragment2 of this.#fragments) {
-      const rendered = renderer.render([fragment2]);
-      const tokens = tokenizer.count(rendered);
-      const cost = tokens / 1e6 * model.cost.input;
-      fragmentEstimates.push({
-        id: fragment2.id,
-        name: fragment2.name,
-        tokens,
-        cost
-      });
-    }
-    if (this.#branch?.headMessageId) {
-      const chain = await this.#store.getMessageChain(
-        this.#branch.headMessageId
-      );
-      for (const msg of chain) {
-        const content = String(msg.data);
-        const tokens = tokenizer.count(content);
-        const cost = tokens / 1e6 * model.cost.input;
-        fragmentEstimates.push({
-          name: msg.name,
-          id: msg.id,
-          tokens,
-          cost
-        });
-      }
-    }
-    for (const fragment2 of this.#pendingMessages) {
-      const content = String(fragment2.data);
-      const tokens = tokenizer.count(content);
-      const cost = tokens / 1e6 * model.cost.input;
-      fragmentEstimates.push({
-        name: fragment2.name,
-        id: fragment2.id,
-        tokens,
-        cost
-      });
-    }
-    const totalTokens = fragmentEstimates.reduce((sum, f) => sum + f.tokens, 0);
-    const totalCost = fragmentEstimates.reduce((sum, f) => sum + f.cost, 0);
-    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
-    };
-  }
-  /**
-   * 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 message2 = await this.#store.getMessage(messageId);
-    if (!message2) {
-      throw new Error(`Message "${messageId}" not found`);
-    }
-    if (message2.chatId !== this.#chatId) {
-      throw new Error(`Message "${messageId}" belongs to a different chat`);
-    }
-    return this.#createBranchFrom(messageId, true);
-  }
-  /**
-   * 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 = [];
-  }
-  /**
-   * Create a parallel branch from the current position ("by the way").
-   *
-   * Use this when you want to fork the conversation without leaving
-   * the current branch. Common use case: user wants to ask another
-   * question while waiting for the model to respond.
-   *
-   * Unlike rewind(), this method:
-   * - Uses the current HEAD (no messageId needed)
-   * - Does NOT switch to the new branch
-   * - Keeps pending messages intact
-   *
-   * @returns The new branch info (does not switch to it)
-   * @throws Error if no messages exist in the conversation
-   *
-   * @example
-   * ```ts
-   * // User asked a question, model is generating...
-   * context.set(user('What is the weather?'));
-   * await context.save();
-   *
-   * // User wants to ask something else without waiting
-   * const newBranch = await context.btw();
-   * // newBranch = { name: 'main-v2', ... }
-   *
-   * // Later, switch to the new branch and add the question
-   * await context.switchBranch(newBranch.name);
-   * context.set(user('Also, what time is it?'));
-   * await context.save();
-   * ```
-   */
-  async btw() {
-    await this.#ensureInitialized();
-    if (!this.#branch?.headMessageId) {
-      throw new Error("Cannot create btw branch: no messages in conversation");
-    }
-    return this.#createBranchFrom(this.#branch.headMessageId, false);
-  }
-  /**
-   * 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 storeUpdates = {};
-    if (updates.title !== void 0) {
-      storeUpdates.title = updates.title;
-    }
-    if (updates.metadata !== void 0) {
-      storeUpdates.metadata = {
-        ...this.#chatData?.metadata,
-        ...updates.metadata
-      };
-    }
-    this.#chatData = await this.#store.updateChat(this.#chatId, storeUpdates);
-  }
-  /**
-   * Track token usage for the current chat.
-   * Accumulates usage metrics in chat.metadata.usage.
-   *
-   * @param usage - Token usage from AI SDK (LanguageModelUsage)
-   *
-   * @example
-   * ```ts
-   * // In onFinish callback
-   * const usage = await result.totalUsage;
-   * await context.trackUsage(usage);
-   * ```
-   */
-  async trackUsage(usage) {
-    await this.#ensureInitialized();
-    const freshChatData = await this.#store.getChat(this.#chatId);
-    const currentUsage = freshChatData?.metadata?.usage ?? {};
-    const updatedUsage = mergeWith(
-      {},
-      currentUsage,
-      usage,
-      (a, b) => typeof a === "number" || typeof b === "number" ? (a ?? 0) + (b ?? 0) : void 0
-    );
-    this.#chatData = await this.#store.updateChat(this.#chatId, {
-      metadata: {
-        ...freshChatData?.metadata,
-        usage: updatedUsage
-      }
-    });
-  }
-  /**
-   * 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;
-  }
-  /**
-   * Extract skill path mappings from available_skills fragments.
-   * Returns array of { host, sandbox } for mounting in sandbox filesystem.
-   *
-   * Reads the original `paths` configuration stored in fragment metadata
-   * by the skills() fragment helper.
-   *
-   * @example
-   * ```ts
-   * const context = new ContextEngine({ store, chatId, userId })
-   *   .set(skills({ paths: [{ host: './skills', sandbox: '/skills' }] }));
-   *
-   * const mounts = context.getSkillMounts();
-   * // [{ host: './skills', sandbox: '/skills' }]
-   * ```
-   */
-  getSkillMounts() {
-    const mounts = [];
-    for (const fragment2 of this.#fragments) {
-      if (fragment2.name === "available_skills" && fragment2.metadata && Array.isArray(fragment2.metadata.paths)) {
-        for (const mapping of fragment2.metadata.paths) {
-          if (typeof mapping === "object" && mapping !== null && typeof mapping.host === "string" && typeof mapping.sandbox === "string") {
-            mounts.push({ host: mapping.host, sandbox: mapping.sandbox });
-          }
-        }
-      }
-    }
-    return mounts;
-  }
-  /**
-   * Inspect the full context state for debugging.
-   * Returns a JSON-serializable object with context information.
-   *
-   * @param options - Inspection options (modelId and renderer required)
-   * @returns Complete inspection data including estimates, rendered output, fragments, and graph
-   *
-   * @example
-   * ```ts
-   * const inspection = await context.inspect({
-   *   modelId: 'openai:gpt-4o',
-   *   renderer: new XmlRenderer(),
-   * });
-   * console.log(JSON.stringify(inspection, null, 2));
-   *
-   * // Or write to file for analysis
-   * await fs.writeFile('context-debug.json', JSON.stringify(inspection, null, 2));
-   * ```
-   */
-  async inspect(options) {
-    await this.#ensureInitialized();
-    const { renderer } = options;
-    const estimateResult = await this.estimate(options.modelId, { renderer });
-    const rendered = renderer.render(this.#fragments);
-    const persistedMessages = [];
-    if (this.#branch?.headMessageId) {
-      const chain = await this.#store.getMessageChain(
-        this.#branch.headMessageId
-      );
-      persistedMessages.push(...chain);
-    }
-    const graph = await this.#store.getGraph(this.#chatId);
-    return {
-      estimate: estimateResult,
-      rendered,
-      fragments: {
-        context: [...this.#fragments],
-        pending: [...this.#pendingMessages],
-        persisted: persistedMessages
-      },
-      graph,
-      meta: {
-        chatId: this.#chatId,
-        branch: this.#branchName,
-        timestamp: Date.now()
-      }
-    };
-  }
-};
-function term(name, definition) {
-  return {
-    name: "term",
-    data: { name, definition }
-  };
-}
-function hint(text) {
-  return {
-    name: "hint",
-    data: text
-  };
-}
-function guardrail(input) {
-  return {
-    name: "guardrail",
-    data: {
-      rule: input.rule,
-      ...input.reason && { reason: input.reason },
-      ...input.action && { action: input.action }
-    }
-  };
-}
-function explain(input) {
-  return {
-    name: "explain",
-    data: {
-      concept: input.concept,
-      explanation: input.explanation,
-      ...input.therefore && { therefore: input.therefore }
-    }
-  };
-}
-function example(input) {
-  return {
-    name: "example",
-    data: {
-      question: input.question,
-      answer: input.answer,
-      ...input.note && { note: input.note }
-    }
-  };
-}
-function clarification(input) {
-  return {
-    name: "clarification",
-    data: {
-      when: input.when,
-      ask: input.ask,
-      reason: input.reason
-    }
-  };
-}
-function workflow(input) {
-  return {
-    name: "workflow",
-    data: {
-      task: input.task,
-      steps: input.steps,
-      ...input.triggers?.length && { triggers: input.triggers },
-      ...input.notes && { notes: input.notes }
-    }
-  };
-}
-function quirk(input) {
-  return {
-    name: "quirk",
-    data: {
-      issue: input.issue,
-      workaround: input.workaround
-    }
-  };
-}
-function styleGuide(input) {
-  return {
-    name: "styleGuide",
-    data: {
-      prefer: input.prefer,
-      ...input.never && { never: input.never },
-      ...input.always && { always: input.always }
-    }
-  };
-}
-function analogy(input) {
-  return {
-    name: "analogy",
-    data: {
-      concepts: input.concepts,
-      relationship: input.relationship,
-      ...input.insight && { insight: input.insight },
-      ...input.therefore && { therefore: input.therefore },
-      ...input.pitfall && { pitfall: input.pitfall }
-    }
-  };
-}
-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 }
-    }
-  };
-}
-var STORE_DDL = `
--- Chats table
--- createdAt/updatedAt: DEFAULT for insert, inline SET for updates
-CREATE TABLE IF NOT EXISTS chats (
-  id TEXT PRIMARY KEY,
-  userId TEXT NOT NULL,
-  title TEXT,
-  metadata TEXT,
-  createdAt INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
-  updatedAt INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)
-);
-
-CREATE INDEX IF NOT EXISTS idx_chats_updatedAt ON chats(updatedAt);
-CREATE INDEX IF NOT EXISTS idx_chats_userId ON chats(userId);
-
--- 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,
-  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
--- messageId/chatId/name are UNINDEXED (stored but not searchable, used for filtering/joining)
--- Only 'content' is indexed for full-text search
-CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
-  messageId UNINDEXED,
-  chatId UNINDEXED,
-  name UNINDEXED,
-  content,
-  tokenize='porter unicode61'
-);
-`;
-var SqliteContextStore = class extends ContextStore {
-  #db;
-  constructor(path3) {
-    super();
-    this.#db = new DatabaseSync(path3);
-    this.#db.exec("PRAGMA foreign_keys = ON");
-    this.#db.exec(STORE_DDL);
-  }
-  /**
-   * Execute a function within a transaction.
-   * Automatically commits on success or rolls back on error.
-   */
-  #useTransaction(fn) {
-    this.#db.exec("BEGIN TRANSACTION");
-    try {
-      const result = fn();
-      this.#db.exec("COMMIT");
-      return result;
-    } catch (error) {
-      this.#db.exec("ROLLBACK");
-      throw error;
-    }
-  }
-  // ==========================================================================
-  // Chat Operations
-  // ==========================================================================
-  async createChat(chat) {
-    this.#useTransaction(() => {
-      this.#db.prepare(
-        `INSERT INTO chats (id, userId, title, metadata)
-           VALUES (?, ?, ?, ?)`
-      ).run(
-        chat.id,
-        chat.userId,
-        chat.title ?? null,
-        chat.metadata ? JSON.stringify(chat.metadata) : null
-      );
-      this.#db.prepare(
-        `INSERT INTO branches (id, chatId, name, headMessageId, isActive, createdAt)
-           VALUES (?, ?, 'main', NULL, 1, ?)`
-      ).run(crypto.randomUUID(), chat.id, Date.now());
-    });
-  }
-  async upsertChat(chat) {
-    return this.#useTransaction(() => {
-      const row = this.#db.prepare(
-        `INSERT INTO chats (id, userId, title, metadata)
-           VALUES (?, ?, ?, ?)
-           ON CONFLICT(id) DO UPDATE SET id = excluded.id
-           RETURNING *`
-      ).get(
-        chat.id,
-        chat.userId,
-        chat.title ?? null,
-        chat.metadata ? JSON.stringify(chat.metadata) : null
-      );
-      this.#db.prepare(
-        `INSERT OR IGNORE INTO branches (id, chatId, name, headMessageId, isActive, createdAt)
-           VALUES (?, ?, 'main', NULL, 1, ?)`
-      ).run(crypto.randomUUID(), chat.id, Date.now());
-      return {
-        id: row.id,
-        userId: row.userId,
-        title: row.title ?? void 0,
-        metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
-        createdAt: row.createdAt,
-        updatedAt: row.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,
-      userId: row.userId,
-      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 = ["updatedAt = strftime('%s', 'now') * 1000"];
-    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));
-    }
-    params.push(chatId);
-    const row = this.#db.prepare(
-      `UPDATE chats SET ${setClauses.join(", ")} WHERE id = ? RETURNING *`
-    ).get(...params);
-    return {
-      id: row.id,
-      userId: row.userId,
-      title: row.title ?? void 0,
-      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
-      createdAt: row.createdAt,
-      updatedAt: row.updatedAt
-    };
-  }
-  async listChats(options) {
-    const params = [];
-    const whereClauses = [];
-    let limitClause = "";
-    if (options?.userId) {
-      whereClauses.push("c.userId = ?");
-      params.push(options.userId);
-    }
-    if (options?.metadata) {
-      whereClauses.push(`json_extract(c.metadata, '$.' || ?) = ?`);
-      params.push(options.metadata.key);
-      params.push(
-        typeof options.metadata.value === "boolean" ? options.metadata.value ? 1 : 0 : options.metadata.value
-      );
-    }
-    const whereClause = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
-    if (options?.limit !== void 0) {
-      limitClause = " LIMIT ?";
-      params.push(options.limit);
-      if (options.offset !== void 0) {
-        limitClause += " OFFSET ?";
-        params.push(options.offset);
-      }
-    }
-    const rows = this.#db.prepare(
-      `SELECT
-          c.id,
-          c.userId,
-          c.title,
-          c.metadata,
-          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
-        ${whereClause}
-        GROUP BY c.id
-        ORDER BY c.updatedAt DESC${limitClause}`
-    ).all(...params);
-    return rows.map((row) => ({
-      id: row.id,
-      userId: row.userId,
-      title: row.title ?? void 0,
-      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
-      messageCount: row.messageCount,
-      branchCount: row.branchCount,
-      createdAt: row.createdAt,
-      updatedAt: row.updatedAt
-    }));
-  }
-  async deleteChat(chatId, options) {
-    return this.#useTransaction(() => {
-      const messageIds = this.#db.prepare("SELECT id FROM messages WHERE chatId = ?").all(chatId);
-      let sql = "DELETE FROM chats WHERE id = ?";
-      const params = [chatId];
-      if (options?.userId !== void 0) {
-        sql += " AND userId = ?";
-        params.push(options.userId);
-      }
-      const result = this.#db.prepare(sql).run(...params);
-      if (result.changes > 0 && messageIds.length > 0) {
-        const placeholders = messageIds.map(() => "?").join(", ");
-        this.#db.prepare(
-          `DELETE FROM messages_fts WHERE messageId IN (${placeholders})`
-        ).run(...messageIds.map((m) => m.id));
-      }
-      return result.changes > 0;
-    });
-  }
-  // ==========================================================================
-  // Message Operations (Graph Nodes)
-  // ==========================================================================
-  async addMessage(message2) {
-    this.#db.prepare(
-      `INSERT INTO messages (id, chatId, parentId, name, type, data, createdAt)
-         VALUES (
-           ?1,
-           ?2,
-           CASE WHEN ?3 = ?1 THEN (SELECT parentId FROM messages WHERE id = ?1) ELSE ?3 END,
-           ?4,
-           ?5,
-           ?6,
-           ?7
-         )
-         ON CONFLICT(id) DO UPDATE SET
-           name = excluded.name,
-           type = excluded.type,
-           data = excluded.data`
-    ).run(
-      message2.id,
-      message2.chatId,
-      message2.parentId,
-      message2.name,
-      message2.type ?? null,
-      JSON.stringify(message2.data),
-      message2.createdAt
-    );
-    const content = typeof message2.data === "string" ? message2.data : JSON.stringify(message2.data);
-    this.#db.prepare(`DELETE FROM messages_fts WHERE messageId = ?`).run(message2.id);
-    this.#db.prepare(
-      `INSERT INTO messages_fts(messageId, chatId, name, content)
-         VALUES (?, ?, ?, ?)`
-    ).run(message2.id, message2.chatId, message2.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),
-      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),
-      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;
-  }
-  async getMessages(chatId) {
-    const chat = await this.getChat(chatId);
-    if (!chat) {
-      throw new Error(`Chat "${chatId}" not found`);
-    }
-    const activeBranch = await this.getActiveBranch(chatId);
-    if (!activeBranch?.headMessageId) {
-      return [];
-    }
-    return this.getMessageChain(activeBranch.headMessageId);
-  }
-  // ==========================================================================
-  // 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.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),
-        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
-    };
-  }
-};
-var InMemoryContextStore = class extends SqliteContextStore {
-  constructor() {
-    super(":memory:");
-  }
-};
-function structuredOutput(options) {
-  return {
-    async generate(contextVariables, config) {
-      if (!options.context) {
-        throw new Error(`structuredOutput is missing a context.`);
-      }
-      if (!options.model) {
-        throw new Error(`structuredOutput is missing a model.`);
-      }
-      const { messages, systemPrompt } = await options.context.resolve({
-        renderer: new XmlRenderer()
-      });
-      const result = await generateText({
-        abortSignal: config?.abortSignal,
-        providerOptions: options.providerOptions,
-        model: options.model,
-        system: systemPrompt,
-        messages: await convertToModelMessages(messages),
-        stopWhen: stepCountIs(25),
-        experimental_repairToolCall: repairToolCall,
-        experimental_context: contextVariables,
-        output: Output.object({ schema: options.schema }),
-        tools: options.tools
-      });
-      return result.output;
-    },
-    async stream(contextVariables, config) {
-      if (!options.context) {
-        throw new Error(`structuredOutput is missing a context.`);
-      }
-      if (!options.model) {
-        throw new Error(`structuredOutput is missing a model.`);
-      }
-      const { messages, systemPrompt } = await options.context.resolve({
-        renderer: new XmlRenderer()
-      });
-      return streamText({
-        abortSignal: config?.abortSignal,
-        providerOptions: options.providerOptions,
-        model: options.model,
-        system: systemPrompt,
-        experimental_repairToolCall: repairToolCall,
-        messages: await convertToModelMessages(messages),
-        stopWhen: stepCountIs(50),
-        experimental_transform: config?.transform ?? smoothStream(),
-        experimental_context: contextVariables,
-        output: Output.object({ schema: options.schema }),
-        tools: options.tools
-      });
-    }
-  };
-}
-var repairToolCall = async ({
-  toolCall,
-  tools,
-  inputSchema,
-  error
-}) => {
-  console.log(
-    `Debug: ${chalk2.yellow("RepairingToolCall")}: ${toolCall.toolName}`,
-    error.name
-  );
-  if (NoSuchToolError.isInstance(error)) {
-    return null;
-  }
-  const tool = tools[toolCall.toolName];
-  const { output } = await generateText({
-    model: groq("openai/gpt-oss-20b"),
-    output: Output.object({ schema: tool.inputSchema }),
-    prompt: [
-      `The model tried to call the tool "${toolCall.toolName}" with the following inputs:`,
-      JSON.stringify(toolCall.input),
-      `The tool accepts the following schema:`,
-      JSON.stringify(inputSchema(toolCall)),
-      "Please fix the inputs."
-    ].join("\n")
-  });
-  return { ...toolCall, input: JSON.stringify(output) };
-};
-
-// packages/text2sql/src/lib/synthesis/extractors/base-contextual-extractor.ts
+import { groq } from "@ai-sdk/groq";
+import {
+  getToolOrDynamicToolName,
+  isTextUIPart,
+  isToolOrDynamicToolUIPart
+} from "ai";
+import dedent from "dedent";
+import z from "zod";
+import {
+  ContextEngine,
+  InMemoryContextStore,
+  fragment,
+  persona,
+  structuredOutput,
+  user
+} from "@deepagents/context";
 var contextResolverSchema = z.object({
   question: z.string().describe(
     "A standalone natural language question that the SQL query answers"
@@ -2173,14 +227,14 @@ async function resolveContext(params) {
     user("Generate a standalone question for this SQL query.")
   );
   const resolverOutput = structuredOutput({
-    model: groq2("openai/gpt-oss-20b"),
+    model: groq("openai/gpt-oss-20b"),
     context,
     schema: contextResolverSchema
   });
   return resolverOutput.generate();
 }
-function getMessageText(message2) {
-  const textParts = message2.parts.filter(isTextUIPart).map((part) => part.text);
+function getMessageText(message) {
+  const textParts = message.parts.filter(isTextUIPart).map((part) => part.text);
   return textParts.join(" ").trim();
 }
 function formatConversation(messages) {
@@ -2217,24 +271,24 @@ var BaseContextualExtractor = class extends PairProducer {
    * Core extraction loop - iterates through messages and calls hooks.
    */
   async extractSqlsWithContext(toolName, includeFailures) {
-    for (const message2 of this.messages) {
-      if (message2.role === "user") {
-        const text = getMessageText(message2);
+    for (const message of this.messages) {
+      if (message.role === "user") {
+        const text = getMessageText(message);
         if (text) {
           await this.onUserMessage(text);
         }
         continue;
       }
-      if (message2.role === "assistant") {
-        await this.extractFromAssistant(message2, toolName, includeFailures);
+      if (message.role === "assistant") {
+        await this.extractFromAssistant(message, toolName, includeFailures);
       }
     }
   }
   /**
    * Extract SQL from assistant message parts.
    */
-  async extractFromAssistant(message2, toolName, includeFailures) {
-    for (const part of message2.parts) {
+  async extractFromAssistant(message, toolName, includeFailures) {
+    for (const part of message.parts) {
       if (!isToolOrDynamicToolUIPart(part)) {
         continue;
       }
@@ -2263,9 +317,9 @@ var BaseContextualExtractor = class extends PairProducer {
         conversationContext: snapshot
       });
     }
-    const assistantText2 = getMessageText(message2);
-    if (assistantText2) {
-      this.context.push(`Assistant: ${assistantText2}`);
+    const assistantText = getMessageText(message);
+    if (assistantText) {
+      this.context.push(`Assistant: ${assistantText}`);
     }
   }
   /**
@@ -2310,13 +364,13 @@ var MessageExtractor = class extends PairProducer {
   async *produce() {
     const { includeFailures = false, toolName = "db_query" } = this.#options;
     let lastUserMessage = null;
-    for (const message2 of this.#messages) {
-      if (message2.role === "user") {
-        lastUserMessage = message2;
+    for (const message of this.#messages) {
+      if (message.role === "user") {
+        lastUserMessage = message;
         continue;
       }
-      if (message2.role === "assistant" && lastUserMessage) {
-        for (const part of message2.parts) {
+      if (message.role === "assistant" && lastUserMessage) {
+        for (const part of message.parts) {
           if (!isToolOrDynamicToolUIPart2(part)) {
             continue;
           }
@@ -2353,9 +407,17 @@ var MessageExtractor = class extends PairProducer {
 };
 
 // packages/text2sql/src/lib/synthesis/extractors/sql-extractor.ts
-import { groq as groq3 } from "@ai-sdk/groq";
+import { groq as groq2 } from "@ai-sdk/groq";
 import dedent2 from "dedent";
 import z2 from "zod";
+import {
+  ContextEngine as ContextEngine2,
+  InMemoryContextStore as InMemoryContextStore2,
+  fragment as fragment2,
+  persona as persona2,
+  structuredOutput as structuredOutput2,
+  user as user2
+} from "@deepagents/context";
 var outputSchema = z2.object({
   question: z2.string().describe("A natural language question that the SQL query answers")
 });
@@ -2390,20 +452,20 @@ var SqlExtractor = class extends PairProducer {
           continue;
         }
       }
-      const context = new ContextEngine({
-        store: new InMemoryContextStore(),
+      const context = new ContextEngine2({
+        store: new InMemoryContextStore2(),
         chatId: `sql-to-question-${crypto.randomUUID()}`,
         userId: "system"
       });
       context.set(
-        persona({
+        persona2({
           name: "sql_to_question",
           role: "You are an expert at understanding SQL queries and generating clear, natural language questions that describe what the query retrieves.",
           objective: "Generate clear, natural language questions that describe what SQL queries retrieve"
         }),
-        fragment("database_schema", introspection),
-        fragment("sql", sql),
-        fragment(
+        fragment2("database_schema", introspection),
+        fragment2("sql", sql),
+        fragment2(
           "task",
           dedent2`
             Given the database schema and the SQL query above, generate a single
@@ -2414,7 +476,7 @@ var SqlExtractor = class extends PairProducer {
             4. Is concise but complete
           `
         ),
-        fragment(
+        fragment2(
           "examples",
           dedent2`
             SQL: SELECT COUNT(*) FROM customers WHERE region = 'NY'
@@ -2427,10 +489,10 @@ var SqlExtractor = class extends PairProducer {
             Question: "Which customers have never placed an order?"
           `
         ),
-        user("Generate a natural language question for this SQL query.")
+        user2("Generate a natural language question for this SQL query.")
       );
-      const sqlToQuestionOutput = structuredOutput({
-        model: groq3("openai/gpt-oss-20b"),
+      const sqlToQuestionOutput = structuredOutput2({
+        model: groq2("openai/gpt-oss-20b"),
         context,
         schema: outputSchema
       });
@@ -2490,28 +552,36 @@ var WindowedContextExtractor = class extends BaseContextualExtractor {
 };
 
 // packages/text2sql/src/lib/synthesis/extractors/segmented-context-extractor.ts
-import { groq as groq4 } from "@ai-sdk/groq";
+import { groq as groq3 } from "@ai-sdk/groq";
 import dedent3 from "dedent";
 import z3 from "zod";
+import {
+  ContextEngine as ContextEngine3,
+  InMemoryContextStore as InMemoryContextStore3,
+  fragment as fragment3,
+  persona as persona3,
+  structuredOutput as structuredOutput3,
+  user as user3
+} from "@deepagents/context";
 var topicChangeSchema = z3.object({
   isTopicChange: z3.boolean().describe("Whether the new message represents a topic change"),
   reason: z3.string().describe("Brief explanation for the decision")
 });
 async function detectTopicChange(params) {
-  const context = new ContextEngine({
-    store: new InMemoryContextStore(),
+  const context = new ContextEngine3({
+    store: new InMemoryContextStore3(),
     chatId: `topic-change-${crypto.randomUUID()}`,
     userId: "system"
   });
   context.set(
-    persona({
+    persona3({
       name: "topic_change_detector",
       role: "You are an expert at understanding conversational flow and detecting topic changes.",
       objective: "Detect significant topic changes in database conversations"
     }),
-    fragment("conversation_context", params.context || "(no prior context)"),
-    fragment("new_message", params.newMessage),
-    fragment(
+    fragment3("conversation_context", params.context || "(no prior context)"),
+    fragment3("new_message", params.newMessage),
+    fragment3(
       "task",
       dedent3`
         Determine if the new message represents a significant topic change from the
@@ -2526,7 +596,7 @@ async function detectTopicChange(params) {
         - Requests for more details on the same topic
       `
     ),
-    fragment(
+    fragment3(
       "examples",
       dedent3`
         Context: "Show me customers in NY" → "Sort by revenue"
@@ -2542,10 +612,10 @@ async function detectTopicChange(params) {
         Decision: Topic change (products → orders/sales)
       `
     ),
-    user("Determine if this is a topic change.")
+    user3("Determine if this is a topic change.")
   );
-  const topicOutput = structuredOutput({
-    model: groq4("openai/gpt-oss-20b"),
+  const topicOutput = structuredOutput3({
+    model: groq3("openai/gpt-oss-20b"),
     context,
     schema: topicChangeSchema
   });
@@ -2645,10 +715,19 @@ var LastQueryExtractor = class extends BaseContextualExtractor {
 import pLimit from "p-limit";
 
 // packages/text2sql/src/lib/agents/question.agent.ts
-import { groq as groq5 } from "@ai-sdk/groq";
+import { groq as groq4 } from "@ai-sdk/groq";
 import dedent4 from "dedent";
 import z4 from "zod";
 import "@deepagents/agent";
+import {
+  ContextEngine as ContextEngine4,
+  InMemoryContextStore as InMemoryContextStore4,
+  fragment as fragment4,
+  guardrail,
+  persona as persona4,
+  structuredOutput as structuredOutput4,
+  user as user4
+} from "@deepagents/context";
 var complexityInstructions = {
   simple: dedent4`
     Generate simple questions that require:
@@ -2692,24 +771,24 @@ var outputSchema2 = z4.object({
 });
 async function generateQuestions(params) {
   const { introspection, complexity, count, prompt, model } = params;
-  const context = new ContextEngine({
-    store: new InMemoryContextStore(),
+  const context = new ContextEngine4({
+    store: new InMemoryContextStore4(),
     chatId: `question-gen-${crypto.randomUUID()}`,
     userId: "system"
   });
   context.set(
-    persona({
+    persona4({
       name: "question_generator",
       role: "You are a synthetic data generator specializing in creating realistic natural language questions that users might ask about a database.",
       objective: "Generate diverse, realistic natural language questions that match the specified complexity level"
     }),
-    fragment("database_schema", introspection || ""),
-    fragment(
+    fragment4("database_schema", introspection || ""),
+    fragment4(
       "complexity",
       { level: complexity },
       complexityInstructions[complexity]
     ),
-    fragment(
+    fragment4(
       "task",
       dedent4`
         Generate exactly ${count} natural language questions at the "${complexity}" complexity level.
@@ -2735,12 +814,12 @@ async function generateQuestions(params) {
     guardrail({
       rule: "All questions must match the specified complexity level"
     }),
-    user(
+    user4(
       prompt ?? `Generate ${count} questions at ${complexity} complexity given db schema.`
     )
   );
-  const questionOutput = structuredOutput({
-    model: model ?? groq5("openai/gpt-oss-20b"),
+  const questionOutput = structuredOutput4({
+    model: model ?? groq4("openai/gpt-oss-20b"),
     context,
     schema: outputSchema2
   });
@@ -2748,7 +827,7 @@ async function generateQuestions(params) {
 }
 
 // packages/text2sql/src/lib/agents/sql.agent.ts
-import { groq as groq6 } from "@ai-sdk/groq";
+import { groq as groq5 } from "@ai-sdk/groq";
 import {
   APICallError,
   JSONParseError,
@@ -2764,6 +843,13 @@ import { createWriteStream } from "node:fs";
 import pRetry from "p-retry";
 import z5 from "zod";
 import "@deepagents/agent";
+import {
+  ContextEngine as ContextEngine5,
+  InMemoryContextStore as InMemoryContextStore5,
+  persona as persona5,
+  structuredOutput as structuredOutput5,
+  user as user5
+} from "@deepagents/context";
 var logger = new Console({
   stdout: createWriteStream("./sql-agent.log", { flags: "a" }),
   stderr: createWriteStream("./sql-agent-error.log", { flags: "a" }),
@@ -2777,8 +863,8 @@ function extractSql(output) {
 var marker = Symbol("SQLValidationError");
 var SQLValidationError = class _SQLValidationError extends Error {
   [marker];
-  constructor(message2) {
-    super(message2);
+  constructor(message) {
+    super(message);
     this.name = "SQLValidationError";
     this[marker] = true;
   }
@@ -2787,8 +873,8 @@ var SQLValidationError = class _SQLValidationError extends Error {
   }
 };
 var UnanswerableSQLError = class _UnanswerableSQLError extends Error {
-  constructor(message2) {
-    super(message2);
+  constructor(message) {
+    super(message);
     this.name = "UnanswerableSQLError";
   }
   static isInstance(error) {
@@ -2799,13 +885,13 @@ async function toSql(options) {
   const { maxRetries = 3 } = options;
   return withRetry(
     async (attemptNumber, errors, attempts) => {
-      const context = new ContextEngine({
-        store: new InMemoryContextStore(),
+      const context = new ContextEngine5({
+        store: new InMemoryContextStore5(),
         chatId: `sql-gen-${crypto.randomUUID()}`,
         userId: "system"
       });
       context.set(
-        persona({
+        persona5({
           name: "Freya",
           role: "You are an expert SQL query generator. You translate natural language questions into precise, efficient SQL queries based on the provided database schema.",
           objective: "Translate natural language questions into precise, efficient SQL queries"
@@ -2815,21 +901,21 @@ async function toSql(options) {
       );
       if (errors.length) {
         context.set(
-          user(options.input),
-          user(
+          user5(options.input),
+          user5(
             `<validation_error>Your previous SQL query had the following error: ${errors.at(-1)?.message}. Please fix the query.</validation_error>`
           )
         );
       } else {
-        context.set(user(options.input));
+        context.set(user5(options.input));
       }
       const temperature = RETRY_TEMPERATURES[attemptNumber - 1] ?? RETRY_TEMPERATURES[RETRY_TEMPERATURES.length - 1];
-      const baseModel = options.model ?? groq6("openai/gpt-oss-20b");
+      const baseModel = options.model ?? groq5("openai/gpt-oss-20b");
       const model = wrapLanguageModel({
         model: baseModel,
         middleware: defaultSettingsMiddleware({ settings: { temperature } })
       });
-      const sqlOutput = structuredOutput({
+      const sqlOutput = structuredOutput5({
         model,
         context,
         schema: z5.union([
@@ -2943,12 +1029,12 @@ var SchemaSynthesizer = class extends PairProducer {
   async *produce() {
     const introspection = "";
     const combinations = this.#personas.flatMap(
-      (persona2) => this.#complexities.map((complexity) => ({ persona: persona2, complexity }))
+      (persona8) => this.#complexities.map((complexity) => ({ persona: persona8, complexity }))
     );
-    for (const { persona: persona2, complexity } of combinations) {
+    for (const { persona: persona8, complexity } of combinations) {
       const pairs = await this.#processCombination(
         introspection,
-        persona2,
+        persona8,
         complexity
       );
       if (pairs.length) {
@@ -2960,8 +1046,8 @@ var SchemaSynthesizer = class extends PairProducer {
    * Processes a single persona × complexity combination by generating questions
    * and converting each to SQL in parallel.
    */
-  async #processCombination(introspection, persona2, complexity) {
-    const personaContext = persona2 ? `As ${persona2.role}, ${persona2.perspective}
+  async #processCombination(introspection, persona8, complexity) {
+    const personaContext = persona8 ? `As ${persona8.role}, ${persona8.perspective}
 
 Generate questions this persona would ask.` : void 0;
     const prompt = personaContext ? `${personaContext}
@@ -3013,11 +1099,20 @@ Generate ${this.options.count} questions at ${complexity} complexity.` : void 0;
 };
 
 // packages/text2sql/src/lib/synthesis/synthesizers/breadth-evolver.ts
-import { groq as groq7 } from "@ai-sdk/groq";
+import { groq as groq6 } from "@ai-sdk/groq";
 import dedent5 from "dedent";
 import pLimit2 from "p-limit";
 import z6 from "zod";
 import "@deepagents/agent";
+import {
+  ContextEngine as ContextEngine6,
+  InMemoryContextStore as InMemoryContextStore6,
+  fragment as fragment5,
+  guardrail as guardrail2,
+  persona as personaFragment,
+  structuredOutput as structuredOutput6,
+  user as user6
+} from "@deepagents/context";
 
 // packages/text2sql/src/lib/synthesis/synthesizers/styles.ts
 var ALL_STYLES = [
@@ -3059,8 +1154,8 @@ var paraphraserOutputSchema = z6.object({
   ).min(1).describe("List of paraphrased questions that would produce the same SQL")
 });
 async function paraphraseQuestion(params) {
-  const context = new ContextEngine({
-    store: new InMemoryContextStore(),
+  const context = new ContextEngine6({
+    store: new InMemoryContextStore6(),
     chatId: `paraphraser-${crypto.randomUUID()}`,
     userId: "system"
   });
@@ -3083,20 +1178,20 @@ async function paraphraseQuestion(params) {
         </communication_styles>
       ` : "";
   context.set(
-    persona({
+    personaFragment({
       name: "question_paraphraser",
       role: "You are a linguistic expert specializing in paraphrasing database questions. Your task is to generate alternative phrasings of questions that preserve the exact same semantic meaning - they must all produce the identical SQL query.",
       objective: "Generate paraphrased versions of questions that preserve exact semantic meaning and produce identical SQL"
     }),
-    fragment("original_question", params.question),
-    fragment(
+    fragment5("original_question", params.question),
+    fragment5(
       "reference_sql",
       params.sql,
       "This SQL shows what the question is really asking - all paraphrases must ask for exactly this"
     ),
-    ...personaInstruction ? [fragment("persona", personaInstruction)] : [],
-    ...styleInstruction ? [fragment("communication_styles", styleInstruction)] : [],
-    fragment(
+    ...personaInstruction ? [fragment5("persona", personaInstruction)] : [],
+    ...styleInstruction ? [fragment5("communication_styles", styleInstruction)] : [],
+    fragment5(
       "task",
       dedent5`
         Generate exactly ${params.count} paraphrased versions of the original question.
@@ -3110,22 +1205,22 @@ async function paraphraseQuestion(params) {
         ${params.persona?.styles?.length ? "6. Apply the specified communication styles to create diverse phrasings" : ""}
       `
     ),
-    guardrail({ rule: "NEVER change what data is being requested" }),
-    guardrail({
+    guardrail2({ rule: "NEVER change what data is being requested" }),
+    guardrail2({
       rule: "NEVER add filters, aggregations, or conditions not in the original"
     }),
-    guardrail({
+    guardrail2({
       rule: "NEVER remove any specificity from the original question"
     }),
-    guardrail({
+    guardrail2({
       rule: "All paraphrases must be answerable by the exact same SQL query"
     }),
-    user(
+    user6(
       `Paraphrase this question ${params.count} times: "${params.question}"`
     )
   );
-  const paraphraserOutput = structuredOutput({
-    model: params.model ?? groq7("openai/gpt-oss-20b"),
+  const paraphraserOutput = structuredOutput6({
+    model: params.model ?? groq6("openai/gpt-oss-20b"),
     context,
     schema: paraphraserOutputSchema
   });
@@ -3173,13 +1268,22 @@ var BreadthEvolver = class extends PairProducer {
 };
 
 // packages/text2sql/src/lib/synthesis/synthesizers/depth-evolver.ts
-import { groq as groq8 } from "@ai-sdk/groq";
+import { groq as groq7 } from "@ai-sdk/groq";
 import { NoObjectGeneratedError as NoObjectGeneratedError2, NoOutputGeneratedError as NoOutputGeneratedError2 } from "ai";
 import dedent6 from "dedent";
 import pLimit3 from "p-limit";
 import pRetry2 from "p-retry";
 import z7 from "zod";
 import "@deepagents/agent";
+import {
+  ContextEngine as ContextEngine7,
+  InMemoryContextStore as InMemoryContextStore7,
+  fragment as fragment6,
+  guardrail as guardrail3,
+  persona as persona6,
+  structuredOutput as structuredOutput7,
+  user as user7
+} from "@deepagents/context";
 var techniqueInstructions = {
   "add-aggregation": dedent6`
     Add aggregation requirements to the question.
@@ -3226,30 +1330,30 @@ var evolverOutputSchema = z7.object({
   evolvedQuestion: z7.string().describe("The evolved, more complex version of the original question")
 });
 async function evolveQuestion(params) {
-  const context = new ContextEngine({
-    store: new InMemoryContextStore(),
+  const context = new ContextEngine7({
+    store: new InMemoryContextStore7(),
     chatId: `evolver-${crypto.randomUUID()}`,
     userId: "system"
   });
   context.set(
-    persona({
+    persona6({
       name: "question_evolver",
       role: "You are an expert at evolving simple database questions into more complex ones. Your task is to take a basic question and transform it into a more sophisticated version that requires advanced SQL techniques to answer.",
       objective: "Transform simple questions into complex versions requiring advanced SQL techniques"
     }),
-    fragment("original_question", params.question),
-    fragment(
+    fragment6("original_question", params.question),
+    fragment6(
       "original_sql",
       params.sql,
       "(This shows what the original question required)"
     ),
-    fragment("database_schema", params.schema),
-    fragment(
+    fragment6("database_schema", params.schema),
+    fragment6(
       "technique",
       { name: params.technique },
       params.techniqueInstruction
     ),
-    fragment(
+    fragment6(
       "task",
       dedent6`
         Evolve the original question using the "${params.technique}" technique.
@@ -3263,22 +1367,22 @@ async function evolveQuestion(params) {
         6. The evolved question should build upon the original topic/domain
       `
     ),
-    guardrail({
+    guardrail3({
       rule: "The evolved question MUST require more complex SQL than the original"
     }),
-    guardrail({
+    guardrail3({
       rule: "Do not ask for data that does not exist in the schema"
     }),
-    guardrail({
+    guardrail3({
       rule: "Keep the question grounded in the same domain as the original"
     }),
-    guardrail({ rule: "Make sure the question is clear and unambiguous" }),
-    user(
+    guardrail3({ rule: "Make sure the question is clear and unambiguous" }),
+    user7(
       `Evolve this question using "${params.technique}": "${params.question}"`
     )
   );
-  const evolverOutput = structuredOutput({
-    model: params.model ?? groq8("openai/gpt-oss-20b"),
+  const evolverOutput = structuredOutput7({
+    model: params.model ?? groq7("openai/gpt-oss-20b"),
     context,
     schema: evolverOutputSchema
   });
@@ -3395,10 +1499,20 @@ async function withRetry2(computation) {
 }
 
 // packages/text2sql/src/lib/synthesis/synthesizers/persona-generator.ts
-import { groq as groq9 } from "@ai-sdk/groq";
+import { groq as groq8 } from "@ai-sdk/groq";
 import dedent7 from "dedent";
 import z8 from "zod";
 import "@deepagents/agent";
+import {
+  ContextEngine as ContextEngine8,
+  InMemoryContextStore as InMemoryContextStore8,
+  XmlRenderer,
+  fragment as fragment7,
+  guardrail as guardrail4,
+  persona as personaFragment2,
+  structuredOutput as structuredOutput8,
+  user as user8
+} from "@deepagents/context";
 var outputSchema3 = z8.object({
   personas: z8.array(
     z8.object({
@@ -3415,19 +1529,19 @@ var outputSchema3 = z8.object({
 async function generatePersonas(schemaFragments, options) {
   const schema = new XmlRenderer().render(schemaFragments);
   const count = options?.count ?? 5;
-  const context = new ContextEngine({
-    store: new InMemoryContextStore(),
+  const context = new ContextEngine8({
+    store: new InMemoryContextStore8(),
     chatId: `persona-gen-${crypto.randomUUID()}`,
     userId: "system"
   });
   context.set(
-    persona({
+    personaFragment2({
       name: "persona_generator",
       role: "You are an expert at understanding database schemas and inferring who would use them.",
       objective: "Generate realistic personas representing users who would query this database"
     }),
-    fragment("database_schema", schema),
-    fragment(
+    fragment7("database_schema", schema),
+    fragment7(
       "task",
       dedent7`
         Analyze the database schema and generate realistic personas representing
@@ -3460,7 +1574,7 @@ async function generatePersonas(schemaFragments, options) {
         - Styles should match how this persona would naturally communicate
       `
     ),
-    fragment(
+    fragment7(
       "example",
       dedent7`
         For an e-commerce schema with orders, customers, products tables:
@@ -3478,21 +1592,21 @@ async function generatePersonas(schemaFragments, options) {
         }
       `
     ),
-    guardrail({
+    guardrail4({
       rule: "Only generate personas relevant to the actual schema provided"
     }),
-    guardrail({
+    guardrail4({
       rule: "Do not invent tables or data that do not exist in the schema"
     }),
-    guardrail({
+    guardrail4({
       rule: "Ensure perspectives are specific to the domain, not generic"
     }),
-    user(
+    user8(
       `Generate exactly ${count} distinct personas who would query this database.`
     )
   );
-  const personaOutput = structuredOutput({
-    model: options?.model ?? groq9("openai/gpt-oss-20b"),
+  const personaOutput = structuredOutput8({
+    model: options?.model ?? groq8("openai/gpt-oss-20b"),
     context,
     schema: outputSchema3
   });
@@ -3500,11 +1614,32 @@ async function generatePersonas(schemaFragments, options) {
   return output.personas;
 }
 
+// packages/text2sql/src/lib/synthesis/synthesizers/teachings-generator.ts
+import { XmlRenderer as XmlRenderer2 } from "@deepagents/context";
+
 // packages/text2sql/src/lib/agents/teachables.agent.ts
-import { groq as groq10 } from "@ai-sdk/groq";
+import { groq as groq9 } from "@ai-sdk/groq";
 import dedent8 from "dedent";
 import z9 from "zod";
 import "@deepagents/agent";
+import {
+  ContextEngine as ContextEngine9,
+  InMemoryContextStore as InMemoryContextStore9,
+  analogy,
+  clarification,
+  example,
+  explain,
+  fragment as fragment8,
+  guardrail as guardrail5,
+  hint,
+  persona as persona7,
+  quirk,
+  structuredOutput as structuredOutput9,
+  styleGuide,
+  term,
+  user as user9,
+  workflow
+} from "@deepagents/context";
 var outputSchema4 = z9.object({
   terms: z9.array(z9.object({ name: z9.string(), definition: z9.string() })).optional().describe("Domain terminology definitions"),
   hints: z9.array(z9.object({ text: z9.string() })).optional().describe("Helpful hints for SQL generation"),
@@ -3557,20 +1692,20 @@ var outputSchema4 = z9.object({
   ).optional().describe("Concept analogies")
 });
 async function toTeachings(input, options) {
-  const context = new ContextEngine({
-    store: new InMemoryContextStore(),
+  const context = new ContextEngine9({
+    store: new InMemoryContextStore9(),
     chatId: `teachables-gen-${crypto.randomUUID()}`,
     userId: "system"
   });
   context.set(
-    persona({
+    persona7({
       name: "teachables-author",
       role: 'You design "fragments" for a Text2SQL system. Fragments become structured XML instructions.',
       objective: "Choose only high-impact items that improve accuracy, safety, or clarity for this database"
     }),
-    fragment("database_schema", input.schema),
-    ...input.context ? [fragment("additional_context", input.context)] : [],
-    fragment(
+    fragment8("database_schema", input.schema),
+    ...input.context ? [fragment8("additional_context", input.context)] : [],
+    fragment8(
       "output_structure",
       dedent8`
         Output a JSON object with these optional arrays (include only relevant ones):
@@ -3586,7 +1721,7 @@ async function toTeachings(input, options) {
         - analogies: [{ concepts: string[], relationship: string, insight?: string, therefore?: string, pitfall?: string }]
       `
     ),
-    fragment(
+    fragment8(
       "task",
       dedent8`
         1. Analyze the schema to infer domain, relationships, and sensitive columns.
@@ -3598,12 +1733,12 @@ async function toTeachings(input, options) {
         4. Only include categories that are relevant to this schema.
       `
     ),
-    user(
+    user9(
       `Analyze this database schema and generate fragments that will help an AI generate accurate SQL queries.`
     )
   );
-  const teachablesOutput = structuredOutput({
-    model: options?.model ?? groq10("openai/gpt-oss-20b"),
+  const teachablesOutput = structuredOutput9({
+    model: options?.model ?? groq9("openai/gpt-oss-20b"),
     context,
     schema: outputSchema4
   });
@@ -3613,7 +1748,7 @@ async function toTeachings(input, options) {
   result.hints?.forEach((h) => fragments.push(hint(h.text)));
   result.guardrails?.forEach(
     (g) => fragments.push(
-      guardrail({ rule: g.rule, reason: g.reason, action: g.action })
+      guardrail5({ rule: g.rule, reason: g.reason, action: g.action })
     )
   );
   result.explains?.forEach(
@@ -3669,7 +1804,7 @@ async function toTeachings(input, options) {
 
 // packages/text2sql/src/lib/synthesis/synthesizers/teachings-generator.ts
 async function generateTeachings(schemaFragments, options) {
-  const schema = new XmlRenderer().render(schemaFragments);
+  const schema = new XmlRenderer2().render(schemaFragments);
   const maxRetries = options?.maxRetries ?? 3;
   let lastError;
   for (let attempt = 0; attempt < maxRetries; attempt++) {