@deepagents/text2sql 0.11.0 → 0.12.1

package/dist/lib/synthesis/index.js

@@ -165,7 +165,7 @@ import {
 } from "ai";
 
 // packages/text2sql/src/lib/synthesis/extractors/base-contextual-extractor.ts
-import { groq } from "@ai-sdk/groq";
+import { groq as groq2 } from "@ai-sdk/groq";
 import {
   getToolOrDynamicToolName,
   isTextUIPart,
@@ -173,1643 +173,1185 @@ import {
 } from "ai";
 import dedent from "dedent";
 import z from "zod";
-import { agent, generate, user } from "@deepagents/agent";
-var contextResolverAgent = agent({
-  name: "context_resolver",
-  model: groq("openai/gpt-oss-20b"),
-  output: z.object({
-    question: z.string().describe(
-      "A standalone natural language question that the SQL query answers"
-    )
-  }),
-  prompt: (state) => dedent`
-    <identity>
-      You are an expert at understanding conversational context and generating clear,
-      standalone questions from multi-turn conversations.
-    </identity>
-
-    ${state?.introspection ? `<schema>
-${state.introspection}
-</schema>` : ""}
-
-    <conversation>
-    ${state?.conversation}
-    </conversation>
-
-    <sql>
-    ${state?.sql}
-    </sql>
-
-    <task>
-      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
-      2. Uses natural business language (not SQL terminology)
-      3. Could be asked by someone who hasn't seen the conversation
-      4. Accurately represents what the SQL query answers
-    </task>
-
-    <examples>
-      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"
 
-      Conversation: "What were sales last month?" → "Break it down by category"
-      SQL: SELECT category, SUM(amount) FROM sales WHERE date >= '2024-11-01' GROUP BY category
-      Question: "What were sales by category for last month?"
-    </examples>
-  `
-});
-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;
+// packages/context/dist/index.js
+import { encode } from "gpt-tokenizer";
+import { generateId } from "ai";
+import pluralize from "pluralize";
+import { titlecase } from "stringcase";
+import chalk from "chalk";
+import { defineCommand } from "just-bash";
+import spawn from "nano-spawn";
+import "bash-tool";
+import spawn2 from "nano-spawn";
+import {
+  createBashTool
+} from "bash-tool";
+import YAML from "yaml";
+import { DatabaseSync } from "node:sqlite";
+import { groq } from "@ai-sdk/groq";
+import {
+  NoSuchToolError,
+  Output,
+  convertToModelMessages,
+  createUIMessageStream,
+  generateId as generateId2,
+  generateText,
+  smoothStream,
+  stepCountIs,
+  streamText
+} from "ai";
+import chalk2 from "chalk";
+import "zod";
+import "@deepagents/agent";
+var defaultTokenizer = {
+  encode(text) {
+    return encode(text);
+  },
+  count(text) {
+    return encode(text).length;
   }
+};
+var ModelsRegistry = class {
+  #cache = /* @__PURE__ */ new Map();
+  #loaded = false;
+  #tokenizers = /* @__PURE__ */ new Map();
+  #defaultTokenizer = defaultTokenizer;
   /**
-   * Template method - defines the extraction algorithm skeleton.
-   * Subclasses customize behavior via hooks, not by overriding this method.
+   * Load models data from models.dev API
    */
-  async *produce() {
-    this.context = [];
-    this.results = [];
-    const { includeFailures = false, toolName = "db_query" } = this.options;
-    await this.extractSqlsWithContext(toolName, includeFailures);
-    if (this.results.length === 0) {
-      return;
+  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 introspection = "";
-    yield* this.resolveQuestions(introspection);
+    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;
   }
   /**
-   * Core extraction loop - iterates through messages and calls hooks.
+   * Get model info by ID
+   * @param modelId - Model ID (e.g., "openai:gpt-4o")
    */
-  async extractSqlsWithContext(toolName, includeFailures) {
-    for (const message2 of this.messages) {
-      if (message2.role === "user") {
-        const text = getMessageText(message2);
-        if (text) {
-          await this.onUserMessage(text);
-        }
-        continue;
-      }
-      if (message2.role === "assistant") {
-        await this.extractFromAssistant(message2, toolName, includeFailures);
-      }
-    }
+  get(modelId) {
+    return this.#cache.get(modelId);
   }
   /**
-   * Extract SQL from assistant message parts.
+   * Check if a model exists in the registry
    */
-  async extractFromAssistant(message2, toolName, includeFailures) {
-    for (const part of message2.parts) {
-      if (!isToolOrDynamicToolUIPart(part)) {
-        continue;
-      }
-      if (getToolOrDynamicToolName(part) !== toolName) {
-        continue;
-      }
-      const toolInput = "input" in part ? part.input : void 0;
-      if (!toolInput?.sql) {
-        continue;
-      }
-      const success = part.state === "output-available";
-      const failed = part.state === "output-error";
-      if (failed && !includeFailures) {
-        continue;
-      }
-      if (!success && !failed) {
-        continue;
-      }
-      const snapshot = this.getContextSnapshot();
-      if (snapshot.length === 0) {
-        continue;
-      }
-      this.results.push({
-        sql: toolInput.sql,
-        success,
-        conversationContext: snapshot
-      });
-    }
-    const assistantText = getMessageText(message2);
-    if (assistantText) {
-      this.context.push(`Assistant: ${assistantText}`);
-    }
+  has(modelId) {
+    return this.#cache.has(modelId);
   }
   /**
-   * Resolve extracted SQL contexts into standalone questions using LLM.
+   * List all available model IDs
    */
-  async *resolveQuestions(introspection) {
-    for (const item of this.results) {
-      const { experimental_output } = await generate(
-        contextResolverAgent,
-        [user("Generate a standalone question for this SQL query.")],
-        {
-          conversation: formatConversation(item.conversationContext),
-          sql: item.sql,
-          introspection
-        }
-      );
-      yield [
-        {
-          question: experimental_output.question,
-          sql: item.sql,
-          context: item.conversationContext,
-          success: item.success
-        }
-      ];
-    }
+  list() {
+    return [...this.#cache.keys()];
   }
-};
-
-// 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
+   * Register a custom tokenizer for specific model families
+   * @param family - Model family name (e.g., "llama", "claude")
+   * @param tokenizer - Tokenizer implementation
    */
-  constructor(messages, options = {}) {
-    super();
-    this.#messages = messages;
-    this.#options = options;
+  registerTokenizer(family, tokenizer) {
+    this.#tokenizers.set(family, tokenizer);
   }
   /**
-   * Extracts question-SQL pairs by parsing tool calls and pairing with user messages.
-   * @returns Pairs extracted from db_query tool invocations
+   * Set the default tokenizer used when no family-specific tokenizer is registered
    */
-  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;
-        continue;
-      }
-      if (message2.role === "assistant" && lastUserMessage) {
-        for (const part of message2.parts) {
-          if (!isToolOrDynamicToolUIPart2(part)) {
-            continue;
-          }
-          if (getToolOrDynamicToolName2(part) !== toolName) {
-            continue;
-          }
-          const toolInput = "input" in part ? part.input : void 0;
-          if (!toolInput?.sql) {
-            continue;
-          }
-          const success = part.state === "output-available";
-          const failed = part.state === "output-error";
-          if (failed && !includeFailures) {
-            continue;
-          }
-          if (!success && !failed) {
-            continue;
-          }
-          const question = getMessageText(lastUserMessage);
-          if (!question) {
-            continue;
-          }
-          yield [
-            {
-              question,
-              sql: toolInput.sql,
-              success
-            }
-          ];
-        }
+  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;
       }
     }
-  }
-};
-
-// packages/text2sql/src/lib/synthesis/extractors/sql-extractor.ts
-import { groq as groq2 } from "@ai-sdk/groq";
-import dedent2 from "dedent";
-import z2 from "zod";
-import { agent as agent2, generate as generate2, user as user2 } from "@deepagents/agent";
-var sqlToQuestionAgent = agent2({
-  name: "sql_to_question",
-  model: groq2("llama-3.3-70b-versatile"),
-  output: z2.object({
-    question: z2.string().describe("A natural language question that the SQL query answers")
-  }),
-  prompt: (state) => dedent2`
-    <identity>
-      You are an expert at understanding SQL queries and generating clear,
-      natural language questions that describe what the query retrieves.
-    </identity>
-
-    <schema>
-    ${state?.introspection}
-    </schema>
-
-    <sql>
-    ${state?.sql}
-    </sql>
-
-    <task>
-      Given the database schema and the SQL query above, generate a single
-      natural language question that:
-      1. Accurately describes what information the query retrieves
-      2. Uses natural business language (not SQL terminology)
-      3. Could be asked by a non-technical user
-      4. Is concise but complete
-    </task>
-
-    <examples>
-      SQL: SELECT COUNT(*) FROM customers WHERE region = 'NY'
-      Question: "How many customers do we have in New York?"
-
-      SQL: SELECT product_name, SUM(quantity) as total FROM orders GROUP BY product_name ORDER BY total DESC LIMIT 10
-      Question: "What are our top 10 products by quantity sold?"
-
-      SQL: SELECT c.name, COUNT(o.id) FROM customers c LEFT JOIN orders o ON c.id = o.customer_id GROUP BY c.id HAVING COUNT(o.id) = 0
-      Question: "Which customers have never placed an order?"
-    </examples>
-  `
-});
-var SqlExtractor = class extends PairProducer {
-  #sqls;
-  #adapter;
-  #options;
-  /**
-   * @param sql - SQL query or queries to generate questions for
-   * @param adapter - Database adapter for validation and schema introspection
-   * @param options - Extraction configuration
-   */
-  constructor(sql, adapter, options = {}) {
-    super();
-    this.#sqls = Array.isArray(sql) ? sql : [sql];
-    this.#adapter = adapter;
-    this.#options = options;
+    return this.#defaultTokenizer;
   }
   /**
-   * Generates natural language questions for each SQL query using an LLM.
-   * @returns Pairs with generated questions and original SQL
+   * 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)
    */
-  async *produce() {
-    const { validateSql = true, skipInvalid = false } = this.#options;
-    const introspection = "";
-    for (const sql of this.#sqls) {
-      let isValid = true;
-      if (validateSql) {
-        const error = await this.#adapter.validate(sql);
-        isValid = error === void 0 || error === null;
-        if (!isValid && skipInvalid) {
-          continue;
-        }
-      }
-      const { experimental_output } = await generate2(
-        sqlToQuestionAgent,
-        [user2("Generate a natural language question for this SQL query.")],
-        {
-          sql,
-          introspection
-        }
+  estimate(modelId, input) {
+    const model = this.get(modelId);
+    if (!model) {
+      throw new Error(
+        `Model "${modelId}" not found. Call load() first or check model ID.`
       );
-      yield [
-        {
-          question: experimental_output.question,
-          sql,
-          success: isValid
-        }
-      ];
     }
+    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: []
+    };
   }
 };
-
-// packages/text2sql/src/lib/synthesis/extractors/full-context-extractor.ts
-var FullContextExtractor = class extends BaseContextualExtractor {
-  constructor(messages, adapter, options = {}) {
-    super(messages, adapter, options);
+var _registry = null;
+function getModelsRegistry() {
+  if (!_registry) {
+    _registry = new ModelsRegistry();
   }
-  /**
-   * Add user message to context (keeps all messages).
-   */
-  async onUserMessage(text) {
-    this.context.push(`User: ${text}`);
+  return _registry;
+}
+function isFragment(data) {
+  return typeof data === "object" && data !== null && "name" in data && "data" in data && typeof data.name === "string";
+}
+function isFragmentObject(data) {
+  return typeof data === "object" && data !== null && !Array.isArray(data) && !isFragment(data);
+}
+function isMessageFragment(fragment2) {
+  return fragment2.type === "message";
+}
+function fragment(name, ...children) {
+  return {
+    name,
+    data: children
+  };
+}
+function user(content) {
+  const message2 = typeof content === "string" ? {
+    id: generateId(),
+    role: "user",
+    parts: [{ type: "text", text: content }]
+  } : content;
+  return {
+    id: message2.id,
+    name: "user",
+    data: "content",
+    type: "message",
+    persist: true,
+    codec: {
+      decode() {
+        return message2;
+      },
+      encode() {
+        return message2;
+      }
+    }
+  };
+}
+function assistant(message2) {
+  return {
+    id: message2.id,
+    name: "assistant",
+    data: "content",
+    type: "message",
+    persist: true,
+    codec: {
+      decode() {
+        return message2;
+      },
+      encode() {
+        return message2;
+      }
+    }
+  };
+}
+function message(content) {
+  const message2 = typeof content === "string" ? {
+    id: generateId(),
+    role: "user",
+    parts: [{ type: "text", text: content }]
+  } : content;
+  return {
+    id: message2.id,
+    name: message2.role,
+    data: "content",
+    type: "message",
+    persist: true,
+    codec: {
+      decode() {
+        return message2;
+      },
+      encode() {
+        return message2;
+      }
+    }
+  };
+}
+function assistantText(content, options) {
+  const id = options?.id ?? crypto.randomUUID();
+  return assistant({
+    id,
+    role: "assistant",
+    parts: [{ type: "text", text: content }]
+  });
+}
+var LAZY_ID = Symbol("lazy-id");
+function isLazyFragment(fragment2) {
+  return LAZY_ID in fragment2;
+}
+var ContextRenderer = class {
+  options;
+  constructor(options = {}) {
+    this.options = options;
   }
   /**
-   * Return all context accumulated so far.
+   * Check if data is a primitive (string, number, boolean).
    */
-  getContextSnapshot() {
-    return [...this.context];
-  }
-};
-
-// packages/text2sql/src/lib/synthesis/extractors/windowed-context-extractor.ts
-var WindowedContextExtractor = class extends BaseContextualExtractor {
-  windowSize;
-  constructor(messages, adapter, options) {
-    super(messages, adapter, options);
-    this.windowSize = options.windowSize;
+  isPrimitive(data) {
+    return typeof data === "string" || typeof data === "number" || typeof data === "boolean";
   }
   /**
-   * Add user message to context (keeps all, windowing happens on snapshot).
+   * Group fragments by name for groupFragments option.
    */
-  async onUserMessage(text) {
-    this.context.push(`User: ${text}`);
+  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;
   }
   /**
-   * Return only the last N messages based on window size.
+   * 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.
    */
-  getContextSnapshot() {
-    if (this.context.length <= this.windowSize) {
-      return [...this.context];
+  sanitizeFragments(fragments) {
+    const sanitized = [];
+    for (const fragment2 of fragments) {
+      const cleaned = this.sanitizeFragment(fragment2, /* @__PURE__ */ new WeakSet());
+      if (cleaned) {
+        sanitized.push(cleaned);
+      }
     }
-    return this.context.slice(-this.windowSize);
+    return sanitized;
   }
-};
-
-// packages/text2sql/src/lib/synthesis/extractors/segmented-context-extractor.ts
-import { groq as groq3 } from "@ai-sdk/groq";
-import dedent3 from "dedent";
-import z3 from "zod";
-import { agent as agent3, generate as generate3, user as user3 } from "@deepagents/agent";
-var topicChangeAgent = agent3({
-  name: "topic_change_detector",
-  model: groq3("openai/gpt-oss-20b"),
-  output: z3.object({
-    isTopicChange: z3.boolean().describe("Whether the new message represents a topic change"),
-    reason: z3.string().describe("Brief explanation for the decision")
-  }),
-  prompt: (state) => dedent3`
-    <identity>
-      You are an expert at understanding conversational flow and detecting topic changes.
-    </identity>
-
-    <conversation_context>
-    ${state?.context || "(no prior context)"}
-    </conversation_context>
-
-    <new_message>
-    ${state?.newMessage}
-    </new_message>
-
-    <task>
-      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
-      2. The user starts a new analytical question unrelated to prior discussion
-      3. There's a clear shift in what data or metrics are being discussed
-
-      NOT a topic change:
-      - Follow-up questions refining the same query ("filter by...", "sort by...")
-      - Questions about the same entities with different conditions
-      - Requests for more details on the same topic
-    </task>
-
-    <examples>
-      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)
-
-      Context: "Show me customers in NY" → "Sort by revenue"
-      New: "What were our total sales last quarter?"
-      Decision: Topic change (shifted from customers to sales metrics)
-
-      Context: "List all products"
-      New: "How many orders did we have last month?"
-      Decision: Topic change (products → orders/sales)
-    </examples>
-  `
-});
-var SegmentedContextExtractor = class extends BaseContextualExtractor {
-  constructor(messages, adapter, options = {}) {
-    super(messages, adapter, options);
+  sanitizeFragment(fragment2, seen) {
+    const data = this.sanitizeData(fragment2.data, seen);
+    if (data == null) {
+      return null;
+    }
+    return {
+      ...fragment2,
+      data
+    };
   }
-  /**
-   * Handle user message with topic change detection.
-   * If topic changes, resolve the message to standalone form before resetting.
-   *
-   * Note: We capture context snapshot before async LLM calls to prevent race conditions
-   * where context might be modified during the async operation.
-   */
-  async onUserMessage(text) {
-    if (this.context.length >= 2) {
-      const contextSnapshot = [...this.context];
-      const isTopicChange = await this.detectTopicChange(text, contextSnapshot);
-      if (isTopicChange) {
-        const resolved = await this.resolveToStandalone(text, contextSnapshot);
-        this.context = [`User: ${resolved}`];
-        return;
+  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;
     }
-    this.context.push(`User: ${text}`);
+    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;
   }
   /**
-   * Return all context in current topic segment.
+   * Template method - dispatches value to appropriate handler.
    */
-  getContextSnapshot() {
-    return [...this.context];
+  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);
   }
   /**
-   * Detect if a new message represents a topic change using LLM.
-   * @param newMessage - The new user message to check
-   * @param contextSnapshot - Snapshot of context captured before this async call
+   * Render all entries of an object.
    */
-  async detectTopicChange(newMessage, contextSnapshot) {
-    const { experimental_output } = await generate3(
-      topicChangeAgent,
-      [user3("Determine if this is a topic change.")],
-      {
-        context: formatConversation(contextSnapshot),
-        newMessage
+  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)
+          );
+        }
       }
-    );
-    return experimental_output.isTopicChange;
+    }
+    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);
   }
-  /**
-   * Resolve a context-dependent message into a standalone question.
-   * Called when topic change is detected to preserve the meaning of
-   * the triggering message before context is reset.
-   * @param text - The user message to resolve
-   * @param contextSnapshot - Snapshot of context captured before this async call
-   */
-  async resolveToStandalone(text, contextSnapshot) {
-    const { experimental_output } = await generate3(
-      contextResolverAgent,
-      [user3("Generate a standalone question for this message.")],
-      {
-        conversation: formatConversation([...contextSnapshot, `User: ${text}`]),
-        sql: ""
-        // No SQL yet, just resolving the question
+  #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)
+          );
+        }
       }
-    );
-    return experimental_output.question;
+    }
+    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}>`;
   }
 };
-
-// packages/text2sql/src/lib/synthesis/extractors/last-query-extractor.ts
-import { generate as generate4, user as user4 } from "@deepagents/agent";
-var LastQueryExtractor = class extends BaseContextualExtractor {
-  constructor(messages, adapter, options = {}) {
-    super(messages, adapter, options);
+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;
+  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";
   }
   /**
-   * Add user message to context (keeps all messages).
+   * Initialize the chat and branch if they don't exist.
    */
-  async onUserMessage(text) {
-    this.context.push(`User: ${text}`);
+  async #ensureInitialized() {
+    if (this.#initialized) {
+      return;
+    }
+    this.#chatData = await this.#store.upsertChat({
+      id: this.#chatId,
+      userId: this.#userId
+    });
+    this.#branch = await this.#store.getActiveBranch(this.#chatId);
+    this.#initialized = true;
   }
   /**
-   * Return all context accumulated so far.
+   * Create a new branch from a specific message.
+   * Shared logic between rewind() and btw().
    */
-  getContextSnapshot() {
-    return [...this.context];
+  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
+    };
   }
   /**
-   * Override to only resolve the LAST query instead of all queries.
+   * Get the current chat ID.
    */
-  async *resolveQuestions(introspection) {
-    if (this.results.length === 0) {
-      return;
-    }
-    const last = this.results.at(-1);
-    const { experimental_output } = await generate4(
-      contextResolverAgent,
-      [user4("Generate a standalone question for this SQL query.")],
-      {
-        conversation: formatConversation(last.conversationContext),
-        sql: last.sql,
-        introspection
-      }
-    );
-    yield [
-      {
-        question: experimental_output.question,
-        sql: last.sql,
-        context: last.conversationContext,
-        success: last.success
-      }
-    ];
-  }
-};
-
-// packages/text2sql/src/lib/synthesis/synthesizers/schema-synthesizer.ts
-import pLimit from "p-limit";
-
-// packages/text2sql/src/lib/agents/question.agent.ts
-import { groq as groq4 } from "@ai-sdk/groq";
-import { defaultSettingsMiddleware, wrapLanguageModel } from "ai";
-import dedent4 from "dedent";
-import z4 from "zod";
-import { agent as agent4, generate as generate5, user as user5 } from "@deepagents/agent";
-var complexityInstructions = {
-  simple: dedent4`
-    Generate simple questions that require:
-    - Basic SELECT with single table
-    - Simple WHERE clauses with one condition
-    - COUNT(*) or basic aggregations
-    - No joins required
-    Examples: "How many customers do we have?", "List all products", "What is the total revenue?"
-  `,
-  moderate: dedent4`
-    Generate moderate questions that require:
-    - JOINs between 2-3 tables
-    - Multiple WHERE conditions (AND/OR)
-    - GROUP BY with HAVING clauses
-    - ORDER BY with LIMIT
-    - Basic subqueries
-    Examples: "What are the top 5 customers by total orders?", "Which products have never been ordered?"
-  `,
-  complex: dedent4`
-    Generate complex questions that require:
-    - Multiple JOINs (3+ tables)
-    - Nested subqueries or CTEs
-    - Complex aggregations with multiple GROUP BY columns
-    - CASE expressions
-    - Date/time calculations
-    Examples: "What is the month-over-month growth rate?", "Which customers have increased spending compared to last year?"
-  `,
-  "high complex": dedent4`
-    Generate highly complex questions that require advanced SQL features:
-    - Window functions (ROW_NUMBER, RANK, DENSE_RANK)
-    - LAG, LEAD for comparisons
-    - Running totals (SUM OVER)
-    - Moving averages
-    - PARTITION BY clauses
-    - Complex CTEs with multiple levels
-    Examples: "What is the running total of sales per month?", "Rank customers by their purchase frequency within each region"
-  `
-};
-var questionGeneratorAgent = agent4({
-  name: "question_generator",
-  model: wrapLanguageModel({
-    model: groq4("openai/gpt-oss-20b"),
-    middleware: defaultSettingsMiddleware({
-      settings: { temperature: 0.8, topP: 0.95 }
-    })
-  }),
-  handoffDescription: "Generates natural language questions that users might ask about the database schema.",
-  output: z4.object({
-    questions: z4.array(z4.string().describe("A natural language question about the data")).min(1).describe("List of natural language questions a user might ask")
-  }),
-  prompt: (state) => {
-    const count = state?.count;
-    const complexity = state?.complexity ?? "moderate";
-    return dedent4`
-      <identity>
-        You are a synthetic data generator specializing in creating realistic natural language questions
-        that users might ask about a database. You understand database schemas and can generate diverse,
-        practical questions that would require SQL queries to answer.
-      </identity>
-
-      ${state?.introspection || ""}
-
-      <complexity level="${complexity}">
-        ${complexityInstructions[complexity]}
-      </complexity>
-
-      <task>
-        Generate exactly ${count} natural language questions at the "${complexity}" complexity level.
-        The questions should:
-        1. Match the complexity requirements above
-        2. Use natural business language, not technical SQL terms
-        3. Be realistic questions a non-technical user would actually ask
-        4. Cover different tables and relationships when possible
-      </task>
-
-      <guardrails>
-        - Questions MUST ONLY reference tables and columns that exist in the schema above
-        - Before generating each question, verify that ALL entities (tables, columns, relationships) you reference are explicitly listed in the schema
-        - DO NOT invent or assume tables/columns that aren't explicitly shown in the schema
-        - Use natural language without SQL keywords like SELECT, WHERE, etc.
-        - All questions must match the specified complexity level
-      </guardrails>
-    `;
-  }
-});
-async function generateQuestions(params) {
-  const { introspection, complexity, count, prompt, model } = params;
-  const agentInstance = model ? questionGeneratorAgent.clone({ model }) : questionGeneratorAgent;
-  const userPrompt = prompt ?? `Generate ${count} questions at ${complexity} complexity given db schema.`;
-  const { experimental_output } = await generate5(
-    agentInstance,
-    [user5(userPrompt)],
-    {
-      introspection,
-      complexity,
-      count
-    }
-  );
-  return { questions: experimental_output.questions };
-}
-
-// packages/text2sql/src/lib/agents/sql.agent.ts
-import { groq as groq5 } from "@ai-sdk/groq";
-import {
-  APICallError,
-  JSONParseError,
-  NoContentGeneratedError,
-  NoObjectGeneratedError,
-  NoOutputGeneratedError,
-  TypeValidationError,
-  defaultSettingsMiddleware as defaultSettingsMiddleware2,
-  wrapLanguageModel as wrapLanguageModel2
-} from "ai";
-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 {
-  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;
-  }
-};
-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 chatId() {
+    return this.#chatId;
   }
   /**
-   * Get model info by ID
-   * @param modelId - Model ID (e.g., "openai:gpt-4o")
+   * Get the current branch name.
    */
-  get(modelId) {
-    return this.#cache.get(modelId);
+  get branch() {
+    return this.#branchName;
   }
   /**
-   * Check if a model exists in the registry
+   * Get metadata for the current chat.
+   * Returns null if the chat hasn't been initialized yet.
    */
-  has(modelId) {
-    return this.#cache.has(modelId);
+  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
+    };
   }
   /**
-   * List all available model IDs
+   * 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
    */
-  list() {
-    return [...this.#cache.keys()];
+  set(...fragments) {
+    for (const fragment2 of fragments) {
+      if (isMessageFragment(fragment2)) {
+        this.#pendingMessages.push(fragment2);
+      } else {
+        this.#fragments.push(fragment2);
+      }
+    }
+    return this;
   }
-  /**
-   * 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);
+  // Unset a fragment by ID (not implemented yet)
+  unset(fragmentId) {
   }
   /**
-   * Set the default tokenizer used when no family-specific tokenizer is registered
+   * Render all fragments using the provided renderer.
+   * @internal Use resolve() instead for public API.
    */
-  setDefaultTokenizer(tokenizer) {
-    this.#defaultTokenizer = tokenizer;
+  render(renderer) {
+    return renderer.render(this.#fragments);
   }
   /**
-   * Get the appropriate tokenizer for a model
+   * 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 });
+   * ```
    */
-  getTokenizer(modelId) {
-    const model = this.get(modelId);
-    if (model) {
-      const familyTokenizer = this.#tokenizers.get(model.family);
-      if (familyTokenizer) {
-        return familyTokenizer;
+  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());
       }
     }
-    return this.#defaultTokenizer;
+    for (const fragment2 of this.#pendingMessages) {
+      const decoded = fragment2.codec.decode();
+      messages.push(decoded);
+    }
+    return { systemPrompt, messages };
   }
   /**
-   * 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)
+   * 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
+   * ```
    */
-  estimate(modelId, input) {
-    const model = this.get(modelId);
-    if (!model) {
-      throw new Error(
-        `Model "${modelId}" not found. Call load() first or check model ID.`
-      );
+  async save() {
+    await this.#ensureInitialized();
+    if (this.#pendingMessages.length === 0) {
+      return;
     }
-    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;
+    for (let i = 0; i < this.#pendingMessages.length; i++) {
+      const fragment2 = this.#pendingMessages[i];
+      if (isLazyFragment(fragment2)) {
+        this.#pendingMessages[i] = await this.#resolveLazyFragment(fragment2);
       }
     }
-  };
-}
-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;
-      }
+    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;
     }
-  };
-}
-var ContextRenderer = class {
-  options;
-  constructor(options = {}) {
-    this.options = options;
+    await this.#store.updateBranchHead(this.#branch.id, parentId);
+    this.#branch.headMessageId = parentId;
+    this.#pendingMessages = [];
   }
   /**
-   * Check if data is a primitive (string, number, boolean).
+   * Resolve a lazy fragment by finding the appropriate ID.
    */
-  isPrimitive(data) {
-    return typeof data === "string" || typeof data === "number" || typeof data === "boolean";
+  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}`);
   }
   /**
-   * Group fragments by name for groupFragments option.
+   * Find the most recent assistant message ID (pending or persisted).
    */
-  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);
+  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;
+      }
     }
-    return groups;
+    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;
   }
   /**
-   * Template method - dispatches value to appropriate handler.
+   * 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
    */
-  renderValue(key, value, ctx) {
-    if (value == null) {
-      return "";
+  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.`
+      );
     }
