@deepagents/text2sql 0.14.0 → 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 dedent2 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 dedent from "dedent";
-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.for("@deepagents/context: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(
-      (it) => it.name === this.#branchName || it.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
-    };
-  }
-  /**
-   * Rewind to a message without clearing pending messages.
-   * Used internally when saving an update to an existing message.
-   */
-  async #rewindForUpdate(messageId) {
-    const pendingBackup = [...this.#pendingMessages];
-    await this.rewind(messageId);
-    this.#pendingMessages = pendingBackup;
-  }
-  /**
-   * 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 (let i = 0; i < this.#pendingMessages.length; i++) {
-      const fragment2 = this.#pendingMessages[i];
-      if (isLazyFragment(fragment2)) {
-        this.#pendingMessages[i] = await this.#resolveLazyFragment(fragment2);
-      }
-    }
-    for (const fragment2 of this.#pendingMessages) {
-      if (!fragment2.codec) {
-        throw new Error(
-          `Fragment "${fragment2.name}" is missing codec. Lazy fragments must be resolved before decode.`
-        );
-      }
-      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);
-      }
-    }
-    for (const fragment2 of this.#pendingMessages) {
-      if (fragment2.id) {
-        const existing = await this.#store.getMessage(fragment2.id);
-        if (existing && existing.parentId) {
-          await this.#rewindForUpdate(existing.parentId);
-          fragment2.id = crypto.randomUUID();
-          break;
-        }
-      }
-    }
-    let parentId = this.#branch.headMessageId;
-    const now = Date.now();
-    for (const fragment2 of this.#pendingMessages) {
-      if (!fragment2.codec) {
-        throw new Error(
-          `Fragment "${fragment2.name}" is missing codec. Lazy fragments must be resolved before encode.`
-        );
-      }
-      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 mounts from available_skills fragments.
-   * Returns unified mount array where entries with `name` are individual skills.
-   *
-   * @example
-   * ```ts
-   * const context = new ContextEngine({ store, chatId, userId })
-   *   .set(skills({ paths: [{ host: './skills', sandbox: '/skills' }] }));
-   *
-   * const { mounts } = context.getSkillMounts();
-   * // mounts: [{ name: 'bi-dashboards', host: './skills/bi-dashboards/SKILL.md', sandbox: '/skills/bi-dashboards/SKILL.md' }]
-   *
-   * // Extract skills only (entries with name)
-   * const skills = mounts.filter(m => m.name);
-   * ```
-   */
-  getSkillMounts() {
-    for (const fragment2 of this.#fragments) {
-      if (fragment2.name === "available_skills" && fragment2.metadata?.mounts) {
-        return { mounts: fragment2.metadata.mounts };
-      }
-    }
-    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 SKILLS_INSTRUCTIONS = dedent`A skill is a set of local instructions to follow that is stored in a \`SKILL.md\` file. Below is the list of skills that can be used. Each entry includes a name, description, and file path so you can open the source for full instructions when using a specific skill.
-
-### How to use skills
-- Discovery: The list below shows the skills available in this session (name + description + file path). Skill bodies live on disk at the listed paths.
-- Trigger rules: If the user names a skill (with \`$SkillName\` or plain text) OR the task clearly matches a skill's description shown below, you must use that skill for that turn before doing anything else. Multiple mentions mean use them all. Do not carry skills across turns unless re-mentioned.
-- Missing/blocked: If a named skill isn't in the list or the path can't be read, say so briefly and continue with the best fallback.
-- How to use a skill (progressive disclosure):
-  1) After deciding to use a skill, open its \`SKILL.md\`. Read only enough to follow the workflow.
-  2) If \`SKILL.md\` points to extra folders such as \`references/\`, load only the specific files needed for the request; don't bulk-load everything.
-  3) If \`scripts/\` exist, prefer running or patching them instead of retyping large code blocks.
-  4) If \`assets/\` or templates exist, reuse them instead of recreating from scratch.
-- Coordination and sequencing:
-  - If multiple skills apply, choose the minimal set that covers the request and state the order you'll use them.
-  - Announce which skill(s) you're using and why (one short line). If you skip an obvious skill, say why.
-- Context hygiene:
-  - Keep context small: summarize long sections instead of pasting them; only load extra files when needed.
-  - Avoid deep reference-chasing: prefer opening only files directly linked from \`SKILL.md\` unless you're blocked.
-  - When variants exist (frameworks, providers, domains), pick only the relevant reference file(s) and note that choice.
-- Safety and fallback: If a skill can't be applied cleanly (missing files, unclear instructions), state the issue, pick the next-best approach, and continue.`;
-var ddl_sqlite_default = "-- Context Store DDL for SQLite\n-- This schema implements a DAG-based message history with branching and checkpoints.\n\n-- Performance PRAGMAs (session-level, run on each connection)\nPRAGMA journal_mode = WAL;\nPRAGMA synchronous = NORMAL;\nPRAGMA cache_size = -64000;\nPRAGMA temp_store = MEMORY;\nPRAGMA mmap_size = 268435456;\n\n-- Integrity\nPRAGMA foreign_keys = ON;\n\n-- Chats table\n-- createdAt/updatedAt: DEFAULT for insert, inline SET for updates\nCREATE TABLE IF NOT EXISTS chats (\n  id TEXT PRIMARY KEY,\n  userId TEXT NOT NULL,\n  title TEXT,\n  metadata TEXT,\n  createdAt INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),\n  updatedAt INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)\n);\n\nCREATE INDEX IF NOT EXISTS idx_chats_updatedAt ON chats(updatedAt);\nCREATE INDEX IF NOT EXISTS idx_chats_userId ON chats(userId);\n-- Composite index for listChats(): WHERE userId = ? ORDER BY updatedAt DESC\nCREATE INDEX IF NOT EXISTS idx_chats_userId_updatedAt ON chats(userId, updatedAt DESC);\n\n-- Messages table (nodes in the DAG)\nCREATE TABLE IF NOT EXISTS messages (\n  id TEXT PRIMARY KEY,\n  chatId TEXT NOT NULL,\n  parentId TEXT,\n  name TEXT NOT NULL,\n  type TEXT,\n  data TEXT NOT NULL,\n  createdAt INTEGER NOT NULL,\n  FOREIGN KEY (chatId) REFERENCES chats(id) ON DELETE CASCADE,\n  FOREIGN KEY (parentId) REFERENCES messages(id)\n);\n\nCREATE INDEX IF NOT EXISTS idx_messages_chatId ON messages(chatId);\nCREATE INDEX IF NOT EXISTS idx_messages_parentId ON messages(parentId);\n-- Composite index for recursive CTE parent traversal in getMessageChain()\nCREATE INDEX IF NOT EXISTS idx_messages_chatId_parentId ON messages(chatId, parentId);\n\n-- Branches table (pointers to head messages)\nCREATE TABLE IF NOT EXISTS branches (\n  id TEXT PRIMARY KEY,\n  chatId TEXT NOT NULL,\n  name TEXT NOT NULL,\n  headMessageId TEXT,\n  isActive INTEGER NOT NULL DEFAULT 0,\n  createdAt INTEGER NOT NULL,\n  FOREIGN KEY (chatId) REFERENCES chats(id) ON DELETE CASCADE,\n  FOREIGN KEY (headMessageId) REFERENCES messages(id),\n  UNIQUE(chatId, name)\n);\n\nCREATE INDEX IF NOT EXISTS idx_branches_chatId ON branches(chatId);\n-- Composite index for getActiveBranch(): WHERE chatId = ? AND isActive = 1\nCREATE INDEX IF NOT EXISTS idx_branches_chatId_isActive ON branches(chatId, isActive);\n\n-- Checkpoints table (pointers to message nodes)\nCREATE TABLE IF NOT EXISTS checkpoints (\n  id TEXT PRIMARY KEY,\n  chatId TEXT NOT NULL,\n  name TEXT NOT NULL,\n  messageId TEXT NOT NULL,\n  createdAt INTEGER NOT NULL,\n  FOREIGN KEY (chatId) REFERENCES chats(id) ON DELETE CASCADE,\n  FOREIGN KEY (messageId) REFERENCES messages(id),\n  UNIQUE(chatId, name)\n);\n\nCREATE INDEX IF NOT EXISTS idx_checkpoints_chatId ON checkpoints(chatId);\n\n-- FTS5 virtual table for full-text search\n-- messageId/chatId/name are UNINDEXED (stored but not searchable, used for filtering/joining)\n-- Only 'content' is indexed for full-text search\nCREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(\n  messageId UNINDEXED,\n  chatId UNINDEXED,\n  name UNINDEXED,\n  content,\n  tokenize='porter unicode61'\n);\n";
-var SqliteContextStore = class extends ContextStore {
-  #db;
-  #statements = /* @__PURE__ */ new Map();
-  /**
-   * Get or create a prepared statement.
-   * Statements are cached for the lifetime of the store to avoid
-   * repeated SQL parsing and compilation overhead.
-   */
-  #stmt(sql) {
-    let stmt = this.#statements.get(sql);
-    if (!stmt) {
-      stmt = this.#db.prepare(sql);
-      this.#statements.set(sql, stmt);
-    }
-    return stmt;
-  }
-  constructor(path3) {
-    super();
-    this.#db = new DatabaseSync(path3);
-    this.#db.exec(ddl_sqlite_default);
-  }
-  /**
-   * 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) {
-    return this.#useTransaction(() => {
-      const row = this.#db.prepare(
-        `INSERT INTO chats (id, userId, title, metadata)
-           VALUES (?, ?, ?, ?)
-           RETURNING *`
-      ).get(
-        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());
-      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 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) {
-    if (message2.parentId === message2.id) {
-      throw new Error(`Message ${message2.id} cannot be its own parent`);
-    }
-    this.#stmt(
-      `INSERT INTO messages (id, chatId, parentId, name, type, data, createdAt)
-       VALUES (?, ?, ?, ?, ?, ?, ?)
-       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.#stmt(`DELETE FROM messages_fts WHERE messageId = ?`).run(message2.id);
-    this.#stmt(
-      `INSERT INTO messages_fts(messageId, chatId, name, content)
-       VALUES (?, ?, ?, ?)`
-    ).run(message2.id, message2.chatId, message2.name, content);
-  }
-  async getMessage(messageId) {
-    const row = this.#stmt("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.#stmt(
-      `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
-        WHERE c.depth < 100000
-      )
-      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.#stmt(
-      "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.#stmt(
-      "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.#stmt("UPDATE branches SET headMessageId = ? WHERE id = ?").run(
-      messageId,
-      branchId
-    );
-  }
-  async listBranches(chatId) {
-    const rows = this.#db.prepare(
-      `SELECT
-          b.id,
-          b.name,
-          b.headMessageId,
-          b.isActive,
-          b.createdAt,
-          COALESCE(
-            (
-              WITH RECURSIVE chain AS (
-                SELECT id, parentId FROM messages WHERE id = b.headMessageId
-                UNION ALL
-                SELECT m.id, m.parentId FROM messages m
-                INNER JOIN chain c ON m.id = c.parentId
-              )
-              SELECT COUNT(*) FROM chain
-            ),
-            0
-          ) as messageCount
-        FROM branches b
-        WHERE b.chatId = ?
-        ORDER BY b.createdAt ASC`
-    ).all(chatId);
-    return rows.map((row) => ({
-      id: row.id,
-      name: row.name,
-      headMessageId: row.headMessageId,
-      isActive: row.isActive === 1,
-      messageCount: row.messageCount,
-      createdAt: row.createdAt
-    }));
-  }
-  // ==========================================================================
-  // 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"
@@ -2149,7 +203,7 @@ async function resolveContext(params) {
     fragment("sql", params.sql),
     fragment(
       "task",
-      dedent2`
+      dedent`
         Given the conversation above and the SQL query that was executed,
         generate a single, standalone natural language question that:
         1. Fully captures the user's intent without needing prior context
@@ -2160,7 +214,7 @@ async function resolveContext(params) {
     ),
     fragment(
       "examples",
-      dedent2`
+      dedent`
         Conversation: "Show me customers" → "Filter to NY" → "Sort by revenue"
         SQL: SELECT * FROM customers WHERE region = 'NY' ORDER BY revenue DESC
         Question: "Show me customers in the NY region sorted by revenue"
@@ -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 dedent3 from "dedent";
+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,22 +452,22 @@ 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",
-          dedent3`
+          dedent2`
             Given the database schema and the SQL query above, generate a single
             natural language question that:
             1. Accurately describes what information the query retrieves
@@ -2414,9 +476,9 @@ var SqlExtractor = class extends PairProducer {
             4. Is concise but complete
           `
         ),
-        fragment(
+        fragment2(
           "examples",
-          dedent3`
+          dedent2`
             SQL: SELECT COUNT(*) FROM customers WHERE region = 'NY'
             Question: "How many customers do we have in New York?"
 
@@ -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,30 +552,38 @@ var WindowedContextExtractor = class extends BaseContextualExtractor {
 };
 
 // packages/text2sql/src/lib/synthesis/extractors/segmented-context-extractor.ts
-import { groq as groq4 } from "@ai-sdk/groq";
-import dedent4 from "dedent";
+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",
-      dedent4`
+      dedent3`
         Determine if the new message represents a significant topic change from the
         prior conversation context. A topic change occurs when:
         1. The user asks about a completely different entity/table/domain
@@ -2526,9 +596,9 @@ async function detectTopicChange(params) {
         - Requests for more details on the same topic
       `
     ),
-    fragment(
+    fragment3(
       "examples",
-      dedent4`
+      dedent3`
         Context: "Show me customers in NY" → "Sort by revenue"
         New: "Filter to those with orders over $1000"
         Decision: NOT a topic change (still refining customer query)
@@ -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,12 +715,21 @@ 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 dedent5 from "dedent";
+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: dedent5`
+  simple: dedent4`
     Generate simple questions that require:
     - Basic SELECT with single table
     - Simple WHERE clauses with one condition
@@ -2658,7 +737,7 @@ var complexityInstructions = {
     - No joins required
     Examples: "How many customers do we have?", "List all products", "What is the total revenue?"
   `,
-  moderate: dedent5`
+  moderate: dedent4`
     Generate moderate questions that require:
     - JOINs between 2-3 tables
     - Multiple WHERE conditions (AND/OR)
@@ -2667,7 +746,7 @@ var complexityInstructions = {
     - Basic subqueries
     Examples: "What are the top 5 customers by total orders?", "Which products have never been ordered?"
   `,
-  complex: dedent5`
+  complex: dedent4`
     Generate complex questions that require:
     - Multiple JOINs (3+ tables)
     - Nested subqueries or CTEs
@@ -2676,7 +755,7 @@ var complexityInstructions = {
     - Date/time calculations
     Examples: "What is the month-over-month growth rate?", "Which customers have increased spending compared to last year?"
   `,
-  "high complex": dedent5`
+  "high complex": dedent4`
     Generate highly complex questions that require advanced SQL features:
     - Window functions (ROW_NUMBER, RANK, DENSE_RANK)
     - LAG, LEAD for comparisons
@@ -2692,26 +771,26 @@ 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",
-      dedent5`
+      dedent4`
         Generate exactly ${count} natural language questions at the "${complexity}" complexity level.
         The questions should:
         1. Match the complexity requirements above
@@ -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 dedent6 from "dedent";
+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,12 +1154,12 @@ 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"
   });
-  const personaInstruction = params.persona ? dedent6`
+  const personaInstruction = params.persona ? dedent5`
         <persona role="${params.persona.role}">
           ${params.persona.perspective}
 
@@ -3072,7 +1167,7 @@ async function paraphraseQuestion(params) {
           Use their vocabulary, priorities, and framing style.
         </persona>
       ` : "";
-  const styleInstruction = params.persona?.styles && params.persona.styles.length > 0 ? dedent6`
+  const styleInstruction = params.persona?.styles && params.persona.styles.length > 0 ? dedent5`
         <communication_styles>
           Generate paraphrases using these communication styles: ${params.persona.styles.join(", ")}
 
@@ -3083,22 +1178,22 @@ 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",
-      dedent6`
+      dedent5`
         Generate exactly ${params.count} paraphrased versions of the original question.
 
         Requirements:
@@ -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,15 +1268,24 @@ 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 dedent7 from "dedent";
+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": dedent7`
+  "add-aggregation": dedent6`
     Add aggregation requirements to the question.
     Transform it to require GROUP BY, COUNT, SUM, AVG, MIN, MAX, or similar operations.
     Examples:
@@ -3189,7 +1293,7 @@ var techniqueInstructions = {
     - "List products" → "What is the average price per category?"
     - "Get employees" → "How many employees are in each department?"
   `,
-  "add-filter": dedent7`
+  "add-filter": dedent6`
     Add filtering conditions to the question.
     Transform it to require WHERE clauses with specific conditions.
     Examples:
@@ -3197,7 +1301,7 @@ var techniqueInstructions = {
     - "List customers" → "List customers who have made more than 5 purchases"
     - "Get products" → "Get products with price above $100"
   `,
-  "add-join": dedent7`
+  "add-join": dedent6`
     Add requirements that need data from related tables.
     Transform it to require JOIN operations between multiple tables.
     Examples:
@@ -3205,7 +1309,7 @@ var techniqueInstructions = {
     - "List products" → "List products with their supplier information"
     - "Get employees" → "Get employees with their department and manager names"
   `,
-  "add-reasoning": dedent7`
+  "add-reasoning": dedent6`
     Add multi-step reasoning requirements.
     Transform it to require logical deduction, comparisons, or derived calculations.
     Examples:
@@ -3213,7 +1317,7 @@ var techniqueInstructions = {
     - "List products" → "Which products are underperforming compared to their category average?"
     - "Get revenue" → "Which month had the highest growth compared to the previous month?"
   `,
-  hypothetical: dedent7`
+  hypothetical: dedent6`
     Add a hypothetical or speculative scenario.
     Transform it to require applying calculations or projections.
     Examples:
@@ -3226,32 +1330,32 @@ 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",
-      dedent7`
+      dedent6`
         Evolve the original question using the "${params.technique}" technique.
 
         Requirements:
@@ -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 dedent8 from "dedent";
+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,21 +1529,21 @@ 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",
-      dedent8`
+      dedent7`
         Analyze the database schema and generate realistic personas representing
         the different types of users who would query this database.
 
@@ -3460,9 +1574,9 @@ async function generatePersonas(schemaFragments, options) {
         - Styles should match how this persona would naturally communicate
       `
     ),
-    fragment(
+    fragment7(
       "example",
-      dedent8`
+      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 dedent9 from "dedent";
+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,22 +1692,22 @@ 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",
-      dedent9`
+      dedent8`
         Output a JSON object with these optional arrays (include only relevant ones):
         - terms: [{ name: string, definition: string }] - Domain terminology
         - hints: [{ text: string }] - Helpful SQL generation hints
@@ -3586,9 +1721,9 @@ async function toTeachings(input, options) {
         - analogies: [{ concepts: string[], relationship: string, insight?: string, therefore?: string, pitfall?: string }]
       `
     ),
-    fragment(
+    fragment8(
       "task",
-      dedent9`
+      dedent8`
         1. Analyze the schema to infer domain, relationships, and sensitive columns.
         2. Generate 3-10 fragments total across all categories, prioritizing:
            - guardrails for PII columns (email, ssn, phone, etc)
@@ -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++) {