@deepagents/text2sql 0.8.0 → 0.9.0

package/dist/index.js

@@ -1741,333 +1741,14 @@ import {
   user as user4
 } from "@deepagents/agent";
 
-// packages/text2sql/src/lib/agents/bi.agent.ts
+// packages/text2sql/src/lib/agents/chat1.agent.ts
 import { groq as groq6 } from "@ai-sdk/groq";
 import { tool as tool3 } from "ai";
-import dedent4 from "dedent";
 import z6 from "zod";
 import { agent as agent6, toState as toState3 } from "@deepagents/agent";
 import { scratchpad_tool as scratchpad_tool3 } from "@deepagents/toolbox";
 var tools3 = {
-  /**
-   * Validate SQL query syntax without executing.
-   * Use this to verify queries are correct before embedding in dashboard components.
-   */
-  validate_query: tool3({
-    description: dedent4`
-      Validate SQL query syntax before embedding in dashboard components.
-      Use this to verify your queries are syntactically correct and reference valid tables/columns.
-
-      This tool does NOT execute the query or return data.
-      Only SELECT or WITH statements are allowed.
-    `,
-    inputSchema: z6.object({
-      reasoning: z6.string().describe(
-        "Why this query helps understand the data for dashboard design."
-      ),
-      sql: z6.string().min(1, { message: "SQL query cannot be empty." }).refine(
-        (sql) => sql.trim().toUpperCase().startsWith("SELECT") || sql.trim().toUpperCase().startsWith("WITH"),
-        {
-          message: "Only read-only SELECT or WITH queries are allowed."
-        }
-      ).describe("The SQL query to validate.")
-    }),
-    execute: async ({ sql }, options) => {
-      const state = toState3(options);
-      const result = await state.adapter.validate(sql);
-      if (typeof result === "string") {
-        return { valid: false, error: result };
-      }
-      return { valid: true };
-    }
-  }),
-  /**
-   * Record insights and reasoning during schema analysis and dashboard design.
-   */
-  scratchpad: scratchpad_tool3
-};
-var COMPONENTS_DOC = dedent4`
-  ## Available Components
-
-  You output markdown with embedded HTML custom elements. Use kebab-case tags with closing tags.
-
-  ### Chart Components
-
-  #### Area Charts
-  | Component | Required Props | Optional Props | Use Case |
-  |-----------|----------------|----------------|----------|
-  | \`<area-chart>\` | \`title\`, \`sql\` | \`x-key\`, \`y-key\`, \`variant\` | Cumulative values, trends with volume |
-
-  **Variants** (use \`variant\` prop):
-  - \`default\` - Basic area with smooth curves
-  - \`linear\` - Sharp-edged lines showing precise changes
-  - \`step\` - Step-based segments for discrete data
-  - \`stacked\` - Multiple series stacked on top of each other
-  - \`stacked-expand\` - Normalized to 100% showing percentage contribution
-  - \`gradient\` - Filled with gradient for visual depth
-
-  #### Bar Charts
-  | Component | Required Props | Optional Props | Use Case |
-  |-----------|----------------|----------------|----------|
-  | \`<bar-chart>\` | \`title\`, \`sql\` | \`x-key\`, \`y-key\`, \`variant\`, \`orientation\` | Categorical comparisons, grouped data |
-
-  **Variants** (use \`variant\` prop):
-  - \`default\` - Basic vertical bars
-  - \`multiple\` - Multiple series side by side
-  - \`stacked\` - Multiple series stacked
-  - \`labeled\` - With value labels on bars
-  - \`negative\` - Supports positive/negative values with conditional coloring
-  - \`mixed\` - Different colors per category
-
-  **Orientation** (use \`orientation\` prop):
-  - \`vertical\` (default) - Vertical bars
-  - \`horizontal\` - Horizontal bars (good for long category names)
-
-  #### Line Charts
-  | Component | Required Props | Optional Props | Use Case |
-  |-----------|----------------|----------------|----------|
-  | \`<line-chart>\` | \`title\`, \`sql\` | \`x-key\`, \`y-key\`, \`variant\` | Trends over time, continuous data |
-
-  **Variants** (use \`variant\` prop):
-  - \`default\` - Smooth curved lines
-  - \`linear\` - Straight lines between points
-  - \`step\` - Step-based transitions
-  - \`dots\` - Lines with visible data point markers
-  - \`multiple\` - Multiple series for comparisons (A/B testing, etc.)
-  - \`interactive\` - With metric switching capability
-  - \`labeled\` - With value labels at each point
-
-  #### Pie & Donut Charts
-  | Component | Required Props | Optional Props | Use Case |
-  |-----------|----------------|----------------|----------|
-  | \`<pie-chart>\` | \`title\`, \`sql\` | \`label-key\`, \`value-key\`, \`variant\` | Part-to-whole relationships, distributions |
-  | \`<donut-chart>\` | \`title\`, \`sql\` | \`label-key\`, \`value-key\`, \`variant\` | Same as pie but with center space for text/KPI |
-
-  **Variants** (use \`variant\` prop):
-  - \`default\` - Basic pie/donut
-  - \`labeled\` - With labels on segments
-  - \`legend\` - With external legend
-  - \`interactive\` - With hover highlighting and selection
-  - \`stacked\` - Multiple concentric rings for comparison
-
-  #### Radar Charts
-  | Component | Required Props | Optional Props | Use Case |
-  |-----------|----------------|----------------|----------|
-  | \`<radar-chart>\` | \`title\`, \`sql\` | \`label-key\`, \`value-key\`, \`variant\` | Multi-dimensional comparisons, skill assessments |
-
-  **Variants** (use \`variant\` prop):
-  - \`default\` - Basic radar with polygon grid
-  - \`dots\` - With visible data point markers
-  - \`filled\` - With filled area
-  - \`multiple\` - Multiple series overlapping
-  - \`circle\` - Circular grid instead of polygon
-  - \`legend\` - With integrated legend
-
-  #### Radial Charts
-  | Component | Required Props | Optional Props | Use Case |
-  |-----------|----------------|----------------|----------|
-  | \`<radial-chart>\` | \`title\`, \`sql\` | \`value-key\`, \`variant\` | Progress indicators, gauges, circular metrics |
-
-  **Variants** (use \`variant\` prop):
-  - \`default\` - Basic radial bars from center outward
-  - \`text\` - With centered value/caption text
-  - \`shape\` - Gauge-style arc (not full circle)
-  - \`stacked\` - Concentric arcs for multiple metrics
-  - \`grid\` - With background grid rings
-
-  #### KPI Component
-  | Component | Required Props | Optional Props | Use Case |
-  |-----------|----------------|----------------|----------|
-  | \`<kpi>\` | \`title\`, \`sql\` | \`variant\`, \`format\`, \`trend-sql\`, \`target\`, \`icon\`, \`description\`, \`color\` | Rich metric displays with trends, progress, sparklines |
-
-  **Variants** (use \`variant\` prop):
-  - \`default\` - Simple value card
-  - \`trend\` - Value with change indicator (↑12.5% or ↓3.2%)
-  - \`comparison\` - Value with previous period value shown
-  - \`progress\` - Value with horizontal progress bar toward target
-  - \`ring\` - Value with circular progress gauge toward target
-  - \`sparkline\` - Value with mini area chart showing recent trend
-
-  **Props Reference**:
-  - \`title\` (required) - Display label
-  - \`sql\` (required) - Query returning \`{ value: number }\`
-  - \`variant\` - Display style (see above)
-  - \`format\` - Value format: \`currency\`, \`percent\`, \`number\`, \`compact\`, \`duration\`
-  - \`trend-sql\` - Query for trend data:
-    - For \`trend\`/\`comparison\`: returns \`{ change: number }\` or \`{ previous: number }\`
-    - For \`sparkline\`: returns time-series \`[{ date, value }]\`
-  - \`target\` - Target value for \`progress\`/\`ring\` variants
-  - \`icon\` - Icon identifier: \`dollar\`, \`users\`, \`cart\`, \`chart\`, \`percent\`, \`clock\`
-  - \`description\` - Subtitle/context text
-  - \`color\` - Accent color: \`positive\` (green), \`negative\` (red), \`neutral\`, \`primary\`
-
-  #### Data Table
-  | Component | Required Props | Optional Props | Use Case |
-  |-----------|----------------|----------------|----------|
-  | \`<data-table>\` | \`title\`, \`sql\` | \`columns\` | Detailed data, lists, rankings |
-
-  ### Layout Components
-  | Component | Props | Description |
-  |-----------|-------|-------------|
-  | \`<row>\` | \`gap?\` | Horizontal flex container (small, medium, or large) |
-  | \`<column>\` | \`span\` (1-12) | Column within row, 12-column grid |
-  | \`<grid>\` | \`cols\`, \`gap?\` | CSS Grid container |
-
-  ### Chart Selection Guide
-  - **Time series / Trends with volume**: Use \`<area-chart>\` (shows magnitude over time)
-  - **Time series / Precise trends**: Use \`<line-chart>\` (clean trend lines)
-  - **Categories / Comparisons**: Use \`<bar-chart>\`
-  - **Part-to-whole / Proportions**: Use \`<pie-chart>\` or \`<donut-chart>\`
-  - **Multi-dimensional comparisons**: Use \`<radar-chart>\` (e.g., comparing skills, features)
-  - **Progress / Gauges**: Use \`<radial-chart>\` (circular progress indicators)
-  - **Detailed data / Rankings**: Use \`<data-table>\`
-  - **Single metrics**: Use \`<kpi>\` with appropriate variant:
-    - Simple value → \`default\`
-    - Value with change indicator → \`trend\`
-    - Value vs previous period → \`comparison\`
-    - Value toward goal → \`progress\` or \`ring\`
-    - Value with recent history → \`sparkline\`
-
-  ### Example Output
-  \`\`\`markdown
-  ## Sales Dashboard
-
-  <row>
-    <column span="3">
-      <kpi
-        title="Total Revenue"
-        sql="SELECT SUM(amount) as value FROM orders"
-        trend-sql="SELECT ((SUM(CASE WHEN created_at >= NOW() - INTERVAL '30 days' THEN amount END) - SUM(CASE WHEN created_at >= NOW() - INTERVAL '60 days' AND created_at < NOW() - INTERVAL '30 days' THEN amount END)) / NULLIF(SUM(CASE WHEN created_at >= NOW() - INTERVAL '60 days' AND created_at < NOW() - INTERVAL '30 days' THEN amount END), 0) * 100) as change FROM orders"
-        variant="trend"
-        format="currency"
-        icon="dollar">
-      </kpi>
-    </column>
-    <column span="3">
-      <kpi
-        title="Orders Today"
-        sql="SELECT COUNT(*) as value FROM orders WHERE DATE(created_at) = CURRENT_DATE"
-        trend-sql="SELECT DATE(created_at) as date, COUNT(*) as value FROM orders WHERE created_at >= NOW() - INTERVAL '7 days' GROUP BY 1 ORDER BY 1"
-        variant="sparkline"
-        icon="cart">
-      </kpi>
-    </column>
-    <column span="3">
-      <kpi
-        title="Sales Target"
-        sql="SELECT SUM(amount) as value FROM orders WHERE EXTRACT(QUARTER FROM created_at) = EXTRACT(QUARTER FROM NOW())"
-        target="100000"
-        variant="progress"
-        format="currency"
-        description="Q4 2024 Goal">
-      </kpi>
-    </column>
-    <column span="3">
-      <kpi
-        title="Conversion Rate"
-        sql="SELECT (COUNT(DISTINCT buyer_id)::float / COUNT(DISTINCT visitor_id) * 100) as value FROM sessions"
-        variant="ring"
-        target="100"
-        format="percent"
-        color="primary">
-      </kpi>
-    </column>
-  </row>
-
-  <row>
-    <column span="8">
-      <area-chart
-        title="Revenue Over Time"
-        sql="SELECT DATE_TRUNC('month', created_at) as month, SUM(amount) as revenue FROM orders GROUP BY 1 ORDER BY 1"
-        x-key="month"
-        y-key="revenue"
-        variant="gradient">
-      </area-chart>
-    </column>
-    <column span="4">
-      <donut-chart
-        title="Revenue by Category"
-        sql="SELECT category, SUM(amount) as revenue FROM orders GROUP BY category"
-        label-key="category"
-        value-key="revenue"
-        variant="interactive">
-      </donut-chart>
-    </column>
-  </row>
-
-  <row>
-    <column span="6">
-      <bar-chart
-        title="Monthly Comparison"
-        sql="SELECT DATE_TRUNC('month', created_at) as month, SUM(CASE WHEN EXTRACT(YEAR FROM created_at) = 2024 THEN amount END) as this_year, SUM(CASE WHEN EXTRACT(YEAR FROM created_at) = 2023 THEN amount END) as last_year FROM orders GROUP BY 1"
-        variant="multiple"
-        x-key="month">
-      </bar-chart>
-    </column>
-    <column span="6">
-      <radar-chart
-        title="Product Performance"
-        sql="SELECT metric, score FROM product_metrics WHERE product_id = 1"
-        label-key="metric"
-        value-key="score"
-        variant="filled">
-      </radar-chart>
-    </column>
-  </row>
-
-  <data-table
-    title="Top 10 Products"
-    sql="SELECT name, SUM(quantity) as sold, SUM(amount) as revenue FROM order_items GROUP BY name ORDER BY revenue DESC LIMIT 10">
-  </data-table>
-  \`\`\`
-`;
-var biAgent = agent6({
-  model: groq6("gpt-oss-20b"),
-  tools: tools3,
-  name: "bi_agent",
-  prompt: (state) => {
-    return dedent4`
-      You are an expert BI analyst that creates dashboard specifications using HTML custom elements.
-
-      ${COMPONENTS_DOC}
-
-      ## Your Workflow
-
-      1. **PLAN**: Analyze the request and schema to determine what metrics/visualizations to create
-      2. **VALIDATE**: Use \`validate_query\` to verify SQL syntax is correct before embedding
-      3. **OUTPUT**: Generate the dashboard using layout and chart components
-
-      ## Critical Rules
-
-      - **Design from schema**: Use the provided schema introspection to understand available tables, columns, and relationships
-      - **Validate all queries**: Use \`validate_query\` to ensure SQL is syntactically correct before embedding in components
-      - **Use kebab-case HTML tags** with closing tags (e.g., \`<bar-chart></bar-chart>\`)
-      - Use \`scratchpad\` to record schema analysis insights and design decisions
-      - Choose chart types based on column types (dates → line/area, categories → bar/pie, numbers → KPI)
-      - Use layout components (row, column, grid) to organize the dashboard
-      - Include a text introduction explaining what the dashboard shows
-
-      ## SQL Rules
-
-      - Only SELECT or WITH statements
-      - Use proper date/time functions for the database
-      - Include appropriate GROUP BY, ORDER BY clauses
-      - Use aliases for calculated columns
-
-      ${state?.teachings || ""}
-      ${state?.introspection || ""}
-    `;
-  }
-});
-
-// packages/text2sql/src/lib/agents/chat1.agent.ts
-import { groq as groq7 } from "@ai-sdk/groq";
-import { tool as tool4 } from "ai";
-import z7 from "zod";
-import { agent as agent7, toState as toState4 } from "@deepagents/agent";
-import { scratchpad_tool as scratchpad_tool4 } from "@deepagents/toolbox";
-var tools4 = {
-  query_database: tool4({
+  query_database: tool3({
     description: `Query the database to answer a question. Provide your question in natural language and this tool will:
 1. Generate the appropriate SQL query
 2. Validate the SQL syntax
@@ -2075,16 +1756,16 @@ var tools4 = {
 4. Return the results
 
 Use this tool when you need to retrieve data to answer the user's question.`,
-    inputSchema: z7.object({
-      question: z7.string().min(1).describe(
+    inputSchema: z6.object({
+      question: z6.string().min(1).describe(
         "The question to answer, expressed in natural language. Be specific about what data you need."
       ),
-      reasoning: z7.string().optional().describe(
+      reasoning: z6.string().optional().describe(
         "Your reasoning for why this query is needed to answer the user."
       )
     }),
     execute: async ({ question }, options) => {
-      const state = toState4(options);
+      const state = toState3(options);
       try {
         const sqlResult = await toSql({
           input: question,
@@ -2112,12 +1793,12 @@ Use this tool when you need to retrieve data to answer the user's question.`,
       }
     }
   }),
-  scratchpad: scratchpad_tool4
+  scratchpad: scratchpad_tool3
 };
-var chat1Agent = agent7({
+var chat1Agent = agent6({
   name: "chat1-combined",
-  model: groq7("openai/gpt-oss-20b"),
-  tools: tools4,
+  model: groq6("openai/gpt-oss-20b"),
+  tools: tools3,
   prompt: (state) => {
     return `
 ${state?.teachings || ""}
@@ -2127,13 +1808,13 @@ ${state?.introspection || ""}
 });
 
 // packages/text2sql/src/lib/agents/chat2.agent.ts
-import { groq as groq8 } from "@ai-sdk/groq";
-import { tool as tool5 } from "ai";
-import z8 from "zod";
-import { agent as agent8, toState as toState5 } from "@deepagents/agent";
-import { scratchpad_tool as scratchpad_tool5 } from "@deepagents/toolbox";
-var tools5 = {
-  generate_sql: tool5({
+import { groq as groq7 } from "@ai-sdk/groq";
+import { tool as tool4 } from "ai";
+import z7 from "zod";
+import { agent as agent7, toState as toState4 } from "@deepagents/agent";
+import { scratchpad_tool as scratchpad_tool4 } from "@deepagents/toolbox";
+var tools4 = {
+  generate_sql: tool4({
     description: `Generate a SQL query from a natural language question. This tool will:
 1. Translate your question into SQL
 2. Validate the SQL syntax
@@ -2144,14 +1825,14 @@ Use this BEFORE execute_sql to see what query will be run. You can then:
 - Explain the approach to the user
 - Decide if the SQL looks correct
 - Refine your question and regenerate if needed`,
-    inputSchema: z8.object({
-      question: z8.string().min(1).describe(
+    inputSchema: z7.object({
+      question: z7.string().min(1).describe(
         "The question to translate into SQL. Be specific about what data you need."
       ),
-      reasoning: z8.string().optional().describe("Your reasoning for why this data is needed.")
+      reasoning: z7.string().optional().describe("Your reasoning for why this data is needed.")
     }),
     execute: async ({ question }, options) => {
-      const state = toState5(options);
+      const state = toState4(options);
       try {
         const sqlResult = await toSql({
           input: question,
@@ -2179,21 +1860,21 @@ Use this BEFORE execute_sql to see what query will be run. You can then:
       }
     }
   }),
-  execute_sql: tool5({
+  execute_sql: tool4({
     description: `Execute a SQL query and return the results. Use this AFTER generate_sql to run the query.
 
 Only SELECT and WITH (CTE) queries are allowed - no data modification.`,
-    inputSchema: z8.object({
-      sql: z8.string().min(1).refine(
+    inputSchema: z7.object({
+      sql: z7.string().min(1).refine(
         (sql) => sql.trim().toUpperCase().startsWith("SELECT") || sql.trim().toUpperCase().startsWith("WITH"),
         {
           message: "Only read-only SELECT or WITH queries are allowed."
         }
       ).describe("The SQL query to execute (must be SELECT or WITH)."),
-      reasoning: z8.string().optional().describe("Brief explanation of what this query retrieves.")
+      reasoning: z7.string().optional().describe("Brief explanation of what this query retrieves.")
     }),
     execute: async ({ sql }, options) => {
-      const state = toState5(options);
+      const state = toState4(options);
       try {
         const data = await state.adapter.execute(sql);
         return {
@@ -2209,12 +1890,12 @@ Only SELECT and WITH (CTE) queries are allowed - no data modification.`,
       }
     }
   }),
-  scratchpad: scratchpad_tool5
+  scratchpad: scratchpad_tool4
 };
-var chat2Agent = agent8({
+var chat2Agent = agent7({
   name: "chat2-with-peek",
-  model: groq8("openai/gpt-oss-20b"),
-  tools: tools5,
+  model: groq7("openai/gpt-oss-20b"),
+  tools: tools4,
   prompt: (state) => {
     return `
 ${state?.teachings || ""}
@@ -2232,34 +1913,34 @@ If the generated SQL doesn't look right, you can refine your question and regene
 });
 
 // packages/text2sql/src/lib/agents/chat3.agent.ts
-import { groq as groq9 } from "@ai-sdk/groq";
-import { defaultSettingsMiddleware as defaultSettingsMiddleware2, tool as tool6, wrapLanguageModel as wrapLanguageModel2 } from "ai";
-import z9 from "zod";
-import { agent as agent9, generate as generate3, toState as toState6, user as user2 } from "@deepagents/agent";
-import { scratchpad_tool as scratchpad_tool6 } from "@deepagents/toolbox";
-var collaborativeSqlOutputSchema = z9.discriminatedUnion("status", [
-  z9.object({
-    status: z9.literal("success"),
-    sql: z9.string().describe("The generated SQL query"),
-    confidence: z9.enum(["high", "medium", "low"]).describe("Confidence level in this SQL being correct"),
-    assumptions: z9.array(z9.string()).optional().describe("Assumptions made during SQL generation"),
-    reasoning: z9.string().optional().describe("Brief explanation of the query approach")
+import { groq as groq8 } from "@ai-sdk/groq";
+import { defaultSettingsMiddleware as defaultSettingsMiddleware2, tool as tool5, wrapLanguageModel as wrapLanguageModel2 } from "ai";
+import z8 from "zod";
+import { agent as agent8, generate as generate3, toState as toState5, user as user2 } from "@deepagents/agent";
+import { scratchpad_tool as scratchpad_tool5 } from "@deepagents/toolbox";
+var collaborativeSqlOutputSchema = z8.discriminatedUnion("status", [
+  z8.object({
+    status: z8.literal("success"),
+    sql: z8.string().describe("The generated SQL query"),
+    confidence: z8.enum(["high", "medium", "low"]).describe("Confidence level in this SQL being correct"),
+    assumptions: z8.array(z8.string()).optional().describe("Assumptions made during SQL generation"),
+    reasoning: z8.string().optional().describe("Brief explanation of the query approach")
   }),
-  z9.object({
-    status: z9.literal("clarification_needed"),
-    question: z9.string().describe("Question to clarify the request"),
-    context: z9.string().optional().describe("Why this clarification is needed"),
-    options: z9.array(z9.string()).optional().describe("Possible options if applicable")
+  z8.object({
+    status: z8.literal("clarification_needed"),
+    question: z8.string().describe("Question to clarify the request"),
+    context: z8.string().optional().describe("Why this clarification is needed"),
+    options: z8.array(z8.string()).optional().describe("Possible options if applicable")
   }),
-  z9.object({
-    status: z9.literal("unanswerable"),
-    reason: z9.string().describe("Why this question cannot be answered"),
-    suggestions: z9.array(z9.string()).optional().describe("Alternative questions that could be answered")
+  z8.object({
+    status: z8.literal("unanswerable"),
+    reason: z8.string().describe("Why this question cannot be answered"),
+    suggestions: z8.array(z8.string()).optional().describe("Alternative questions that could be answered")
   })
 ]);
-var collaborativeSqlAgent = agent9({
+var collaborativeSqlAgent = agent8({
   name: "collaborative-sql",
-  model: groq9("openai/gpt-oss-20b"),
+  model: groq8("openai/gpt-oss-20b"),
   output: collaborativeSqlOutputSchema,
   prompt: (state) => {
     return `
@@ -2293,8 +1974,8 @@ Prefer asking for clarification over making low-confidence guesses.
 `;
   }
 });
-var tools6 = {
-  consult_sql_agent: tool6({
+var tools5 = {
+  consult_sql_agent: tool5({
     description: `Consult the SQL specialist agent to generate a query. The SQL agent may:
 - Return a SQL query with confidence level and assumptions
 - Ask for clarification if the question is ambiguous
@@ -2304,15 +1985,15 @@ Based on the response:
 - If clarification is needed, you can provide context or ask the user
 - If assumptions were made, verify them with the user for important queries
 - If unanswerable, relay the suggestions to the user`,
-    inputSchema: z9.object({
-      question: z9.string().min(1).describe("The question to translate into SQL."),
-      context: z9.string().optional().describe("Additional context from the conversation that might help."),
-      previousClarification: z9.string().optional().describe(
+    inputSchema: z8.object({
+      question: z8.string().min(1).describe("The question to translate into SQL."),
+      context: z8.string().optional().describe("Additional context from the conversation that might help."),
+      previousClarification: z8.string().optional().describe(
         "Answer to a previous clarification question from the SQL agent."
       )
     }),
     execute: async ({ question, context: context2, previousClarification }, options) => {
-      const state = toState6(options);
+      const state = toState5(options);
       try {
         let fullQuestion = question;
         if (context2) {
@@ -2382,11 +2063,11 @@ Clarification provided: ${previousClarification}`;
       }
     }
   }),
-  execute_sql: tool6({
+  execute_sql: tool5({
     description: `Execute a SQL query directly. Use this when you have SQL that you want to run
 (e.g., after receiving SQL from consult_sql_agent or for follow-up queries).`,
-    inputSchema: z9.object({
-      sql: z9.string().min(1).refine(
+    inputSchema: z8.object({
+      sql: z8.string().min(1).refine(
         (sql) => sql.trim().toUpperCase().startsWith("SELECT") || sql.trim().toUpperCase().startsWith("WITH"),
         {
           message: "Only read-only SELECT or WITH queries are allowed."
@@ -2394,7 +2075,7 @@ Clarification provided: ${previousClarification}`;
       ).describe("The SQL query to execute.")
     }),
     execute: async ({ sql }, options) => {
-      const state = toState6(options);
+      const state = toState5(options);
       try {
         const validationError = await state.adapter.validate(sql);
         if (validationError) {
@@ -2417,12 +2098,12 @@ Clarification provided: ${previousClarification}`;
       }
     }
   }),
-  scratchpad: scratchpad_tool6
+  scratchpad: scratchpad_tool5
 };
-var chat3Agent = agent9({
+var chat3Agent = agent8({
   name: "chat3-collaborative",
-  model: groq9("openai/gpt-oss-20b"),
-  tools: tools6,
+  model: groq8("openai/gpt-oss-20b"),
+  tools: tools5,
   prompt: (state) => {
     return `
 ${state?.teachings || ""}
@@ -2442,39 +2123,39 @@ For clarification requests, try to answer from conversation context first before
 });
 
 // packages/text2sql/src/lib/agents/chat4.agent.ts
-import { groq as groq10 } from "@ai-sdk/groq";
-import { defaultSettingsMiddleware as defaultSettingsMiddleware3, tool as tool7, wrapLanguageModel as wrapLanguageModel3 } from "ai";
-import z10 from "zod";
-import { agent as agent10, generate as generate4, toState as toState7, user as user3 } from "@deepagents/agent";
-import { scratchpad_tool as scratchpad_tool7 } from "@deepagents/toolbox";
-var questionDecompositionSchema = z10.object({
-  originalQuestion: z10.string().describe("The original question being decomposed"),
-  breakdown: z10.array(z10.string()).min(1).describe(
+import { groq as groq9 } from "@ai-sdk/groq";
+import { defaultSettingsMiddleware as defaultSettingsMiddleware3, tool as tool6, wrapLanguageModel as wrapLanguageModel3 } from "ai";
+import z9 from "zod";
+import { agent as agent9, generate as generate4, toState as toState6, user as user3 } from "@deepagents/agent";
+import { scratchpad_tool as scratchpad_tool6 } from "@deepagents/toolbox";
+var questionDecompositionSchema = z9.object({
+  originalQuestion: z9.string().describe("The original question being decomposed"),
+  breakdown: z9.array(z9.string()).min(1).describe(
     "Semantic breakdown of the question into its component parts. Each part describes an aspect of what is being asked, NOT how to implement it."
   ),
-  entities: z10.array(z10.string()).optional().describe(
+  entities: z9.array(z9.string()).optional().describe(
     "Key entities/concepts mentioned (e.g., customers, orders, products)"
   ),
-  filters: z10.array(z10.string()).optional().describe(
+  filters: z9.array(z9.string()).optional().describe(
     'Filtering criteria mentioned (e.g., "last quarter", "above $100")'
   ),
-  aggregation: z10.string().optional().describe(
+  aggregation: z9.string().optional().describe(
     'Type of aggregation if any (e.g., "count", "sum", "average", "top N")'
   ),
-  ambiguities: z10.array(z10.string()).optional().describe("Any ambiguous parts that might need clarification")
+  ambiguities: z9.array(z9.string()).optional().describe("Any ambiguous parts that might need clarification")
 });
-var decompositionSqlOutputSchema = z10.union([
-  z10.object({
-    sql: z10.string().describe("The SQL query that answers the decomposed question"),
-    reasoning: z10.string().optional().describe("How each breakdown component was addressed")
+var decompositionSqlOutputSchema = z9.union([
+  z9.object({
+    sql: z9.string().describe("The SQL query that answers the decomposed question"),
+    reasoning: z9.string().optional().describe("How each breakdown component was addressed")
   }),
-  z10.object({
-    error: z10.string().describe("Error message if the question cannot be answered")
+  z9.object({
+    error: z9.string().describe("Error message if the question cannot be answered")
   })
 ]);
-var decompositionSqlAgent = agent10({
+var decompositionSqlAgent = agent9({
   name: "decomposition-sql",
-  model: groq10("openai/gpt-oss-20b"),
+  model: groq9("openai/gpt-oss-20b"),
   output: decompositionSqlOutputSchema,
   prompt: (state) => {
     return `
@@ -2501,8 +2182,8 @@ If there are ambiguities, make reasonable assumptions and note them in your reas
   }
 });
 var RETRY_TEMPERATURES2 = [0, 0.2, 0.3];
-var tools7 = {
-  query_with_decomposition: tool7({
+var tools6 = {
+  query_with_decomposition: tool6({
     description: `Query the database using question decomposition. This tool:
 1. Breaks down your question into semantic components (entities, filters, aggregations)
 2. Passes the decomposition to the SQL specialist
@@ -2510,22 +2191,22 @@ var tools7 = {
 4. Executes and returns results
 
 This approach helps ensure all aspects of the question are addressed in the query.`,
-    inputSchema: z10.object({
-      question: z10.string().min(1).describe("The question to answer."),
-      breakdown: z10.array(z10.string()).min(1).describe(
+    inputSchema: z9.object({
+      question: z9.string().min(1).describe("The question to answer."),
+      breakdown: z9.array(z9.string()).min(1).describe(
         'Break down the question into its semantic parts. Each part should describe an ASPECT of what is being asked, not instructions. Example for "top customers by revenue last month": ["customers who made purchases", "revenue from those purchases", "time period: last month", "ranking: top by total revenue"]'
       ),
-      entities: z10.array(z10.string()).optional().describe(
+      entities: z9.array(z9.string()).optional().describe(
         'Key entities mentioned (e.g., ["customers", "orders", "products"])'
       ),
-      filters: z10.array(z10.string()).optional().describe('Filter criteria (e.g., ["last month", "status = active"])'),
-      aggregation: z10.string().optional().describe(
+      filters: z9.array(z9.string()).optional().describe('Filter criteria (e.g., ["last month", "status = active"])'),
+      aggregation: z9.string().optional().describe(
         'Aggregation type if any (e.g., "sum revenue", "count orders", "top 10")'
       ),
-      ambiguities: z10.array(z10.string()).optional().describe("Note any ambiguous parts you identified")
+      ambiguities: z9.array(z9.string()).optional().describe("Note any ambiguous parts you identified")
     }),
     execute: async ({ question, breakdown, entities, filters, aggregation, ambiguities }, options) => {
-      const state = toState7(options);
+      const state = toState6(options);
       const decomposition = {
         originalQuestion: question,
         breakdown,
@@ -2597,10 +2278,10 @@ Previous attempt failed with: ${lastError}. Please fix the query.` : decomposedP
       }
     }
   }),
-  execute_sql: tool7({
+  execute_sql: tool6({
     description: `Execute a SQL query directly. Use for follow-up queries or when you already have SQL.`,
-    inputSchema: z10.object({
-      sql: z10.string().min(1).refine(
+    inputSchema: z9.object({
+      sql: z9.string().min(1).refine(
         (sql) => sql.trim().toUpperCase().startsWith("SELECT") || sql.trim().toUpperCase().startsWith("WITH"),
         {
           message: "Only read-only SELECT or WITH queries are allowed."
@@ -2608,7 +2289,7 @@ Previous attempt failed with: ${lastError}. Please fix the query.` : decomposedP
       ).describe("The SQL query to execute.")
     }),
     execute: async ({ sql }, options) => {
-      const state = toState7(options);
+      const state = toState6(options);
       try {
         const validationError = await state.adapter.validate(sql);
         if (validationError) {
@@ -2631,7 +2312,7 @@ Previous attempt failed with: ${lastError}. Please fix the query.` : decomposedP
       }
     }
   }),
-  scratchpad: scratchpad_tool7
+  scratchpad: scratchpad_tool6
 };
 function formatDecomposition(decomposition) {
   const parts = [
@@ -2662,10 +2343,10 @@ function formatDecomposition(decomposition) {
   );
   return parts.join("\n");
 }
-var chat4Agent = agent10({
+var chat4Agent = agent9({
   name: "chat4-decomposition",
-  model: groq10("openai/gpt-oss-20b"),
-  tools: tools7,
+  model: groq9("openai/gpt-oss-20b"),
+  tools: tools6,
   prompt: (state) => {
     return `
 ${state?.teachings || ""}
@@ -2691,15 +2372,6 @@ Break the question into its semantic aspects, and let the SQL specialist figure
   }
 });
 
-// packages/text2sql/src/lib/synthesis/types.ts
-async function toPairs(producer) {
-  const pairs = [];
-  for await (const chunk of producer.produce()) {
-    pairs.push(...chunk);
-  }
-  return pairs;
-}
-
 // packages/text2sql/src/lib/teach/teachings.ts
 function guidelines(options = {}) {
   const { date = "strict" } = options;
@@ -2874,7 +2546,7 @@ var Text2Sql = class {
   instruct(...dataset) {
     this.#config.instructions.push(...dataset);
   }
-  async inspect(agent11) {
+  async inspect(agent10) {
     const [grounding] = await Promise.all([this.index()]);
     const renderToolNames = Object.keys(this.#config.tools ?? {}).filter(
       (name) => name.startsWith("render_")
@@ -2894,14 +2566,14 @@ var Text2Sql = class {
         })
       ] : []
     ];
-    const tools8 = Object.keys({
-      ...agent11.handoff.tools,
+    const tools7 = Object.keys({
+      ...agent10.handoff.tools,
       ...this.#config.memory ? memoryTools : {},
       ...this.#config.tools
     });
     return {
-      tools: tools8,
-      prompt: agent11.instructions({
+      tools: tools7,
+      prompt: agent10.instructions({
         introspection: grounding,
         teachings: toInstructions("instructions", ...allInstructions)
       })
@@ -2937,7 +2609,7 @@ var Text2Sql = class {
    */
   async toPairs(factory) {
     const producer = factory(this.#config.adapter);
-    return toPairs(producer);
+    return producer.toPairs();
   }
   // public async suggest() {
   //   const [introspection, adapterInfo] = await Promise.all([
@@ -3064,7 +2736,7 @@ var Text2Sql = class {
       chat1Agent.clone({
         model: this.#config.model,
         tools: {
-          ...tools4,
+          ...tools3,
           ...this.#config.memory ? memoryTools : {},
           ...this.#config.tools
         }
@@ -3130,7 +2802,7 @@ var Text2Sql = class {
       chat2Agent.clone({
         model: this.#config.model,
         tools: {
-          ...tools5,
+          ...tools4,
           ...this.#config.memory ? memoryTools : {},
           ...this.#config.tools
         }
@@ -3195,7 +2867,7 @@ var Text2Sql = class {
       chat3Agent.clone({
         model: this.#config.model,
         tools: {
-          ...tools6,
+          ...tools5,
           ...this.#config.memory ? memoryTools : {},
           ...this.#config.tools
         }
@@ -3263,7 +2935,7 @@ var Text2Sql = class {
       chat4Agent.clone({
         model: this.#config.model,
         tools: {
-          ...tools7,
+          ...tools6,
           ...this.#config.memory ? memoryTools : {},
           ...this.#config.tools
         }
@@ -3289,58 +2961,6 @@ var Text2Sql = class {
       originalMessage
     );
   }
-  /**
-   * Business intelligence focused chat agent.
-   *
-   * Creates dashboards using MDX components with embedded SQL queries.
-   * The agent explores data, validates SQL, and outputs markdown with
-   * JSX chart components that the frontend renders via MDX.
-   *
-   * @example
-   * ```typescript
-   * const result = await text2sql.bi(
-   *   [user("Show me a sales dashboard for last 30 days")],
-   *   { chatId: 'dashboard-1', userId: 'user-1' }
-   * );
-   * // Result contains markdown with <BarChart sql="..." />, <KPI sql="..." />, etc.
-   * ```
-   */
-  async bi(messages, params) {
-    const [introspection, userTeachables] = await Promise.all([
-      this.index({ onProgress: console.log }),
-      this.#config.memory ? this.#config.memory.toTeachables(params.userId) : []
-    ]);
-    const chat = await this.#config.history.upsertChat({
-      id: params.chatId,
-      userId: params.userId,
-      title: "Chat " + params.chatId
-    });
-    const originalMessages = [
-      ...chat.messages.map((it) => it.content),
-      ...messages
-    ];
-    const result = stream(
-      biAgent.clone({
-        model: this.#config.model
-      }),
-      originalMessages,
-      {
-        teachings: toInstructions(
-          "instructions",
-          ...this.#config.instructions,
-          teachable("user_profile", ...userTeachables)
-        ),
-        adapter: this.#config.adapter,
-        introspection
-      }
-    );
-    return this.#createUIMessageStream(
-      result,
-      messages,
-      params,
-      originalMessages
-    );
-  }
   /**
    * Developer-focused conversational interface for SQL generation.
    *
@@ -3364,36 +2984,26 @@ var Text2Sql = class {
       this.index({ onProgress: console.log }),
       this.#config.memory ? this.#config.memory.toTeachables(params.userId) : []
     ]);
-    const chat = await this.#config.history.upsertChat({
-      id: params.chatId,
-      userId: params.userId,
-      title: "Chat " + params.chatId
-    });
-    const originalMessages = [
-      ...chat.messages.map((it) => it.content),
-      ...messages
-    ];
-    const result = stream(
-      developerAgent.clone({
-        model: this.#config.model
-      }),
-      originalMessages,
-      {
-        teachings: toInstructions(
-          "instructions",
-          ...this.#config.instructions,
-          teachable("user_profile", ...userTeachables)
-        ),
-        adapter: this.#config.adapter,
-        introspection,
-        instructions: this.#config.instructions
-      }
-    );
-    return this.#createUIMessageStream(
-      result,
-      messages,
+    return withChat(
+      this.#config.history,
       params,
-      originalMessages
+      messages,
+      (originalMessages) => stream(
+        developerAgent.clone({
+          model: this.#config.model
+        }),
+        originalMessages,
+        {
+          teachings: toInstructions(
+            "instructions",
+            ...this.#config.instructions,
+            teachable("user_profile", ...userTeachables)
+          ),
+          adapter: this.#config.adapter,
+          introspection,
+          instructions: this.#config.instructions
+        }
+      )
     );
   }
   /**
@@ -3442,6 +3052,58 @@ var Text2Sql = class {
     });
   }
 };
+async function withChat(history, params, messages, streamFn) {
+  const chat = await history.upsertChat({
+    id: params.chatId,
+    userId: params.userId,
+    title: "Chat " + params.chatId
+  });
+  const originalMessages = [
+    ...chat.messages.map((it) => it.content),
+    ...messages
+  ];
+  const result = streamFn(originalMessages);
+  return result.toUIMessageStream({
+    onError: (error) => {
+      if (NoSuchToolError.isInstance(error)) {
+        return "The model tried to call an unknown tool.";
+      } else if (InvalidToolInputError.isInstance(error)) {
+        return "The model called a tool with invalid arguments.";
+      } else if (ToolCallRepairError.isInstance(error)) {
+        return "The model tried to call a tool with invalid arguments, but it was repaired.";
+      } else {
+        return JSON.stringify(error);
+      }
+    },
+    sendStart: true,
+    sendFinish: true,
+    sendReasoning: true,
+    sendSources: true,
+    originalMessages,
+    generateMessageId: generateId,
+    onFinish: async ({ responseMessage, isContinuation }) => {
+      const userMessage = messages.at(-1);
+      if (!isContinuation && userMessage) {
+        console.log(
+          "Saving user message to history:",
+          JSON.stringify(userMessage)
+        );
+        await history.addMessage({
+          id: v72(),
+          chatId: params.chatId,
+          role: userMessage.role,
+          content: userMessage
+        });
+      }
+      await history.addMessage({
+        id: v72(),
+        chatId: params.chatId,
+        role: responseMessage.role,
+        content: responseMessage
+      });
+    }
+  });
+}
 export {
   Adapter,
   Checkpoint,
@@ -3465,6 +3127,7 @@ export {
   matchesFilter,
   memoryTools,
   suggestionsAgent,
-  t_a_g
+  t_a_g,
+  withChat
 };
 //# sourceMappingURL=index.js.map