orcaq 1.0.30 → 1.0.32

package/.output/server/chunks/routes/api/ai/agent.mjs

@@ -8,8 +8,8 @@ import { createXai } from '@ai-sdk/xai';
 import { createOpenRouter } from '@openrouter/ai-sdk-provider';
 import { z } from 'zod/v4';
 import Papa from 'papaparse';
-import 'ssh2';
 import 'node:net';
+import 'ssh2';
 import 'node:http';
 import 'node:https';
 import 'node:events';
@@ -20,7 +20,6 @@ import 'node:crypto';
 import 'node:url';
 import '@iconify/utils';
 import 'consola';
-import 'node:module';
 import 'knex';
 import 'pg';
 
@@ -53,73 +52,6 @@ function createProviderModel(provider, apiKey, model) {
   }
 }
 
-const AGENT_COMMAND_OPTIONS = [
-  {
-    id: "generate-query",
-    label: "Generate Query",
-    toolName: "generate_query",
-    category: "SQL",
-    description: "Turn a natural language request into SQL for the active schema.",
-    insertText: "Generate SQL for ",
-    icon: "hugeicons:ai-brain-03",
-    promptHint: "The user wants help drafting SQL from natural language. Prefer generate_query first and keep the response focused on producing or refining SQL."
-  },
-  {
-    id: "render-table",
-    label: "Render Table",
-    toolName: "render_table",
-    category: "Execution",
-    description: "Run a read-only SQL query and show the result rows as a table.",
-    insertText: "Run this query and show the table result for ",
-    icon: "hugeicons:table-01",
-    promptHint: "The user expects concrete table output. After generating or receiving read-only SQL, prefer render_table and summarize the returned rows briefly."
-  },
-  {
-    id: "visualize-table",
-    label: "Visualize Table",
-    toolName: "visualize_table",
-    category: "Charts",
-    description: "Build a bar, line, pie, or scatter chart from a read-only query.",
-    insertText: "Visualize this data as a bar, line, pie, or scatter chart for ",
-    icon: "hugeicons:chart-line-data-01",
-    promptHint: "The user wants a chart-oriented answer. Prefer visualize_table for read-only SQL, and ask for the chart type only if it is still missing."
-  },
-  {
-    id: "describe-table",
-    label: "Describe Table",
-    toolName: "describe_table",
-    category: "Schema",
-    description: "Inspect columns, keys, relationships, and table structure.",
-    insertText: "Describe the structure of table ",
-    icon: "hugeicons:database",
-    promptHint: "The user is asking about schema shape, keys, or relationships. Prefer describe_table when a specific table is involved."
-  },
-  {
-    id: "explain-query",
-    label: "Explain Query",
-    toolName: "explain_query",
-    category: "Performance",
-    description: "Analyze a query plan and explain possible performance issues.",
-    insertText: "Explain why this query is slow: ",
-    icon: "hugeicons:activity-02",
-    promptHint: "The user is focused on query performance. Prefer explain_query once a concrete SQL statement is available."
-  },
-  {
-    id: "detect-anomaly",
-    label: "Detect Anomaly",
-    toolName: "detect_anomaly",
-    category: "Quality",
-    description: "Scan for nulls, duplicates, orphaned keys, and outlier values.",
-    insertText: "Detect anomalies in table ",
-    icon: "hugeicons:search-list-01",
-    promptHint: "The user wants data quality checks. Prefer detect_anomaly for table-level validation and summarize the findings with severity."
-  }
-];
-const getAgentCommandOptionsByIds = (ids) => {
-  const allowedIds = new Set(ids);
-  return AGENT_COMMAND_OPTIONS.filter((option) => allowedIds.has(option.id));
-};
-
 var FunctionSchemaEnum = /* @__PURE__ */ ((FunctionSchemaEnum2) => {
   FunctionSchemaEnum2["Function"] = "FUNCTION";
   FunctionSchemaEnum2["Procedure"] = "PROCEDURE";
@@ -411,10 +343,77 @@ function buildSchemaContext(schemaSnapshot) {
   }
   return lines.join("\n");
 }
+function buildSchemaSummary(schemaSnapshots) {
+  var _a, _b, _c, _d;
+  if (!(schemaSnapshots == null ? void 0 : schemaSnapshots.length)) {
+    return "No schema context is currently loaded. Use `list_schemas` to discover available schemas.";
+  }
+  const lines = [
+    `Connected database has ${schemaSnapshots.length} schema(s):`
+  ];
+  for (const snapshot of schemaSnapshots) {
+    const tableCount = snapshot.tables.length;
+    const viewCount = (_b = (_a = snapshot.views) == null ? void 0 : _a.length) != null ? _b : 0;
+    const fnCount = (_d = (_c = snapshot.functions) == null ? void 0 : _c.length) != null ? _d : 0;
+    const parts = [`${tableCount} tables`];
+    if (viewCount > 0) parts.push(`${viewCount} views`);
+    if (fnCount > 0) parts.push(`${fnCount} functions`);
+    lines.push(`- "${snapshot.name}": ${parts.join(", ")}`);
+  }
+  lines.push("");
+  lines.push(
+    "Use `list_schemas` to see table names, and `get_table_schema` for detailed column/key information."
+  );
+  return lines.join("\n");
+}
+function buildSchemaTableList(schemaSnapshots) {
+  if (!(schemaSnapshots == null ? void 0 : schemaSnapshots.length)) return [];
+  return schemaSnapshots.map((snapshot) => {
+    var _a, _b;
+    return {
+      schemaName: snapshot.name,
+      tables: [...snapshot.tables],
+      views: ((_a = snapshot.views) != null ? _a : []).map((v) => v.name),
+      functions: ((_b = snapshot.functions) != null ? _b : []).map((f) => f.name)
+    };
+  });
+}
+function buildTableSchemaDetail(schemaSnapshots, schemaName, tableName) {
+  var _a, _b, _c, _d;
+  const snapshot = schemaSnapshots == null ? void 0 : schemaSnapshots.find(
+    (s) => s.name.toLowerCase() === schemaName.toLowerCase()
+  );
+  if (!snapshot) {
+    throw new Error(`Schema "${schemaName}" not found.`);
+  }
+  const { tableName: canonicalName, detail } = resolveTableDetail(
+    snapshot,
+    tableName
+  );
+  const pkSet = new Set(((_a = detail.primary_keys) != null ? _a : []).map((k) => k.column));
+  const fkSet = new Set(((_b = detail.foreign_keys) != null ? _b : []).map((k) => k.column));
+  return {
+    schemaName: snapshot.name,
+    tableName: canonicalName,
+    columns: ((_c = detail.columns) != null ? _c : []).map((c) => ({
+      name: c.name,
+      type: c.short_type_name || c.type,
+      isPrimaryKey: pkSet.has(c.name),
+      isForeignKey: fkSet.has(c.name),
+      isNullable: c.is_nullable
+    })),
+    primaryKeys: Array.from(pkSet),
+    foreignKeys: ((_d = detail.foreign_keys) != null ? _d : []).map((fk) => ({
+      column: fk.column,
+      referencedSchema: fk.referenced_table_schema,
+      referencedTable: fk.referenced_table,
+      referencedColumn: fk.referenced_column
+    }))
+  };
+}
 
-function buildAgentSystemPrompt(schemaSnapshots, selectedCommandOptions) {
-  const resolvedSchema = buildSchemaContext(schemaSnapshots);
-  const selectedOptions = (selectedCommandOptions == null ? void 0 : selectedCommandOptions.length) ? getAgentCommandOptionsByIds(selectedCommandOptions) : [];
+function buildAgentSystemPrompt(schemaSnapshots) {
+  const schemaSummary = buildSchemaSummary(schemaSnapshots);
   const sectionIdentity = [
     "# You are Orca Agent.",
     "",
@@ -424,13 +423,25 @@ function buildAgentSystemPrompt(schemaSnapshots, selectedCommandOptions) {
   const sectionAvailableTools = [
     "## Available tools",
     "Use tools whenever they can produce a structured result:",
+    "- `list_schemas` \u2014 discover available schemas and table names (call this first to learn the database structure).",
+    "- `get_table_schema` \u2014 get detailed column, key, and FK info for a specific table.",
     "- `generate_query` \u2014 convert natural language into SQL.",
     "- `render_table` \u2014 execute SQL and show structured rows.",
     "- `export_file` \u2014 package structured rows into CSV, JSON, SQL for download.",
     "- `visualize_table` \u2014 execute read-only SQL and render a bar, line, pie, or scatter chart.",
     "- `describe_table` \u2014 schema introspection (columns, keys, relationships).",
     "- `explain_query` \u2014 performance analysis via EXPLAIN.",
-    "- `detect_anomaly` \u2014 data quality scans (nulls, duplicates, orphan FKs, outliers)."
+    "- `detect_anomaly` \u2014 data quality scans (nulls, duplicates, orphan FKs, outliers).",
+    "- `render_erd` \u2014 generate an ERD diagram showing table relationships (dont use Mermaid when used render_erd tool).",
+    "",
+    "### Mermaid diagrams",
+    "When the user asks for a diagram, flowchart, sequence diagram, class diagram, state diagram, Gantt chart, or any visual explanation, not for ERD diagrams:",
+    "- Respond with a Mermaid code block (```mermaid ... ```) inline in your message.",
+    "- The frontend renders Mermaid automatically \u2014 do NOT describe the syntax, just output the block.",
+    "",
+    "### Mermaid diagrams vs render_erd",
+    "- Use `render_erd` for concrete ERD diagrams that reflect the actual tables, columns, and relationships in the connected database schema.",
+    "- Use Mermaid for abstract diagrams that illustrate concepts, workflows, or relationships that are NOT directly tied to the actual database schema. Examples: flowcharts of decision processes, sequence diagrams of interactions, class diagrams of conceptual entities."
   ].join("\n");
   const sectionConnection = [
     "## Connection",
@@ -489,15 +500,11 @@ function buildAgentSystemPrompt(schemaSnapshots, selectedCommandOptions) {
     '  - After the conversation contains a "[Quiz answers]" message, NEVER call `askClarification` again \u2014 use the answers and proceed fully.',
     "  - Do NOT call `askClarification` to confirm read-only queries \u2014 just execute them."
   ].join("\n");
-  const sectionUserIntent = selectedOptions.length ? [
-    "## Current user intent focus",
-    "The user explicitly selected these tool intents before sending the message:",
-    ...selectedOptions.map((o) => `- ${o.label}: ${o.promptHint}`),
-    "Honor these hints when they fit the request, but do not invent missing information or bypass any approval rule."
-  ].join("\n") : null;
   const sectionSchema = [
-    "## Database schema (always loaded)",
-    resolvedSchema
+    "## Database schema (summary)",
+    "Call `list_schemas` and `get_table_schema` for detailed column information.",
+    "",
+    schemaSummary
   ].join("\n");
   return [
     sectionIdentity,
@@ -507,7 +514,6 @@ function buildAgentSystemPrompt(schemaSnapshots, selectedCommandOptions) {
     sectionMutationQueries,
     sectionRules,
     sectionClarification,
-    ...sectionUserIntent ? [sectionUserIntent] : [],
     sectionSchema
   ].join("\n\n");
 }
@@ -523,6 +529,12 @@ const AgentToolName = {
   ExportQueryResult: "export_query_result",
   /** Exports free-form text (notes, scripts, docs) directly to a file */
   ExportContent: "export_content",
+  /** Lists available schemas with table names (lightweight) */
+  ListSchemas: "list_schemas",
+  /** Returns detailed column/key info for a specific table */
+  GetTableSchema: "get_table_schema",
+  /** Renders an ERD diagram for selected tables */
+  RenderErd: "render_erd",
   AskClarification: "askClarification"
 };
 
@@ -1142,13 +1154,22 @@ function resolveActiveTools(adapter, schemaSnapshots) {
       AgentToolName.ExportContent,
       AgentToolName.VisualizeTable,
       AgentToolName.ExplainQuery,
-      ...hasSnapshot ? [AgentToolName.DetectAnomaly, AgentToolName.DescribeTable] : [],
+      ...hasSnapshot ? [
+        AgentToolName.DetectAnomaly,
+        AgentToolName.DescribeTable,
+        AgentToolName.ListSchemas,
+        AgentToolName.GetTableSchema,
+        AgentToolName.RenderErd
+      ] : [],
       AgentToolName.AskClarification
     ];
   }
   return hasSnapshot ? [
     AgentToolName.GenerateQuery,
     AgentToolName.DescribeTable,
+    AgentToolName.ListSchemas,
+    AgentToolName.GetTableSchema,
+    AgentToolName.RenderErd,
     AgentToolName.ExportContent,
     AgentToolName.AskClarification
   ] : [
@@ -1523,10 +1544,162 @@ ${input.schema || resolvedSchemaContext}`,
         ).min(1).max(5)
       }),
       execute: async () => ({ acknowledged: true })
+    }),
+    list_schemas: tool({
+      description: "List all available database schemas with their table, view, and function names. Use this to discover what tables exist before calling get_table_schema or generate_query.",
+      inputSchema: z.object({}),
+      execute: async () => {
+        return {
+          schemas: buildSchemaTableList(schemaSnapshots)
+        };
+      }
+    }),
+    get_table_schema: tool({
+      description: "Get detailed column, primary key, and foreign key information for a specific table. Use this before generate_query when you need to know column names and types.",
+      inputSchema: z.object({
+        schemaName: z.string().min(1).describe('The schema name, e.g. "public"'),
+        tableName: z.string().min(1).describe("The table name")
+      }),
+      execute: async (input) => {
+        return buildTableSchemaDetail(
+          schemaSnapshots,
+          input.schemaName,
+          input.tableName
+        );
+      }
+    }),
+    render_erd: tool({
+      description: "Generate an ERD (Entity Relationship Diagram) showing tables, their columns, and foreign key relationships. Use this when the user asks to visualize or draw table relationships, schema diagrams, or ERD.",
+      inputSchema: z.object({
+        tableNames: z.array(z.string().min(1)).min(1).max(20).describe("Table names to include in the ERD"),
+        schemaName: z.string().min(1).describe('The schema name, e.g. "public"')
+      }),
+      execute: async (input) => {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const snapshot = findSnapshotForTable(
+          schemaSnapshots,
+          input.schemaName
+        );
+        if (!(snapshot == null ? void 0 : snapshot.tableDetails)) {
+          throw new Error(
+            "Schema metadata is not available for ERD rendering."
+          );
+        }
+        const nodes = [];
+        const edges = [];
+        const includedTableIds = /* @__PURE__ */ new Set();
+        for (const requestedTable of input.tableNames) {
+          const { tableName, detail } = resolveTableDetail(
+            snapshot,
+            requestedTable
+          );
+          const tableId = `${snapshot.name}.${tableName}`;
+          if (includedTableIds.has(tableId)) continue;
+          includedTableIds.add(tableId);
+          const pkSet = new Set(((_a = detail.primary_keys) != null ? _a : []).map((k) => k.column));
+          const fkSet = new Set(((_b = detail.foreign_keys) != null ? _b : []).map((k) => k.column));
+          nodes.push({
+            id: tableId,
+            tableName,
+            schemaName: snapshot.name,
+            columns: ((_c = detail.columns) != null ? _c : []).map((c) => ({
+              name: c.name,
+              type: c.short_type_name || c.type,
+              isPrimaryKey: pkSet.has(c.name),
+              isForeignKey: fkSet.has(c.name)
+            }))
+          });
+          for (const fk of (_d = detail.foreign_keys) != null ? _d : []) {
+            const targetId = `${fk.referenced_table_schema}.${fk.referenced_table}`;
+            edges.push({
+              id: `${tableId}.${fk.column}->${targetId}.${fk.referenced_column}`,
+              source: tableId,
+              target: targetId,
+              sourceColumn: fk.column,
+              targetColumn: fk.referenced_column
+            });
+            if (!includedTableIds.has(targetId)) {
+              try {
+                const refSnapshot = findSnapshotForTable(
+                  schemaSnapshots,
+                  fk.referenced_table_schema
+                );
+                const { tableName: refTableName, detail: refDetail } = resolveTableDetail(refSnapshot, fk.referenced_table);
+                const refPkSet = new Set(
+                  ((_e = refDetail.primary_keys) != null ? _e : []).map((k) => k.column)
+                );
+                const refFkSet = new Set(
+                  ((_f = refDetail.foreign_keys) != null ? _f : []).map((k) => k.column)
+                );
+                includedTableIds.add(targetId);
+                nodes.push({
+                  id: targetId,
+                  tableName: refTableName,
+                  schemaName: fk.referenced_table_schema,
+                  columns: ((_g = refDetail.columns) != null ? _g : []).map((c) => ({
+                    name: c.name,
+                    type: c.short_type_name || c.type,
+                    isPrimaryKey: refPkSet.has(c.name),
+                    isForeignKey: refFkSet.has(c.name)
+                  }))
+                });
+              } catch {
+              }
+            }
+          }
+        }
+        return { nodes, edges };
+      }
     })
   };
 }
 
+const LARGE_OUTPUT_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "export_query_result",
+  "export_content",
+  "render_table"
+]);
+function filterLargeToolOutputs(messages) {
+  return messages.map((message) => {
+    if (message.role !== "assistant" || !Array.isArray(message.parts)) {
+      return message;
+    }
+    const filteredParts = message.parts.map((part) => {
+      const toolName = String(part.type || "").replace(/^tool-/, "");
+      if (!LARGE_OUTPUT_TOOL_NAMES.has(toolName) || part.state !== "output-available" || !part.output) {
+        return part;
+      }
+      if (toolName === "export_query_result" || toolName === "export_content") {
+        return {
+          ...part,
+          output: {
+            filename: part.output.filename,
+            format: part.output.format,
+            fileSize: part.output.fileSize,
+            mimeType: part.output.mimeType,
+            content: "[exported \u2014 content omitted from context]",
+            encoding: part.output.encoding,
+            preview: { columns: [], rows: [], truncated: true }
+          }
+        };
+      }
+      if (toolName === "render_table") {
+        return {
+          ...part,
+          output: {
+            sql: part.output.sql,
+            columns: part.output.columns,
+            rows: [],
+            rowCount: part.output.rowCount,
+            truncated: true
+          }
+        };
+      }
+      return part;
+    });
+    return { ...message, parts: filteredParts };
+  });
+}
 function resolveDialect(body) {
   if (body.dialect) {
     return body.dialect;
@@ -1560,7 +1733,6 @@ const agent = defineEventHandler(async (event) => {
     apiKey,
     messages,
     dbConnectionString,
-    selectedCommandOptions,
     sendReasoning
   } = body;
   const dialect = resolveDialect(body);
@@ -1592,10 +1764,7 @@ const agent = defineEventHandler(async (event) => {
     });
     const agent = new ToolLoopAgent({
       model: providerModel,
-      instructions: buildAgentSystemPrompt(
-        schemaSnapshots,
-        selectedCommandOptions
-      ),
+      instructions: buildAgentSystemPrompt(schemaSnapshots),
       tools,
       stopWhen: ({ steps }) => steps.some(
         (s) => {
@@ -1609,7 +1778,7 @@ const agent = defineEventHandler(async (event) => {
     });
     return await createAgentUIStreamResponse({
       agent,
-      uiMessages: messages || [],
+      uiMessages: filterLargeToolOutputs(messages || []),
       sendReasoning: sendReasoning != null ? sendReasoning : true,
       experimental_transform: smoothStream(),
       sendSources: true