-    if (isFragment(value)) {
-      return this.renderFragment(value, ctx);
+    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 (Array.isArray(value)) {
-      return this.renderArray(key, value, ctx);
+    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
+        });
+      }
     }
-    if (isFragmentObject(value)) {
-      return this.renderObject(key, value, ctx);
+    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
+      });
     }
-    return this.renderPrimitive(key, String(value), ctx);
+    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
+    };
   }
   /**
-   * Render all entries of an object.
+   * 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();
+   * ```
    */
-  renderEntries(data, ctx) {
-    return Object.entries(data).map(([key, value]) => this.renderValue(key, value, ctx)).filter(Boolean);
+  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);
   }
-};
-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]);
+  /**
+   * 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");
     }
-    return this.#wrap(
-      fragment2.name,
-      this.renderEntries(fragment2.data, { depth: 1, path: [] })
-    );
+    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
+    };
   }
-  #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: [] })
-        );
-      }
+  /**
+   * 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.#wrap(name, children);
+    return this.rewind(checkpoint.messageId);
   }
-  #leafRoot(tag, value) {
-    const safe = this.#escape(value);
-    if (safe.includes("\n")) {
-      return `<${tag}>
-${this.#indent(safe, 2)}
-</${tag}>`;
+  /**
+   * 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}"`);
     }
-    return `<${tag}>${safe}</${tag}>`;
+    await this.#store.setActiveBranch(this.#chatId, branch.id);
+    this.#branch = { ...branch, isActive: true };
+    this.#branchName = name;
+    this.#pendingMessages = [];
   }
-  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);
+  /**
+   * 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");
     }
-    const children = this.renderEntries(data, { ...ctx, depth: ctx.depth + 1 });
-    return this.#wrapIndented(name, children, ctx.depth);
+    return this.#createBranchFrom(this.#branch.headMessageId, false);
   }
-  #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)
-        );
-      }
+  /**
+   * 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 (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: [] })
-        );
-      }
+    if (updates.metadata !== void 0) {
+      storeUpdates.metadata = {
+        ...this.#chatData?.metadata,
+        ...updates.metadata
+      };
     }
-    return this.#wrapIndented(name, children, depth);
+    this.#chatData = await this.#store.updateChat(this.#chatId, storeUpdates);
   }
-  renderPrimitive(key, value, ctx) {
-    return this.#leaf(key, value, ctx.depth);
+  /**
+   * 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;
   }
-  renderArray(key, items, ctx) {
-    if (!items.length) {
-      return "";
+  /**
+   * Extract skill path mappings from available_skills fragments.
+   * Returns array of { host, sandbox } for mounting in sandbox filesystem.
+   *
+   * Reads the original `paths` configuration stored in fragment metadata
+   * by the skills() fragment helper.
+   *
+   * @example
+   * ```ts
+   * const context = new ContextEngine({ store, chatId, userId })
+   *   .set(skills({ paths: [{ host: './skills', sandbox: '/skills' }] }));
+   *
+   * const mounts = context.getSkillMounts();
+   * // [{ host: './skills', sandbox: '/skills' }]
+   * ```
+   */
+  getSkillMounts() {
+    const mounts = [];
+    for (const fragment2 of this.#fragments) {
+      if (fragment2.name === "available_skills" && fragment2.metadata && Array.isArray(fragment2.metadata.paths)) {
+        for (const mapping of fragment2.metadata.paths) {
+          if (typeof mapping === "object" && mapping !== null && typeof mapping.host === "string" && typeof mapping.sandbox === "string") {
+            mounts.push({ host: mapping.host, sandbox: mapping.sandbox });
+          }
+        }
+      }
     }
-    const itemTag = pluralize.singular(key);
-    const children = items.filter((item) => item != null).map((item) => this.#leaf(itemTag, String(item), ctx.depth + 1));
-    return this.#wrapIndented(key, children, ctx.depth);
-  }
-  renderObject(key, obj, ctx) {
-    const children = this.renderEntries(obj, { ...ctx, depth: ctx.depth + 1 });
-    return this.#wrapIndented(key, children, ctx.depth);
-  }
-  #escape(value) {
-    if (value == null) {
-      return "";
-    }
-    return value.replaceAll(/&/g, "&amp;").replaceAll(/</g, "&lt;").replaceAll(/>/g, "&gt;").replaceAll(/"/g, "&quot;").replaceAll(/'/g, "&apos;");
-  }
-  #indent(text, spaces) {
-    if (!text.trim()) {
-      return "";
-    }
-    const padding = " ".repeat(spaces);
-    return text.split("\n").map((line) => line.length ? padding + line : padding).join("\n");
-  }
-  #leaf(tag, value, depth) {
-    const safe = this.#escape(value);
-    const pad = "  ".repeat(depth);
-    if (safe.includes("\n")) {
-      return `${pad}<${tag}>
-${this.#indent(safe, (depth + 1) * 2)}
-${pad}</${tag}>`;
-    }
-    return `${pad}<${tag}>${safe}</${tag}>`;
-  }
-  #wrap(tag, children) {
-    const content = children.filter(Boolean).join("\n");
-    if (!content) {
-      return "";
-    }
-    return `<${tag}>
-${content}
-</${tag}>`;
-  }
-  #wrapIndented(tag, children, depth) {
-    const content = children.filter(Boolean).join("\n");
-    if (!content) {
-      return "";
-    }
-    const pad = "  ".repeat(depth);
-    return `${pad}<${tag}>
-${content}
-${pad}</${tag}>`;
-  }
-};
-var 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";
-  }
-  /**
-   * 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);
+    return mounts;
   }
   /**
-   * Resolve context into AI SDK-ready format.
+   * Inspect the full context state for debugging.
+   * Returns a JSON-serializable object with context information.
    *
-   * - 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
+   * @param options - Inspection options (modelId and renderer required)
+   * @returns Complete inspection data including estimates, rendered output, fragments, and graph
    *
    * @example
    * ```ts
-   * const context = new ContextEngine({ store, chatId: 'chat-1' })
-   *   .set(role('You are helpful'), user('Hello'));
+   * const inspection = await context.inspect({
+   *   modelId: 'openai:gpt-4o',
+   *   renderer: new XmlRenderer(),
+   * });
+   * console.log(JSON.stringify(inspection, null, 2));
    *
-   * const { systemPrompt, messages } = await context.resolve();
-   * await generateText({ system: systemPrompt, messages });
+   * // Or write to file for analysis
+   * await fs.writeFile('context-debug.json', JSON.stringify(inspection, null, 2));
    * ```
    */
