yamchart 0.8.7 → 0.9.0

package/dist/chunk-ZA6AOQVZ.js

@@ -0,0 +1,677 @@
+// ../../packages/chat/dist/agent.js
+import Anthropic from "@anthropic-ai/sdk";
+
+// ../../packages/chat/dist/tools.js
+import yaml from "yaml";
+
+// ../../packages/chat/dist/catalog-filter.js
+function extractSchema(table) {
+  const parts = table.split(".");
+  if (parts.length >= 3)
+    return parts[parts.length - 2] ?? null;
+  if (parts.length === 2)
+    return parts[0] ?? null;
+  return null;
+}
+function filterCatalogEntries(entries, filterConfig) {
+  if (!filterConfig)
+    return [];
+  const schemas = filterConfig.schemas ?? [];
+  const tags = filterConfig.tags ?? [];
+  if (schemas.length === 0 && tags.length === 0)
+    return [];
+  const schemasLower = schemas.map((s) => s.toLowerCase());
+  const tagsLower = tags.map((t) => t.toLowerCase());
+  return entries.filter((entry) => {
+    if (schemasLower.length > 0 && entry.table) {
+      const schema = extractSchema(entry.table);
+      if (schema && schemasLower.includes(schema.toLowerCase()))
+        return true;
+    }
+    if (tagsLower.length > 0 && entry.tags?.length) {
+      if (entry.tags.some((t) => tagsLower.includes(t.toLowerCase())))
+        return true;
+    }
+    return false;
+  });
+}
+
+// ../../packages/chat/dist/tools.js
+var CHAT_TOOL_DEFINITIONS = [
+  {
+    name: "query_model",
+    description: 'Execute a chart or SQL model by name with optional parameters. Returns rows and columns. Accepts either a chart name (e.g. "social-traffic") or a model name (e.g. "revenue_over_time").',
+    parameters: {
+      type: "object",
+      properties: {
+        model: { type: "string", description: 'Chart name or model name (e.g. "social-traffic" or "revenue_over_time")' },
+        params: { type: "object", description: "Optional parameters to pass to the model" },
+        limit: { type: "number", description: "Max rows to return (default: 100)" }
+      },
+      required: ["model"]
+    }
+  },
+  {
+    name: "get_chart_config",
+    description: "Get the full YAML configuration of a chart by name.",
+    parameters: {
+      type: "object",
+      properties: { name: { type: "string", description: "Chart name" } },
+      required: ["name"]
+    }
+  },
+  {
+    name: "get_dashboard_summary",
+    description: "Get a summary of a dashboard: all charts, their types, and cached KPI values.",
+    parameters: {
+      type: "object",
+      properties: { name: { type: "string", description: "Dashboard name" } },
+      required: ["name"]
+    }
+  },
+  {
+    name: "apply_filter",
+    description: "Apply a filter to the dashboard the user is viewing. Updates UI in real-time.",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Filter/parameter name" },
+        value: { description: "Filter value" }
+      },
+      required: ["name", "value"]
+    }
+  },
+  {
+    name: "run_sql",
+    description: "Execute an ad-hoc SQL query against the connected database.",
+    parameters: {
+      type: "object",
+      properties: {
+        sql: { type: "string", description: "SQL query to execute" },
+        limit: { type: "number", description: "Max rows (default: 50)" }
+      },
+      required: ["sql"]
+    }
+  },
+  {
+    name: "compare_periods",
+    description: "Run a model with two different date ranges and return both result sets for comparison.",
+    parameters: {
+      type: "object",
+      properties: {
+        model: { type: "string", description: "Model name" },
+        current: { type: "object", properties: { start_date: { type: "string" }, end_date: { type: "string" } }, required: ["start_date", "end_date"] },
+        previous: { type: "object", properties: { start_date: { type: "string" }, end_date: { type: "string" } }, required: ["start_date", "end_date"] },
+        params: { type: "object", description: "Additional parameters" }
+      },
+      required: ["model", "current", "previous"]
+    }
+  },
+  {
+    name: "get_catalog_tables",
+    description: "Search the warehouse catalog for tables matching a keyword. Returns table names, columns, and sample rows.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Keyword to search for in table/column names" },
+        limit: { type: "number", description: "Max tables to return (default: 5)" }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "suggest_actions",
+    description: "Show the user clickable suggested follow-up actions. Use after answering a question when there are natural next steps.",
+    parameters: {
+      type: "object",
+      properties: {
+        suggestions: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              label: { type: "string", description: "Button text" },
+              message: { type: "string", description: "Message to send when clicked" },
+              type: { type: "string", enum: ["explore", "save"], description: "explore for follow-up questions, save for creating artifacts" }
+            },
+            required: ["label", "message", "type"]
+          }
+        }
+      },
+      required: ["suggestions"]
+    }
+  },
+  {
+    name: "save_model",
+    description: "Create a new SQL model file in the project. Writes to models/<name>.sql with metadata headers.",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Model name (alphanumeric + underscores)" },
+        sql: { type: "string", description: "SQL query body" },
+        description: { type: "string", description: "Model description" },
+        params: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              type: { type: "string" },
+              default: { type: "string" }
+            },
+            required: ["name", "type"]
+          },
+          description: "Model parameters"
+        }
+      },
+      required: ["name", "sql"]
+    }
+  },
+  {
+    name: "save_chart",
+    description: "Create a new chart YAML file in the project. Writes to charts/<name>.yaml.",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Chart name (alphanumeric, hyphens, underscores)" },
+        title: { type: "string", description: "Display title" },
+        model: { type: "string", description: "Source model name" },
+        chart_type: { type: "string", description: "Chart type (line, bar, area, pie, donut, scatter, kpi, combo, heatmap, funnel, waterfall, gauge, sankey, table)" },
+        config: { type: "object", description: "Chart-type-specific configuration (x, y, series, etc.)" }
+      },
+      required: ["name", "title", "model", "chart_type", "config"]
+    }
+  },
+  {
+    name: "add_to_dashboard",
+    description: "Add a chart widget to an existing dashboard layout.",
+    parameters: {
+      type: "object",
+      properties: {
+        dashboard: { type: "string", description: "Dashboard name" },
+        chart: { type: "string", description: "Chart name to add" },
+        cols: { type: "number", description: "Column span (1-12, default: 6)" },
+        height: { type: "number", description: "Row height in pixels (default: 300)" },
+        tab: { type: "string", description: "Tab name to add to (if dashboard uses tabs)" }
+      },
+      required: ["dashboard", "chart"]
+    }
+  },
+  {
+    name: "create_dashboard",
+    description: "Create a new dashboard YAML file with layout referencing saved charts.",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: 'Dashboard name (kebab-case, e.g. "sales-overview")' },
+        title: { type: "string", description: "Display title" },
+        description: { type: "string", description: "Optional dashboard description" },
+        charts: {
+          type: "array",
+          items: { type: "string" },
+          description: "List of chart names to include in the dashboard layout"
+        },
+        layout: {
+          type: "string",
+          enum: ["auto"],
+          description: 'Layout mode (only "auto" supported for now)'
+        }
+      },
+      required: ["name", "title", "charts"]
+    }
+  },
+  {
+    name: "call_agent",
+    description: "Delegate a question to a specialized agent. Use when the question is better handled by a domain-specific agent.",
+    parameters: {
+      type: "object",
+      properties: {
+        agent: { type: "string", description: "Agent name to delegate to" },
+        question: { type: "string", description: "Question to ask the agent" }
+      },
+      required: ["agent", "question"]
+    }
+  }
+];
+async function executeChatTool(toolName, args, ctx) {
+  switch (toolName) {
+    case "query_model": {
+      const modelName = args.model;
+      if (!/^[a-zA-Z_][a-zA-Z0-9_.\-]*$/.test(modelName)) {
+        return `Error: Invalid model name "${modelName}"`;
+      }
+      const charts = ctx.configLoader.getCharts();
+      const chart = charts.find((c) => c.name === modelName) ?? charts.find((c) => c.source?.model === modelName);
+      if (!chart) {
+        try {
+          const result2 = await ctx.queryService.executeRawSql(`SELECT * FROM ${modelName} LIMIT ${args.limit ?? 100}`);
+          return JSON.stringify({ columns: result2.columns, rows: result2.rows.slice(0, args.limit ?? 100) });
+        } catch (err) {
+          return `Error: Model "${modelName}" not found as a chart source and raw query failed: ${err instanceof Error ? err.message : String(err)}`;
+        }
+      }
+      const params = args.params ?? {};
+      const result = await ctx.queryService.executeChart(chart, params, ctx.userContext);
+      const limit = args.limit ?? 100;
+      return JSON.stringify({ columns: result.columns, rows: result.rows.slice(0, limit) });
+    }
+    case "get_chart_config": {
+      const chart = ctx.configLoader.getChartByName(args.name);
+      if (!chart)
+        return `Error: Chart "${args.name}" not found`;
+      return JSON.stringify(chart);
+    }
+    case "get_dashboard_summary": {
+      const dashName = args.name ?? ctx.chatContext?.name;
+      if (!dashName)
+        return "Error: No dashboard name provided and no dashboard context available";
+      let dashboard = ctx.configLoader.getDashboardByName(dashName);
+      if (!dashboard) {
+        const all = ctx.configLoader.getDashboards();
+        dashboard = all.find((d) => d.title?.toLowerCase() === dashName.toLowerCase() || d.name.toLowerCase() === dashName.toLowerCase().replace(/\s+/g, "-"));
+      }
+      if (!dashboard)
+        return `Error: Dashboard "${dashName}" not found`;
+      const chartRefs = [];
+      const extractRefs = (layout) => {
+        for (const row of layout.rows ?? []) {
+          for (const widget of row.widgets ?? []) {
+            if (widget.type === "chart" && widget.ref)
+              chartRefs.push(widget.ref);
+          }
+        }
+      };
+      if (dashboard.layout)
+        extractRefs(dashboard.layout);
+      if (dashboard.tabs) {
+        for (const tab of dashboard.tabs) {
+          if (tab.layout)
+            extractRefs(tab.layout);
+        }
+      }
+      const chartSummaries = [];
+      for (const ref of chartRefs) {
+        const chart = ctx.configLoader.getChartByName(ref);
+        if (!chart)
+          continue;
+        const model = chart.source?.model ? ` [model: ${chart.source.model}]` : "";
+        chartSummaries.push(`- ${ref} (${chart.chart?.type ?? "unknown"}): ${chart.title ?? ref}${model}`);
+      }
+      return [`Dashboard: ${dashboard.title ?? dashboard.name}`, `Charts (${chartRefs.length}):`, ...chartSummaries].join("\n");
+    }
+    case "apply_filter": {
+      const filterName = args.name;
+      const filterValue = args.value;
+      ctx.emitEvent({ type: "filter_update", data: { filters: { [filterName]: filterValue } } });
+      return `Filter applied: ${filterName} = ${JSON.stringify(filterValue)}`;
+    }
+    case "run_sql": {
+      const sql = args.sql;
+      const destructivePattern = /^\s*(INSERT|UPDATE|DELETE|DROP|ALTER|TRUNCATE|CREATE)\b/i;
+      if (destructivePattern.test(sql)) {
+        return "Error: Destructive SQL statements are not allowed through the chat interface.";
+      }
+      const limit = args.limit ?? 50;
+      const limitedSql = sql.toLowerCase().includes("limit") ? sql : `${sql.replace(/;\s*$/, "")} LIMIT ${limit}`;
+      const result = await ctx.queryService.executeRawSql(limitedSql);
+      return JSON.stringify({ columns: result.columns, rows: result.rows });
+    }
+    case "compare_periods": {
+      const modelName = args.model;
+      const current = args.current;
+      const previous = args.previous;
+      const extraParams = args.params ?? {};
+      const charts = ctx.configLoader.getCharts();
+      const chart = charts.find((c) => c.source?.model === modelName);
+      if (!chart)
+        return `Error: No chart found using model "${modelName}"`;
+      const [currentResult, previousResult] = await Promise.all([
+        ctx.queryService.executeChart(chart, { ...extraParams, start_date: current.start_date, end_date: current.end_date }, ctx.userContext),
+        ctx.queryService.executeChart(chart, { ...extraParams, start_date: previous.start_date, end_date: previous.end_date }, ctx.userContext)
+      ]);
+      return JSON.stringify({
+        current: { period: current, rows: currentResult.rows, columns: currentResult.columns },
+        previous: { period: previous, rows: previousResult.rows, columns: previousResult.columns }
+      });
+    }
+    case "get_catalog_tables": {
+      if (!ctx.catalogPath) {
+        return "Error: No catalog available. Run `yamchart sync-warehouse` to sync warehouse metadata.";
+      }
+      try {
+        const fs = await import("fs/promises");
+        const raw = await fs.readFile(ctx.catalogPath, "utf-8");
+        const catalog = JSON.parse(raw);
+        const allEntries = catalog.models ?? [];
+        const entries = ctx.catalogFilter ? filterCatalogEntries(allEntries, ctx.catalogFilter) : allEntries;
+        if (entries.length === 0) {
+          if (allEntries.length > 0 && ctx.catalogFilter) {
+            return "No tables match your catalog filter configuration. Check catalog.include in yamchart.yaml to adjust which schemas/tags are included.";
+          }
+          return "No catalog data available. Run `yamchart sync-warehouse` to populate the catalog.";
+        }
+        const query = args.query.toLowerCase();
+        const limit = args.limit ?? 5;
+        const matches = entries.filter((t) => t.name.toLowerCase().includes(query) || (t.columns ?? []).some((c) => c.name.toLowerCase().includes(query)));
+        return JSON.stringify(matches.slice(0, limit));
+      } catch (err) {
+        return `Error reading catalog: ${err instanceof Error ? err.message : String(err)}`;
+      }
+    }
+    case "suggest_actions": {
+      const suggestions = args.suggestions;
+      ctx.emitEvent({ type: "suggestions", data: { suggestions } });
+      return `Suggested ${suggestions.length} follow-up actions.`;
+    }
+    case "save_model": {
+      const name = args.name;
+      if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+        return `Error: Invalid model name "${name}". Use only letters, numbers, and underscores.`;
+      }
+      const sql = args.sql;
+      const description = args.description;
+      const params = args.params;
+      const lines = [];
+      lines.push(`-- @name: ${name}`);
+      if (description)
+        lines.push(`-- @description: ${description}`);
+      if (params) {
+        for (const p of params) {
+          const def = p.default ? ` = ${p.default}` : "";
+          lines.push(`-- @param ${p.name}: ${p.type}${def}`);
+        }
+      }
+      lines.push("");
+      lines.push(sql);
+      const fs = await import("fs/promises");
+      const path = await import("path");
+      const modelsDir = path.join(ctx.projectDir, "models");
+      await fs.mkdir(modelsDir, { recursive: true });
+      const filePath = path.join(modelsDir, `${name}.sql`);
+      await fs.writeFile(filePath, lines.join("\n"), "utf-8");
+      await ctx.configLoader.load();
+      return `Model "${name}" saved to models/${name}.sql`;
+    }
+    case "save_chart": {
+      const name = args.name;
+      if (!/^[a-zA-Z_][a-zA-Z0-9_\-]*$/.test(name)) {
+        return `Error: Invalid chart name "${name}". Use only letters, numbers, hyphens, and underscores.`;
+      }
+      const title = args.title;
+      const model = args.model;
+      const chartType = args.chart_type;
+      const config = args.config ?? {};
+      const chartObj = {
+        name,
+        title,
+        source: { model },
+        chart: { type: chartType, ...config }
+      };
+      const fs = await import("fs/promises");
+      const path = await import("path");
+      const chartsDir = path.join(ctx.projectDir, "charts");
+      await fs.mkdir(chartsDir, { recursive: true });
+      const filePath = path.join(chartsDir, `${name}.yaml`);
+      await fs.writeFile(filePath, yaml.stringify(chartObj), "utf-8");
+      await ctx.configLoader.load();
+      ctx.emitEvent({ type: "chart_saved", data: { name } });
+      return `Chart "${name}" saved to charts/${name}.yaml`;
+    }
+    case "add_to_dashboard": {
+      const dashboardName = args.dashboard;
+      const chartName = args.chart;
+      const cols = args.cols ?? 6;
+      const height = args.height ?? 300;
+      const tabName = args.tab;
+      const fs = await import("fs/promises");
+      const path = await import("path");
+      const dashDir = path.join(ctx.projectDir, "dashboards");
+      let filePath;
+      try {
+        const files = await fs.readdir(dashDir);
+        const match = files.find((f) => {
+          const base = f.replace(/\.ya?ml$/, "");
+          return base === dashboardName;
+        });
+        if (match)
+          filePath = path.join(dashDir, match);
+      } catch {
+        return `Error: Dashboard directory not found at ${dashDir}`;
+      }
+      if (!filePath)
+        return `Error: Dashboard file "${dashboardName}" not found in dashboards/`;
+      const raw = await fs.readFile(filePath, "utf-8");
+      const doc = yaml.parse(raw);
+      const newRow = { height, widgets: [{ type: "chart", ref: chartName, cols }] };
+      if (tabName && doc.tabs) {
+        const tab = doc.tabs.find((t) => t.name === tabName);
+        if (!tab)
+          return `Error: Tab "${tabName}" not found in dashboard "${dashboardName}"`;
+        if (!tab.layout)
+          tab.layout = { rows: [] };
+        if (!tab.layout.rows)
+          tab.layout.rows = [];
+        tab.layout.rows.push(newRow);
+      } else {
+        if (!doc.layout)
+          doc.layout = { rows: [] };
+        if (!doc.layout.rows)
+          doc.layout.rows = [];
+        doc.layout.rows.push(newRow);
+      }
+      await fs.writeFile(filePath, yaml.stringify(doc), "utf-8");
+      await ctx.configLoader.load();
+      return `Added chart "${chartName}" to dashboard "${dashboardName}"${tabName ? ` (tab: ${tabName})` : ""}`;
+    }
+    case "create_dashboard": {
+      const name = args.name;
+      if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+        return `Error: Invalid dashboard name "${name}". Use kebab-case (e.g. "sales-overview").`;
+      }
+      const title = args.title;
+      const description = args.description;
+      const chartNames = args.charts;
+      for (const chartName of chartNames) {
+        const chart = ctx.configLoader.getChartByName(chartName);
+        if (!chart)
+          return `Error: Chart "${chartName}" not found. Save the chart first using save_chart.`;
+      }
+      const rows = [];
+      let currentPairWidgets = [];
+      const flushPair = () => {
+        if (currentPairWidgets.length > 0) {
+          rows.push({ height: 300, widgets: currentPairWidgets });
+          currentPairWidgets = [];
+        }
+      };
+      for (const chartName of chartNames) {
+        const chart = ctx.configLoader.getChartByName(chartName);
+        const chartType = chart?.chart?.type ?? "";
+        if (chartType === "kpi") {
+          flushPair();
+          const lastRow = rows[rows.length - 1];
+          if (lastRow && lastRow.widgets.every((w) => w.cols === 3)) {
+            lastRow.widgets.push({ type: "chart", ref: chartName, cols: 3 });
+          } else {
+            rows.push({ height: 150, widgets: [{ type: "chart", ref: chartName, cols: 3 }] });
+          }
+        } else if (chartType === "line" || chartType === "area" || chartType === "combo" || chartType === "sankey") {
+          flushPair();
+          rows.push({ height: 300, widgets: [{ type: "chart", ref: chartName, cols: 12 }] });
+        } else {
+          currentPairWidgets.push({ type: "chart", ref: chartName, cols: 6 });
+          if (currentPairWidgets.length === 2) {
+            rows.push({ height: 300, widgets: currentPairWidgets });
+            currentPairWidgets = [];
+          }
+        }
+      }
+      flushPair();
+      const dashObj = { name, title };
+      if (description)
+        dashObj.description = description;
+      dashObj.layout = { rows };
+      const fs = await import("fs/promises");
+      const path = await import("path");
+      const yamlLib = await import("yaml");
+      const dashDir = path.join(ctx.projectDir, "dashboards");
+      await fs.mkdir(dashDir, { recursive: true });
+      const filePath = path.join(dashDir, `${name}.yaml`);
+      await fs.writeFile(filePath, yamlLib.stringify(dashObj), "utf-8");
+      await ctx.configLoader.load();
+      ctx.emitEvent({ type: "navigate", data: { target: "dashboard", name, edit: true } });
+      return `Dashboard "${name}" created at dashboards/${name}.yaml with ${chartNames.length} chart(s).`;
+    }
+    case "call_agent": {
+      const agentName = args.agent;
+      const question = args.question;
+      if (!ctx.agentRegistry) {
+        return "Error: Agent registry not available.";
+      }
+      const agentConfig = ctx.agentRegistry.getAgent(agentName);
+      if (!agentConfig) {
+        const available = ctx.agentRegistry.listAgents().map((a) => a.name).join(", ");
+        return `Error: Agent "${agentName}" not found. Available agents: ${available}`;
+      }
+      const apiKey = process.env.ANTHROPIC_API_KEY;
+      if (!apiKey) {
+        return "Error: ANTHROPIC_API_KEY not set.";
+      }
+      const { StreamingChatAgent: Agent } = await import("./agent-KWKPAYT2.js");
+      const filteredConfig = {
+        ...agentConfig,
+        tools: agentConfig.tools.filter((t) => t !== "call_agent")
+      };
+      const subAgent = new Agent(filteredConfig, apiKey);
+      const parentToolId = `call_agent_${agentName}_${Date.now()}`;
+      const subEmitEvent = (event) => {
+        if (event.type === "tool_start") {
+          ctx.emitEvent({ type: "tool_start", data: { ...event.data, parentToolId } });
+        } else if (event.type === "tool_end") {
+          ctx.emitEvent({ type: "tool_end", data: { ...event.data, parentToolId } });
+        } else if (event.type !== "done") {
+          ctx.emitEvent(event);
+        }
+      };
+      try {
+        const result = await Promise.race([
+          subAgent.run(agentConfig.systemPrompt, [{ role: "user", content: question }], ctx, subEmitEvent),
+          new Promise((_, reject) => setTimeout(() => reject(new Error("Sub-agent timed out after 30s")), 3e4))
+        ]);
+        return result.content || "Agent completed with no text response.";
+      } catch (err) {
+        return `Error from agent "${agentName}": ${err instanceof Error ? err.message : String(err)}`;
+      }
+    }
+    default:
+      return `Unknown tool: ${toolName}`;
+  }
+}
+
+// ../../packages/chat/dist/agent.js
+var MAX_TOOL_ROUNDS = 10;
+var DEFAULT_MODEL = "claude-sonnet-4-5-20250929";
+var MAX_TOKENS = 4096;
+var StreamingChatAgent = class {
+  client;
+  config;
+  toolDefs;
+  constructor(config, apiKey) {
+    this.client = new Anthropic({ apiKey });
+    this.config = config;
+    this.toolDefs = this.buildToolDefs();
+  }
+  buildToolDefs() {
+    if (this.config.tools.length === 0)
+      return [];
+    return CHAT_TOOL_DEFINITIONS.filter((t) => this.config.tools.includes(t.name));
+  }
+  getToolDefinitions() {
+    return this.toolDefs;
+  }
+  async run(systemPrompt, messages, toolContext, emitEvent) {
+    const model = this.config.model ?? DEFAULT_MODEL;
+    const allToolCalls = [];
+    let finalContent = "";
+    const anthropicTools = this.toolDefs.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.parameters
+    }));
+    let currentMessages = [...messages];
+    for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
+      const stream = this.client.messages.stream({
+        model,
+        max_tokens: MAX_TOKENS,
+        system: systemPrompt,
+        messages: currentMessages,
+        tools: anthropicTools.length > 0 ? anthropicTools : void 0
+      });
+      let roundText = "";
+      const roundToolUses = [];
+      for await (const event of stream) {
+        if (event.type === "content_block_delta") {
+          const delta = event.delta;
+          if (delta.type === "text_delta" && delta.text) {
+            roundText += delta.text;
+            emitEvent({ type: "text_delta", data: { text: delta.text } });
+          }
+        } else if (event.type === "content_block_start") {
+          const block = event.content_block;
+          if (block.type === "tool_use" && block.id && block.name) {
+            roundToolUses.push({ id: block.id, name: block.name, input: {} });
+          }
+        }
+      }
+      const finalMessage = await stream.finalMessage();
+      for (const block of finalMessage.content) {
+        if (block.type === "tool_use") {
+          const existing = roundToolUses.find((t) => t.id === block.id);
+          if (existing) {
+            existing.input = block.input;
+          }
+        }
+      }
+      finalContent += roundText;
+      if (roundToolUses.length === 0 || finalMessage.stop_reason !== "tool_use") {
+        emitEvent({
+          type: "done",
+          data: { usage: { inputTokens: finalMessage.usage.input_tokens, outputTokens: finalMessage.usage.output_tokens } }
+        });
+        break;
+      }
+      const toolResults = [];
+      for (const toolUse of roundToolUses) {
+        const toolCall = { id: toolUse.id, name: toolUse.name, args: toolUse.input, status: "running" };
+        emitEvent({ type: "tool_start", data: { id: toolUse.id, name: toolUse.name, args: toolUse.input } });
+        const startTime = Date.now();
+        try {
+          const result = await executeChatTool(toolUse.name, toolUse.input, toolContext);
+          toolCall.status = "completed";
+          toolCall.result = result;
+          toolCall.durationMs = Date.now() - startTime;
+          toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: result });
+        } catch (err) {
+          toolCall.status = "error";
+          toolCall.result = err instanceof Error ? err.message : String(err);
+          toolCall.durationMs = Date.now() - startTime;
+          toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Error: ${toolCall.result}` });
+        }
+        emitEvent({ type: "tool_end", data: { id: toolUse.id, name: toolUse.name, result: toolCall.result ?? "", durationMs: toolCall.durationMs ?? 0 } });
+        allToolCalls.push(toolCall);
+      }
+      currentMessages = [
+        ...currentMessages,
+        { role: "assistant", content: finalMessage.content },
+        { role: "user", content: toolResults }
+      ];
+    }
+    return { content: finalContent, toolCalls: allToolCalls };
+  }
+};
+
+export {
+  filterCatalogEntries,
+  StreamingChatAgent
+};
+//# sourceMappingURL=chunk-ZA6AOQVZ.js.map