@deepagents/text2sql 0.10.2 → 0.11.0

package/dist/lib/synthesis/index.js

@@ -220,22 +220,25 @@ ${state.introspection}
     </examples>
   `
 });
-function getMessageText(message) {
-  const textParts = message.parts.filter(isTextUIPart).map((part) => part.text);
+function getMessageText(message2) {
+  const textParts = message2.parts.filter(isTextUIPart).map((part) => part.text);
   return textParts.join(" ").trim();
 }
 function formatConversation(messages) {
   return messages.map((msg, i) => `[${i + 1}] ${msg}`).join("\n");
 }
 var BaseContextualExtractor = class extends PairProducer {
+  context = [];
+  results = [];
+  messages;
+  adapter;
+  options;
   constructor(messages, adapter, options = {}) {
     super();
     this.messages = messages;
     this.adapter = adapter;
     this.options = options;
   }
-  context = [];
-  results = [];
   /**
    * Template method - defines the extraction algorithm skeleton.
    * Subclasses customize behavior via hooks, not by overriding this method.
@@ -248,31 +251,31 @@ var BaseContextualExtractor = class extends PairProducer {
     if (this.results.length === 0) {
       return;
     }
-    const introspection = await this.adapter.introspect();
+    const introspection = "";
     yield* this.resolveQuestions(introspection);
   }
   /**
    * Core extraction loop - iterates through messages and calls hooks.
    */
   async extractSqlsWithContext(toolName, includeFailures) {
-    for (const message of this.messages) {
-      if (message.role === "user") {
-        const text = getMessageText(message);
+    for (const message2 of this.messages) {
+      if (message2.role === "user") {
+        const text = getMessageText(message2);
         if (text) {
           await this.onUserMessage(text);
         }
         continue;
       }
-      if (message.role === "assistant") {
-        await this.extractFromAssistant(message, toolName, includeFailures);
+      if (message2.role === "assistant") {
+        await this.extractFromAssistant(message2, toolName, includeFailures);
       }
     }
   }
   /**
    * Extract SQL from assistant message parts.
    */
-  async extractFromAssistant(message, toolName, includeFailures) {
-    for (const part of message.parts) {
+  async extractFromAssistant(message2, toolName, includeFailures) {
+    for (const part of message2.parts) {
       if (!isToolOrDynamicToolUIPart(part)) {
         continue;
       }
@@ -301,7 +304,7 @@ var BaseContextualExtractor = class extends PairProducer {
         conversationContext: snapshot
       });
     }
-    const assistantText = getMessageText(message);
+    const assistantText = getMessageText(message2);
     if (assistantText) {
       this.context.push(`Assistant: ${assistantText}`);
     }
@@ -334,29 +337,31 @@ var BaseContextualExtractor = class extends PairProducer {
 
 // packages/text2sql/src/lib/synthesis/extractors/message-extractor.ts
 var MessageExtractor = class extends PairProducer {
+  #messages;
+  #options;
   /**
    * @param messages - Chat history to extract pairs from
    * @param options - Extraction configuration
    */
   constructor(messages, options = {}) {
     super();
-    this.messages = messages;
-    this.options = options;
+    this.#messages = messages;
+    this.#options = options;
   }
   /**
    * Extracts question-SQL pairs by parsing tool calls and pairing with user messages.
    * @returns Pairs extracted from db_query tool invocations
    */
   async *produce() {
-    const { includeFailures = false, toolName = "db_query" } = this.options;
+    const { includeFailures = false, toolName = "db_query" } = this.#options;
     let lastUserMessage = null;
-    for (const message of this.messages) {
-      if (message.role === "user") {
-        lastUserMessage = message;
+    for (const message2 of this.#messages) {
+      if (message2.role === "user") {
+        lastUserMessage = message2;
         continue;
       }
-      if (message.role === "assistant" && lastUserMessage) {
-        for (const part of message.parts) {
+      if (message2.role === "assistant" && lastUserMessage) {
+        for (const part of message2.parts) {
           if (!isToolOrDynamicToolUIPart2(part)) {
             continue;
           }
@@ -459,7 +464,7 @@ var SqlExtractor = class extends PairProducer {
    */
   async *produce() {
     const { validateSql = true, skipInvalid = false } = this.#options;
-    const introspection = await this.#adapter.introspect();
+    const introspection = "";
     for (const sql of this.#sqls) {
       let isValid = true;
       if (validateSql) {
@@ -822,377 +827,1595 @@ import { Console } from "node:console";
 import { createWriteStream } from "node:fs";
 import pRetry from "p-retry";
 import z5 from "zod";
+import "@deepagents/agent";
+
+// packages/context/dist/index.js
+import { encode } from "gpt-tokenizer";
+import { generateId } from "ai";
+import pluralize from "pluralize";
+import { titlecase } from "stringcase";
+import { defineCommand } from "just-bash";
+import spawn from "nano-spawn";
+import "bash-tool";
+import spawn2 from "nano-spawn";
 import {
-  agent as agent5,
-  generate as generate6,
-  toOutput,
-  user as user6
-} from "@deepagents/agent";
-
-// packages/text2sql/src/lib/teach/xml.ts
-function wrapBlock(tag, children) {
-  const content = children.filter((child) => Boolean(child)).join("\n");
-  if (!content) {
-    return "";
+  createBashTool
+} from "bash-tool";
+import YAML from "yaml";
+import { DatabaseSync } from "node:sqlite";
+import {
+  Output,
+  convertToModelMessages,
+  createUIMessageStream,
+  generateId as generateId2,
+  generateText,
+  smoothStream,
+  stepCountIs,
+  streamText
+} from "ai";
+import chalk from "chalk";
+import "zod";
+import "@deepagents/agent";
+var defaultTokenizer = {
+  encode(text) {
+    return encode(text);
+  },
+  count(text) {
+    return encode(text).length;
   }
-  return `<${tag}>
-${indentBlock(content, 2)}
-</${tag}>`;
+};
+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 role(content) {
+  return {
+    name: "role",
+    data: content
+  };
+}
+function user6(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 list(tag, values, childTag) {
-  if (!values.length) {
-    return "";
+function message(content) {
+  const message2 = typeof content === "string" ? {
+    id: generateId(),
+    role: "user",
+    parts: [{ type: "text", text: content }]
+  } : content;
+  return {
+    id: message2.id,
+    name: "message",
+    data: "content",
+    type: "message",
+    persist: true,
+    codec: {
+      decode() {
+        return message2;
+      },
+      encode() {
+        return message2;
+      }
+    }
+  };
+}
+var ContextRenderer = class {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /**
+   * Check if data is a primitive (string, number, boolean).
+   */
+  isPrimitive(data) {
+    return typeof data === "string" || typeof data === "number" || typeof data === "boolean";
+  }
+  /**
+   * Group fragments by name for groupFragments option.
+   */
+  groupByName(fragments) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const fragment2 of fragments) {
+      const existing = groups.get(fragment2.name) ?? [];
+      existing.push(fragment2);
+      groups.set(fragment2.name, existing);
+    }
+    return groups;
+  }
+  /**
+   * Template method - dispatches value to appropriate handler.
+   */
+  renderValue(key, value, ctx) {
+    if (value == null) {
+      return "";
+    }
+    if (isFragment(value)) {
+      return this.renderFragment(value, ctx);
+    }
+    if (Array.isArray(value)) {
+      return this.renderArray(key, value, ctx);
+    }
+    if (isFragmentObject(value)) {
+      return this.renderObject(key, value, ctx);
+    }
+    return this.renderPrimitive(key, String(value), ctx);
   }
-  const children = values.map((value) => leaf(childTag, value)).join("\n");
-  return `<${tag}>
-${indentBlock(children, 2)}
+  /**
+   * Render all entries of an object.
+   */
+  renderEntries(data, ctx) {
+    return Object.entries(data).map(([key, value]) => this.renderValue(key, value, ctx)).filter(Boolean);
+  }
+};
+var XmlRenderer = class extends ContextRenderer {
+  render(fragments) {
+    return fragments.map((f) => this.#renderTopLevel(f)).filter(Boolean).join("\n");
+  }
+  #renderTopLevel(fragment2) {
+    if (this.isPrimitive(fragment2.data)) {
+      return this.#leafRoot(fragment2.name, String(fragment2.data));
+    }
+    if (Array.isArray(fragment2.data)) {
+      return this.#renderArray(fragment2.name, fragment2.data, 0);
+    }
+    if (isFragment(fragment2.data)) {
+      const child = this.renderFragment(fragment2.data, { depth: 1, path: [] });
+      return this.#wrap(fragment2.name, [child]);
+    }
+    return this.#wrap(
+      fragment2.name,
+      this.renderEntries(fragment2.data, { depth: 1, path: [] })
+    );
+  }
+  #renderArray(name, items, depth) {
+    const fragmentItems = items.filter(isFragment);
+    const nonFragmentItems = items.filter((item) => !isFragment(item));
+    const children = [];
+    for (const item of nonFragmentItems) {
+      if (item != null) {
+        children.push(
+          this.#leaf(pluralize.singular(name), String(item), depth + 1)
+        );
+      }
+    }
+    if (this.options.groupFragments && fragmentItems.length > 0) {
+      const groups = this.groupByName(fragmentItems);
+      for (const [groupName, groupFragments] of groups) {
+        const groupChildren = groupFragments.map(
+          (frag) => this.renderFragment(frag, { depth: depth + 2, path: [] })
+        );
+        const pluralName = pluralize.plural(groupName);
+        children.push(this.#wrapIndented(pluralName, groupChildren, depth + 1));
+      }
+    } else {
+      for (const frag of fragmentItems) {
+        children.push(
+          this.renderFragment(frag, { depth: depth + 1, path: [] })
+        );
+      }
+    }
+    return this.#wrap(name, children);
+  }
+  #leafRoot(tag, value) {
+    const safe = this.#escape(value);
+    if (safe.includes("\n")) {
+      return `<${tag}>
+${this.#indent(safe, 2)}
 </${tag}>`;
-}
-function leaf(tag, value) {
-  const safe = escapeXml(value);
-  if (safe.includes("\n")) {
+    }
+    return `<${tag}>${safe}</${tag}>`;
+  }
+  renderFragment(fragment2, ctx) {
+    const { name, data } = fragment2;
+    if (this.isPrimitive(data)) {
+      return this.#leaf(name, String(data), ctx.depth);
+    }
+    if (isFragment(data)) {
+      const child = this.renderFragment(data, { ...ctx, depth: ctx.depth + 1 });
+      return this.#wrapIndented(name, [child], ctx.depth);
+    }
+    if (Array.isArray(data)) {
+      return this.#renderArrayIndented(name, data, ctx.depth);
+    }
+    const children = this.renderEntries(data, { ...ctx, depth: ctx.depth + 1 });
+    return this.#wrapIndented(name, children, ctx.depth);
+  }
+  #renderArrayIndented(name, items, depth) {
+    const fragmentItems = items.filter(isFragment);
+    const nonFragmentItems = items.filter((item) => !isFragment(item));
+    const children = [];
+    for (const item of nonFragmentItems) {
+      if (item != null) {
+        children.push(
+          this.#leaf(pluralize.singular(name), String(item), depth + 1)
+        );
+      }
+    }
+    if (this.options.groupFragments && fragmentItems.length > 0) {
+      const groups = this.groupByName(fragmentItems);
+      for (const [groupName, groupFragments] of groups) {
+        const groupChildren = groupFragments.map(
+          (frag) => this.renderFragment(frag, { depth: depth + 2, path: [] })
+        );
+        const pluralName = pluralize.plural(groupName);
+        children.push(this.#wrapIndented(pluralName, groupChildren, depth + 1));
+      }
+    } else {
+      for (const frag of fragmentItems) {
+        children.push(
+          this.renderFragment(frag, { depth: depth + 1, path: [] })
+        );
+      }
+    }
+    return this.#wrapIndented(name, children, depth);
+  }
+  renderPrimitive(key, value, ctx) {
+    return this.#leaf(key, value, ctx.depth);
+  }
+  renderArray(key, items, ctx) {
+    if (!items.length) {
+      return "";
+    }
+    const itemTag = pluralize.singular(key);
+    const children = items.filter((item) => item != null).map((item) => this.#leaf(itemTag, String(item), ctx.depth + 1));
+    return this.#wrapIndented(key, children, ctx.depth);
+  }
+  renderObject(key, obj, ctx) {
+    const children = this.renderEntries(obj, { ...ctx, depth: ctx.depth + 1 });
+    return this.#wrapIndented(key, children, ctx.depth);
+  }
+  #escape(value) {
+    if (value == null) {
+      return "";
+    }
+    return value.replaceAll(/&/g, "&amp;").replaceAll(/</g, "&lt;").replaceAll(/>/g, "&gt;").replaceAll(/"/g, "&quot;").replaceAll(/'/g, "&apos;");
+  }
+  #indent(text, spaces) {
+    if (!text.trim()) {
+      return "";
+    }
+    const padding = " ".repeat(spaces);
+    return text.split("\n").map((line) => line.length ? padding + line : padding).join("\n");
+  }
+  #leaf(tag, value, depth) {
+    const safe = this.#escape(value);
+    const pad = "  ".repeat(depth);
+    if (safe.includes("\n")) {
+      return `${pad}<${tag}>
+${this.#indent(safe, (depth + 1) * 2)}
+${pad}</${tag}>`;
+    }
+    return `${pad}<${tag}>${safe}</${tag}>`;
+  }
+  #wrap(tag, children) {
+    const content = children.filter(Boolean).join("\n");
+    if (!content) {
+      return "";
+    }
     return `<${tag}>
-${indentBlock(safe, 2)}
+${content}
 </${tag}>`;
   }