-  async resolve(options) {
+  async inspect(options) {
     await this.#ensureInitialized();
-    const systemPrompt = options.renderer.render(this.#fragments);
-    const messages = [];
+    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
       );
-      for (const msg of chain) {
-        messages.push(message(msg.data).codec?.decode());
+      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 }
     }
-    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 {
-    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 explain(input) {
+  return {
+    name: "explain",
+    data: {
+      concept: input.concept,
+      explanation: input.explanation,
+      ...input.therefore && { therefore: input.therefore }
     }
   };
 }
@@ -1880,7 +1422,8 @@ function persona(input) {
     name: "persona",
     data: {
       name: input.name,
-      role: input.role,
+      ...input.role && { role: input.role },
+      ...input.objective && { objective: input.objective },
       ...input.tone && { tone: input.tone }
     }
   };
@@ -1890,6 +1433,7 @@ var STORE_DDL = `
 -- createdAt/updatedAt: DEFAULT for insert, inline SET for updates
 CREATE TABLE IF NOT EXISTS chats (
   id TEXT PRIMARY KEY,
+  userId TEXT NOT NULL,
   title TEXT,
   metadata TEXT,
   createdAt INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
@@ -1897,6 +1441,7 @@ CREATE TABLE IF NOT EXISTS chats (
 );
 
 CREATE INDEX IF NOT EXISTS idx_chats_updatedAt ON chats(updatedAt);
+CREATE INDEX IF NOT EXISTS idx_chats_userId ON chats(userId);
 
 -- Messages table (nodes in the DAG)
 CREATE TABLE IF NOT EXISTS messages (
@@ -1962,37 +1507,67 @@ var SqliteContextStore = class extends ContextStore {
     this.#db.exec("PRAGMA foreign_keys = ON");
     this.#db.exec(STORE_DDL);
   }
+  /**
+   * Execute a function within a transaction.
+   * Automatically commits on success or rolls back on error.
+   */
+  #useTransaction(fn) {
+    this.#db.exec("BEGIN TRANSACTION");
+    try {
+      const result = fn();
+      this.#db.exec("COMMIT");
+      return result;
+    } catch (error) {
+      this.#db.exec("ROLLBACK");
+      throw error;
+    }
+  }
   // ==========================================================================
   // Chat Operations
   // ==========================================================================
   async createChat(chat) {
-    this.#db.prepare(
-      `INSERT INTO chats (id, title, metadata)
-         VALUES (?, ?, ?)`
-    ).run(
-      chat.id,
-      chat.title ?? null,
-      chat.metadata ? JSON.stringify(chat.metadata) : null
-    );
+    this.#useTransaction(() => {
+      this.#db.prepare(
+        `INSERT INTO chats (id, userId, title, metadata)
+           VALUES (?, ?, ?, ?)`
+      ).run(
+        chat.id,
+        chat.userId,
+        chat.title ?? null,
+        chat.metadata ? JSON.stringify(chat.metadata) : null
+      );
+      this.#db.prepare(
+        `INSERT INTO branches (id, chatId, name, headMessageId, isActive, createdAt)
+           VALUES (?, ?, 'main', NULL, 1, ?)`
+      ).run(crypto.randomUUID(), chat.id, Date.now());
+    });
   }
   async upsertChat(chat) {
-    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
-    };
+    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);
@@ -2001,6 +1576,7 @@ var SqliteContextStore = class extends ContextStore {
     }
     return {
       id: row.id,
+      userId: row.userId,
       title: row.title ?? void 0,
       metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
       createdAt: row.createdAt,
@@ -2024,16 +1600,33 @@ var SqliteContextStore = class extends ContextStore {
     ).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() {
+  async listChats(options) {
+    const params = [];
+    let whereClause = "";
+    let limitClause = "";
+    if (options?.userId) {
+      whereClause = "WHERE c.userId = ?";
+      params.push(options.userId);
+    }
+    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.createdAt,
           c.updatedAt,
@@ -2042,11 +1635,13 @@ var SqliteContextStore = class extends ContextStore {
         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`
-    ).all();
+        ORDER BY c.updatedAt DESC${limitClause}`
+    ).all(...params);
     return rows.map((row) => ({
       id: row.id,
+      userId: row.userId,
       title: row.title ?? void 0,
       messageCount: row.messageCount,
       branchCount: row.branchCount,
@@ -2054,371 +1649,1062 @@ var SqliteContextStore = class extends ContextStore {
       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) {
+    const existingParent = message2.parentId === message2.id ? this.#db.prepare("SELECT parentId FROM messages WHERE id = ?").get(message2.id) : void 0;
+    const parentId = message2.parentId === message2.id ? existingParent?.parentId ?? null : message2.parentId;
+    this.#db.prepare(
+      `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,
+      parentId,
+      message2.name,
+      message2.type ?? null,
+      JSON.stringify(message2.data),
+      message2.createdAt
+    );
+    const content = typeof message2.data === "string" ? message2.data : JSON.stringify(message2.data);
+    this.#db.prepare(`DELETE FROM messages_fts WHERE messageId = ?`).run(message2.id);
+    this.#db.prepare(
+      `INSERT INTO messages_fts(messageId, chatId, name, content)
+         VALUES (?, ?, ?, ?)`
+    ).run(message2.id, message2.chatId, message2.name, content);
+  }
+  async getMessage(messageId) {
+    const row = this.#db.prepare("SELECT * FROM messages WHERE id = ?").get(messageId);
+    if (!row) {
+      return void 0;
+    }
+    return {
+      id: row.id,
+      chatId: row.chatId,
+      parentId: row.parentId,
+      name: row.name,
+      type: row.type ?? void 0,
+      data: JSON.parse(row.data),
+      createdAt: row.createdAt
+    };
+  }
+  async getMessageChain(headId) {
+    const rows = this.#db.prepare(
+      `WITH RECURSIVE chain AS (
+          SELECT *, 0 as depth FROM messages WHERE id = ?
+          UNION ALL
+          SELECT m.*, c.depth + 1 FROM messages m
+          INNER JOIN chain c ON m.id = c.parentId
+        )
+        SELECT * FROM chain
+        ORDER BY depth DESC`
+    ).all(headId);
+    return rows.map((row) => ({
+      id: row.id,
+      chatId: row.chatId,
+      parentId: row.parentId,
+      name: row.name,
+      type: row.type ?? void 0,
+      data: JSON.parse(row.data),
+      createdAt: row.createdAt
+    }));
+  }
+  async hasChildren(messageId) {
+    const row = this.#db.prepare(
+      "SELECT EXISTS(SELECT 1 FROM messages WHERE parentId = ?) as hasChildren"
+    ).get(messageId);
+    return row.hasChildren === 1;
+  }
+  async getMessages(chatId) {
+    const chat = await this.getChat(chatId);
+    if (!chat) {
+      throw new Error(`Chat "${chatId}" not found`);
+    }
+    const activeBranch = await this.getActiveBranch(chatId);
+    if (!activeBranch?.headMessageId) {
+      return [];
+    }
+    return this.getMessageChain(activeBranch.headMessageId);
+  }
+  // ==========================================================================
+  // Branch Operations
+  // ==========================================================================
+  async createBranch(branch) {
+    this.#db.prepare(
+      `INSERT INTO branches (id, chatId, name, headMessageId, isActive, createdAt)
+         VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(
+      branch.id,
+      branch.chatId,
+      branch.name,
+      branch.headMessageId,
+      branch.isActive ? 1 : 0,
+      branch.createdAt
+    );
+  }
+  async getBranch(chatId, name) {
+    const row = this.#db.prepare("SELECT * FROM branches WHERE chatId = ? AND name = ?").get(chatId, name);
+    if (!row) {
+      return void 0;
+    }
+    return {
+      id: row.id,
+      chatId: row.chatId,
+      name: row.name,
+      headMessageId: row.headMessageId,
+      isActive: row.isActive === 1,
+      createdAt: row.createdAt
+    };
+  }
+  async getActiveBranch(chatId) {
+    const row = this.#db.prepare("SELECT * FROM branches WHERE chatId = ? AND isActive = 1").get(chatId);
+    if (!row) {
+      return void 0;
+    }
+    return {
+      id: row.id,
+      chatId: row.chatId,
+      name: row.name,
+      headMessageId: row.headMessageId,
+      isActive: true,
+      createdAt: row.createdAt
+    };
+  }
+  async setActiveBranch(chatId, branchId) {
+    this.#db.prepare("UPDATE branches SET isActive = 0 WHERE chatId = ?").run(chatId);
+    this.#db.prepare("UPDATE branches SET isActive = 1 WHERE id = ?").run(branchId);
+  }
+  async updateBranchHead(branchId, messageId) {
+    this.#db.prepare("UPDATE branches SET headMessageId = ? WHERE id = ?").run(messageId, branchId);
+  }
+  async listBranches(chatId) {
+    const branches = this.#db.prepare(
+      `SELECT
+          b.id,
+          b.name,
+          b.headMessageId,
+          b.isActive,
+          b.createdAt
+        FROM branches b
+        WHERE b.chatId = ?
+        ORDER BY b.createdAt ASC`
+    ).all(chatId);
+    const result = [];
+    for (const branch of branches) {
+      let messageCount = 0;
+      if (branch.headMessageId) {
+        const countRow = this.#db.prepare(
+          `WITH RECURSIVE chain AS (
+              SELECT id, parentId FROM messages WHERE id = ?
+              UNION ALL
+              SELECT m.id, m.parentId FROM messages m
+              INNER JOIN chain c ON m.id = c.parentId
+            )
+            SELECT COUNT(*) as count FROM chain`
+        ).get(branch.headMessageId);
+        messageCount = countRow.count;
+      }
+      result.push({
+        id: branch.id,
+        name: branch.name,
+        headMessageId: branch.headMessageId,
+        isActive: branch.isActive === 1,
+        messageCount,
+        createdAt: branch.createdAt
+      });
+    }
+    return result;
+  }
   // ==========================================================================
-  // Message Operations (Graph Nodes)
+  // Checkpoint Operations
   // ==========================================================================
-  async addMessage(message2) {
+  async createCheckpoint(checkpoint) {
     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`
+      `INSERT INTO checkpoints (id, chatId, name, messageId, createdAt)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(chatId, name) DO UPDATE SET
+           messageId = excluded.messageId,
+           createdAt = excluded.createdAt`
     ).run(
-      message2.id,
-      message2.chatId,
-      message2.parentId,
-      message2.name,
-      message2.type ?? null,
-      JSON.stringify(message2.data),
-      message2.createdAt
+      checkpoint.id,
+      checkpoint.chatId,
+      checkpoint.name,
+      checkpoint.messageId,
+      checkpoint.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);
+  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,
-      parentId: row.parentId,
       name: row.name,
