@shwfed/config 2.0.0 → 2.0.1

package/dist/runtime/components/table/ai/columns-button.vue

@@ -0,0 +1,491 @@
+<script setup>
+import { celCheck as $celCheck } from "../../../utils/cel";
+import { Icon } from "@iconify/vue";
+import { Either, ParseResult, Schema } from "effect";
+import { computed, ref } from "vue";
+import { toast } from "vue-sonner";
+import ShwfedModal from "../../modal.vue";
+import { Button } from "../../ui/button";
+import { InputGroupButton } from "../../ui/input-group";
+import { Markdown } from "../../ui/markdown";
+import { Textarea } from "../../ui/textarea";
+import { Tooltip, TooltipContent, TooltipTrigger } from "../../ui/tooltip";
+import { composeCelPrompt } from "../../../utils/ai/cel-prompt";
+import { StructuredOutputDecodeError, ai as $ai } from "../../../utils/ai";
+import { COLUMNS, findColumn } from "../utils/resolve";
+import TASK from "./columns-task.md?raw";
+defineOptions({ name: "ShwfedTableAiColumnsButton" });
+const props = defineProps({
+  dataSource: { type: Object, required: false },
+  columns: { type: Array, required: false }
+});
+const emit = defineEmits(["apply"]);
+const LocaleEntry = Schema.Struct({
+  locale: Schema.String,
+  message: Schema.String
+}).annotations({ identifier: "LocaleEntry" });
+const ColumnDraft = Schema.Struct({
+  id: Schema.optional(Schema.String).annotations({
+    description: "Stable column id. Reuse the existing id when the described column clearly maps onto an existing one (pinning state references it). For brand-new columns, call the `gen_uuid` tool to obtain a fresh id \u2014 do NOT invent UUIDs yourself. (If omitted entirely the host mints a fallback UUID, but always prefer `gen_uuid`.)"
+  }),
+  type: Schema.String.annotations({
+    description: 'Column type \u2014 must match a `type` listed under "Available column types" in the system prompt.'
+  }),
+  compatibilityDate: Schema.String.annotations({
+    description: "Compatibility date for the column type \u2014 copy verbatim from the matching registry entry."
+  }),
+  groupId: Schema.optional(Schema.String),
+  title: Schema.optional(Schema.Array(LocaleEntry)).annotations({
+    description: 'Localized column title, e.g. [{"locale":"zh","message":"\u59D3\u540D"}].'
+  }),
+  accessor: Schema.optional(Schema.String).annotations({
+    description: "CEL expression returning the cell value. Bound variables: row (dyn), index (number), id (string)."
+  }),
+  size: Schema.optional(Schema.Number),
+  grow: Schema.optional(Schema.Boolean),
+  enableSorting: Schema.optional(Schema.Boolean),
+  align: Schema.optional(Schema.String),
+  tooltip: Schema.optional(Schema.Array(LocaleEntry)),
+  copyExpression: Schema.optional(Schema.String).annotations({
+    description: "CEL expression returning a string to copy on click."
+  }),
+  displayMode: Schema.optional(Schema.String),
+  preserveMode: Schema.optional(Schema.String),
+  preserveDigits: Schema.optional(Schema.Number),
+  format: Schema.optional(Schema.String),
+  color: Schema.optional(Schema.String),
+  mode: Schema.optional(Schema.String),
+  crossPage: Schema.optional(Schema.Boolean),
+  enableRowSelection: Schema.optional(Schema.String),
+  enableMultiRowSelection: Schema.optional(Schema.String),
+  markdown: Schema.optional(Schema.Array(LocaleEntry)).annotations({
+    description: "Localized markdown body with {{ CEL }} interpolations bound to row/index/id."
+  })
+});
+const ColumnsDraft = Schema.Struct({
+  columns: Schema.Array(ColumnDraft).annotations({
+    description: "FULL replacement for the columns array. Emit every column the user described, in render order. The host does NOT merge with the previous configuration \u2014 columns you omit are removed."
+  })
+});
+const ROW_SCOPE = {
+  row: { type: "dyn", label: "\u5F53\u524D\u884C", description: "\u5F53\u524D\u6E32\u67D3\u7684\u6574\u884C\u6570\u636E\uFF1B\u7C7B\u578B\u5728\u914D\u7F6E\u65F6\u672A\u77E5\uFF08dyn\uFF09", value: void 0 },
+  index: { type: "number", label: "\u884C\u5E8F\u53F7", description: "\u5F53\u524D\u884C\u5728\u6240\u6709\u6570\u636E\u4E2D\u7684\u5E8F\u53F7\uFF0C\u4ECE 0 \u5F00\u59CB", value: 0 },
+  id: { type: "string", label: "\u5217 ID", description: "\u5F53\u524D\u5355\u5143\u683C\u6240\u5728\u5217\u7684 id", value: "" }
+};
+const PROHIBITED_TYPE = "com.shwfed.table.column.actions";
+const REQUIRES_EXPLICIT_TYPE = "com.shwfed.table.column.markdown";
+function renderRegisterables() {
+  const lines = [];
+  lines.push("# Available column types");
+  lines.push("");
+  for (const entry of COLUMNS) {
+    if (entry.type === PROHIBITED_TYPE) continue;
+    const fields = describeColumnFields(entry.type);
+    lines.push(`## \`${entry.type}\` (compatibilityDate \`${entry.compatibilityDate}\`)`);
+    lines.push("");
+    lines.push(`Renders: ${entry.metadata.name}.`);
+    if (entry.type === REQUIRES_EXPLICIT_TYPE) {
+      lines.push("");
+      lines.push("**Only emit this when the user explicitly asks for markdown / rich content / formatted body / \u5BCC\u6587\u672C.**");
+    }
+    lines.push("");
+    lines.push(fields);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function describeColumnFields(type) {
+  const common = [
+    "- `id` (string, recommended): stable column id; reuse the existing id when the described column maps onto an existing one.",
+    '- `title` (locale array): `[{ "locale": "zh", "message": "..." }]`.',
+    "- `accessor` (CEL string): expression returning the cell value, given `row`, `index`, `id`.",
+    "- `size` (number, optional), `grow` (bool, optional), `enableSorting` (bool, optional).",
+    "- `tooltip` (locale array, optional), `copyExpression` (CEL string, optional).",
+    '- `align`: one of `"left" | "center" | "right"`.'
+  ];
+  switch (type) {
+    case "com.shwfed.table.column.text":
+      return [
+        ...common,
+        '- `displayMode`: `"plain"` (default) or `"mono"` for monospace.'
+      ].join("\n");
+    case "com.shwfed.table.column.number":
+      return [
+        ...common,
+        '- `displayMode`: `"plain"` | `"uppercaseChinese"` | `"monoThousand"`.',
+        '- `preserveMode` (optional): `"round" | "floor" | "ceil"`.',
+        "- `preserveDigits` (optional, non-negative integer)."
+      ].join("\n");
+    case "com.shwfed.table.column.date":
+      return [
+        ...common,
+        '- `format` (string, required): Unicode date pattern, e.g. `"yyyy-MM-dd"` or `"yyyy-MM-dd HH:mm:ss"`.'
+      ].join("\n");
+    case "com.shwfed.table.column.icon":
+      return [
+        ...common,
+        "- `accessor`: CEL returning an Iconify identifier (e.g. `row.iconName`).",
+        "- `color` (CEL string, optional): expression returning a CSS color."
+      ].join("\n");
+    case "com.shwfed.table.column.select":
+      return [
+        "- `id` (string, recommended).",
+        '- `mode`: `"radio"` (single) or `"checkbox"` (default, multi).',
+        "- `crossPage` (bool, optional): remember selection across pages.",
+        "- `enableRowSelection` / `enableMultiRowSelection` (CEL string, optional): predicates over `row`/`index` returning bool.",
+        "- No `accessor` / `title` \u2014 selection is rendered with a checkbox header."
+      ].join("\n");
+    case "com.shwfed.table.column.markdown":
+      return [
+        "- `id` (string, recommended).",
+        "- `title` (locale array): column header.",
+        "- `markdown` (locale array, required): body content per locale; supports `{{ CEL }}` interpolation referencing `row`, `index`, `id`.",
+        "- `size` / `grow` / `tooltip` / `copyExpression`: same as common.",
+        "- No `accessor` (rendered content comes from `markdown`)."
+      ].join("\n");
+    default:
+      return common.join("\n");
+  }
+}
+const open = ref(false);
+const context = ref("");
+const submitting = ref(false);
+const tick = ref(0);
+const description = [
+  "\u63CF\u8FF0\u4F60\u60F3\u8981\u7684**\u5B8C\u6574\u5217\u5E03\u5C40**\uFF0C\u53EF\u9644\u793A\u4F8B\u54CD\u5E94\u3001\u5B57\u6BB5\u542B\u4E49\u6216 PRD\u3002",
+  "",
+  "AI \u4F1A**\u6574\u5217\u66FF\u6362**\u5F53\u524D\u7684\u5217\u914D\u7F6E \u2014 \u672A\u5728\u63CF\u8FF0\u4E2D\u63D0\u5230\u7684\u5217\u4F1A\u88AB\u79FB\u9664\uFF0C\u8BF7\u628A\u6240\u6709\u9700\u8981\u4FDD\u7559\u7684\u5217\u4E5F\u4E00\u5E76\u63CF\u8FF0\u51FA\u6765\u3002"
+].join("\n");
+const canSubmit = computed(() => !submitting.value && context.value.trim().length > 0);
+function onTrigger() {
+  open.value = true;
+}
+const CEL_FIELDS_BY_TYPE = {
+  "com.shwfed.table.column.text": ["accessor", "copyExpression"],
+  "com.shwfed.table.column.number": ["accessor", "copyExpression"],
+  "com.shwfed.table.column.date": ["accessor", "copyExpression"],
+  "com.shwfed.table.column.icon": ["accessor", "color"],
+  "com.shwfed.table.column.select": ["enableRowSelection", "enableMultiRowSelection"],
+  "com.shwfed.table.column.markdown": ["copyExpression"]
+};
+function checkCelString(expr) {
+  if (typeof expr !== "string" || expr.trim() === "") return null;
+  const checked = $celCheck(expr);
+  if (Either.isLeft(checked)) {
+    return checked.left instanceof Error ? checked.left.message : String(checked.left);
+  }
+  return null;
+}
+function collectErrors(cols) {
+  const out = [];
+  cols.forEach((col, i) => {
+    const prefix = `columns[${i}]`;
+    if (col.type === PROHIBITED_TYPE) {
+      out.push({
+        path: prefix,
+        message: `Column type "${PROHIBITED_TYPE}" is prohibited. Drop this column entirely \u2014 action columns are wired by a separate registry.`
+      });
+      return;
+    }
+    const entry = findColumn(col.type, col.compatibilityDate);
+    if (!entry) {
+      out.push({
+        path: `${prefix}.type`,
+        message: `Unknown column type "${col.type}@${col.compatibilityDate}". Use one of the registered types listed in the system prompt.`
+      });
+      return;
+    }
+    const perTypeSchema = entry.schema(() => {
+    });
+    const decoded = Schema.decodeUnknownEither(perTypeSchema)(col);
+    if (Either.isLeft(decoded)) {
+      const issues = ParseResult.ArrayFormatter.formatErrorSync(decoded.left);
+      for (const issue of issues) {
+        const sub = issue.path.map(String).join(".");
+        out.push({
+          path: sub ? `${prefix}.${sub}` : prefix,
+          message: issue.message
+        });
+      }
+    }
+    for (const field of CEL_FIELDS_BY_TYPE[col.type] ?? []) {
+      const msg = checkCelString(col[field]);
+      if (msg) out.push({ path: `${prefix}.${field}`, message: msg });
+    }
+  });
+  return out;
+}
+function buildRetryFeedback(errors) {
+  const lines = errors.map(({ path, message }) => `- \`${path}\`: ${message}`);
+  return [
+    "The previous output failed validation. Fix only the listed paths and return the corrected object \u2014 keep the other fields identical.",
+    "",
+    "Reminders:",
+    `- NEVER emit a column with type "${PROHIBITED_TYPE}".`,
+    `- ONLY emit a column with type "${REQUIRES_EXPLICIT_TYPE}" when the user explicitly asks for markdown / rich content.`,
+    "- The `columns` array is a full replacement; emit every column the user described.",
+    "",
+    "Errors:",
+    ...lines
+  ].join("\n");
+}
+function buildShapeFeedback(message) {
+  return [
+    "The previous output did not match the required JSON shape. Re-emit the structured output, this time matching the schema exactly. The output must be a JSON object with a required `columns` array. Each column needs at minimum `type` and `compatibilityDate`.",
+    "",
+    "Decoder error:",
+    message
+  ].join("\n");
+}
+function tryUnwrap(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const entries = Object.entries(raw);
+  if (entries.length !== 1) return null;
+  const [, inner] = entries[0];
+  let candidate = inner;
+  if (typeof candidate === "string") {
+    try {
+      candidate = JSON.parse(candidate);
+    } catch {
+      return null;
+    }
+  }
+  if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) return null;
+  if (!("columns" in candidate)) return null;
+  return candidate;
+}
+const genUuidTool = {
+  name: "gen_uuid",
+  description: "Generate a fresh RFC 4122 UUID string. Call this whenever you need an `id` for a new column. Returns the UUID directly as a plain string \u2014 use the returned value verbatim. Never invent UUIDs yourself; call this tool instead.",
+  inputJsonSchema: { type: "object", properties: {}, additionalProperties: false },
+  execute: () => crypto.randomUUID()
+};
+async function callModel(prompt, system, retry) {
+  try {
+    const value = await $ai.generateObject({
+      prompt,
+      system,
+      schema: ColumnsDraft,
+      objectName: "columns",
+      tools: [genUuidTool],
+      ...retry ? { retry } : {},
+      onProgress: () => {
+        tick.value++;
+      }
+    });
+    const errors = collectErrors(value.columns);
+    if (errors.length > 0) {
+      return { kind: "retry", previousOutput: value, feedback: buildRetryFeedback(errors) };
+    }
+    return { kind: "ok", value };
+  } catch (err) {
+    if (err instanceof StructuredOutputDecodeError) {
+      const unwrapped = tryUnwrap(err.rawOutput);
+      if (unwrapped !== null) {
+        const decoded = Schema.decodeUnknownEither(ColumnsDraft)(unwrapped);
+        if (Either.isRight(decoded)) {
+          const value = decoded.right;
+          const errors = collectErrors(value.columns);
+          if (errors.length === 0) return { kind: "ok", value };
+          return { kind: "retry", previousOutput: value, feedback: buildRetryFeedback(errors) };
+        }
+      }
+      return { kind: "retry", previousOutput: err.rawOutput, feedback: buildShapeFeedback(err.message) };
+    }
+    throw err;
+  }
+}
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function sanitizeColumn(col) {
+  const raw = {};
+  for (const [k, v] of Object.entries(col)) {
+    if (v === void 0) continue;
+    if (typeof v === "string" && v.trim() === "") continue;
+    raw[k] = v;
+  }
+  const incomingId = typeof raw.id === "string" ? raw.id : void 0;
+  raw.id = incomingId && UUID_RE.test(incomingId) ? incomingId : crypto.randomUUID();
+  return raw;
+}
+function buildEmit(value) {
+  return value.columns.filter((c) => c.type !== PROHIBITED_TYPE).map((c) => sanitizeColumn(c));
+}
+function buildUserPrompt() {
+  return [
+    context.value.trim(),
+    "",
+    "# Current configuration",
+    "",
+    "```json",
+    // Knowing the data source informs row shape; knowing the existing columns
+    // lets the model reuse stable ids where the described layout corresponds.
+    JSON.stringify({
+      dataSource: props.dataSource ?? null,
+      columns: props.columns ?? []
+    }, null, 2),
+    "```"
+  ].join("\n");
+}
+async function onSubmit() {
+  if (!canSubmit.value) return;
+  submitting.value = true;
+  tick.value = 0;
+  try {
+    const baseSystem = composeCelPrompt({
+      scope: [
+        { name: "\u5217\u5185 CEL \u5B57\u6BB5\uFF08\u5982 `accessor`, `copyExpression`, `color`, `enableRowSelection` \u7B49\uFF09\u53EF\u7528\u53D8\u91CF", context: ROW_SCOPE }
+      ],
+      task: TASK
+    });
+    const system = `${baseSystem}
+
+${renderRegisterables()}`;
+    const prompt = buildUserPrompt();
+    let outcome = await callModel(prompt, system);
+    if (outcome.kind === "retry") {
+      tick.value = 0;
+      outcome = await callModel(prompt, system, {
+        previousOutput: outcome.previousOutput,
+        feedback: outcome.feedback
+      });
+    }
+    if (outcome.kind === "ok") {
+      const cols = buildEmit(outcome.value);
+      if (cols.length > 0) {
+        emit("apply", cols);
+        toast.success("\u5DF2\u6839\u636E\u63CF\u8FF0\u751F\u6210\u5217");
+      } else {
+        toast.message("AI \u672A\u8FD4\u56DE\u4EFB\u4F55\u53EF\u5E94\u7528\u7684\u5217");
+      }
+      open.value = false;
+      context.value = "";
+      return;
+    }
+    const last = outcome.previousOutput;
+    const candidate = last && typeof last === "object" ? last : null;
+    const usable = candidate && "columns" in candidate ? candidate : tryUnwrap(last);
+    if (usable && typeof usable === "object" && Array.isArray(usable.columns)) {
+      const cols = buildEmit(usable);
+      if (cols.length > 0) {
+        emit("apply", cols);
+        toast.message("AI \u8F93\u51FA\u672A\u901A\u8FC7\u6821\u9A8C\uFF0C\u5DF2\u5E94\u7528\u53EF\u89E3\u6790\u7684\u90E8\u5206\uFF0C\u8BF7\u68C0\u67E5");
+        open.value = false;
+        context.value = "";
+        return;
+      }
+    }
+    toast.error("AI \u751F\u6210\u5931\u8D25", { description: "\u6A21\u578B\u672A\u8FD4\u56DE\u53EF\u5E94\u7528\u7684\u5217\uFF0C\u8BF7\u8C03\u6574\u63CF\u8FF0\u540E\u91CD\u8BD5" });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    toast.error("AI \u751F\u6210\u5931\u8D25", { description: message });
+  } finally {
+    submitting.value = false;
+  }
+}
+</script>
+
+<template>
+  <Tooltip :delay-duration="180">
+    <TooltipTrigger as-child>
+      <InputGroupButton
+        size="icon-xs"
+        variant="ghost"
+        as-child
+      >
+        <button
+          type="button"
+          :disabled="submitting"
+          class="-ml-4"
+          @click="onTrigger"
+        >
+          <Icon
+            icon="fluent:magic-wand-20-regular"
+            class="size-4"
+          />
+        </button>
+      </InputGroupButton>
+    </TooltipTrigger>
+    <TooltipContent side="top">
+      AI 生成列
+    </TooltipContent>
+  </Tooltip>
+
+  <ShwfedModal
+    v-model:open="open"
+    content-width="48rem"
+    :dismissible="!submitting"
+  >
+    <template #title>
+      <span class="flex items-center gap-2">
+        <Icon
+          icon="fluent:magic-wand-20-regular"
+          class="size-5"
+        />
+        AI 生成列
+      </span>
+    </template>
+    <template #description>
+      <Markdown
+        :source="description"
+        block
+        class="prose prose-sm prose-zinc max-w-none"
+      />
+    </template>
+
+    <form
+      class="flex flex-col gap-2 py-2"
+      @submit.prevent="onSubmit"
+    >
+      <Textarea
+        v-model="context"
+        placeholder="任意上下文，建议包含：&#10;- 想要的列：例如「显示姓名、邮箱、注册时间」&#10;- 字段含义或示例响应（JSON）&#10;- 列宽 / 对齐 / 复制等额外要求"
+        wrap="soft"
+        class="field-sizing-fixed h-72 max-h-[60vh] resize-none overflow-auto break-all whitespace-pre-wrap font-mono text-xs"
+        :disabled="submitting"
+      />
+    </form>
+
+    <template #footer>
+      <div class="flex items-center gap-2">
+        <div
+          v-if="submitting"
+          class="mr-auto flex items-center gap-2 text-xs text-muted-foreground"
+          aria-live="polite"
+        >
+          <span
+            :key="tick"
+            class="ai-progress-dot"
+            :class="tick > 0 ? 'is-streaming' : 'is-waiting'"
+          />
+          <span>{{ tick > 0 ? "\u6B63\u5728\u63A5\u6536\u6A21\u578B\u8F93\u51FA\u2026" : "\u6B63\u5728\u8BF7\u6C42\u6A21\u578B\u2026" }}</span>
+        </div>
+        <Button
+          type="button"
+          size="sm"
+          :disabled="submitting"
+          @click="open = false"
+        >
+          <Icon icon="fluent:dismiss-20-regular" />
+          取消
+        </Button>
+        <Button
+          type="button"
+          variant="primary"
+          size="sm"
+          :disabled="!canSubmit"
+          @click="onSubmit"
+        >
+          <Icon
+            :icon="submitting ? 'fluent:arrow-sync-20-regular' : 'fluent:sparkle-20-regular'"
+            :class="submitting ? 'animate-spin' : ''"
+          />
+          生成
+        </Button>
+      </div>
+    </template>
+  </ShwfedModal>
+</template>
+
+<style scoped>
+.ai-progress-dot{background-color:var(--primary,currentColor);border-radius:9999px;display:inline-block;height:.5rem;width:.5rem}.ai-progress-dot.is-waiting{animation:ai-progress-waiting 1.2s ease-in-out infinite}.ai-progress-dot.is-streaming{animation:ai-progress-kick .32s ease-out}@keyframes ai-progress-waiting{0%,to{opacity:.35;transform:scale(1)}50%{opacity:1;transform:scale(1.15)}}@keyframes ai-progress-kick{0%{opacity:1;transform:scale(1.6)}to{opacity:.7;transform:scale(1)}}
+</style>

package/dist/runtime/components/table/ai/columns-button.vue.d.ts

@@ -0,0 +1,12 @@
+type AnyRecord = Record<string, any>;
+type __VLS_Props = {
+    dataSource?: AnyRecord;
+    columns?: ReadonlyArray<AnyRecord>;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    apply: (value: AnyRecord[]) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onApply?: ((value: AnyRecord[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/table/ai/columns-task.md

@@ -0,0 +1,44 @@
+Generate the **full columns array** for a table from the user's free-form description. The output is a single struct with one required field: `columns` — an array of column objects in render order.
+
+The `columns` array is a **full replacement**: whatever you emit becomes the entire column configuration. The host does **not** merge with the previous columns. Treat the user's prompt as the complete description of the desired layout, and emit every column they want in the final table, in render order.
+
+# Hard rules
+
+1. **NEVER** emit a column with `type === "com.shwfed.table.column.actions"`. Action columns are wired by a separate registry; emitting one will be rejected and you will be retried.
+2. **ONLY** emit a column with `type === "com.shwfed.table.column.markdown"` when the user **explicitly** asks for markdown / rich content / formatted body / 富文本 / Markdown. Otherwise prefer `com.shwfed.table.column.text`.
+3. **NEVER** set `enableSorting: true`. Client-side sorting is rarely the right call in practice (paginated/server-driven data, mixed types, etc.) and the user should opt in manually. Omit the field or set it to `false`.
+4. **NEVER** wrap the `accessor` in type coercions (`string(...)`, `int(...)`, `double(...)`) and **NEVER** supply a default via `.orValue(...)`. Emit the bare optional access — e.g. `row.?name`, `row.?age`. Coercion and defaults make it impossible for the user to distinguish real data from filler, which is actively harmful.
+   - Correct: `row.?name`
+   - Correct: `row.?age`
+   - Wrong: `string(row.?name)`
+   - Wrong: `double(row.?age.orValue(0))`
+
+# Column fields
+
+Each column object needs at minimum:
+
+- `id`: stable string. For new columns, call the `gen_uuid` tool to obtain an id — do **not** invent UUIDs yourself. If the user's described layout clearly maps onto an existing column from the current configuration (same role / accessor / field), reuse that column's `id` so pinning state survives — otherwise mint a fresh one via `gen_uuid`.
+- `type`: one of the registered types listed in "Available column types".
+- `compatibilityDate`: copy from the matching registry entry verbatim.
+- Type-specific fields (see registry).
+
+Common fields (where supported by the type):
+- `title`: localized string array, e.g. `[{ "locale": "zh", "message": "姓名" }]`. The `zh` entry is what users see in the Chinese UI.
+- `accessor`: CEL expression that, given the bound `row`, returns the cell value. Use bare optional access: `row.?name`. Do **not** add coercions or `.orValue(...)` defaults — see hard rule 4.
+- `size`: pixel column width (number).
+- `grow`: when true, the column stretches to fill remaining space.
+- `enableSorting`: client-side sorting flag. **Do not enable** — see hard rule 3.
+- `align`: `'left' | 'center' | 'right'`.
+- `tooltip`: localized markdown shown on header hover.
+- `copyExpression`: CEL returning a string to copy on click.
+
+The CEL `accessor` runs in a row-scoped environment with these variables:
+- `row` (`dyn`): current row data — shape depends on the data source.
+- `index` (`number`): row index.
+- `id` (`string`): the column's id.
+
+Always use optional access (`row.?field`) rather than `row.field` to avoid runtime errors on missing keys. Do **not** add type coercions or `.orValue(...)` defaults (see hard rule 4) — a missing/typed-wrong value should surface as missing, not be silently masked.
+
+If the user gives a sample response, derive accessors directly from its shape. Otherwise, infer field names from the user's prose (e.g. "show name and email" → `row.?name`, `row.?email`).
+
+The current configuration (existing data source + columns) is appended to the user prompt under `Current configuration`. Use it only to (a) reuse existing column `id`s where the user's described column clearly corresponds to an existing one, and (b) inform field shapes (e.g. response keys). Do **not** copy columns forward that the user did not describe — the user's prompt is the source of truth for which columns should exist.

package/dist/runtime/components/table/ai/data-source-button.d.vue.ts

@@ -0,0 +1,20 @@
+type AnyRecord = Record<string, any>;
+type __VLS_Props = {
+    dataSource?: AnyRecord;
+    columns?: ReadonlyArray<AnyRecord>;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    apply: (value: {
+        request?: string;
+        data?: string;
+        total?: string;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onApply?: ((value: {
+        request?: string;
+        data?: string;
+        total?: string;
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;