-  return `<${tag}>${safe}</${tag}>`;
-}
-function indentBlock(text, spaces) {
-  if (!text.trim()) {
-    return "";
+  #wrapIndented(tag, children, depth) {
+    const content = children.filter(Boolean).join("\n");
+    if (!content) {
+      return "";
+    }
+    const pad = "  ".repeat(depth);
+    return `${pad}<${tag}>
+${content}
+${pad}</${tag}>`;
   }
-  const padding = " ".repeat(spaces);
-  return text.split("\n").map((line) => line.length ? padding + line : padding).join("\n");
-}
-function escapeXml(value) {
-  if (value == null) {
-    return "";
+};
+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;
+  #branchName;
+  #branch = null;
+  #chatData = null;
+  #initialized = false;
+  constructor(options) {
+    if (!options.chatId) {
+      throw new Error("chatId is required");
+    }
+    this.#store = options.store;
+    this.#chatId = options.chatId;
+    this.#branchName = options.branch ?? "main";
   }
-  return value.replaceAll(/&/g, "&amp;").replaceAll(/</g, "&lt;").replaceAll(/>/g, "&gt;").replaceAll(/"/g, "&quot;").replaceAll(/'/g, "&apos;");
-}
-
-// packages/text2sql/src/lib/teach/teachables.ts
+  /**
+   * 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 });
+    const existingBranch = await this.#store.getBranch(
+      this.#chatId,
+      this.#branchName
+    );
+    if (existingBranch) {
+      this.#branch = existingBranch;
+    } else {
+      this.#branch = {
+        id: crypto.randomUUID(),
+        chatId: this.#chatId,
+        name: this.#branchName,
+        headMessageId: null,
+        isActive: true,
+        createdAt: Date.now()
+      };
+      await this.#store.createBranch(this.#branch);
+    }
+    this.#initialized = true;
+  }
+  /**
+   * Create a new branch from a specific message.
+   * Shared logic between rewind() and btw().
+   */
+  async #createBranchFrom(messageId, switchTo) {
+    const branches = await this.#store.listBranches(this.#chatId);
+    const samePrefix = branches.filter(
+      (b) => b.name === this.#branchName || b.name.startsWith(`${this.#branchName}-v`)
+    );
+    const newBranchName = `${this.#branchName}-v${samePrefix.length + 1}`;
+    const newBranch = {
+      id: crypto.randomUUID(),
+      chatId: this.#chatId,
+      name: newBranchName,
+      headMessageId: messageId,
+      isActive: false,
+      createdAt: Date.now()
+    };
+    await this.#store.createBranch(newBranch);
+    if (switchTo) {
+      await this.#store.setActiveBranch(this.#chatId, newBranch.id);
+      this.#branch = { ...newBranch, isActive: true };
+      this.#branchName = newBranchName;
+      this.#pendingMessages = [];
+    }
+    const chain = await this.#store.getMessageChain(messageId);
+    return {
+      id: newBranch.id,
+      name: newBranch.name,
+      headMessageId: newBranch.headMessageId,
+      isActive: switchTo,
+      messageCount: chain.length,
+      createdAt: newBranch.createdAt
+    };
+  }
+  /**
+   * Get the current chat ID.
+   */
+  get chatId() {
+    return this.#chatId;
+  }
+  /**
+   * Get the current branch name.
+   */
+  get branch() {
+    return this.#branchName;
+  }
+  /**
+   * Get metadata for the current chat.
+   * Returns null if the chat hasn't been initialized yet.
+   */
+  get chat() {
+    if (!this.#chatData) {
+      return null;
+    }
+    return {
+      id: this.#chatData.id,
+      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' })
+   *   .set(role('You are helpful'), user('Hello'));
+   *
+   * const { systemPrompt, messages } = await context.resolve();
+   * await generateText({ system: systemPrompt, messages });
+   * ```
+   */
+  async resolve(options) {
+    await this.#ensureInitialized();
+    const systemPrompt = options.renderer.render(this.#fragments);
+    const messages = [];
+    if (this.#branch?.headMessageId) {
+      const chain = await this.#store.getMessageChain(
+        this.#branch.headMessageId
+      );
+      for (const msg of chain) {
+        messages.push(message(msg.data).codec?.decode());
+      }
+    }
+    for (const fragment2 of this.#pendingMessages) {
+      const decoded = fragment2.codec.decode();
+      messages.push(decoded);
+    }
+    return { systemPrompt, messages };
+  }
+  /**
+   * Save pending messages to the graph.
+   *
+   * Each message is added as a node with parentId pointing to the previous message.
+   * The branch head is updated to point to the last message.
+   *
+   * @example
+   * ```ts
+   * context.set(user('Hello'));
+   * // AI responds...
+   * context.set(assistant('Hi there!'));
+   * await context.save(); // Persist to graph
+   * ```
+   */
+  async save() {
+    await this.#ensureInitialized();
+    if (this.#pendingMessages.length === 0) {
+      return;
+    }
+    let parentId = this.#branch.headMessageId;
+    const now = Date.now();
+    for (const fragment2 of this.#pendingMessages) {
+      const messageData = {
+        id: fragment2.id ?? crypto.randomUUID(),
+        chatId: this.#chatId,
+        parentId,
+        name: fragment2.name,
+        type: fragment2.type,
+        data: fragment2.codec.encode(),
+        createdAt: now
+      };
+      await this.#store.addMessage(messageData);
+      parentId = messageData.id;
+    }
+    await this.#store.updateBranchHead(this.#branch.id, parentId);
+    this.#branch.headMessageId = parentId;
+    this.#pendingMessages = [];
+  }
+  /**
+   * 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);
+  }
+  /**
+   * 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;
+  }
+  /**
+   * Inspect the full context state for debugging.
+   * Returns a comprehensive JSON-serializable object with all 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 {
-    type: "term",
-    encode: () => ({ type: "term", name, definition }),
-    decode: () => wrapBlock("term", [leaf("name", name), leaf("definition", definition)])
+    name: "term",
+    data: { name, definition }
   };
 }
 function hint(text) {
   return {
-    type: "hint",
-    encode: () => ({ type: "hint", text }),
-    decode: () => leaf("hint", text)
+    name: "hint",
+    data: text
   };
 }
 function guardrail(input) {
-  const { rule, reason, action } = input;
   return {
-    type: "guardrail",
-    encode: () => ({ type: "guardrail", rule, reason, action }),
-    decode: () => wrapBlock("guardrail", [
-      leaf("rule", rule),
-      reason ? leaf("reason", reason) : "",
-      action ? leaf("action", action) : ""
-    ])
+    name: "guardrail",
+    data: {
+      rule: input.rule,
+      ...input.reason && { reason: input.reason },
+      ...input.action && { action: input.action }
+    }
   };
 }
 function explain(input) {
-  const { concept, explanation, therefore } = input;
   return {
-    type: "explain",
-    encode: () => ({ type: "explain", concept, explanation, therefore }),
-    decode: () => wrapBlock("explanation", [
-      leaf("concept", concept),
-      leaf("details", explanation),
-      therefore ? leaf("therefore", therefore) : ""
-    ])
+    name: "explain",
+    data: {
+      concept: input.concept,
+      explanation: input.explanation,
+      ...input.therefore && { therefore: input.therefore }
+    }
   };
 }
 function example(input) {
-  const { question, answer, note } = input;
   return {
-    type: "example",
-    encode: () => ({ type: "example", question, answer, note }),
-    decode: () => wrapBlock("example", [
-      leaf("question", question),
-      leaf("answer", answer),
-      note ? leaf("note", note) : ""
-    ])
+    name: "example",
+    data: {
+      question: input.question,
+      answer: input.answer,
+      ...input.note && { note: input.note }
+    }
   };
 }
 function clarification(input) {
-  const { when, ask, reason } = input;
   return {
-    type: "clarification",
-    encode: () => ({ type: "clarification", when, ask, reason }),
-    decode: () => wrapBlock("clarification", [
-      leaf("when", when),
-      leaf("ask", ask),
-      leaf("reason", reason)
-    ])
+    name: "clarification",
+    data: {
+      when: input.when,
+      ask: input.ask,
+      reason: input.reason
+    }
   };
 }
 function workflow(input) {
-  const { task, steps, triggers, notes } = input;
   return {
-    type: "workflow",
-    encode: () => ({ type: "workflow", task, steps, triggers, notes }),
-    decode: () => wrapBlock("workflow", [
-      leaf("task", task),
-      triggers?.length ? list("triggers", triggers, "trigger") : "",
-      list("steps", steps, "step"),
-      notes ? leaf("notes", notes) : ""
-    ])
+    name: "workflow",
+    data: {
+      task: input.task,
+      steps: input.steps,
+      ...input.triggers?.length && { triggers: input.triggers },
+      ...input.notes && { notes: input.notes }
+    }
   };
 }
 function quirk(input) {
-  const { issue, workaround } = input;
   return {
-    type: "quirk",
-    encode: () => ({ type: "quirk", issue, workaround }),
-    decode: () => wrapBlock("quirk", [
-      leaf("issue", issue),
-      leaf("workaround", workaround)
-    ])
+    name: "quirk",
+    data: {
+      issue: input.issue,
+      workaround: input.workaround
+    }
   };
 }
 function styleGuide(input) {
-  const { prefer, never, always } = input;
   return {
-    type: "styleGuide",
-    encode: () => ({ type: "styleGuide", prefer, never, always }),
-    decode: () => wrapBlock("style_guide", [
-      leaf("prefer", prefer),
-      always ? leaf("always", always) : "",
-      never ? leaf("never", never) : ""
-    ])
+    name: "styleGuide",
+    data: {
+      prefer: input.prefer,
+      ...input.never && { never: input.never },
+      ...input.always && { always: input.always }
+    }
   };
 }
 function analogy(input) {
-  const { concept, relationship, insight, therefore, pitfall } = input;
-  return {
-    type: "analogy",
-    encode: () => ({
-      type: "analogy",
-      concept,
-      relationship,
-      insight,
-      therefore,
-      pitfall
-    }),
-    decode: () => wrapBlock("analogy", [
-      list("concepts", concept, "concept"),
-      leaf("relationship", relationship),
-      insight ? leaf("insight", insight) : "",
-      therefore ? leaf("therefore", therefore) : "",
-      pitfall ? leaf("pitfall", pitfall) : ""
-    ])
-  };
-}
-function glossary(entries) {
-  return {
-    type: "glossary",
-    encode: () => ({ type: "glossary", entries }),
-    decode: () => wrapBlock(
-      "glossary",
-      Object.entries(entries).map(
-        ([term2, sql]) => wrapBlock("entry", [leaf("term", term2), leaf("sql", sql)])
-      )
-    )
-  };
-}
-function identity(input) {
-  const { name, role } = input;
   return {
-    type: "identity",
-    encode: () => ({ type: "identity", name, role }),
-    decode: () => wrapBlock("identity", [
-      name ? leaf("name", name) : "",
-      role ? leaf("role", role) : ""
-    ])
+    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) {
-  const { name, role, tone } = input;
   return {
-    type: "persona",
-    encode: () => ({ type: "persona", name, role, tone: tone ?? "" }),
-    decode: () => wrapBlock("persona", [
-      leaf("name", name),
-      leaf("role", role),
-      tone ? leaf("tone", tone) : ""
-    ])
-  };
-}
-function alias(termName, meaning) {
-  return {
-    type: "alias",
-    encode: () => ({ type: "alias", term: termName, meaning }),
-    decode: () => wrapBlock("alias", [leaf("term", termName), leaf("meaning", meaning)])
-  };
-}
-function preference(aspect, value) {
-  return {
-    type: "preference",
-    encode: () => ({ type: "preference", aspect, value }),
-    decode: () => wrapBlock("preference", [leaf("aspect", aspect), leaf("value", value)])
-  };
-}
-function context(description) {
-  return {
-    type: "context",
-    encode: () => ({ type: "context", description }),
-    decode: () => leaf("context", description)
-  };
-}
-function correction(subject, clarification2) {
-  return {
-    type: "correction",
-    encode: () => ({ type: "correction", subject, clarification: clarification2 }),
-    decode: () => wrapBlock("correction", [
-      leaf("subject", subject),
-      leaf("clarification", clarification2)
-    ])
+    name: "persona",
+    data: {
+      name: input.name,
+      role: input.role,
+      ...input.tone && { tone: input.tone }
+    }
   };
 }
-function toInstructions(tag, ...teachables) {
-  if (!teachables.length) {
-    return "";
-  }
-  const grouped = /* @__PURE__ */ new Map();
-  for (const teachable of teachables) {
-    const existing = grouped.get(teachable.type) ?? [];
-    existing.push(teachable);
-    grouped.set(teachable.type, existing);
-  }
-  const definedTypes = new Set(SECTION_ORDER.map((s) => s.type));
-  const sections = SECTION_ORDER.map(({ type, tag: tag2 }) => {
-    const items = grouped.get(type);
-    if (!items?.length) {
-      return "";
+var STORE_DDL = `
+-- Chats table
+-- createdAt/updatedAt: DEFAULT for insert, inline SET for updates
+CREATE TABLE IF NOT EXISTS chats (
+  id TEXT PRIMARY KEY,
+  title TEXT,
+  metadata TEXT,
+  createdAt INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+  updatedAt INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)
+);
+
+CREATE INDEX IF NOT EXISTS idx_chats_updatedAt ON chats(updatedAt);
+
+-- Messages table (nodes in the DAG)
+CREATE TABLE IF NOT EXISTS messages (
+  id TEXT PRIMARY KEY,
+  chatId TEXT NOT NULL,
+  parentId TEXT,
+  name TEXT NOT NULL,
+  type TEXT,
+  data TEXT NOT NULL,
+  createdAt INTEGER NOT NULL,
+  FOREIGN KEY (chatId) REFERENCES chats(id) ON DELETE CASCADE,
+  FOREIGN KEY (parentId) REFERENCES messages(id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_messages_chatId ON messages(chatId);
+CREATE INDEX IF NOT EXISTS idx_messages_parentId ON messages(parentId);
+
+-- Branches table (pointers to head messages)
+CREATE TABLE IF NOT EXISTS branches (
+  id TEXT PRIMARY KEY,
+  chatId TEXT NOT NULL,
+  name TEXT NOT NULL,
+  headMessageId TEXT,
+  isActive INTEGER NOT NULL DEFAULT 0,
+  createdAt INTEGER NOT NULL,
+  FOREIGN KEY (chatId) REFERENCES chats(id) ON DELETE CASCADE,
+  FOREIGN KEY (headMessageId) REFERENCES messages(id),
+  UNIQUE(chatId, name)
+);
+
+CREATE INDEX IF NOT EXISTS idx_branches_chatId ON branches(chatId);
+
+-- Checkpoints table (pointers to message nodes)
+CREATE TABLE IF NOT EXISTS checkpoints (
+  id TEXT PRIMARY KEY,
+  chatId TEXT NOT NULL,
+  name TEXT NOT NULL,
+  messageId TEXT NOT NULL,
+  createdAt INTEGER NOT NULL,
+  FOREIGN KEY (chatId) REFERENCES chats(id) ON DELETE CASCADE,
+  FOREIGN KEY (messageId) REFERENCES messages(id),
+  UNIQUE(chatId, name)
+);
+
+CREATE INDEX IF NOT EXISTS idx_checkpoints_chatId ON checkpoints(chatId);
+
+-- FTS5 virtual table for full-text search
+-- messageId/chatId/name are UNINDEXED (stored but not searchable, used for filtering/joining)
+-- Only 'content' is indexed for full-text search
+CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
+  messageId UNINDEXED,
+  chatId UNINDEXED,
+  name UNINDEXED,
+  content,
+  tokenize='porter unicode61'
+);
+`;
+var SqliteContextStore = class extends ContextStore {
+  #db;
+  constructor(path3) {
+    super();
+    this.#db = new DatabaseSync(path3);
+    this.#db.exec("PRAGMA foreign_keys = ON");
+    this.#db.exec(STORE_DDL);
+  }
+  // ==========================================================================
+  // Chat Operations
+  // ==========================================================================
+  async createChat(chat) {
+    this.#db.prepare(
+      `INSERT INTO chats (id, title, metadata)
+         VALUES (?, ?, ?)`
+    ).run(
+      chat.id,
+      chat.title ?? null,
+      chat.metadata ? JSON.stringify(chat.metadata) : null
+    );
+  }
+  async upsertChat(chat) {
+    const row = this.#db.prepare(
+      `INSERT INTO chats (id, title, metadata)
+         VALUES (?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET id = excluded.id
+         RETURNING *`
+    ).get(
+      chat.id,
+      chat.title ?? null,
+      chat.metadata ? JSON.stringify(chat.metadata) : null
+    );
+    return {
+      id: row.id,
+      title: row.title ?? void 0,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    };
+  }
+  async getChat(chatId) {
+    const row = this.#db.prepare("SELECT * FROM chats WHERE id = ?").get(chatId);
+    if (!row) {
+      return void 0;
     }
-    const renderedItems = items.map((item) => item.decode().trim()).filter(Boolean).map((item) => indentBlock(item, 2)).join("\n");
-    if (!renderedItems.length) {
-      return "";
+    return {
+      id: row.id,
+      title: row.title ?? void 0,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    };
+  }
+  async updateChat(chatId, updates) {
+    const setClauses = ["updatedAt = strftime('%s', 'now') * 1000"];
+    const params = [];
+    if (updates.title !== void 0) {
+      setClauses.push("title = ?");
+      params.push(updates.title ?? null);
     }
-    return `<${tag2}>
-${renderedItems}
-</${tag2}>`;
-  }).filter((section) => Boolean(section));
-  for (const [type, items] of grouped) {
-    if (definedTypes.has(type)) {
-      continue;
+    if (updates.metadata !== void 0) {
+      setClauses.push("metadata = ?");
+      params.push(JSON.stringify(updates.metadata));
     }
-    const renderedItems = items.map((item) => item.decode().trim()).filter(Boolean).map((item) => indentBlock(item, 2)).join("\n");
-    if (renderedItems.length) {
-      sections.push(renderedItems);
+    params.push(chatId);
+    const row = this.#db.prepare(
+      `UPDATE chats SET ${setClauses.join(", ")} WHERE id = ? RETURNING *`
+    ).get(...params);
+    return {
+      id: row.id,
+      title: row.title ?? void 0,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    };
+  }
+  async listChats() {
+    const rows = this.#db.prepare(
+      `SELECT
+          c.id,
+          c.title,
+          c.createdAt,
+          c.updatedAt,
+          COUNT(DISTINCT m.id) as messageCount,
+          COUNT(DISTINCT b.id) as branchCount
+        FROM chats c
+        LEFT JOIN messages m ON m.chatId = c.id
+        LEFT JOIN branches b ON b.chatId = c.id
+        GROUP BY c.id
+        ORDER BY c.updatedAt DESC`
+    ).all();
+    return rows.map((row) => ({
+      id: row.id,
+      title: row.title ?? void 0,
+      messageCount: row.messageCount,
+      branchCount: row.branchCount,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    }));
+  }
+  // ==========================================================================
+  // Message Operations (Graph Nodes)
+  // ==========================================================================
+  async addMessage(message2) {
+    this.#db.prepare(
+      `INSERT INTO messages (id, chatId, parentId, name, type, data, createdAt)
+         VALUES (?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           parentId = excluded.parentId,
+           name = excluded.name,
+           type = excluded.type,
+           data = excluded.data`
+    ).run(
+      message2.id,
+      message2.chatId,
+      message2.parentId,
+      message2.name,
+      message2.type ?? null,
+      JSON.stringify(message2.data),
+      message2.createdAt
+    );
+    const content = typeof message2.data === "string" ? message2.data : JSON.stringify(message2.data);
+    this.#db.prepare(`DELETE FROM messages_fts WHERE messageId = ?`).run(message2.id);
+    this.#db.prepare(
+      `INSERT INTO messages_fts(messageId, chatId, name, content)
+         VALUES (?, ?, ?, ?)`
+    ).run(message2.id, message2.chatId, message2.name, content);
+  }
+  async getMessage(messageId) {
+    const row = this.#db.prepare("SELECT * FROM messages WHERE id = ?").get(messageId);
+    if (!row) {
+      return void 0;
     }
+    return {
+      id: row.id,
+      chatId: row.chatId,
+      parentId: row.parentId,
+      name: row.name,
+      type: row.type ?? void 0,
+      data: JSON.parse(row.data),
+      createdAt: row.createdAt
+    };
+  }
+  async getMessageChain(headId) {
+    const rows = this.#db.prepare(
+      `WITH RECURSIVE chain AS (
+          SELECT *, 0 as depth FROM messages WHERE id = ?
+          UNION ALL
+          SELECT m.*, c.depth + 1 FROM messages m
+          INNER JOIN chain c ON m.id = c.parentId
+        )
+        SELECT * FROM chain
+        ORDER BY depth DESC`
+    ).all(headId);
+    return rows.map((row) => ({
+      id: row.id,
+      chatId: row.chatId,
+      parentId: row.parentId,
+      name: row.name,
+      type: row.type ?? void 0,
+      data: JSON.parse(row.data),
+      createdAt: row.createdAt
+    }));
+  }
+  async hasChildren(messageId) {
+    const row = this.#db.prepare(
+      "SELECT EXISTS(SELECT 1 FROM messages WHERE parentId = ?) as hasChildren"
+    ).get(messageId);
+    return row.hasChildren === 1;
+  }
+  // ==========================================================================
+  // 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
+    );
   }
-  if (!sections.length) {
-    return "";
+  async getBranch(chatId, name) {
+    const row = this.#db.prepare("SELECT * FROM branches WHERE chatId = ? AND name = ?").get(chatId, name);
+    if (!row) {
+      return void 0;
+    }
+    return {
+      id: row.id,
+      chatId: row.chatId,
+      name: row.name,
+      headMessageId: row.headMessageId,
+      isActive: row.isActive === 1,
+      createdAt: row.createdAt
+    };
+  }
+  async getActiveBranch(chatId) {
+    const row = this.#db.prepare("SELECT * FROM branches WHERE chatId = ? AND isActive = 1").get(chatId);
+    if (!row) {
+      return void 0;
+    }
+    return {
+      id: row.id,
+      chatId: row.chatId,
+      name: row.name,
+      headMessageId: row.headMessageId,
+      isActive: true,
+      createdAt: row.createdAt
+    };
+  }
+  async setActiveBranch(chatId, branchId) {
+    this.#db.prepare("UPDATE branches SET isActive = 0 WHERE chatId = ?").run(chatId);
+    this.#db.prepare("UPDATE branches SET isActive = 1 WHERE id = ?").run(branchId);
+  }
+  async updateBranchHead(branchId, messageId) {
+    this.#db.prepare("UPDATE branches SET headMessageId = ? WHERE id = ?").run(messageId, branchId);
+  }
+  async listBranches(chatId) {
+    const branches = this.#db.prepare(
+      `SELECT
+          b.id,
+          b.name,
+          b.headMessageId,
+          b.isActive,
+          b.createdAt
+        FROM branches b
+        WHERE b.chatId = ?
+        ORDER BY b.createdAt ASC`
+    ).all(chatId);
+    const result = [];
+    for (const branch of branches) {
+      let messageCount = 0;
+      if (branch.headMessageId) {
+        const countRow = this.#db.prepare(
+          `WITH RECURSIVE chain AS (
+              SELECT id, parentId FROM messages WHERE id = ?
+              UNION ALL
+              SELECT m.id, m.parentId FROM messages m
+              INNER JOIN chain c ON m.id = c.parentId
+            )
+            SELECT COUNT(*) as count FROM chain`
+        ).get(branch.headMessageId);
+        messageCount = countRow.count;
+      }
+      result.push({
+        id: branch.id,
+        name: branch.name,
+        headMessageId: branch.headMessageId,
+        isActive: branch.isActive === 1,
+        messageCount,
+        createdAt: branch.createdAt
+      });
+    }
+    return result;
+  }
+  // ==========================================================================
+  // Checkpoint Operations
+  // ==========================================================================
+  async createCheckpoint(checkpoint) {
+    this.#db.prepare(
+      `INSERT INTO checkpoints (id, chatId, name, messageId, createdAt)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(chatId, name) DO UPDATE SET
+           messageId = excluded.messageId,
+           createdAt = excluded.createdAt`
+    ).run(
+      checkpoint.id,
+      checkpoint.chatId,
+      checkpoint.name,
+      checkpoint.messageId,
+      checkpoint.createdAt
+    );
   }
-  const content = indentBlock(sections.join("\n"), 2);
-  return `<${tag}>
-${content}
-</${tag}>`;
-}
-var SECTION_ORDER = [
-  // User context (render first - most important for personalization)
-  { type: "identity", tag: "identity" },
-  { type: "persona", tag: "persona" },
-  { type: "context", tag: "user_context" },
-  { type: "preference", tag: "user_preferences" },
-  { type: "alias", tag: "user_vocabulary" },
-  { type: "correction", tag: "user_corrections" },
-  // Domain knowledge
-  { type: "guardrail", tag: "guardrails" },
-  { type: "styleGuide", tag: "style_guides" },
-  { type: "hint", tag: "hints" },
-  { type: "clarification", tag: "clarifications" },
-  { type: "workflow", tag: "workflows" },
-  { type: "quirk", tag: "quirks" },
-  { type: "term", tag: "terminology" },
-  { type: "explain", tag: "explanations" },
-  { type: "analogy", tag: "analogies" },
-  { type: "glossary", tag: "glossary" },
-  { type: "example", tag: "examples" }
-];
-function toTeachables(generated) {
-  return generated.map((item) => {
-    switch (item.type) {
-      case "persona":
-        return persona({ name: item.name, role: item.role, tone: item.tone });
-      case "term":
-        return term(item.name, item.definition);
-      case "hint":
-        return hint(item.text);
-      case "guardrail":
-        return guardrail({
-          rule: item.rule,
-          reason: item.reason,
-          action: item.action
-        });
-      case "explain":
-        return explain({
-          concept: item.concept,
-          explanation: item.explanation,
-          therefore: item.therefore
-        });
-      case "example":
-        return example({
-          question: item.question,
-          answer: item.answer,
-          note: item.note
-        });
-      case "clarification":
-        return clarification({
-          when: item.when,
-          ask: item.ask,
-          reason: item.reason
-        });
-      case "workflow":
-        return workflow({
-          task: item.task,
-          steps: item.steps,
-          triggers: item.triggers,
-          notes: item.notes
-        });
-      case "quirk":
-        return quirk({
-          issue: item.issue,
-          workaround: item.workaround
-        });
-      case "styleGuide":
-        return styleGuide({
-          prefer: item.prefer,
-          never: item.never,
-          always: item.always
-        });
-      case "analogy":
-        return analogy({
-          concept: item.concept,
-          relationship: item.relationship,
-          insight: item.insight,
-          therefore: item.therefore,
-          pitfall: item.pitfall
-        });
-      case "glossary":
-        return glossary(item.entries);
-      // User-specific teachable types
-      case "identity":
-        return identity({ name: item.name, role: item.role });
-      case "alias":
-        return alias(item.term, item.meaning);
-      case "preference":
-        return preference(item.aspect, item.value);
-      case "context":
-        return context(item.description);
-      case "correction":
-        return correction(item.subject, item.clarification);
+  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 "${options.name}" is missing a context.`
+        );
+      }
+      if (!options.model) {
+        throw new Error(
+          `structuredOutput "${options.name}" 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: convertToModelMessages(messages),
+        stopWhen: stepCountIs(25),
+        experimental_context: contextVariables,
+        experimental_output: Output.object({ schema: options.schema })
+      });
+      return result.experimental_output;
+    },
+    async stream(contextVariables, config) {
+      if (!options.context) {
+        throw new Error(
+          `structuredOutput "${options.name}" is missing a context.`
+        );
+      }
+      if (!options.model) {
+        throw new Error(
+          `structuredOutput "${options.name}" 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,
+        messages: convertToModelMessages(messages),
+        stopWhen: stepCountIs(25),
+        experimental_transform: config?.transform ?? smoothStream(),
+        experimental_context: contextVariables,
+        experimental_output: Output.object({ schema: options.schema })
+      });
+    }
+  };
 }
 
 // packages/text2sql/src/lib/agents/sql.agent.ts