-      type: row.type ?? void 0,
-      data: JSON.parse(row.data),
+      messageId: row.messageId,
       createdAt: row.createdAt
     };
   }
-  async getMessageChain(headId) {
+  async listCheckpoints(chatId) {
     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);
+      `SELECT id, name, messageId, createdAt
+         FROM checkpoints
+         WHERE chatId = ?
+         ORDER BY createdAt DESC`
+    ).all(chatId);
     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),
+      messageId: row.messageId,
       createdAt: row.createdAt
     }));
   }
-  async hasChildren(messageId) {
-    const row = this.#db.prepare(
-      "SELECT EXISTS(SELECT 1 FROM messages WHERE parentId = ?) as hasChildren"
-    ).get(messageId);
-    return row.hasChildren === 1;
+  async 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
+var contextResolverSchema = z.object({
+  question: z.string().describe(
+    "A standalone natural language question that the SQL query answers"
+  )
+});
+async function resolveContext(params) {
+  const context = new ContextEngine({
+    store: new InMemoryContextStore(),
+    chatId: `context-resolver-${crypto.randomUUID()}`,
+    userId: "system"
+  });
+  context.set(
+    persona({
+      name: "context_resolver",
+      role: "You are an expert at understanding conversational context and generating clear, standalone questions from multi-turn conversations.",
+      objective: "Transform context-dependent messages into standalone questions that fully capture user intent"
+    }),
+    ...params.introspection ? [fragment("database_schema", params.introspection)] : [],
+    fragment("conversation", params.conversation),
+    fragment("sql", params.sql),
+    fragment(
+      "task",
+      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
+        2. Uses natural business language (not SQL terminology)
+        3. Could be asked by someone who hasn't seen the conversation
+        4. Accurately represents what the SQL query answers
+      `
+    ),
+    fragment(
+      "examples",
+      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"
+
+        Conversation: "What were sales last month?" → "Break it down by category"
+        SQL: SELECT category, SUM(amount) FROM sales WHERE date >= '2024-11-01' GROUP BY category
+        Question: "What were sales by category for last month?"
+      `
+    ),
+    user("Generate a standalone question for this SQL query.")
+  );
+  const resolverOutput = structuredOutput({
+    model: groq2("openai/gpt-oss-20b"),
+    context,
+    schema: contextResolverSchema
+  });
+  return resolverOutput.generate();
+}
+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;
   }
