@objectstack/service-ai 6.0.0 → 6.1.1

package/dist/index.js

@@ -844,8 +844,112 @@ var MemoryLLMAdapter = class {
   async chat(messages, options) {
     const lastUserMessage = [...messages].reverse().find((m) => m.role === "user");
     const userContent = lastUserMessage?.content;
-    const text = typeof userContent === "string" ? userContent : "(complex content)";
-    const content = lastUserMessage ? `[memory] ${text}` : "[memory] (no user message)";
+    const userText = typeof userContent === "string" ? userContent : "(complex content)";
+    const tools = options?.tools;
+    const hasQueryDataTool = Array.isArray(tools) && tools.some((t) => t?.name === "query_data");
+    const alreadyCalledQueryData = messages.some(
+      (m) => m.role === "tool" && Array.isArray(m.content) && m.content.some((c) => c?.toolName === "query_data")
+    );
+    const alreadyCalledAction = messages.some(
+      (m) => m.role === "tool" && Array.isArray(m.content) && m.content.some(
+        (c) => typeof c?.toolName === "string" && c.toolName.startsWith("action_")
+      )
+    );
+    if (Array.isArray(tools) && !alreadyCalledAction && lastUserMessage) {
+      const actionTools = tools.filter((t) => typeof t?.name === "string" && t.name.startsWith("action_"));
+      const chosen = pickActionTool(userText, actionTools);
+      if (chosen) {
+        const recordId = extractRecordIdFromMessages(messages, userText);
+        if (recordId) {
+          const toolCallId = `memory_tc_${Date.now().toString(36)}`;
+          return {
+            content: "",
+            model: options?.model ?? "memory",
+            usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+            toolCalls: [
+              {
+                type: "tool-call",
+                toolCallId,
+                toolName: chosen.name,
+                input: { recordId }
+              }
+            ]
+          };
+        }
+      }
+    }
+    if (hasQueryDataTool && !alreadyCalledQueryData && lastUserMessage) {
+      const toolCallId = `memory_tc_${Date.now().toString(36)}`;
+      return {
+        content: "",
+        model: options?.model ?? "memory",
+        usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+        toolCalls: [
+          {
+            type: "tool-call",
+            toolCallId,
+            toolName: "query_data",
+            input: { request: userText }
+          }
+        ]
+      };
+    }
+    if (alreadyCalledAction) {
+      const lastTool = [...messages].reverse().find((m) => m.role === "tool");
+      const part = Array.isArray(lastTool?.content) ? lastTool.content.find((c) => typeof c?.toolName === "string" && c.toolName.startsWith("action_")) : void 0;
+      const raw = part?.output && typeof part.output === "object" && "value" in part.output ? part.output.value : part?.result;
+      let payload = {};
+      if (typeof raw === "string") {
+        try {
+          payload = JSON.parse(raw);
+        } catch {
+        }
+      } else if (raw && typeof raw === "object") {
+        payload = raw;
+      }
+      if (payload.error) {
+        return {
+          content: `[memory] action ${payload.action ?? ""} failed: ${payload.error}`,
+          model: options?.model ?? "memory",
+          usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 }
+        };
+      }
+      return {
+        content: `[memory] ${payload.message ?? "Action executed."} (${payload.action ?? "action"})`,
+        model: options?.model ?? "memory",
+        usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 }
+      };
+    }
+    if (alreadyCalledQueryData) {
+      const lastTool = [...messages].reverse().find((m) => m.role === "tool");
+      const part = Array.isArray(lastTool?.content) ? lastTool.content.find((c) => c?.toolName === "query_data") : void 0;
+      let payload = {};
+      const raw = part?.output && typeof part.output === "object" && "value" in part.output ? part.output.value : part?.result;
+      if (typeof raw === "string") {
+        try {
+          payload = JSON.parse(raw);
+        } catch {
+          payload = {};
+        }
+      } else if (raw && typeof raw === "object") {
+        payload = raw;
+      }
+      if (payload.error) {
+        return {
+          content: `[memory] query_data failed: ${payload.error}`,
+          model: options?.model ?? "memory",
+          usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 }
+        };
+      }
+      const records = payload.records ?? [];
+      const count = payload.count ?? records.length;
+      return {
+        content: `[memory] Found ${count} record${count === 1 ? "" : "s"} for "${userText}".`,
+        model: options?.model ?? "memory",
+        usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 }
+      };
+    }
+    const content = lastUserMessage ? `[memory] ${userText}` : "[memory] (no user message)";
     return {
       content,
       model: options?.model ?? "memory",
@@ -897,23 +1001,42 @@ var MemoryLLMAdapter = class {
    */
   async generateObject(messages, schema, options) {
     const sys = messages.filter((m) => m.role === "system").map((m) => typeof m.content === "string" ? m.content : "").join("\n");
-    const headerRe = /^###\s+([a-z0-9_]+)\b/gim;
+    const headerRe = /^###\s+([a-z0-9_]+)(?:\s+—\s+([^\n]+))?/gim;
     const candidates = [];
     for (const match of sys.matchAll(headerRe)) {
-      if (match[1]) candidates.push(match[1]);
+      const machineName = match[1];
+      if (!machineName) continue;
+      const aliasText = match[2] ?? "";
+      const aliasTokens = /* @__PURE__ */ new Set();
+      for (const t of machineName.split(/[^a-z0-9]+/)) {
+        if (t) aliasTokens.add(t);
+      }
+      for (const t of aliasText.toLowerCase().split(/[^a-z0-9]+/)) {
+        if (t) aliasTokens.add(t);
+      }
+      for (const t of [...aliasTokens]) {
+        if (t.length > 3 && t.endsWith("s")) aliasTokens.add(t.slice(0, -1));
+      }
+      candidates.push({ name: machineName, aliasTokens });
     }
     const lastUser = [...messages].reverse().find((m) => m.role === "user");
     const userText = typeof lastUser?.content === "string" ? lastUser.content.toLowerCase() : "";
     const userTokens = new Set(
       userText.split(/[^a-z0-9_]+/).filter((t) => t.length > 1)
     );
-    let chosen = candidates[0];
+    for (const t of [...userTokens]) {
+      if (t.length > 3 && t.endsWith("s")) userTokens.add(t.slice(0, -1));
+    }
+    let chosen = candidates[0]?.name;
     let bestScore = -1;
-    for (const name of candidates) {
-      const score = name.split(/[^a-z0-9]+/).reduce((acc, tok) => acc + (tok && userTokens.has(tok) ? 1 : 0), 0);
+    for (const cand of candidates) {
+      let score = 0;
+      for (const tok of cand.aliasTokens) {
+        if (userTokens.has(tok)) score += 1;
+      }
       if (score > bestScore) {
         bestScore = score;
-        chosen = name;
+        chosen = cand.name;
       }
     }
     const attempts = [];
@@ -934,6 +1057,98 @@ var MemoryLLMAdapter = class {
     );
   }
 };
+function pickActionTool(userText, actionTools) {
+  if (actionTools.length === 0 || !userText) return null;
+  const userTokens = new Set(
+    userText.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 2)
+  );
+  const ACTION_VERBS = /* @__PURE__ */ new Set([
+    "complete",
+    "finish",
+    "done",
+    "close",
+    "start",
+    "begin",
+    "resume",
+    "clone",
+    "copy",
+    "duplicate",
+    "cancel",
+    "abort",
+    "archive",
+    "restore",
+    "approve",
+    "reject",
+    "assign",
+    "unassign",
+    "export",
+    "import",
+    "send",
+    "notify",
+    "publish",
+    "unpublish",
+    "mark"
+  ]);
+  const hasActionVerb = [...userTokens].some((t) => ACTION_VERBS.has(t));
+  if (!hasActionVerb) return null;
+  let best = null;
+  let bestScore = 0;
+  for (const tool of actionTools) {
+    const nameTokens = tool.name.replace(/^action_/, "").toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 2);
+    let score = 0;
+    for (const tok of nameTokens) {
+      if (!userTokens.has(tok)) continue;
+      score += ACTION_VERBS.has(tok) ? 3 : 1;
+    }
+    if (score > bestScore) {
+      bestScore = score;
+      best = tool;
+    }
+  }
+  return bestScore >= 3 ? best : null;
+}
+function extractRecordIdFromMessages(messages, userText) {
+  const userTokens = userText.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 2);
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m.role !== "tool" || !Array.isArray(m.content)) continue;
+    const parts = m.content;
+    for (const part of parts) {
+      if (part?.toolName !== "query_data") continue;
+      const raw = part.output && typeof part.output === "object" && "value" in part.output ? part.output.value : part.result;
+      let payload = {};
+      if (typeof raw === "string") {
+        try {
+          payload = JSON.parse(raw);
+        } catch {
+        }
+      } else if (raw && typeof raw === "object") {
+        payload = raw;
+      }
+      const records = payload.records ?? [];
+      if (records.length === 0) continue;
+      let bestId;
+      let bestScore = -1;
+      for (const rec of records) {
+        if (!rec || typeof rec !== "object") continue;
+        const id = rec.id;
+        if (typeof id !== "string" && typeof id !== "number") continue;
+        const hay = Object.values(rec).filter((v) => typeof v === "string").join(" ").toLowerCase();
+        const hayTokens = hay.split(/[^a-z0-9]+/).filter(Boolean);
+        let score = 0;
+        for (const ut of userTokens) {
+          if (hayTokens.includes(ut)) score += 1;
+        }
+        if (score > bestScore) {
+          bestScore = score;
+          bestId = String(id);
+        }
+      }
+      return bestId ?? String(records[0].id);
+    }
+  }
+  return void 0;
+}
 
 // src/tools/tool-registry.ts
 var ToolRegistry = class {
@@ -1297,6 +1512,13 @@ var _AIService = class _AIService {
    *    maximum number of iterations (`maxIterations`) is reached.
    */
   async chatWithTools(messages, options) {
+    return this.instrument(
+      "chat_with_tools",
+      options,
+      () => this.chatWithToolsImpl(messages, options)
+    );
+  }
+  async chatWithToolsImpl(messages, options) {
     const { maxIterations: maxIter, onToolError, ...restOptions } = options ?? {};
     const maxIterations = maxIter ?? _AIService.DEFAULT_MAX_ITERATIONS;
     const registeredTools = this.toolRegistry.getAll();
@@ -2808,6 +3030,63 @@ var AiTraceObject = ObjectSchema3.create({
   }
 });
 
+// src/views/ai-trace.view.ts
+import { defineView } from "@objectstack/spec";
+var AiTraceView = defineView({
+  list: {
+    type: "grid",
+    data: { provider: "object", object: "ai_traces" },
+    columns: [
+      { field: "created_at", label: "Time" },
+      { field: "operation" },
+      { field: "model" },
+      { field: "agent_id", label: "Agent" },
+      { field: "latency_ms", label: "Latency (ms)" },
+      { field: "total_tokens", label: "Tokens" },
+      { field: "cost_total", label: "Cost" },
+      { field: "status" }
+    ],
+    sort: [{ field: "created_at", order: "desc" }],
+    pagination: { pageSize: 50 },
+    searchableFields: ["conversation_id", "agent_id", "model", "error"],
+    filterableFields: ["operation", "model", "status"]
+  },
+  listViews: {
+    errors: {
+      label: "Errors",
+      type: "grid",
+      data: { provider: "object", object: "ai_traces" },
+      columns: [
+        { field: "created_at", label: "Time" },
+        { field: "operation" },
+        { field: "model" },
+        { field: "latency_ms", label: "Latency (ms)" },
+        { field: "error" }
+      ],
+      filter: [
+        { field: "status", operator: "=", value: "error" }
+      ],
+      sort: [{ field: "created_at", order: "desc" }]
+    },
+    by_model: {
+      label: "By Model",
+      type: "grid",
+      data: { provider: "object", object: "ai_traces" },
+      columns: [
+        { field: "model" },
+        { field: "operation" },
+        { field: "latency_ms", label: "Latency (ms)" },
+        { field: "total_tokens", label: "Tokens" },
+        { field: "cost_total", label: "Cost" },
+        { field: "status" },
+        { field: "created_at", label: "Time" }
+      ],
+      grouping: { fields: [{ field: "model" }] },
+      sort: [{ field: "created_at", order: "desc" }]
+    }
+  }
+});
+
 // src/plugin.ts
 init_data_tools();
 init_metadata_tools();
@@ -2860,8 +3139,11 @@ var SchemaRetriever = class {
     const lines = ["## Schema context (auto-injected)"];
     for (const hit of hits) {
       const obj = hit.object;
-      const label = obj.label ? ` \u2014 ${obj.label}` : "";
-      lines.push(`### ${obj.name}${label}`);
+      const parts = [];
+      if (obj.label) parts.push(obj.label);
+      if (obj.pluralLabel && obj.pluralLabel !== obj.label) parts.push(`(${obj.pluralLabel})`);
+      const header = parts.length > 0 ? ` \u2014 ${parts.join(" ")}` : "";
+      lines.push(`### ${obj.name}${header}`);
       const fields = Object.entries(obj.fields ?? {}).slice(0, maxFieldsPerObject);
       for (const [name, field] of fields) {
         lines.push(`  - ${name}: ${describeField(field)}`);
@@ -3063,6 +3345,228 @@ function registerQueryDataTool(registry, context) {
   registry.register(QUERY_DATA_TOOL, createQueryDataHandler(context));
 }
 
+// src/tools/action-tools.ts
+function actionSkipReason(action) {
+  if (action.aiExposed === false) {
+    return "opted-out via aiExposed:false";
+  }
+  if (action.type !== "script") return `type='${action.type}' not yet supported`;
+  if (!action.target && !action.body) return "no target or body";
+  if (action.confirmText) return "requires confirmation (confirmText set)";
+  if (action.mode === "delete") return "mode='delete' \u2014 destructive";
+  if (action.variant === "danger") return "variant='danger' \u2014 destructive";
+  return null;
+}
+function fieldTypeToJsonType(t) {
+  switch (t) {
+    case "number":
+    case "currency":
+    case "percent":
+    case "rating":
+    case "slider":
+    case "autonumber":
+      return "number";
+    case "boolean":
+    case "toggle":
+      return "boolean";
+    case "multiselect":
+    case "checkboxes":
+    case "tags":
+      return "array";
+    default:
+      return "string";
+  }
+}
+function resolveParam(param, ownerObject, allObjects) {
+  const fieldRef = param.field;
+  const owner = param.objectOverride && allObjects.get(param.objectOverride) ? allObjects.get(param.objectOverride) : ownerObject;
+  const field = fieldRef ? owner?.fields?.[fieldRef] : void 0;
+  const name = param.name ?? fieldRef;
+  if (!name) return null;
+  const type = param.type ?? field?.type;
+  const jsonType = fieldTypeToJsonType(type);
+  const schema = { type: jsonType };
+  const label = typeof param.label === "string" ? param.label : field?.label;
+  const help = param.helpText ?? field?.description;
+  const description = [label, help].filter(Boolean).join(" \u2014 ") || void 0;
+  if (description) schema.description = description;
+  const optionSource = param.options ?? field?.options;
+  if (Array.isArray(optionSource) && optionSource.length > 0) {
+    const values = optionSource.map((o) => typeof o === "string" ? o : o.value).filter((v) => typeof v === "string");
+    if (values.length > 0) {
+      schema.enum = jsonType === "array" ? void 0 : values;
+      if (jsonType === "array") {
+        schema.items = { type: "string", enum: values };
+      }
+    }
+  } else if (jsonType === "array") {
+    schema.items = { type: "string" };
+  }
+  if (param.defaultValue !== void 0) {
+    schema.default = param.defaultValue;
+  }
+  const required = Boolean(param.required ?? field?.required ?? false);
+  return { name, schema, required };
+}
+function buildParametersSchema(action, ownerObject, allObjects) {
+  const properties = {};
+  const required = [];
+  const isRowContext = Array.isArray(action.locations) && action.locations.some((l) => l === "list_item" || l === "record_header" || l === "record_more" || l === "record_related");
+  if (action.objectName && isRowContext) {
+    properties.recordId = {
+      type: "string",
+      description: `The ${action.objectName} record id to act on.`
+    };
+    if (action.recordIdParam || action.recordIdField) {
+      required.push("recordId");
+    }
+  }
+  for (const param of action.params ?? []) {
+    const resolved = resolveParam(param, ownerObject, allObjects);
+    if (!resolved) continue;
+    properties[resolved.name] = resolved.schema;
+    if (resolved.required) required.push(resolved.name);
+  }
+  return {
+    type: "object",
+    properties,
+    ...required.length > 0 ? { required } : {},
+    additionalProperties: false
+  };
+}
+function actionToolName(action, prefix = "action_") {
+  return `${prefix}${action.name}`;
+}
+function describeAction(action, ownerObject) {
+  const label = typeof action.label === "string" ? action.label : action.name.replace(/_/g, " ");
+  const target = action.objectName ?? ownerObject?.name;
+  const targetLabel = ownerObject?.label ?? target;
+  const parts = [];
+  parts.push(`${label}${targetLabel ? ` \u2014 operates on ${targetLabel}` : ""}.`);
+  if (action.successMessage && typeof action.successMessage === "string") {
+    parts.push(`On success: ${action.successMessage}`);
+  }
+  if (action.mode) parts.push(`Mode: ${action.mode}.`);
+  parts.push(
+    "Use this when the user asks to perform this operation in natural language."
+  );
+  return parts.join(" ");
+}
+function actionToToolDefinition(action, ownerObject, allObjects, toolPrefix = "action_") {
+  if (actionSkipReason(action) !== null) return null;
+  return {
+    name: actionToolName(action, toolPrefix),
+    description: describeAction(action, ownerObject),
+    parameters: buildParametersSchema(action, ownerObject, allObjects)
+  };
+}
+function buildHandlerEngineAdapter(engine) {
+  return {
+    update: (object, id, data) => engine.update(object, { ...data, id }, { where: { id } }),
+    insert: (object, data) => engine.insert(object, data),
+    find: (object, where) => engine.find(object, { where }),
+    delete: (object, ids) => engine.delete(object, { where: { id: ids.length === 1 ? ids[0] : { $in: ids } } })
+  };
+}
+function createActionToolHandler(action, ctx) {
+  const principal = ctx.principal ?? { id: "ai_agent", name: "AI Assistant" };
+  const engineAdapter = buildHandlerEngineAdapter(ctx.dataEngine);
+  const requiresRecord = Array.isArray(action.locations) && action.locations.some(
+    (l) => l === "list_item" || l === "record_header" || l === "record_more" || l === "record_related"
+  );
+  return async (args) => {
+    const objectName = action.objectName;
+    const target = action.target;
+    const result = {
+      ok: false,
+      action: action.name,
+      objectName
+    };
+    if (!objectName) {
+      result.error = "Action has no objectName; cannot dispatch.";
+      return JSON.stringify(result);
+    }
+    if (!target) {
+      result.error = "Action has no target handler.";
+      return JSON.stringify(result);
+    }
+    const recordId = typeof args.recordId === "string" && args.recordId.length > 0 ? args.recordId : void 0;
+    let record;
+    if (requiresRecord) {
+      if (!recordId) {
+        result.error = `recordId is required for this action \u2014 supply the id of the ${objectName} record to act on (use query_data first if you don't have it).`;
+        return JSON.stringify(result);
+      }
+      try {
+        const found = await ctx.dataEngine.find(objectName, {
+          where: { id: recordId },
+          limit: 1
+        });
+        record = found[0];
+        if (!record) {
+          result.error = `Record ${recordId} not found in ${objectName}.`;
+          return JSON.stringify(result);
+        }
+        result.recordId = recordId;
+      } catch (err) {
+        result.error = `Failed to load record: ${err instanceof Error ? err.message : String(err)}`;
+        return JSON.stringify(result);
+      }
+    }
+    const { recordId: _omit, ...userParams } = args;
+    try {
+      const handlerCtx = {
+        record,
+        user: principal,
+        engine: engineAdapter,
+        params: userParams
+      };
+      const out = await ctx.dataEngine.executeAction?.(objectName, target, handlerCtx);
+      result.ok = true;
+      result.result = out ?? null;
+      const successMsg = typeof action.successMessage === "string" ? action.successMessage : void 0;
+      result.message = successMsg ?? `Action '${action.name}' executed successfully.`;
+      return JSON.stringify(result);
+    } catch (err) {
+      result.error = err instanceof Error ? err.message : String(err);
+      return JSON.stringify(result);
+    }
+  };
+}
+async function registerActionsAsTools(registry, context) {
+  const objects = await context.metadata.listObjects();
+  const objMap = new Map(
+    objects.filter((o) => Boolean(o?.name)).map((o) => [o.name, o])
+  );
+  const registered = [];
+  const skipped = [];
+  const prefix = context.toolPrefix ?? "action_";
+  for (const obj of objects) {
+    if (!obj?.actions || !Array.isArray(obj.actions)) continue;
+    for (const action of obj.actions) {
+      if (!action || typeof action.name !== "string") continue;
+      const normalized = {
+        ...action,
+        objectName: action.objectName ?? obj.name
+      };
+      const reason = actionSkipReason(normalized);
+      if (reason !== null) {
+        skipped.push({ action: normalized.name, reason });
+        continue;
+      }
+      const definition = actionToToolDefinition(normalized, obj, objMap, prefix);
+      if (!definition) continue;
+      if (registry.has(definition.name)) {
+        skipped.push({ action: normalized.name, reason: "tool name already registered" });
+        continue;
+      }
+      registry.register(definition, createActionToolHandler(normalized, context));
+      registered.push(definition.name);
+    }
+  }
+  return { registered, skipped };
+}
+
 // src/agent-runtime.ts
 import { AgentSchema } from "@objectstack/spec/ai";
 var AgentRuntime = class {
@@ -3365,6 +3869,16 @@ var SkillRegistry = class {
     const resolved = [];
     for (const skill of skills) {
       for (const toolName of skill.tools) {
+        if (toolName.endsWith("*")) {
+          const prefix = toolName.slice(0, -1);
+          for (const def2 of availableTools) {
+            if (!def2.name.startsWith(prefix)) continue;
+            if (seen.has(def2.name)) continue;
+            resolved.push(def2);
+            seen.add(def2.name);
+          }
+          continue;
+        }
         if (seen.has(toolName)) continue;
         const def = toolMap.get(toolName);
         if (def) {
@@ -3428,7 +3942,8 @@ Always answer in the same language the user is using. Detailed tool-usage guidan
     maxTokens: 4096
   },
   // Capability bundle lives on the skill; the agent only references it.
-  skills: ["data_explorer"],
+  // `data_explorer` = read side, `actions_executor` = write side.
+  skills: ["data_explorer", "actions_executor"],
   active: true,
   visibility: "global",
   guardrails: {
@@ -3508,6 +4023,7 @@ Guidelines:
 7. Never expose internal IDs unless the user explicitly asks for them.
 8. Always answer in the same language the user is using.`,
   tools: [
+    "query_data",
     "list_objects",
     "describe_object",
     "query_records",
@@ -3577,6 +4093,44 @@ Guidelines:
   active: true
 };
 
+// src/skills/actions-executor-skill.ts
+var ACTIONS_EXECUTOR_SKILL = {
+  name: "actions_executor",
+  label: "Action Executor",
+  description: "Perform business operations on the user's data \u2014 invoke actions like 'mark as complete', 'start task', 'clone record' through natural language.",
+  instructions: `You can perform business operations by invoking the user's registered actions.
+
+Capabilities:
+- Each tool whose name starts with \`action_\` is a business operation declared on an object.
+- Read the tool description carefully \u2014 it tells you what the action does and what record types it applies to.
+- Most actions need a \`recordId\` argument. If you don't already have one from a prior \`query_data\` call, run \`query_data\` first to find the right record, then invoke the action with its id.
+
+Guidelines:
+1. Confirm intent \u2014 when the user says "complete it" / "start that one", make sure you know *which* record they mean. Ask if ambiguous.
+2. Use \`query_data\` to look up records by natural-language description ("the design review task", "tickets assigned to me").
+3. After invoking an action, the tool returns \`{ ok, message, result }\`. Summarise success in plain language; surface errors verbatim.
+4. Never invent recordIds. If \`query_data\` didn't return one, tell the user instead of guessing.
+5. Action tools are pre-filtered for safety \u2014 destructive operations (\`mode: 'delete'\`, \`variant: 'danger'\`, anything with \`confirmText\`) are *not* exposed here and require explicit user confirmation in the UI.
+6. Always answer in the same language the user is using.`,
+  // Dynamically materialised: the runtime registers one tool per Action,
+  // and the skill subscribes to the whole family via the `action_*`
+  // glob (resolved by SkillRegistry.flattenToTools).
+  tools: ["action_*"],
+  triggerPhrases: [
+    "complete",
+    "mark as",
+    "start",
+    "finish",
+    "clone",
+    "duplicate",
+    "do it",
+    "run",
+    "invoke",
+    "execute"
+  ],
+  active: true
+};
+
 // src/adapters/vercel-adapter.ts
 import { generateText, streamText, generateObject, tool as vercelTool, jsonSchema } from "ai";
 function buildVercelOptions(options) {
@@ -3919,7 +4473,8 @@ var AIServicePlugin = class {
       type: "plugin",
       scope: "project",
       namespace: "ai",
-      objects: [AiConversationObject, AiMessageObject, AiTraceObject]
+      objects: [AiConversationObject, AiMessageObject, AiTraceObject],
+      views: [AiTraceView]
     });
     if (this.options.debug) {
       ctx.hook("ai:beforeChat", async (messages) => {
@@ -3958,6 +4513,31 @@ var AIServicePlugin = class {
             dataEngine
           });
           ctx.logger.info("[AI] query_data tool registered");
+          try {
+            const { registered, skipped } = await registerActionsAsTools(
+              this.service.toolRegistry,
+              {
+                metadata: metadataService,
+                dataEngine
+              }
+            );
+            if (registered.length > 0) {
+              ctx.logger.info(
+                `[AI] ${registered.length} action tool(s) registered: ${registered.join(", ")}`
+              );
+            }
+            if (skipped.length > 0) {
+              ctx.logger.debug(
+                `[AI] Skipped ${skipped.length} action(s) for AI exposure`,
+                { skipped }
+              );
+            }
+          } catch (err) {
+            ctx.logger.warn(
+              "[AI] Failed to register action tools",
+              err instanceof Error ? { error: err.message } : { error: String(err) }
+            );
+          }
         }
         if (metadataService) {
           const { DATA_TOOL_DEFINITIONS: DATA_TOOL_DEFINITIONS2 } = await Promise.resolve().then(() => (init_data_tools(), data_tools_exports));
@@ -4009,6 +4589,19 @@ var AIServicePlugin = class {
           } catch (err) {
             ctx.logger.warn("[AI] Failed to register data_explorer skill", err instanceof Error ? { error: err.message } : { error: String(err) });
           }
+          try {
+            const skillExists = typeof metadataService.exists === "function" ? await withTimeout(metadataService.exists("skill", ACTIONS_EXECUTOR_SKILL.name)) : false;
+            if (skillExists === null) {
+              ctx.logger.warn("[AI] Metadata service timed out checking actions_executor skill, skipping");
+            } else if (!skillExists) {
+              await withTimeout(metadataService.register("skill", ACTIONS_EXECUTOR_SKILL.name, ACTIONS_EXECUTOR_SKILL));
+              ctx.logger.info("[AI] actions_executor skill registered");
+            } else {
+              ctx.logger.debug("[AI] actions_executor skill already exists, skipping auto-registration");
+            }
+          } catch (err) {
+            ctx.logger.warn("[AI] Failed to register actions_executor skill", err instanceof Error ? { error: err.message } : { error: String(err) });
+          }
         }
       }
     } catch {
@@ -4468,16 +5061,20 @@ function registerPackageTools(registry, context) {
   registry.register(setActivePackageTool, createSetActivePackageHandler(context));
 }
 export {
+  ACTIONS_EXECUTOR_SKILL,
   AIService,
   AIServicePlugin,
   AgentRuntime,
   AiConversationObject,
   AiMessageObject,
   AiTraceObject,
+  AiTraceView,
   DATA_CHAT_AGENT,
+  DATA_EXPLORER_SKILL,
   DATA_TOOL_DEFINITIONS,
   InMemoryConversationService,
   METADATA_ASSISTANT_AGENT,
+  METADATA_AUTHORING_SKILL,
   METADATA_TOOL_DEFINITIONS,
   MemoryLLMAdapter,
   ModelRegistry,
@@ -4490,6 +5087,9 @@ export {
   SkillRegistry,
   ToolRegistry,
   VercelLLMAdapter,
+  actionSkipReason,
+  actionToToolDefinition,
+  actionToolName,
   addFieldTool,
   buildAIRoutes,
   buildAgentRoutes,
@@ -4509,6 +5109,7 @@ export {
   listObjectsTool,
   listPackagesTool,
   modifyFieldTool,
+  registerActionsAsTools,
   registerDataTools,
   registerMetadataTools,
   registerPackageTools,