@@ -1202,28 +2425,6 @@ var logger = new Console({
   inspectOptions: { depth: null }
 });
 var RETRY_TEMPERATURES = [0, 0.2, 0.3];
-var sqlQueryAgent = agent5({
-  name: "text2sql",
-  model: groq5("openai/gpt-oss-20b"),
-  logging: process.env.AGENT_LOGGING === "true",
-  output: z5.union([
-    z5.object({
-      sql: z5.string().describe("The SQL query that answers the question"),
-      reasoning: z5.string().optional().describe("The reasoning steps taken to generate the SQL")
-    }),
-    z5.object({
-      error: z5.string().describe(
-        "Error message explaining why the question cannot be answered with the given schema"
-      )
-    })
-  ]),
-  prompt: (state) => {
-    return `
-    ${state?.teachings || ""}
-    ${state?.introspection || ""}
-  `;
-  }
-});
 function extractSql(output) {
   const match = output.match(/```sql\n?([\s\S]*?)```/);
   return match ? match[1].trim() : output.trim();
@@ -1231,8 +2432,8 @@ function extractSql(output) {
 var marker = Symbol("SQLValidationError");
 var SQLValidationError = class _SQLValidationError extends Error {
   [marker];
-  constructor(message) {
-    super(message);
+  constructor(message2) {
+    super(message2);
     this.name = "SQLValidationError";
     this[marker] = true;
   }
@@ -1241,8 +2442,8 @@ var SQLValidationError = class _SQLValidationError extends Error {
   }
 };
 var UnanswerableSQLError = class _UnanswerableSQLError extends Error {
-  constructor(message) {
-    super(message);
+  constructor(message2) {
+    super(message2);
     this.name = "UnanswerableSQLError";
   }
   static isInstance(error) {
@@ -1253,36 +2454,53 @@ async function toSql(options) {
   const { maxRetries = 3 } = options;
   return withRetry(
     async (attemptNumber, errors, attempts) => {
-      const agentInstance = sqlQueryAgent.clone({
+      const context = new ContextEngine({
+        store: new InMemoryContextStore(),
+        chatId: `sql-gen-${crypto.randomUUID()}`
+      });
+      context.set(
+        persona({
+          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."
+        }),
+        ...options.instructions,
+        ...options.schemaFragments
+      );
+      if (errors.length) {
+        context.set(
+          user6(options.input),
+          user6(
+            `<validation_error>Your previous SQL query had the following error: ${errors.at(-1)?.message}. Please fix the query.</validation_error>`
+          )
+        );
+      } else {
+        context.set(user6(options.input));
+      }
+      const sqlOutput = structuredOutput({
+        name: "text2sql",
         model: wrapLanguageModel2({
-          model: options.model ?? sqlQueryAgent.model,
+          model: options.model ?? groq5("openai/gpt-oss-20b"),
           middleware: defaultSettingsMiddleware2({
             settings: {
               temperature: RETRY_TEMPERATURES[attemptNumber - 1] ?? 0.3,
               topP: 1
             }
           })
-        })
+        }),
+        context,
+        schema: z5.union([
+          z5.object({
+            sql: z5.string().describe("The SQL query that answers the question"),
+            reasoning: z5.string().optional().describe("The reasoning steps taken to generate the SQL")
+          }),
+          z5.object({
+            error: z5.string().describe(
+              "Error message explaining why the question cannot be answered with the given schema"
+            )
+          })
+        ])
       });
-      const messages = errors.length ? [
-        user6(options.input),
-        user6(
-          `<validation_error>Your previous SQL query had the following error: ${errors.at(-1)?.message}. Please fix the query.</validation_error>`
-        )
-      ] : [user6(options.input)];
-      const output = await toOutput(
-        generate6(agentInstance, messages, {
-          introspection: options.introspection,
-          teachings: toInstructions(
-            "instructions",
-            persona({
-              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."
-            }),
-            ...options.instructions
-          )
-        })
-      );
+      const output = await sqlOutput.generate();
       if ("error" in output) {
         throw new UnanswerableSQLError(output.error);
       }
@@ -1321,35 +2539,35 @@ async function withRetry(computation, options = { retries: 3 }) {
     },
     {
       retries: options.retries,
-      shouldRetry: (context2) => {
-        if (UnanswerableSQLError.isInstance(context2.error)) {
+      shouldRetry: (context) => {
+        if (UnanswerableSQLError.isInstance(context.error)) {
           return false;
         }
-        if (SQLValidationError.isInstance(context2.error)) {
+        if (SQLValidationError.isInstance(context.error)) {
           return true;
         }
         console.log({
           NoObjectGeneratedError: NoObjectGeneratedError.isInstance(
-            context2.error
+            context.error
           ),
           NoOutputGeneratedError: NoOutputGeneratedError.isInstance(
-            context2.error
+            context.error
           ),
-          APICallError: APICallError.isInstance(context2.error),
-          JSONParseError: JSONParseError.isInstance(context2.error),
-          TypeValidationError: TypeValidationError.isInstance(context2.error),
+          APICallError: APICallError.isInstance(context.error),
+          JSONParseError: JSONParseError.isInstance(context.error),
+          TypeValidationError: TypeValidationError.isInstance(context.error),
           NoContentGeneratedError: NoContentGeneratedError.isInstance(
-            context2.error
+            context.error
           )
         });
-        return APICallError.isInstance(context2.error) || JSONParseError.isInstance(context2.error) || TypeValidationError.isInstance(context2.error) || NoObjectGeneratedError.isInstance(context2.error) || NoOutputGeneratedError.isInstance(context2.error) || NoContentGeneratedError.isInstance(context2.error);
+        return APICallError.isInstance(context.error) || JSONParseError.isInstance(context.error) || TypeValidationError.isInstance(context.error) || NoObjectGeneratedError.isInstance(context.error) || NoOutputGeneratedError.isInstance(context.error) || NoContentGeneratedError.isInstance(context.error);
       },
-      onFailedAttempt(context2) {
-        logger.error(`toSQL`, context2.error);
+      onFailedAttempt(context) {
+        logger.error(`toSQL`, context.error);
         console.log(
-          `Attempt ${context2.attemptNumber} failed. There are ${context2.retriesLeft} retries left.`
+          `Attempt ${context.attemptNumber} failed. There are ${context.retriesLeft} retries left.`
         );
-        errors.push(context2.error);
+        errors.push(context.error);
       }
     }
   );
@@ -1379,7 +2597,7 @@ var SchemaSynthesizer = class extends PairProducer {
    * @returns Generated pairs from all combinations
    */
   async *produce() {
-    const introspection = await this.adapter.introspect();
+    const introspection = "";
     const combinations = this.#personas.flatMap(
       (persona2) => this.#complexities.map((complexity) => ({ persona: persona2, complexity }))
     );
@@ -1421,7 +2639,8 @@ Generate ${this.options.count} questions at ${complexity} complexity.` : void 0;
             return await toSql({
               input: question,
               adapter: this.adapter,
-              introspection,
+              schemaFragments: [],
+              // Placeholder - needs to pass actual fragments
               instructions: this.options.teachings ?? [],
               model: this.options.model
             });
@@ -1456,9 +2675,9 @@ import dedent5 from "dedent";
 import pLimit2 from "p-limit";
 import z6 from "zod";
 import {
-  agent as agent6,
-  generate as generate7,
-  toOutput as toOutput2,
+  agent as agent5,
+  generate as generate6,
+  toOutput,
   user as user7
 } from "@deepagents/agent";
 
@@ -1496,7 +2715,7 @@ var styleInstructions = {
 };
 
 // packages/text2sql/src/lib/synthesis/synthesizers/breadth-evolver.ts
-var paraphraserAgent = agent6({
+var paraphraserAgent = agent5({
   name: "question_paraphraser",
   model: wrapLanguageModel3({
     model: groq6("openai/gpt-oss-20b"),
@@ -1592,8 +2811,8 @@ var BreadthEvolver = class extends PairProducer {
     for await (const chunk of this.from(this.source)) {
       const tasks = chunk.map(
         (pair) => this.#limit(async () => {
-          const { paraphrases } = await toOutput2(
-            generate7(
+          const { paraphrases } = await toOutput(
+            generate6(
               paraphraserAgent.clone({ model: this.options.model }),
               [
                 user7(
@@ -1634,7 +2853,7 @@ import dedent6 from "dedent";
 import pLimit3 from "p-limit";
 import pRetry2 from "p-retry";
 import z7 from "zod";
-import { agent as agent7, generate as generate8, user as user8 } from "@deepagents/agent";
+import { agent as agent6, generate as generate7, user as user8 } from "@deepagents/agent";
 var techniqueInstructions = {
   "add-aggregation": dedent6`
     Add aggregation requirements to the question.
@@ -1677,7 +2896,7 @@ var techniqueInstructions = {
     - "Get costs" → "What would be the impact of a 10% discount on profit margins?"
   `
 };
-var questionEvolverAgent = agent7({
+var questionEvolverAgent = agent6({
   name: "question_evolver",
   model: wrapLanguageModel4({
     model: groq7("openai/gpt-oss-20b"),
@@ -1760,7 +2979,7 @@ var DepthEvolver = class extends PairProducer {
    * Removes batch barrier - no longer waits for all evolutions before yielding.
    */
   async *produce() {
-    const introspection = await this.adapter.introspect();
+    const introspection = "";
     const count = this.options?.count ?? 1;
     const techniques = this.options?.techniques ?? ALL_TECHNIQUES;
     let pairIndex = 0;
@@ -1780,7 +2999,7 @@ var DepthEvolver = class extends PairProducer {
   }
   async #processTask(pair, technique, introspection) {
     const { experimental_output } = await withRetry2(
-      () => generate8(
+      () => generate7(
         questionEvolverAgent.clone({
           model: this.options?.model
         }),
@@ -1799,7 +3018,8 @@ var DepthEvolver = class extends PairProducer {
       const sqlResult = await toSql({
         input: evolvedQuestion,
         adapter: this.adapter,
-        introspection,
+        schemaFragments: [],
+        // Placeholder - needs to pass actual fragments
         instructions: [],
         model: this.options?.model
       });
@@ -1828,22 +3048,22 @@ var DepthEvolver = class extends PairProducer {
 async function withRetry2(computation) {
   return pRetry2(computation, {
     retries: 3,
-    shouldRetry: (context2) => {
+    shouldRetry: (context) => {
       console.log({
         NoObjectGeneratedError: NoObjectGeneratedError2.isInstance(
-          context2.error
+          context.error
         ),
         NoOutputGeneratedError: NoOutputGeneratedError2.isInstance(
-          context2.error
+          context.error
         )
       });
-      return NoObjectGeneratedError2.isInstance(context2.error) || NoOutputGeneratedError2.isInstance(context2.error);
+      return NoObjectGeneratedError2.isInstance(context.error) || NoOutputGeneratedError2.isInstance(context.error);
     },
-    onFailedAttempt(context2) {
+    onFailedAttempt(context) {
       console.log(
-        `Attempt ${context2.attemptNumber} failed. There are ${context2.retriesLeft} retries left.`
+        `Attempt ${context.attemptNumber} failed. There are ${context.retriesLeft} retries left.`
       );
-      console.dir(context2.error, { depth: null });
+      console.dir(context.error, { depth: null });
     }
   });
 }
@@ -1853,70 +3073,65 @@ import { groq as groq8 } from "@ai-sdk/groq";
 import { defaultSettingsMiddleware as defaultSettingsMiddleware5, wrapLanguageModel as wrapLanguageModel5 } from "ai";
 import dedent7 from "dedent";
 import z8 from "zod";
-import { agent as agent8, generate as generate9, user as user9 } from "@deepagents/agent";
-var personaGeneratorAgent = agent8({
-  name: "persona_generator",
-  model: wrapLanguageModel5({
-    model: groq8("openai/gpt-oss-20b"),
-    middleware: defaultSettingsMiddleware5({
-      settings: { temperature: 0.8, topP: 0.95, presencePenalty: 0.2 }
+import "@deepagents/agent";
+var outputSchema = z8.object({
+  personas: z8.array(
+    z8.object({
+      role: z8.string().describe("The job title or role of this persona"),
+      perspective: z8.string().describe(
+        "Rich description of what this persona cares about when querying the database"
+      ),
+      styles: z8.array(z8.enum(ALL_STYLES)).min(1).max(3).describe(
+        "Typical communication styles for this persona (1-3 styles)"
+      )
     })
-  }),
-  logging: process.env.AGENT_LOGGING === "true",
-  output: z8.object({
-    personas: z8.array(
-      z8.object({
-        role: z8.string().describe("The job title or role of this persona"),
-        perspective: z8.string().describe(
-          "Rich description of what this persona cares about when querying the database"
-        ),
-        styles: z8.array(z8.enum(ALL_STYLES)).min(1).max(3).describe(
-          "Typical communication styles for this persona (1-3 styles)"
-        )
-      })
-    ).min(1).describe("List of personas who would query this database")
-  }),
-  prompt: (state) => {
-    return dedent7`
-      <identity>
-        You are an expert at understanding database schemas and inferring who would use them.
-        Your task is to analyze a database schema and generate realistic personas representing
-        the different types of users who would query this database.
-      </identity>
+  ).min(1).describe("List of personas who would query this database")
+});
+async function generatePersonas(schemaFragments, options) {
+  const schema = new XmlRenderer().render(schemaFragments);
+  const count = options?.count ?? 5;
+  const context = new ContextEngine({
+    store: new InMemoryContextStore(),
+    chatId: `persona-gen-${crypto.randomUUID()}`
+  });
+  context.set(
+    persona({
+      name: "persona_generator",
+      role: "You are an expert at understanding database schemas and inferring who would use them."
+    }),
+    role(dedent7`
+      Your task is to analyze a database schema and generate realistic personas representing
+      the different types of users who would query this database.
 
       <database_schema>
-        ${state?.schema}
+        ${schema}
       </database_schema>
 
-      <task>
-        Generate exactly ${state?.count} distinct personas who would query this database.
-
-        For each persona, provide:
-        1. **role**: Their job title or role (e.g., "Financial Analyst", "Customer Support Rep")
-        2. **perspective**: A rich description of what they care about, including:
-           - What questions they typically ask
-           - What metrics/data points matter to them
-           - How they prefer data formatted or presented
-           - Their priorities (speed vs accuracy, detail vs summary)
-           - Domain-specific concerns relevant to their role
-        3. **styles**: 1-3 communication styles typical for this persona. Choose from:
-           - formal: Professional business language, complete sentences
-           - colloquial: Casual everyday speech, contractions
-           - imperative: Commands like "Show me...", "Get...", "List..."
-           - interrogative: Questions like "What is...", "How many..."
-           - descriptive: Verbose, detailed phrasing
-           - concise: Brief, minimal words
-           - vague: Ambiguous, hedging language
-           - metaphorical: Figurative language, analogies
-           - conversational: Chat-like, casual tone
-
-        Requirements:
-        - Personas should be realistic for the given schema
-        - Each persona should have distinct concerns and priorities
-        - Perspectives should be detailed enough to guide question paraphrasing
-        - Cover different levels of technical expertise (some technical, some business-focused)
-        - Styles should match how this persona would naturally communicate
-      </task>
+      For each persona, provide:
+      1. **role**: Their job title or role (e.g., "Financial Analyst", "Customer Support Rep")
+      2. **perspective**: A rich description of what they care about, including:
+         - What questions they typically ask
+         - What metrics/data points matter to them
+         - How they prefer data formatted or presented
+         - Their priorities (speed vs accuracy, detail vs summary)
+         - Domain-specific concerns relevant to their role
+      3. **styles**: 1-3 communication styles typical for this persona. Choose from:
+         - formal: Professional business language, complete sentences
+         - colloquial: Casual everyday speech, contractions
+         - imperative: Commands like "Show me...", "Get...", "List..."
+         - interrogative: Questions like "What is...", "How many..."
+         - descriptive: Verbose, detailed phrasing
+         - concise: Brief, minimal words
+         - vague: Ambiguous, hedging language
+         - metaphorical: Figurative language, analogies
+         - conversational: Chat-like, casual tone
+
+      Requirements:
+      - Personas should be realistic for the given schema
+      - Each persona should have distinct concerns and priorities
+      - Perspectives should be detailed enough to guide question paraphrasing
+      - Cover different levels of technical expertise (some technical, some business-focused)
+      - Styles should match how this persona would naturally communicate
 
       <example>
         For an e-commerce schema with orders, customers, products tables:
@@ -1939,46 +3154,33 @@ var personaGeneratorAgent = agent8({
         - Do not invent tables or data that don't exist in the schema
         - Ensure perspectives are specific to the domain, not generic
       </guardrails>
-    `;
-  }
-});
-var PersonaGenerator = class {
-  /**
-   * @param adapter - Database adapter for schema introspection
-   * @param options - Generation options including count and model
-   */
-  constructor(adapter, options) {
-    this.adapter = adapter;
-    this.options = options;
-  }
-  /**
-   * Generates personas by analyzing the database schema to infer user types.
-   * @returns Array of personas with roles and perspectives
-   */
-  async generate() {
-    const schema = await this.adapter.introspect();
-    const count = this.options?.count ?? 5;
-    const { experimental_output } = await generate9(
-      personaGeneratorAgent.clone({
-        model: this.options?.model
-      }),
-      [user9(`Generate ${count} personas for this database schema.`)],
-      {
-        schema,
-        count
-      }
-    );
-    return experimental_output.personas;
-  }
-};
+    `),
+    user6(
+      `Generate exactly ${count} distinct personas who would query this database.`
+    )
+  );
+  const personaOutput = structuredOutput({
+    name: "persona_generator",
+    model: wrapLanguageModel5({
+      model: options?.model ?? groq8("openai/gpt-oss-20b"),
+      middleware: defaultSettingsMiddleware5({
+        settings: { temperature: 0.8, topP: 0.95, presencePenalty: 0.2 }
+      })
+    }),
+    context,
+    schema: outputSchema
+  });
+  const output = await personaOutput.generate();
+  return output.personas;
+}
 
 // packages/text2sql/src/lib/agents/teachables.agent.ts
 import { groq as groq9 } from "@ai-sdk/groq";
 import { defaultSettingsMiddleware as defaultSettingsMiddleware6, wrapLanguageModel as wrapLanguageModel6 } from "ai";
 import dedent8 from "dedent";
 import z9 from "zod";
-import { agent as agent9, generate as generate10, user as user10 } from "@deepagents/agent";
-var outputSchema = z9.object({
+import { agent as agent7, generate as generate8, user as user9 } from "@deepagents/agent";
+var outputSchema2 = 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"),
   guardrails: z9.array(
@@ -2021,7 +3223,7 @@ var outputSchema = z9.object({
   ).optional().describe("SQL style preferences"),
   analogies: z9.array(
     z9.object({
-      concept: z9.array(z9.string()).min(2),
+      concepts: z9.array(z9.string()).min(2),
       relationship: z9.string(),
       insight: z9.string().optional(),
       therefore: z9.string().optional(),
@@ -2029,7 +3231,7 @@ var outputSchema = z9.object({
     })
   ).optional().describe("Concept analogies")
 });
-var teachablesAuthorAgent = agent9({
+var teachablesAuthorAgent = agent7({
   name: "teachables-author",
   model: wrapLanguageModel6({
     model: groq9("openai/gpt-oss-20b"),
@@ -2037,10 +3239,10 @@ var teachablesAuthorAgent = agent9({
       settings: { temperature: 0.4, topP: 0.95 }
     })
   }),
-  output: outputSchema,
+  output: outputSchema2,
   prompt: (state) => dedent8`
     <identity>
-      You design "teachables" for a Text2SQL system. Teachables become structured XML instructions.
+      You design "fragments" for a Text2SQL system. Fragments become structured XML instructions.
       Choose only high-impact items that improve accuracy, safety, or clarity for this database.
     </identity>
 
@@ -2061,12 +3263,12 @@ var teachablesAuthorAgent = agent9({
       - workflows: [{ task: string, steps: string[], triggers?: string[], notes?: string }] - Multi-step tasks
       - quirks: [{ issue: string, workaround: string }] - Known issues
       - styleGuides: [{ prefer: string, never?: string, always?: string }] - SQL style rules
-      - analogies: [{ concept: string[], relationship: string, insight?: string, therefore?: string, pitfall?: string }]
+      - analogies: [{ concepts: string[], relationship: string, insight?: string, therefore?: string, pitfall?: string }]
     </output_structure>
 
     <instructions>
       1. Analyze the schema to infer domain, relationships, and sensitive columns.
-      2. Generate 3-10 teachables total across all categories, prioritizing:
+      2. Generate 3-10 fragments total across all categories, prioritizing:
          - guardrails for PII columns (email, ssn, phone, etc)
          - hints for status/enum columns
          - clarifications for ambiguous terms
@@ -2076,75 +3278,95 @@ var teachablesAuthorAgent = agent9({
   `
 });
 async function toTeachings(input, options) {
-  const { experimental_output: result } = await generate10(
+  const { experimental_output: result } = await generate8(
     teachablesAuthorAgent.clone({ model: options?.model }),
     [
-      user10(
-        `Analyze this database schema and generate teachings that will help an AI generate accurate SQL queries.`
+      user9(
+        `Analyze this database schema and generate fragments that will help an AI generate accurate SQL queries.`
       )
     ],
     input
   );
-  const generated = [
-    ...result.terms?.map((t) => ({ type: "term", ...t })) ?? [],
-    ...result.hints?.map((h) => ({ type: "hint", ...h })) ?? [],
-    ...result.guardrails?.map((g) => ({ type: "guardrail", ...g })) ?? [],
-    ...result.explains?.map((e) => ({ type: "explain", ...e })) ?? [],
-    ...result.examples?.map((e) => ({ type: "example", ...e })) ?? [],
-    ...result.clarifications?.map((c) => ({
-      type: "clarification",
-      ...c
-    })) ?? [],
-    ...result.workflows?.map((w) => ({ type: "workflow", ...w })) ?? [],
-    ...result.quirks?.map((q) => ({ type: "quirk", ...q })) ?? [],
-    ...result.styleGuides?.map((s) => ({
-      type: "styleGuide",
-      ...s
-    })) ?? [],
-    ...result.analogies?.map((a) => ({ type: "analogy", ...a })) ?? []
-  ];
-  return toTeachables(generated);
+  const fragments = [];
+  result.terms?.forEach((t) => fragments.push(term(t.name, t.definition)));
+  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 })
+    )
+  );
+  result.explains?.forEach(
+    (e) => fragments.push(
+      explain({
+        concept: e.concept,
+        explanation: e.explanation,
+        therefore: e.therefore
+      })
+    )
+  );
+  result.examples?.forEach(
+    (e) => fragments.push(
+      example({ question: e.question, answer: e.answer, note: e.note })
+    )
+  );
+  result.clarifications?.forEach(
+    (c) => fragments.push(
+      clarification({ when: c.when, ask: c.ask, reason: c.reason })
+    )
+  );
+  result.workflows?.forEach(
+    (w) => fragments.push(
+      workflow({
+        task: w.task,
+        steps: w.steps,
+        triggers: w.triggers,
+        notes: w.notes
+      })
+    )
+  );
+  result.quirks?.forEach(
+    (q) => fragments.push(quirk({ issue: q.issue, workaround: q.workaround }))
+  );
+  result.styleGuides?.forEach(
+    (s) => fragments.push(
+      styleGuide({ prefer: s.prefer, never: s.never, always: s.always })
+    )
+  );
+  result.analogies?.forEach(
+    (a) => fragments.push(
+      analogy({
+        concepts: a.concepts,
+        relationship: a.relationship,
+        insight: a.insight,
+        therefore: a.therefore,
+        pitfall: a.pitfall
+      })
+    )
+  );
+  return fragments;
 }
 
 // packages/text2sql/src/lib/synthesis/synthesizers/teachings-generator.ts
-var TeachingsGenerator = class {
-  /**
-   * @param adapter - Database adapter for schema introspection
-   * @param options - Generation options including context and model
-   */
-  constructor(adapter, options) {
-    this.adapter = adapter;
-    this.options = options;
-  }
-  /**
-   * Generates domain-specific teachings by analyzing the database schema.
-   * Retries on transient generation errors up to maxRetries attempts.
-   * @param maxRetries - Maximum retry attempts for transient failures
-   * @returns Array of teachings including vocabulary, patterns, and guardrails
-   */
-  async generate(maxRetries = 3) {
-    const schema = await this.adapter.introspect();
-    let lastError;
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-      try {
-        return await toTeachings(
-          {
-            schema,
-            context: this.options?.context
-          },
-          { model: this.options?.model }
-        );
-      } catch (error) {
-        lastError = error;
-        const isRetryable = lastError.message.includes("parse") || lastError.message.includes("schema") || lastError.message.includes("No object generated") || lastError.name.includes("AI_");
-        if (!isRetryable) {
-          throw lastError;
-        }
+async function generateTeachings(schemaFragments, options) {
+  const schema = new XmlRenderer().render(schemaFragments);
+  const maxRetries = options?.maxRetries ?? 3;
+  let lastError;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      return await toTeachings(
+        { schema, context: options?.context },
+        { model: options?.model }
+      );
+    } catch (error) {
+      lastError = error;
+      const isRetryable = lastError.message.includes("parse") || lastError.message.includes("schema") || lastError.message.includes("No object generated") || lastError.name.includes("AI_");
+      if (!isRetryable) {
+        throw lastError;
       }
     }
-    throw lastError;
   }
-};
+  throw lastError;
+}
 export {
   ALL_STYLES,
   BaseContextualExtractor,
@@ -2156,15 +3378,15 @@ export {
   LastQueryExtractor,
   MessageExtractor,
   PairProducer,
-  PersonaGenerator,
   SchemaSynthesizer,
   SegmentedContextExtractor,
   SqlExtractor,
-  TeachingsGenerator,
   ValidatedProducer,
   WindowedContextExtractor,
   contextResolverAgent,
   formatConversation,
+  generatePersonas,
+  generateTeachings,
   getMessageText,
   styleInstructions,
   toPairs