Files
dbx/apps/desktop/src/lib/ai/aiAgentPlan.ts
T
Abeautifulsnow 8539011f25 feat(ai): split Ask/Agent action menus with task-oriented Agent actions
* feat(ai): add task-oriented Agent actions with per-action contract

Introduce three Agent-native actions — query, exploreSchema,
executeAndExplain — so Agent mode surfaces task-oriented operations
instead of reusing Ask's SQL-producing action set.

- ai.ts: extend AiAction with the new actions; add ASK_ACTIONS /
  AGENT_ACTIONS and defaultActionForMode / isValidActionForMode
  helpers; raise maxTokens for the explanatory task actions.
- aiSkills.ts: add skill definitions (zh/en) for the three actions.
- aiAgentPlan.ts: task actions no longer emit a misleading
  "unsupported_action" execute step; they execute via the
  execute_query tool events, not the legacy client-side path.
- agent_loop.rs: per-action task-contract rules in both the prompt
  augmentation and repair paths (query -> execute & answer from real
  data; exploreSchema -> list_tables/get_columns; executeAndExplain
  -> run current SQL & explain).
- i18n (en/zh-CN/zh-TW): new action labels, placeholders, a
  generateNoExec label for Agent mode, and a task-oriented agent
  modeHint.

es/it/ja/pt-BR have no `ai` section and fall back to `en`, matching
existing coverage.

* feat(ai): split Ask/Agent action menus with mode-aware defaults

Wire the new Agent task actions into the assistant UI so each mode
shows a distinct, intent-matching action set.

- actionButtons is now a computed returning Ask or Agent buttons
  based on assistantMode. Agent menu: query / exploreSchema /
  executeAndExplain / generate (labeled "生成但不执行" via
  generateNoExec). Ask menu is unchanged.
- Switching mode lands on that mode's default (Ask -> generate,
  Agent -> query); the shared `generate` is not carried across
  because its label/semantics differ per mode. Vector DBs stay on
  `generate` since their action menu is hidden and they lack SQL
  tools (no execute_query contract).
- External Ask-style triggers (Fix with AI, Explain history) switch
  to Ask mode when invoked from Agent mode so the action is valid
  and the menu reflects what runs.
- Reset the active action to the mode default after each send.

* test(ai): cover Agent task-action contract and mode/action mapping

Lock in the deterministic parts of the Ask/Agent split so only the
LLM-behavior criteria need manual verification.

Backend (agent_loop.rs):
- query contract instructs the LLM to call execute_query and is not
  treated as a SQL-producing action.
- exploreSchema contract points to list_tables/get_columns and says
  not to execute data queries.
- executeAndExplain contract tells the LLM to run the current SQL.
- task actions do not require a SQL deliverable (a conclusion without
  a fenced SQL block still satisfies the contract).
- query repair prompt also targets execute_query.

Frontend (aiActions.spec.ts):
- defaultActionForMode: Ask -> generate, Agent -> query (not generate).
- isValidActionForMode: generate valid in both; Ask-only actions
  rejected in Agent mode and vice versa.
- ASK_ACTIONS / AGENT_ACTIONS composition (Agent menu starts with
  query and still offers generate).

* fix(ai): correct action menu on mode-switched triggers and i18n gaps

Issues found during review of the Ask/Agent action split:

- [#I01] triggerAction (Fix with AI / Explain history) invoked from
  Agent mode switched to Ask and set the action, but the mode-switch
  watch then reset activeAction to the Ask default ("generate"),
  overwriting the action just set — so the menu showed "Generate SQL"
  during a fix. Add a suppressModeActionReset flag so programmatic
  mode switches don't clobber the explicitly-set action.
- [#C01] Remove dead `unsupported_action` reason: buildAiAgentPlan no
  longer produces it, so drop the type variant and the unreachable
  skippedTitleKey case.
- [#I02] es/it/ja/pt-BR were missing the new Agent action keys
  (query/exploreSchema/executeAndExplain/generateNoExec) and their
  placeholders, causing English fallback in the Agent menu. Add the
  translations to match each locale's existing style.

* test(ai): align app-tests with task-action split

- aiSkills: add query/exploreSchema/executeAndExplain to the expected
  action set; broaden the id check (new ids are not _sql-suffixed) and
  relax the userInstruction assertion (schema inspection need not mention SQL).
- aiAgentPlan: drop the unsupported_action skipped step for non-generate
  actions (#C01 removed it from the plan and the reason union); add coverage
  for task-oriented Agent actions not driving client-side execution.

* test(ai): pin locale in dialect prompt spec

buildSystemPrompt selects zh/en copy via currentLocale(), which reflects the
host navigator.language. The spec asserts English strings, so it failed on
zh-CN machines (e.g. Windows with a Chinese system locale) while passing on
CI's en-US runners. Pin the locale to en in beforeAll so the assertions are
deterministic regardless of the host OS locale.
2026-07-06 14:41:39 +08:00

88 lines
2.9 KiB
TypeScript

import type { AiAction, AiAssistantMode } from "@/lib/ai/ai";
import { classifyAiSqlExecution, shouldAttemptAiAutoExecute, stripAiSqlComments, type AiSqlExecutionDecision } from "@/lib/ai/aiSqlExecutionPolicy";
import type { ConnectionConfig } from "@/types/database";
export type AiAgentStep =
| { kind: "generate_sql"; status: "done"; sql: string }
| { kind: "generate_sql"; status: "skipped"; reason: "no_sql" }
| ({
kind: "risk_check";
status: "done";
} & AiSqlExecutionDecision)
| { kind: "execute_sql"; status: "pending"; sql: string }
| {
kind: "execute_sql";
status: "skipped";
reason: "ask_mode" | "no_sql" | "no_execution_intent" | "blocked_by_policy" | "requires_confirmation";
};
export interface AiAgentPlanInput {
mode: AiAssistantMode;
action: AiAction;
instruction: string;
assistantContent: string;
connection?: ConnectionConfig;
}
export interface AiAgentPlan {
steps: AiAgentStep[];
executableSql?: string;
handoffSql?: string;
}
export function buildAiAgentPlan(input: AiAgentPlanInput): AiAgentPlan {
const sql = extractFirstExecutableSqlCodeBlock(input.assistantContent);
if (!sql) {
return {
steps: [
{ kind: "generate_sql", status: "skipped", reason: "no_sql" },
{ kind: "execute_sql", status: "skipped", reason: "no_sql" },
],
};
}
const steps: AiAgentStep[] = [{ kind: "generate_sql", status: "done", sql }];
if (input.mode !== "agent") {
steps.push({ kind: "execute_sql", status: "skipped", reason: "ask_mode" });
return { steps };
}
// Task-oriented Agent actions (query / exploreSchema / executeAndExplain) execute via the
// execute_query tool, surfaced through real-time tool-call events — not via this legacy
// client-side auto-execute path. Only render the generated SQL; do not drive client-side
// execution for these actions.
if (input.action !== "generate") {
return { steps };
}
if (!shouldAttemptAiAutoExecute(input.instruction, input.action)) {
steps.push({ kind: "execute_sql", status: "skipped", reason: "no_execution_intent" });
return { steps };
}
const decision = classifyAiSqlExecution(sql, input.connection);
steps.push({ kind: "risk_check", status: "done", ...decision });
if (decision.action === "auto_execute") {
steps.push({ kind: "execute_sql", status: "pending", sql });
return { steps, executableSql: sql, handoffSql: sql };
}
steps.push({
kind: "execute_sql",
status: "skipped",
reason: decision.action === "block" ? "blocked_by_policy" : "requires_confirmation",
});
return { steps, handoffSql: sql };
}
function extractFirstExecutableSqlCodeBlock(content: string): string | undefined {
const blocks = content.matchAll(/```(?:sql|mysql|postgresql|sqlite|tsql|clickhouse)?\s*\n([\s\S]*?)```/gi);
for (const block of blocks) {
const sql = block[1]?.trim();
if (sql && stripAiSqlComments(sql).trim()) return sql;
}
return undefined;
}