-  // ==========================================================================
-  // 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
-    );
+  /**
+   * Template method - defines the extraction algorithm skeleton.
+   * Subclasses customize behavior via hooks, not by overriding this method.
+   */
+  async *produce() {
+    this.context = [];
+    this.results = [];
+    const { includeFailures = false, toolName = "db_query" } = this.options;
+    await this.extractSqlsWithContext(toolName, includeFailures);
+    if (this.results.length === 0) {
+      return;
+    }
+    const introspection = "";
+    yield* this.resolveQuestions(introspection);
   }
-  async getBranch(chatId, name) {
-    const row = this.#db.prepare("SELECT * FROM branches WHERE chatId = ? AND name = ?").get(chatId, name);
-    if (!row) {
-      return void 0;
+  /**
+   * 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);
+        if (text) {
+          await this.onUserMessage(text);
+        }
+        continue;
+      }
+      if (message2.role === "assistant") {
+        await this.extractFromAssistant(message2, toolName, includeFailures);
+      }
     }
-    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;
+  /**
+   * Extract SQL from assistant message parts.
+   */
+  async extractFromAssistant(message2, toolName, includeFailures) {
+    for (const part of message2.parts) {
+      if (!isToolOrDynamicToolUIPart(part)) {
+        continue;
+      }
+      if (getToolOrDynamicToolName(part) !== toolName) {
+        continue;
+      }
+      const toolInput = "input" in part ? part.input : void 0;
+      if (!toolInput?.sql) {
+        continue;
+      }
+      const success = part.state === "output-available";
+      const failed = part.state === "output-error";
+      if (failed && !includeFailures) {
+        continue;
+      }
+      if (!success && !failed) {
+        continue;
+      }
+      const snapshot = this.getContextSnapshot();
+      if (snapshot.length === 0) {
+        continue;
+      }
+      this.results.push({
+        sql: toolInput.sql,
+        success,
+        conversationContext: snapshot
+      });
+    }
+    const assistantText2 = getMessageText(message2);
+    if (assistantText2) {
+      this.context.push(`Assistant: ${assistantText2}`);
     }
-    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);
+  /**
+   * Resolve extracted SQL contexts into standalone questions using LLM.
+   */
+  async *resolveQuestions(introspection) {
+    for (const item of this.results) {
+      const output = await resolveContext({
+        conversation: formatConversation(item.conversationContext),
+        sql: item.sql,
+        introspection
+      });
+      yield [
+        {
+          question: output.question,
+          sql: item.sql,
+          context: item.conversationContext,
+          success: item.success
+        }
+      ];
+    }
   }
-  async updateBranchHead(branchId, messageId) {
-    this.#db.prepare("UPDATE branches SET headMessageId = ? WHERE id = ?").run(messageId, branchId);
+};
+
+// 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;
   }
-  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;
+  /**
+   * 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;
+    let lastUserMessage = null;
+    for (const message2 of this.#messages) {
+      if (message2.role === "user") {
+        lastUserMessage = message2;
+        continue;
       }
-      result.push({
-        id: branch.id,
-        name: branch.name,
-        headMessageId: branch.headMessageId,
-        isActive: branch.isActive === 1,
-        messageCount,
-        createdAt: branch.createdAt
+      if (message2.role === "assistant" && lastUserMessage) {
+        for (const part of message2.parts) {
+          if (!isToolOrDynamicToolUIPart2(part)) {
+            continue;
+          }
+          if (getToolOrDynamicToolName2(part) !== toolName) {
+            continue;
+          }
+          const toolInput = "input" in part ? part.input : void 0;
+          if (!toolInput?.sql) {
+            continue;
+          }
+          const success = part.state === "output-available";
+          const failed = part.state === "output-error";
+          if (failed && !includeFailures) {
+            continue;
+          }
+          if (!success && !failed) {
+            continue;
+          }
+          const question = getMessageText(lastUserMessage);
+          if (!question) {
+            continue;
+          }
+          yield [
+            {
+              question,
+              sql: toolInput.sql,
+              success
+            }
+          ];
+        }
+      }
+    }
+  }
+};
+
+// packages/text2sql/src/lib/synthesis/extractors/sql-extractor.ts
+import { groq as groq3 } from "@ai-sdk/groq";
+import dedent2 from "dedent";
+import z2 from "zod";
+var outputSchema = z2.object({
+  question: z2.string().describe("A natural language question that the SQL query answers")
+});
+var SqlExtractor = class extends PairProducer {
+  #sqls;
+  #adapter;
+  #options;
+  /**
+   * @param sql - SQL query or queries to generate questions for
+   * @param adapter - Database adapter for validation and schema introspection
+   * @param options - Extraction configuration
+   */
+  constructor(sql, adapter, options = {}) {
+    super();
+    this.#sqls = Array.isArray(sql) ? sql : [sql];
+    this.#adapter = adapter;
+    this.#options = options;
+  }
+  /**
+   * Generates natural language questions for each SQL query using an LLM.
+   * @returns Pairs with generated questions and original SQL
+   */
+  async *produce() {
+    const { validateSql = true, skipInvalid = false } = this.#options;
+    const introspection = "";
+    for (const sql of this.#sqls) {
+      let isValid = true;
+      if (validateSql) {
+        const error = await this.#adapter.validate(sql);
+        isValid = error === void 0 || error === null;
+        if (!isValid && skipInvalid) {
+          continue;
+        }
+      }
+      const context = new ContextEngine({
+        store: new InMemoryContextStore(),
+        chatId: `sql-to-question-${crypto.randomUUID()}`,
+        userId: "system"
       });
+      context.set(
+        persona({
+          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(
+          "task",
+          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
+            2. Uses natural business language (not SQL terminology)
+            3. Could be asked by a non-technical user
+            4. Is concise but complete
+          `
+        ),
+        fragment(
+          "examples",
+          dedent2`
+            SQL: SELECT COUNT(*) FROM customers WHERE region = 'NY'
+            Question: "How many customers do we have in New York?"
+
+            SQL: SELECT product_name, SUM(quantity) as total FROM orders GROUP BY product_name ORDER BY total DESC LIMIT 10
+            Question: "What are our top 10 products by quantity sold?"
+
+            SQL: SELECT c.name, COUNT(o.id) FROM customers c LEFT JOIN orders o ON c.id = o.customer_id GROUP BY c.id HAVING COUNT(o.id) = 0
+            Question: "Which customers have never placed an order?"
+          `
+        ),
+        user("Generate a natural language question for this SQL query.")
+      );
+      const sqlToQuestionOutput = structuredOutput({
+        model: groq3("openai/gpt-oss-20b"),
+        context,
+        schema: outputSchema
+      });
+      const output = await sqlToQuestionOutput.generate();
+      yield [
+        {
+          question: output.question,
+          sql,
+          success: isValid
+        }
+      ];
     }
-    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
-    );
+};
+
+// packages/text2sql/src/lib/synthesis/extractors/full-context-extractor.ts
+var FullContextExtractor = class extends BaseContextualExtractor {
+  constructor(messages, adapter, options = {}) {
+    super(messages, adapter, options);
   }
-  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
-    };
+  /**
+   * Add user message to context (keeps all messages).
+   */
+  async onUserMessage(text) {
+    this.context.push(`User: ${text}`);
   }
-  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
-    }));
+  /**
+   * Return all context accumulated so far.
+   */
+  getContextSnapshot() {
+    return [...this.context];
   }
-  async deleteCheckpoint(chatId, name) {
-    this.#db.prepare("DELETE FROM checkpoints WHERE chatId = ? AND name = ?").run(chatId, name);
+};
+
+// packages/text2sql/src/lib/synthesis/extractors/windowed-context-extractor.ts
+var WindowedContextExtractor = class extends BaseContextualExtractor {
+  windowSize;
+  constructor(messages, adapter, options) {
+    super(messages, adapter, options);
+    this.windowSize = options.windowSize;
   }
-  // ==========================================================================
-  // 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);
+  /**
+   * Add user message to context (keeps all, windowing happens on snapshot).
+   */
+  async onUserMessage(text) {
+    this.context.push(`User: ${text}`);
+  }
+  /**
+   * Return only the last N messages based on window size.
+   */
+  getContextSnapshot() {
+    if (this.context.length <= this.windowSize) {
+      return [...this.context];
     }
-    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
-    }));
+    return this.context.slice(-this.windowSize);
   }
-  // ==========================================================================
-  // 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
-      };
+};
+
+// packages/text2sql/src/lib/synthesis/extractors/segmented-context-extractor.ts
+import { groq as groq4 } from "@ai-sdk/groq";
+import dedent3 from "dedent";
+import z3 from "zod";
+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(),
+    chatId: `topic-change-${crypto.randomUUID()}`,
+    userId: "system"
+  });
+  context.set(
+    persona({
+      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(
+      "task",
+      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
+        2. The user starts a new analytical question unrelated to prior discussion
+        3. There's a clear shift in what data or metrics are being discussed
+
+        NOT a topic change:
+        - Follow-up questions refining the same query ("filter by...", "sort by...")
+        - Questions about the same entities with different conditions
+        - Requests for more details on the same topic
+      `
+    ),
+    fragment(
+      "examples",
+      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)
+
+        Context: "Show me customers in NY" → "Sort by revenue"
+        New: "What were our total sales last quarter?"
+        Decision: Topic change (shifted from customers to sales metrics)
+
+        Context: "List all products"
+        New: "How many orders did we have last month?"
+        Decision: Topic change (products → orders/sales)
+      `
+    ),
+    user("Determine if this is a topic change.")
+  );
+  const topicOutput = structuredOutput({
+    model: groq4("openai/gpt-oss-20b"),
+    context,
+    schema: topicChangeSchema
+  });
+  return topicOutput.generate();
+}
+var SegmentedContextExtractor = class extends BaseContextualExtractor {
+  constructor(messages, adapter, options = {}) {
+    super(messages, adapter, options);
+  }
+  /**
+   * Handle user message with topic change detection.
+   * If topic changes, resolve the message to standalone form before resetting.
+   *
+   * Note: We capture context snapshot before async LLM calls to prevent race conditions
+   * where context might be modified during the async operation.
+   */
+  async onUserMessage(text) {
+    if (this.context.length >= 2) {
+      const contextSnapshot = [...this.context];
+      const { isTopicChange } = await detectTopicChange({
+        context: formatConversation(contextSnapshot),
+        newMessage: text
+      });
+      if (isTopicChange) {
+        const resolved = await this.resolveToStandalone(text, contextSnapshot);
+        this.context = [`User: ${resolved}`];
+        return;
+      }
+    }
+    this.context.push(`User: ${text}`);
+  }
+  /**
+   * Return all context in current topic segment.
+   */
+  getContextSnapshot() {
+    return [...this.context];
+  }
+  /**
+   * Resolve a context-dependent message into a standalone question.
+   * Called when topic change is detected to preserve the meaning of
+   * the triggering message before context is reset.
+   * @param text - The user message to resolve
+   * @param contextSnapshot - Snapshot of context captured before this async call
+   */
+  async resolveToStandalone(text, contextSnapshot) {
+    const output = await resolveContext({
+      conversation: formatConversation([...contextSnapshot, `User: ${text}`]),
+      sql: ""
+      // No SQL yet, just resolving the question
     });
-    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
-    };
+    return output.question;
+  }
+};
+
+// packages/text2sql/src/lib/synthesis/extractors/last-query-extractor.ts
+var LastQueryExtractor = class extends BaseContextualExtractor {
+  constructor(messages, adapter, options = {}) {
+    super(messages, adapter, options);
+  }
+  /**
+   * Add user message to context (keeps all messages).
+   */
+  async onUserMessage(text) {
+    this.context.push(`User: ${text}`);
+  }
+  /**
+   * Return all context accumulated so far.
+   */
+  getContextSnapshot() {
+    return [...this.context];
   }
-};
-var InMemoryContextStore = class extends SqliteContextStore {
-  constructor() {
-    super(":memory:");
+  /**
+   * Override to only resolve the LAST query instead of all queries.
+   */
+  async *resolveQuestions(introspection) {
+    if (this.results.length === 0) {
+      return;
+    }
+    const last = this.results.at(-1);
+    const output = await resolveContext({
+      conversation: formatConversation(last.conversationContext),
+      sql: last.sql,
+      introspection
+    });
+    yield [
+      {
+        question: output.question,
+        sql: last.sql,
+        context: last.conversationContext,
+        success: last.success
+      }
+    ];
   }
 };
-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/synthesis/synthesizers/schema-synthesizer.ts
+import pLimit from "p-limit";
+
+// packages/text2sql/src/lib/agents/question.agent.ts
+import { groq as groq5 } from "@ai-sdk/groq";
+import dedent4 from "dedent";
+import z4 from "zod";
+import "@deepagents/agent";
+var complexityInstructions = {
+  simple: dedent4`
+    Generate simple questions that require:
+    - Basic SELECT with single table
+    - Simple WHERE clauses with one condition
+    - COUNT(*) or basic aggregations
+    - No joins required
+    Examples: "How many customers do we have?", "List all products", "What is the total revenue?"
+  `,
+  moderate: dedent4`
+    Generate moderate questions that require:
+    - JOINs between 2-3 tables
+    - Multiple WHERE conditions (AND/OR)
+    - GROUP BY with HAVING clauses
+    - ORDER BY with LIMIT
+    - Basic subqueries
+    Examples: "What are the top 5 customers by total orders?", "Which products have never been ordered?"
+  `,
+  complex: dedent4`
+    Generate complex questions that require:
+    - Multiple JOINs (3+ tables)
+    - Nested subqueries or CTEs
+    - Complex aggregations with multiple GROUP BY columns
+    - CASE expressions
+    - Date/time calculations
+    Examples: "What is the month-over-month growth rate?", "Which customers have increased spending compared to last year?"
+  `,
+  "high complex": dedent4`
+    Generate highly complex questions that require advanced SQL features:
+    - Window functions (ROW_NUMBER, RANK, DENSE_RANK)
+    - LAG, LEAD for comparisons
+    - Running totals (SUM OVER)
+    - Moving averages
+    - PARTITION BY clauses
+    - Complex CTEs with multiple levels
+    Examples: "What is the running total of sales per month?", "Rank customers by their purchase frequency within each region"
+  `
+};
+var outputSchema2 = z4.object({
+  questions: z4.array(z4.string().describe("A natural language question about the data")).min(1).describe("List of natural language questions a user might ask")
+});
+async function generateQuestions(params) {
+  const { introspection, complexity, count, prompt, model } = params;
+  const context = new ContextEngine({
+    store: new InMemoryContextStore(),
+    chatId: `question-gen-${crypto.randomUUID()}`,
+    userId: "system"
+  });
+  context.set(
+    persona({
+      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(
+      "complexity",
+      { level: complexity },
+      complexityInstructions[complexity]
+    ),
+    fragment(
+      "task",
+      dedent4`
+        Generate exactly ${count} natural language questions at the "${complexity}" complexity level.
+        The questions should:
+        1. Match the complexity requirements above
+        2. Use natural business language, not technical SQL terms
+        3. Be realistic questions a non-technical user would actually ask
+        4. Cover different tables and relationships when possible
+      `
+    ),
+    guardrail({
+      rule: "Questions MUST ONLY reference tables and columns that exist in the schema above"
+    }),
+    guardrail({
+      rule: "Before generating each question, verify that ALL entities (tables, columns, relationships) you reference are explicitly listed in the schema"
+    }),
+    guardrail({
+      rule: "DO NOT invent or assume tables/columns that are not explicitly shown in the schema"
+    }),
+    guardrail({
+      rule: "Use natural language without SQL keywords like SELECT, WHERE, etc."
+    }),
+    guardrail({
+      rule: "All questions must match the specified complexity level"
+    }),
+    user(
+      prompt ?? `Generate ${count} questions at ${complexity} complexity given db schema.`
+    )
+  );
+  const questionOutput = structuredOutput({
+    model: model ?? groq5("openai/gpt-oss-20b"),
+    context,
+    schema: outputSchema2
+  });
+  return questionOutput.generate();
 }
 
 // packages/text2sql/src/lib/agents/sql.agent.ts
+import { groq as groq6 } from "@ai-sdk/groq";
+import {
+  APICallError,
+  JSONParseError,
+  NoContentGeneratedError,
+  NoObjectGeneratedError,
+  NoOutputGeneratedError,
+  TypeValidationError,
+  defaultSettingsMiddleware,
+  wrapLanguageModel
+} from "ai";
+import { Console } from "node:console";
+import { createWriteStream } from "node:fs";
+import pRetry from "p-retry";
+import z5 from "zod";
+import "@deepagents/agent";
 var logger = new Console({
   stdout: createWriteStream("./sql-agent.log", { flags: "a" }),
   stderr: createWriteStream("./sql-agent-error.log", { flags: "a" }),
@@ -2456,37 +2742,36 @@ async function toSql(options) {
     async (attemptNumber, errors, attempts) => {
       const context = new ContextEngine({
         store: new InMemoryContextStore(),
-        chatId: `sql-gen-${crypto.randomUUID()}`
+        chatId: `sql-gen-${crypto.randomUUID()}`,
+        userId: "system"
       });
       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."
+          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"
         }),
         ...options.instructions,
         ...options.schemaFragments
       );
       if (errors.length) {
         context.set(
-          user6(options.input),
-          user6(
+          user(options.input),
+          user(
             `<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));
+        context.set(user(options.input));
       }
+      const temperature = RETRY_TEMPERATURES[attemptNumber - 1] ?? RETRY_TEMPERATURES[RETRY_TEMPERATURES.length - 1];
+      const baseModel = options.model ?? groq6("openai/gpt-oss-20b");
+      const model = wrapLanguageModel({
+        model: baseModel,
+        middleware: defaultSettingsMiddleware({ settings: { temperature } })
+      });
       const sqlOutput = structuredOutput({
-        name: "text2sql",
-        model: wrapLanguageModel2({
-          model: options.model ?? groq5("openai/gpt-oss-20b"),
-          middleware: defaultSettingsMiddleware2({
-            settings: {
-              temperature: RETRY_TEMPERATURES[attemptNumber - 1] ?? 0.3,
-              topP: 1
-            }
-          })
-        }),
+        model,
         context,
         schema: z5.union([
           z5.object({
@@ -2669,17 +2954,11 @@ Generate ${this.options.count} questions at ${complexity} complexity.` : void 0;
 };
 
 // packages/text2sql/src/lib/synthesis/synthesizers/breadth-evolver.ts
-import { groq as groq6 } from "@ai-sdk/groq";
-import { defaultSettingsMiddleware as defaultSettingsMiddleware3, wrapLanguageModel as wrapLanguageModel3 } from "ai";
+import { groq as groq7 } from "@ai-sdk/groq";
 import dedent5 from "dedent";
 import pLimit2 from "p-limit";
 import z6 from "zod";
-import {
-  agent as agent5,
-  generate as generate6,
-  toOutput,
-  user as user7
-} from "@deepagents/agent";
+import "@deepagents/agent";
 
 // packages/text2sql/src/lib/synthesis/synthesizers/styles.ts
 var ALL_STYLES = [
@@ -2715,63 +2994,53 @@ var styleInstructions = {
 };
 
 // packages/text2sql/src/lib/synthesis/synthesizers/breadth-evolver.ts
-var paraphraserAgent = agent5({
-  name: "question_paraphraser",
-  model: wrapLanguageModel3({
-    model: groq6("openai/gpt-oss-20b"),
-    middleware: defaultSettingsMiddleware3({
-      settings: { temperature: 0.9, topP: 0.95, frequencyPenalty: 0.2 }
-    })
-  }),
-  logging: process.env.AGENT_LOGGING === "true",
-  output: z6.object({
-    paraphrases: z6.array(
-      z6.string().describe("A paraphrased version of the original question")
-    ).min(1).describe(
-      "List of paraphrased questions that would produce the same SQL"
-    )
-  }),
-  prompt: (state) => {
-    const personaInstruction = state?.persona ? dedent5`
-        <persona role="${state.persona.role}">
-          ${state.persona.perspective}
+var paraphraserOutputSchema = z6.object({
+  paraphrases: z6.array(
+    z6.string().describe("A paraphrased version of the original question")
+  ).min(1).describe("List of paraphrased questions that would produce the same SQL")
+});
+async function paraphraseQuestion(params) {
+  const context = new ContextEngine({
+    store: new InMemoryContextStore(),
+    chatId: `paraphraser-${crypto.randomUUID()}`,
+    userId: "system"
+  });
+  const personaInstruction = params.persona ? dedent5`
+        <persona role="${params.persona.role}">
+          ${params.persona.perspective}
 
           Paraphrase the question as this persona would naturally ask it.
           Use their vocabulary, priorities, and framing style.
         </persona>
       ` : "";
-    const styleInstruction = state?.persona?.styles && state.persona.styles.length > 0 ? dedent5`
+  const styleInstruction = params.persona?.styles && params.persona.styles.length > 0 ? dedent5`
         <communication_styles>
-          Generate paraphrases using these communication styles: ${state.persona.styles.join(", ")}
+          Generate paraphrases using these communication styles: ${params.persona.styles.join(", ")}
 
           Style definitions:
-          ${state.persona.styles.map((s) => `- ${s}: ${styleInstructions[s]}`).join("\n")}
+          ${params.persona.styles.map((s) => `- ${s}: ${styleInstructions[s]}`).join("\n")}
 
           Distribute paraphrases across these styles for variety.
         </communication_styles>
       ` : "";
-    return dedent5`
-      <identity>
-        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.
-      </identity>
-
-      <original_question>
-        ${state?.question}
-      </original_question>
-
-      <reference_sql>
-        ${state?.sql}
-        (This SQL shows what the question is really asking - all paraphrases must ask for exactly this)
-      </reference_sql>
-
-      ${personaInstruction}
-
-      ${styleInstruction}
-
-      <task>
-        Generate exactly ${state?.count} paraphrased versions of the original question.
+  context.set(
+    persona({
+      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(
+      "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(
+      "task",
+      dedent5`
+        Generate exactly ${params.count} paraphrased versions of the original question.
 
         Requirements:
         1. Each paraphrase must be semantically equivalent - it should produce the EXACT same SQL
@@ -2779,18 +3048,30 @@ var paraphraserAgent = agent5({
         3. Use natural language without SQL keywords (SELECT, WHERE, JOIN, etc.)
         4. Keep paraphrases realistic - how actual users would ask
         5. Do not add or remove any conditions, filters, or requirements from the original
-        ${state?.persona?.styles?.length ? "6. Apply the specified communication styles to create diverse phrasings" : ""}
-      </task>
-
-      <guardrails>
-        - NEVER change what data is being requested
-        - NEVER add filters, aggregations, or conditions not in the original
-        - NEVER remove any specificity from the original question
-        - All paraphrases must be answerable by the exact same SQL query
-      </guardrails>
-    `;
-  }
-});
+        ${params.persona?.styles?.length ? "6. Apply the specified communication styles to create diverse phrasings" : ""}
+      `
+    ),
+    guardrail({ rule: "NEVER change what data is being requested" }),
+    guardrail({
+      rule: "NEVER add filters, aggregations, or conditions not in the original"
+    }),
+    guardrail({
+      rule: "NEVER remove any specificity from the original question"
+    }),
+    guardrail({
+      rule: "All paraphrases must be answerable by the exact same SQL query"
+    }),
+    user(
+      `Paraphrase this question ${params.count} times: "${params.question}"`
+    )
+  );
+  const paraphraserOutput = structuredOutput({
+    model: params.model ?? groq7("openai/gpt-oss-20b"),
+    context,
+    schema: paraphraserOutputSchema
+  });
+  return paraphraserOutput.generate();
+}
 var BreadthEvolver = class extends PairProducer {
   /**
    * @param source - Source pairs or producer to evolve
@@ -2811,23 +3092,14 @@ 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 toOutput(
-            generate6(
-              paraphraserAgent.clone({ model: this.options.model }),
-              [
-                user7(
-                  `Paraphrase this question ${this.options.count} times: "${pair.question}"`
-                )
-              ],
-              {
-                question: pair.question,
-                sql: pair.sql,
-                count: this.options.count,
-                persona: this.options.persona
-              }
-            )
-          );
-          return paraphrases.map((paraphrase) => ({
+          const result = await paraphraseQuestion({
+            question: pair.question,
+            sql: pair.sql,
+            count: this.options.count,
+            persona: this.options.persona,
+            model: this.options.model
+          });
+          return result.paraphrases.map((paraphrase) => ({
             question: paraphrase,
             sql: pair.sql,
             context: pair.context,
@@ -2842,18 +3114,13 @@ var BreadthEvolver = class extends PairProducer {
 };
 
 // packages/text2sql/src/lib/synthesis/synthesizers/depth-evolver.ts
-import { groq as groq7 } from "@ai-sdk/groq";
-import {
-  NoObjectGeneratedError as NoObjectGeneratedError2,
-  NoOutputGeneratedError as NoOutputGeneratedError2,
-  defaultSettingsMiddleware as defaultSettingsMiddleware4,
-  wrapLanguageModel as wrapLanguageModel4
-} from "ai";
+import { groq as groq8 } from "@ai-sdk/groq";
+import { NoObjectGeneratedError as NoObjectGeneratedError2, NoOutputGeneratedError as NoOutputGeneratedError2 } from "ai";
 import dedent6 from "dedent";
 import pLimit3 from "p-limit";
 import pRetry2 from "p-retry";
 import z7 from "zod";
-import { agent as agent6, generate as generate7, user as user8 } from "@deepagents/agent";
+import "@deepagents/agent";
 var techniqueInstructions = {
   "add-aggregation": dedent6`
     Add aggregation requirements to the question.
@@ -2896,44 +3163,37 @@ var techniqueInstructions = {
     - "Get costs" → "What would be the impact of a 10% discount on profit margins?"
   `
 };
-var questionEvolverAgent = agent6({
-  name: "question_evolver",
-  model: wrapLanguageModel4({
-    model: groq7("openai/gpt-oss-20b"),
-    middleware: defaultSettingsMiddleware4({
-      settings: { temperature: 0.7, topP: 0.95 }
-    })
-  }),
-  output: z7.object({
-    evolvedQuestion: z7.string().describe("The evolved, more complex version of the original question")
-  }),
-  prompt: (state) => {
-    return dedent6`
-      <identity>
-        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.
-      </identity>
-
-      <original_question>
-        ${state?.question}
-      </original_question>
-
-      <original_sql>
-        ${state?.sql}
-        (This shows what the original question required)
-      </original_sql>
-
-      <database_schema>
-        ${state?.schema}
-      </database_schema>
-
-      <technique name="${state?.technique}">
-        ${state?.techniqueInstruction}
-      </technique>
-
-      <task>
-        Evolve the original question using the "${state?.technique}" technique.
+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(),
+    chatId: `evolver-${crypto.randomUUID()}`,
+    userId: "system"
+  });
+  context.set(
+    persona({
+      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(
+      "original_sql",
+      params.sql,
+      "(This shows what the original question required)"
+    ),
+    fragment("database_schema", params.schema),
+    fragment(
+      "technique",
+      { name: params.technique },
+      params.techniqueInstruction
+    ),
+    fragment(
+      "task",
+      dedent6`
+        Evolve the original question using the "${params.technique}" technique.
 
         Requirements:
         1. The evolved question must be MORE COMPLEX than the original
@@ -2942,17 +3202,29 @@ var questionEvolverAgent = agent6({
         4. Use natural language - no SQL keywords
         5. Keep the question realistic and practical
         6. The evolved question should build upon the original topic/domain
-      </task>
-
-      <guardrails>
-        - The evolved question MUST require more complex SQL than the original
-        - Do not ask for data that doesn't exist in the schema
-        - Keep the question grounded in the same domain as the original
-        - Make sure the question is clear and unambiguous
-      </guardrails>
-    `;
-  }
-});
+      `
+    ),
+    guardrail({
+      rule: "The evolved question MUST require more complex SQL than the original"
+    }),
+    guardrail({
+      rule: "Do not ask for data that does not exist in the schema"
+    }),
+    guardrail({
+      rule: "Keep the question grounded in the same domain as the original"
+    }),
+    guardrail({ rule: "Make sure the question is clear and unambiguous" }),
+    user(
+      `Evolve this question using "${params.technique}": "${params.question}"`
+    )
+  );
+  const evolverOutput = structuredOutput({
+    model: params.model ?? groq8("openai/gpt-oss-20b"),
+    context,
+    schema: evolverOutputSchema
+  });
+  return evolverOutput.generate();
+}
 var ALL_TECHNIQUES = [
   "add-aggregation",
   "add-filter",
@@ -2998,22 +3270,17 @@ var DepthEvolver = class extends PairProducer {
     }
   }
   async #processTask(pair, technique, introspection) {
-    const { experimental_output } = await withRetry2(
-      () => generate7(
-        questionEvolverAgent.clone({
-          model: this.options?.model
-        }),
-        [user8(`Evolve this question using "${technique}": "${pair.question}"`)],
-        {
-          question: pair.question,
-          sql: pair.sql,
-          schema: introspection,
-          technique,
-          techniqueInstruction: techniqueInstructions[technique]
-        }
-      )
+    const output = await withRetry2(
+      () => evolveQuestion({
+        question: pair.question,
+        sql: pair.sql,
+        schema: introspection,
+        technique,
+        techniqueInstruction: techniqueInstructions[technique],
+        model: this.options?.model
+      })
     );
-    const evolvedQuestion = experimental_output.evolvedQuestion;
+    const evolvedQuestion = output.evolvedQuestion;
     try {
       const sqlResult = await toSql({
         input: evolvedQuestion,
@@ -3069,12 +3336,11 @@ async function withRetry2(computation) {
 }
 
 // packages/text2sql/src/lib/synthesis/synthesizers/persona-generator.ts
-import { groq as groq8 } from "@ai-sdk/groq";
-import { defaultSettingsMiddleware as defaultSettingsMiddleware5, wrapLanguageModel as wrapLanguageModel5 } from "ai";
+import { groq as groq9 } from "@ai-sdk/groq";
 import dedent7 from "dedent";
 import z8 from "zod";
 import "@deepagents/agent";
-var outputSchema = z8.object({
+var outputSchema3 = z8.object({
   personas: z8.array(
     z8.object({
       role: z8.string().describe("The job title or role of this persona"),
@@ -3092,48 +3358,52 @@ async function generatePersonas(schemaFragments, options) {
   const count = options?.count ?? 5;
   const context = new ContextEngine({
     store: new InMemoryContextStore(),
-    chatId: `persona-gen-${crypto.randomUUID()}`
+    chatId: `persona-gen-${crypto.randomUUID()}`,
+    userId: "system"
   });
   context.set(
     persona({
       name: "persona_generator",
-      role: "You are an expert at understanding database schemas and inferring who would use them."
+      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"
     }),
-    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>
-        ${schema}
-      </database_schema>
+    fragment("database_schema", schema),
+    fragment(
+      "task",
+      dedent7`
+        Analyze the database schema and generate realistic personas representing
+        the different types of users 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
 
-      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>
+        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
+      `
+    ),
+    fragment(
+      "example",
+      dedent7`
         For an e-commerce schema with orders, customers, products tables:
 
         {
@@ -3147,40 +3417,36 @@ async function generatePersonas(schemaFragments, options) {
           "perspective": "As inventory manager, I care about:\\n- Current stock levels and reorder points\\n- Product availability across warehouses\\n- Slow-moving inventory identification\\n- Supplier lead times and pending orders\\n- I need accurate counts, often aggregated by location",
           "styles": ["formal", "interrogative"]
         }
-      </example>
-
-      <guardrails>
-        - Only generate personas relevant to the actual schema provided
-        - Do not invent tables or data that don't exist in the schema
-        - Ensure perspectives are specific to the domain, not generic
-      </guardrails>
-    `),
-    user6(
+      `
+    ),
+    guardrail({
+      rule: "Only generate personas relevant to the actual schema provided"
+    }),
+    guardrail({
+      rule: "Do not invent tables or data that do not exist in the schema"
+    }),
+    guardrail({
+      rule: "Ensure perspectives are specific to the domain, not generic"
+    }),
+    user(
       `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 }
-      })
-    }),
+    model: options?.model ?? groq9("openai/gpt-oss-20b"),
     context,
-    schema: outputSchema
+    schema: outputSchema3
   });
   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 { groq as groq10 } from "@ai-sdk/groq";
 import dedent8 from "dedent";
 import z9 from "zod";
-import { agent as agent7, generate as generate8, user as user9 } from "@deepagents/agent";
-var outputSchema2 = z9.object({
+import "@deepagents/agent";
+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"),
   guardrails: z9.array(
@@ -3231,62 +3497,58 @@ var outputSchema2 = z9.object({
     })
   ).optional().describe("Concept analogies")
 });
-var teachablesAuthorAgent = agent7({
-  name: "teachables-author",
-  model: wrapLanguageModel6({
-    model: groq9("openai/gpt-oss-20b"),
-    middleware: defaultSettingsMiddleware6({
-      settings: { temperature: 0.4, topP: 0.95 }
-    })
-  }),
-  output: outputSchema2,
-  prompt: (state) => dedent8`
-    <identity>
-      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>
-
-    <database_schema>
-    ${state?.schema}
-    </database_schema>
-
-    ${state?.context ? `<additional_context>${state.context}</additional_context>` : ""}
-
-    <output_structure>
-      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
-      - guardrails: [{ rule: string, reason?: string, action?: string }] - Safety constraints
-      - explains: [{ concept: string, explanation: string, therefore?: string }] - Concept explanations
-      - examples: [{ question: string, answer: string, note?: string }] - Q&A examples
-      - clarifications: [{ when: string, ask: string, reason: string }] - Clarification triggers
-      - 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: [{ 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 fragments total across all categories, prioritizing:
-         - guardrails for PII columns (email, ssn, phone, etc)
-         - hints for status/enum columns
-         - clarifications for ambiguous terms
-      3. Ground everything in the schema - do not invent tables/columns.
-      4. Only include categories that are relevant to this schema.
-    </instructions>
-  `
-});
 async function toTeachings(input, options) {
-  const { experimental_output: result } = await generate8(
-    teachablesAuthorAgent.clone({ model: options?.model }),
-    [
-      user9(
-        `Analyze this database schema and generate fragments that will help an AI generate accurate SQL queries.`
-      )
-    ],
-    input
+  const context = new ContextEngine({
+    store: new InMemoryContextStore(),
+    chatId: `teachables-gen-${crypto.randomUUID()}`,
+    userId: "system"
+  });
+  context.set(
+    persona({
+      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(
+      "output_structure",
+      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
+        - guardrails: [{ rule: string, reason?: string, action?: string }] - Safety constraints
+        - explains: [{ concept: string, explanation: string, therefore?: string }] - Concept explanations
+        - examples: [{ question: string, answer: string, note?: string }] - Q&A examples
+        - clarifications: [{ when: string, ask: string, reason: string }] - Clarification triggers
+        - 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: [{ concepts: string[], relationship: string, insight?: string, therefore?: string, pitfall?: string }]
+      `
+    ),
+    fragment(
+      "task",
+      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)
+           - hints for status/enum columns
+           - clarifications for ambiguous terms
+        3. Ground everything in the schema - do not invent tables/columns.
+        4. Only include categories that are relevant to this schema.
+      `
+    ),
+    user(
+      `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"),
+    context,
+    schema: outputSchema4
+  });
+  const result = await teachablesOutput.generate();
   const fragments = [];
   result.terms?.forEach((t) => fragments.push(term(t.name, t.definition)));
   result.hints?.forEach((h) => fragments.push(hint(h.text)));
@@ -3383,11 +3645,11 @@ export {
   SqlExtractor,
   ValidatedProducer,
   WindowedContextExtractor,
-  contextResolverAgent,
   formatConversation,
   generatePersonas,
   generateTeachings,
   getMessageText,
+  resolveContext,
   styleInstructions,
   toPairs
 };