@fleox-agent-crm/agentcrm 0.0.0-stage → 0.3.1

package/dist/agent/chunks/tools-iSH-yMpl.mjs

@@ -0,0 +1,884 @@
+import { createRequire as __acrmRequire } from "node:module";
+import { fileURLToPath as __acrmPath } from "node:url";
+import { dirname as __acrmDirname } from "node:path";
+const require2 = __acrmRequire(import.meta.url);
+const __filename = __acrmPath(import.meta.url);
+const __dirname = __acrmDirname(__filename);
+import { recordLabel, normalizeEmail, formatFieldValue } from "./fields-B0bitgmr.mjs";
+import { r as resolveField } from "./query-C5nJB_3C.mjs";
+import { F as FILTER_OPS, A as ACTIVITY_TYPES, a as FIELD_TYPES } from "../agentcrm.mjs";
+import { OpsError } from "./context-CxFfqS4D.mjs";
+import { listActivities, addNote, addActivity, createTask, completeTask, listTasks } from "./activities-Cj_SIOay.mjs";
+import { mergeRecords } from "./dedupe-BepmsaHv.mjs";
+import { importCsv } from "./importCsv-LVmMTaWU.mjs";
+import { moveStage, forecast, listPipelines } from "./pipelines-BAKpPk1w.mjs";
+import { getRecord, searchRecords, listRecords, getRecordDetails, createRecord, updateRecord, deleteRecord, queryContext } from "./records-DcHFelq5.mjs";
+import { runReport, REPORTS } from "./reports-BACHGccj.mjs";
+import { describeSchema, createField } from "./schema-C4lSslXv.mjs";
+import { objectOf, recordOf, userOf, activitiesOf, fileOf } from "./store-5gqRSKXg.mjs";
+import { ACTION_TYPES, TRIGGER_TYPES, listAutomationRuns, AUTOMATION_TEMPLATES, listAutomations, createAutomationFromTemplate, createAutomation, setAutomationEnabled, testAutomation, runScheduled } from "./automations-DwWruxmu.mjs";
+import { listForms, ingestInbox } from "./forms-BfuWaQjA.mjs";
+import { B as BUTTON_STYLES, C as CONTRASTS, d as COLOR_MODES, S as SIDEBAR_STYLES, e as DENSITIES, R as RADII, N as NEUTRALS, F as FONTS } from "./schema-DnLj8dUO.mjs";
+import { listPresets, getAppearance, setAppearance, applyPreset } from "./appearance-BloHbiLA.mjs";
+import { listExtensions, setExtensionEnabled } from "./extensions-Bp72uZ9a.mjs";
+import { listModules, setModuleEnabled } from "./modules-clWdE-K2.mjs";
+import { inlineFileIds, formatBytes, fileKind } from "./files-CjsPJSR6.mjs";
+import { listFiles, fileUsage } from "./files-D1daDgY0.mjs";
+import { l as labelOf } from "./relations-B9TynBmA.mjs";
+import "node:util";
+import "node:fs";
+import "node:path";
+import "node:url";
+import "node:crypto";
+import "node:os";
+import "node:child_process";
+import "node:http";
+import "./pluginRegistry-DyHtlkcr.mjs";
+import "./ids-CvnmrMJX.mjs";
+import "./papaparse-Df7i1dHr.mjs";
+import "./_commonjsHelpers-ClciMIcB.mjs";
+import "stream";
+import "./utils-DmI8FtXP.mjs";
+import "./standardObjects-CheqfDqa.mjs";
+import "./settings-Di8nzNEL.mjs";
+import "./runtimeConfig-CCOFg1RM.mjs";
+import "./extensionActions-D2HtpQz4.mjs";
+import "./themes-DPZFv3yc.mjs";
+import "./api-Cz0Ubj-B.mjs";
+import "./package-B7mI6HGi.mjs";
+import "./index-w03ReRs4.mjs";
+import "events";
+import "buffer";
+import "util";
+import "./index-RCmo-uld.mjs";
+import "./http-Bk9ICb7I.mjs";
+import "./index-BM8qeGOb.mjs";
+function summarizeAutomation(ctx, a) {
+  const last = listAutomationRuns(ctx, { automationId: a.id, limit: 1 })[0];
+  return {
+    id: a.id,
+    name: a.name,
+    enabled: a.enabled,
+    object: a.object,
+    trigger: a.trigger,
+    conditions: a.conditions,
+    actions: a.actions,
+    ...a.lastRunAt ? { lastRunAt: new Date(a.lastRunAt).toISOString() } : {},
+    ...last ? { lastRun: { status: last.status, at: new Date(last.startedAt).toISOString(), ...last.message ? { message: last.message } : {} } } : {}
+  };
+}
+function summarizeForm(f) {
+  return {
+    id: f.id,
+    name: f.name,
+    object: f.object,
+    fields: f.fields,
+    inbox: f.inbox.kind,
+    ...f.publishedUrl ? { url: f.publishedUrl } : {},
+    ...f.publishedAt ? { publishedAt: new Date(f.publishedAt).toISOString() } : {},
+    ...f.lastIngestAt ? { lastIngestAt: new Date(f.lastIngestAt).toISOString() } : {}
+  };
+}
+const triggerSchema = {
+  type: "object",
+  description: "record.created | record.updated (optional field) | field.changed (field, optional to = new value: option id or label) | stage.changed (optional to = stage id or kind won/lost/open) | schedule (everyHours) | inactivity (days without activity).",
+  properties: {
+    type: { type: "string", enum: TRIGGER_TYPES },
+    field: { type: "string" },
+    to: { description: "Value the field / stage must change to." },
+    days: { type: "number" },
+    everyHours: { type: "number" }
+  },
+  required: ["type"]
+};
+const actionSchema = {
+  type: "object",
+  description: 'One of: {type:"createTask", title, dueInDays?, assignTo?: "owner"|userId} · {type:"updateField", field, value} · {type:"addNote", body} · {type:"assignOwner", userId: userId|"roundRobin"} · {type:"webhook", url}. Texts accept {{label}}, {{<fieldId>}}, {{owner}} placeholders.',
+  properties: {
+    type: { type: "string", enum: ACTION_TYPES },
+    title: { type: "string" },
+    dueInDays: { type: "number" },
+    assignTo: { type: "string" },
+    field: { type: "string" },
+    value: {},
+    body: { type: "string" },
+    userId: { type: "string" },
+    url: { type: "string" }
+  },
+  required: ["type"]
+};
+const conditionSchema = {
+  type: "object",
+  properties: { field: { type: "string" }, op: { type: "string", enum: FILTER_OPS }, value: {} },
+  required: ["field", "op"]
+};
+const AUTOMATION_FORM_TOOLS = [
+  {
+    name: "list_automations",
+    description: "List the automations (trigger, conditions, actions, enabled, last run) and, with includeRuns, the latest runs log. Also lists the ready-made templates.",
+    inputSchema: { type: "object", properties: { includeRuns: { type: "boolean" }, limit: { type: "number", default: 20, maximum: 100 } } },
+    mutating: false,
+    handler: (ctx, input) => ({
+      automations: listAutomations(ctx).map((a) => summarizeAutomation(ctx, a)),
+      templates: AUTOMATION_TEMPLATES.map((t) => ({ id: t.id, name: t.name, description: t.description })),
+      ...input.includeRuns ? {
+        runs: listAutomationRuns(ctx, { limit: Math.min(100, typeof input.limit === "number" ? input.limit : 20) }).map((r) => ({
+          automationId: r.automationId,
+          recordId: r.recordId,
+          status: r.status,
+          at: new Date(r.startedAt).toISOString(),
+          ...r.message ? { message: r.message } : {},
+          actions: r.actions
+        }))
+      } : {}
+    })
+  },
+  {
+    name: "create_automation",
+    description: "Create an automation (admin only), either from a template (templateId, see list_automations) or from a full definition (name, object, trigger, conditions, actions). Use describe_schema for field ids. Set enabled false to create it paused.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        templateId: { type: "string", enum: AUTOMATION_TEMPLATES.map((t) => t.id) },
+        name: { type: "string" },
+        object: { type: "string" },
+        trigger: triggerSchema,
+        conditions: { type: "array", items: conditionSchema },
+        actions: { type: "array", items: actionSchema },
+        enabled: { type: "boolean", default: true }
+      }
+    },
+    mutating: true,
+    handler: async (ctx, input) => {
+      const enabled = input.enabled === void 0 ? void 0 : input.enabled !== false;
+      if (typeof input.templateId === "string") {
+        const overrides = { ...typeof input.name === "string" ? { name: input.name } : {}, ...enabled !== void 0 ? { enabled } : {} };
+        return summarizeAutomation(ctx, await createAutomationFromTemplate(ctx, input.templateId, overrides));
+      }
+      if (typeof input.object !== "string" || !input.trigger || !Array.isArray(input.actions)) throw new OpsError("validation", "Give a templateId, or name + object + trigger + actions.");
+      const a = await createAutomation(ctx, {
+        name: typeof input.name === "string" ? input.name : "",
+        object: input.object,
+        trigger: input.trigger,
+        conditions: input.conditions ?? [],
+        actions: input.actions,
+        ...enabled !== void 0 ? { enabled } : {}
+      });
+      return summarizeAutomation(ctx, a);
+    }
+  },
+  {
+    name: "run_automations",
+    description: "Run the scheduled automations (schedule / inactivity triggers) now, or test one automation on one record (automationId + recordId). DRY RUN unless confirm is true — show the planned actions to the user before confirming. Can also enable / disable an automation (enabled).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        automationId: { type: "string" },
+        recordId: { type: "string", description: "Test the automation on this record (ignores the trigger, checks conditions)." },
+        enabled: { type: "boolean", description: "Only enable / disable automationId, don't run." },
+        confirm: { type: "boolean", default: false }
+      }
+    },
+    mutating: true,
+    handler: async (ctx, input) => {
+      const automationId = typeof input.automationId === "string" ? input.automationId : void 0;
+      if (typeof input.enabled === "boolean") {
+        if (!automationId) throw new OpsError("validation", "enabled needs an automationId.");
+        return summarizeAutomation(ctx, await setAutomationEnabled(ctx, automationId, input.enabled));
+      }
+      const dryRun = input.confirm !== true;
+      if (typeof input.recordId === "string") {
+        if (!automationId) throw new OpsError("validation", "recordId needs an automationId.");
+        const a = listAutomations(ctx).find((x) => x.id === automationId);
+        if (!a) throw new OpsError("notFound", `Automation "${automationId}" not found.`);
+        const res = await testAutomation(ctx, a, input.recordId, { dryRun });
+        return { dryRun, matched: res.matched, failedConditions: res.failedConditions, status: res.run.status, actions: res.run.actions, message: res.run.message };
+      }
+      const report = await runScheduled(ctx, { dryRun, automationId, force: !!automationId });
+      return {
+        dryRun,
+        ran: report.ran,
+        skipped: report.skipped,
+        errors: report.errors,
+        runs: report.runs.slice(0, 50).map((r) => ({ automationId: r.automationId, recordId: r.recordId, status: r.status, actions: r.actions, ...r.message ? { message: r.message } : {} })),
+        runsTruncated: report.runs.length > 50
+      };
+    }
+  },
+  {
+    name: "list_forms",
+    description: "List the lead capture forms: object, fields, inbox kind (s3 / firebase / webhook), published URL, last ingestion.",
+    inputSchema: { type: "object", properties: {} },
+    mutating: false,
+    handler: (ctx) => ({ forms: listForms(ctx).map(summarizeForm) })
+  },
+  {
+    name: "ingest_inbox",
+    description: "Import pending lead form submissions from the inbox(es): creates or updates records (dedupe on email), creates companies from email domains, logs a 'Form submission' note, then removes processed submissions. DRY RUN unless confirm is true.",
+    inputSchema: { type: "object", properties: { formId: { type: "string" }, confirm: { type: "boolean", default: false } } },
+    mutating: true,
+    handler: async (ctx, input) => {
+      const r = await ingestInbox(ctx, typeof input.formId === "string" ? input.formId : void 0, { dryRun: input.confirm !== true });
+      return { dryRun: input.confirm !== true, ...r, results: r.results?.slice(0, 50) };
+    }
+  },
+  {
+    name: "draft_email",
+    description: "Prepare an email draft to a person (or a company's people / a deal's contacts): returns recipients, a subject and body (yours if given, else a skeleton) plus context (record, recent activities, last email). Never sends — show the draft to the user; they send it from the record's Emails tab.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        recordId: { type: "string" },
+        subject: { type: "string" },
+        body: { type: "string", description: "Markdown / plain text body you wrote." },
+        purpose: { type: "string", description: "What the email is for (follow-up, intro, proposal…)." }
+      },
+      required: ["recordId"]
+    },
+    mutating: false,
+    handler: (ctx, input) => {
+      const record = getRecord(ctx, String(input.recordId));
+      const object = objectOf(ctx.store, record.object);
+      const recipients = [];
+      const addPerson = (id) => {
+        const p = typeof id === "string" ? recordOf(ctx.store, id) : void 0;
+        const email = p && !p.deletedAt ? normalizeEmail(p.fields.email) : "";
+        if (p && email && !recipients.some((r) => r.email === email)) recipients.push({ id: p.id, name: recordLabel(objectOf(ctx.store, "people"), p), email });
+      };
+      if (record.object === "people") addPerson(record.id);
+      for (const v of Object.values(record.fields)) {
+        for (const id of Array.isArray(v) ? v : [v]) if (typeof id === "string" && recordOf(ctx.store, id)?.object === "people") addPerson(id);
+      }
+      if (record.object === "companies") {
+        for (const p of ctx.store.list("records")) if (p.object === "people" && !p.deletedAt && p.fields.company === record.id) addPerson(p.id);
+      }
+      const activities = listActivities(ctx, { target: record.id, includeRelated: true, limit: 8 }).items;
+      const lastEmail = activities.find((a) => a.type === "email");
+      const me = ctx.user ? userOf(ctx.store, ctx.user.id) ?? ctx.user : null;
+      const first = recipients[0]?.name.split(" ")[0];
+      const subject = typeof input.subject === "string" && input.subject.trim() ? input.subject.trim() : typeof input.purpose === "string" ? input.purpose.trim() : `Following up — ${recordLabel(object, record)}`;
+      const body = typeof input.body === "string" && input.body.trim() ? input.body : `Hi ${first ?? "there"},
+
+[Write the message${typeof input.purpose === "string" ? ` (${input.purpose})` : ""} here.]
+
+Best,
+${me?.name ?? ""}`;
+      return {
+        draft: { to: recipients.slice(0, 10), subject, body },
+        sent: false,
+        note: "Draft only — nothing was sent. The user can send it from the record's Emails tab (Gmail / Outlook integration).",
+        context: {
+          record: { id: record.id, object: record.object, label: recordLabel(object, record) },
+          recentActivities: activities.map((a) => ({ type: a.type, title: a.title, at: new Date(a.createdAt).toISOString() })),
+          ...lastEmail ? { lastEmail: { title: lastEmail.title, body: lastEmail.body?.slice(0, 800), at: new Date(lastEmail.createdAt).toISOString() } } : {}
+        }
+      };
+    }
+  }
+];
+function compactAppearance(a) {
+  const { logo, favicon, customCss, ...rest } = a;
+  return { ...rest, hasLogo: !!logo, hasFavicon: !!favicon, customCssBytes: customCss ? customCss.length : 0 };
+}
+const appearanceProps = {
+  accent: { type: "string", description: "Accent color, hex #rrggbb (a full 50–950 scale is generated from it)." },
+  neutral: { type: "string", enum: NEUTRALS, description: "Gray scale used for surfaces, borders and text." },
+  radius: { type: "string", enum: RADII },
+  density: { type: "string", enum: DENSITIES, description: "compact = shorter table rows and paddings." },
+  font: { type: "string", enum: FONTS.map((f) => f.id), description: '"system" needs no network; the others load from Google Fonts.' },
+  sidebar: { type: "string", enum: SIDEBAR_STYLES },
+  defaultMode: { type: "string", enum: COLOR_MODES, description: "Default light/dark mode for users who never toggled it." },
+  contrast: { type: "string", enum: CONTRASTS },
+  buttons: { type: "string", enum: BUTTON_STYLES, description: "Primary buttons: neutral (near-black) or accent colored." },
+  customCss: { type: ["string", "null"], description: "Extra CSS for the whole workspace (≤ 50 KB). null removes it." },
+  themeId: { type: ["string", "null"], description: "Installed theme extension to use (see list_extensions); null clears it." }
+};
+const CUSTOMIZE_TOOLS = [
+  {
+    name: "list_modules",
+    description: "List the workspace modules (built-in features such as dashboard, deals, reports, tasks, automations, forms, integrations, assistant, plus installed extension modules) with enabled / required state and dependencies.",
+    inputSchema: { type: "object", properties: {} },
+    mutating: false,
+    handler: (ctx) => listModules(ctx).map((m) => ({
+      id: m.id,
+      name: m.name,
+      category: m.category,
+      source: m.source,
+      enabled: m.enabled,
+      ...m.required ? { required: true } : {},
+      ...m.dependsOn.length ? { dependsOn: m.dependsOn } : {},
+      ...m.dependents.length ? { dependents: m.dependents } : {},
+      ...m.objects.length ? { objects: m.objects } : {},
+      ...m.version ? { version: m.version } : {}
+    }))
+  },
+  {
+    name: "set_module_enabled",
+    description: "Enable or disable a module for the whole workspace (admin only). Disabling hides its pages, navigation and widgets (and objects, e.g. deals) without deleting data. Fails when other modules depend on it unless cascade is true.",
+    inputSchema: {
+      type: "object",
+      properties: { id: { type: "string", description: "Module id (see list_modules)." }, enabled: { type: "boolean" }, cascade: { type: "boolean", default: false, description: "Also disable dependents / enable dependencies." } },
+      required: ["id", "enabled"]
+    },
+    mutating: true,
+    handler: (ctx, input) => setModuleEnabled(ctx, String(input.id), input.enabled === true, { cascade: input.cascade === true })
+  },
+  {
+    name: "get_appearance",
+    description: "Get the workspace appearance (accent color, neutral scale, radius, density, font, sidebar style, default mode, selected theme) and the available presets / themes.",
+    inputSchema: { type: "object", properties: {} },
+    mutating: false,
+    handler: (ctx) => ({ appearance: compactAppearance(getAppearance(ctx)), presets: listPresets(ctx).map((p) => ({ id: p.id, name: p.name, source: p.source, description: p.description })) })
+  },
+  {
+    name: "set_appearance",
+    description: "Change the workspace appearance for every user (admin only). Pass only the keys to change; null resets a key to its default. Applied live in every open admin.",
+    inputSchema: { type: "object", properties: appearanceProps, additionalProperties: false },
+    mutating: true,
+    handler: async (ctx, input) => compactAppearance(await setAppearance(ctx, input))
+  },
+  {
+    name: "apply_appearance_preset",
+    description: "Apply an appearance preset (default, ocean, forest, sunset, graphite, rose, high-contrast) or an installed theme extension id (admin only). Logo, favicon and custom CSS are kept.",
+    inputSchema: { type: "object", properties: { id: { type: "string", description: "Preset or theme id (see get_appearance)." } }, required: ["id"] },
+    mutating: true,
+    handler: async (ctx, input) => compactAppearance(await applyPreset(ctx, String(input.id)))
+  },
+  {
+    name: "list_extensions",
+    description: "List the installed extensions (external modules and themes) with version, author, enabled state and API compatibility.",
+    inputSchema: { type: "object", properties: { kind: { type: "string", enum: ["module", "theme"] } } },
+    mutating: false,
+    handler: (ctx, input) => listExtensions(ctx, input.kind === "module" || input.kind === "theme" ? { kind: input.kind } : {})
+  },
+  {
+    name: "set_extension_enabled",
+    description: "Enable or disable an installed extension without uninstalling it (admin only). Installing new code is not possible through tools — use Settings → Modules or the CLI.",
+    inputSchema: { type: "object", properties: { id: { type: "string" }, enabled: { type: "boolean" }, cascade: { type: "boolean", default: false } }, required: ["id", "enabled"] },
+    mutating: true,
+    handler: (ctx, input) => {
+      if (typeof input.id !== "string" || !input.id) throw new OpsError("validation", 'Missing "id".');
+      return setExtensionEnabled(ctx, input.id, input.enabled === true, { cascade: input.cascade === true });
+    }
+  }
+];
+const KINDS = ["image", "pdf", "document", "spreadsheet", "presentation", "archive", "text", "audio", "video", "other"];
+function summarizeFile(ctx, f) {
+  return {
+    id: f.id,
+    name: f.name,
+    kind: fileKind(f.mime, f.name),
+    mime: f.mime,
+    size: f.size,
+    sizeLabel: formatBytes(f.size),
+    ...f.width && f.height ? { dimensions: `${f.width}×${f.height}` } : {},
+    createdAt: new Date(f.createdAt).toISOString(),
+    ...f.createdBy ? { uploadedBy: userOf(ctx.store, f.createdBy)?.name ?? f.createdBy } : {},
+    attachedTo: f.targets.map((t) => t.kind === "record" ? { kind: "record", id: t.id, label: labelOf(ctx, t.id) } : { kind: "activity", id: t.id, title: ctx.store.get("activities", t.id)?.title }),
+    ...f.via ? { via: f.via.kind } : {},
+    ...f.deletedAt ? { deleted: true } : {}
+  };
+}
+const FILE_TOOLS = [
+  {
+    name: "list_files",
+    description: "Files (images, PDFs, documents) of a record — attached to it, its image fields, its activities' attachments; includeRelated adds linked records' files — or of one activity. Metadata only (name, type, size, attached to); without recordId / activityId: storage usage + the most recent files.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        recordId: { type: "string", description: "Record id." },
+        activityId: { type: "string", description: "Activity id (note, task…)." },
+        includeRelated: { type: "boolean", description: "Also files of related records (e.g. a company's people and deals)." },
+        kind: { type: "string", enum: KINDS },
+        search: { type: "string", description: "Part of the file name." },
+        limit: { type: "number", default: 30, maximum: 200 }
+      }
+    },
+    mutating: false,
+    handler: (ctx, input) => {
+      const target = typeof input.recordId === "string" && input.recordId ? input.recordId : typeof input.activityId === "string" && input.activityId ? input.activityId : null;
+      const limit = Math.min(200, typeof input.limit === "number" ? input.limit : 30);
+      const items = listFiles(ctx, target, {
+        includeRelated: input.includeRelated === true,
+        kind: KINDS.includes(input.kind) ? input.kind : void 0,
+        search: typeof input.search === "string" ? input.search : void 0
+      });
+      return {
+        ...target ? {} : { usage: fileUsage(ctx) },
+        total: items.length,
+        files: items.slice(0, limit).map((f) => summarizeFile(ctx, f))
+      };
+    }
+  },
+  {
+    name: "describe_attachments",
+    description: "What is attached to an activity, or to every activity of a record: file metadata (name, type, size, dimensions) and the images referenced inline in the Markdown body. Use it before summarising a note / task that mentions attachments. Never returns file contents.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        activityId: { type: "string" },
+        recordId: { type: "string", description: "All activities of this record that have attachments." }
+      }
+    },
+    mutating: false,
+    handler: (ctx, input) => {
+      const activityId = typeof input.activityId === "string" ? input.activityId : "";
+      const recordId = typeof input.recordId === "string" ? input.recordId : "";
+      if (!activityId && !recordId) throw new OpsError("validation", "Give activityId or recordId.");
+      if (recordId && !recordOf(ctx.store, recordId)) throw new OpsError("notFound", `Record "${recordId}" not found.`);
+      const acts = activitiesOf(ctx.store).filter((a) => activityId ? a.id === activityId : a.targets.some((t) => t.id === recordId));
+      if (activityId && !acts.length) throw new OpsError("notFound", `Activity "${activityId}" not found.`);
+      const out = acts.map((a) => {
+        const ids = [.../* @__PURE__ */ new Set([...a.attachments ?? [], ...inlineFileIds(a.body)])];
+        const files = ids.map((id) => fileOf(ctx.store, id)).filter((f) => !!f && !f.deletedAt);
+        return { activity: { id: a.id, type: a.type, title: a.title }, inline: inlineFileIds(a.body), files: files.map((f) => summarizeFile(ctx, f)) };
+      }).filter((x) => x.files.length);
+      return { activities: out };
+    }
+  }
+];
+const objectProp = { type: "string", description: 'Object id, e.g. "companies", "people", "deals" (see describe_schema).' };
+const fieldsProp = {
+  type: "object",
+  description: "Field values keyed by field id (see describe_schema). Select fields take the option id or label; relation fields take record ids; dates YYYY-MM-DD; datetimes ISO 8601; multi values as arrays.",
+  additionalProperties: true
+};
+const filterSchema = {
+  type: "object",
+  properties: {
+    field: { type: "string", description: "Field id, or id / ownerId / createdAt / updatedAt." },
+    op: { type: "string", enum: FILTER_OPS },
+    value: { description: "Operand. in/notIn: array. withinDays: number (negative = past). Dates: YYYY-MM-DD, 'today', '+30d'." }
+  },
+  required: ["field", "op"]
+};
+const targetSchema = { type: "string", description: "Record id the activity is attached to." };
+function summarizeRecord(ctx, record, opts = {}) {
+  const object = objectOf(ctx.store, record.object);
+  const qctx = object ? queryContext(ctx, object) : void 0;
+  const values = {};
+  for (const [k, v] of Object.entries(record.fields)) {
+    const field = object ? resolveField(object, k) : void 0;
+    if (!field || !qctx) {
+      values[k] = v;
+      continue;
+    }
+    if (field.type === "relation") {
+      const ids = Array.isArray(v) ? v : [v];
+      values[k] = ids.map((id) => ({ id, label: qctx.recordLabel("", String(id)) ?? String(id) }));
+      if (field.relation?.cardinality === "one") values[k] = values[k][0];
+    } else if (field.type === "image" || field.type === "files") {
+      const ids = (Array.isArray(v) ? v : [v]).map(String);
+      const files = ids.map((id) => ({ id, name: ctx.store.get("files", id)?.name ?? id }));
+      values[k] = field.type === "image" ? files[0] : files;
+    } else if (field.type === "select" || field.type === "multiSelect" || field.type === "user") {
+      values[k] = { value: v, label: formatFieldValue(field, v, qctx) };
+    } else {
+      values[k] = v;
+    }
+  }
+  return {
+    id: record.id,
+    object: record.object,
+    label: recordLabel(object, record),
+    fields: values,
+    ...record.ownerId ? { owner: { id: record.ownerId, name: userOf(ctx.store, record.ownerId)?.name } } : {},
+    ...opts.full ? { createdAt: new Date(record.createdAt).toISOString(), updatedAt: new Date(record.updatedAt).toISOString() } : {},
+    ...record.deletedAt ? { deleted: true } : {}
+  };
+}
+function summarizeActivity(a) {
+  return {
+    id: a.id,
+    type: a.type,
+    title: a.title,
+    ...a.body ? { body: a.body.length > 600 ? `${a.body.slice(0, 600)}…` : a.body } : {},
+    targets: a.targets,
+    ...a.dueAt ? { dueAt: new Date(a.dueAt).toISOString() } : {},
+    ...a.doneAt ? { doneAt: new Date(a.doneAt).toISOString() } : {},
+    ...a.assigneeId ? { assigneeId: a.assigneeId } : {},
+    ...a.attachments?.length ? { attachments: a.attachments.length } : {},
+    createdAt: new Date(a.createdAt).toISOString()
+  };
+}
+function str(input, key, required = true) {
+  const v = input[key];
+  if (typeof v === "string" && v.trim()) return v.trim();
+  if (required) throw new OpsError("validation", `Missing "${key}".`);
+  return "";
+}
+function num(input, key, fallback) {
+  const v = input[key];
+  return typeof v === "number" && Number.isFinite(v) ? v : fallback;
+}
+const AI_TOOLS = [
+  {
+    name: "describe_schema",
+    description: "Describe the CRM data model: objects, their fields (ids, types, select options, relations) and pipelines with stages. Call this first to learn field ids.",
+    inputSchema: { type: "object", properties: { object: { ...objectProp, description: "Only this object (optional)." } } },
+    mutating: false,
+    handler: (ctx, input) => describeSchema(ctx, typeof input.object === "string" ? input.object : void 0)
+  },
+  {
+    name: "search_records",
+    description: "Full-text search across records (names, emails, domains, phones) and activity titles. Returns the best matches with ids.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search text." },
+        objects: { type: "array", items: { type: "string" }, description: "Restrict to these object ids." },
+        limit: { type: "number", default: 10, maximum: 50 }
+      },
+      required: ["query"]
+    },
+    mutating: false,
+    handler: (ctx, input) => searchRecords(ctx, str(input, "query"), { objects: input.objects, limit: Math.min(50, num(input, "limit", 10)) })
+  },
+  {
+    name: "list_records",
+    description: "List records of an object with optional filters, sorts and pagination (max 100 per call).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        object: objectProp,
+        filters: { type: "array", items: filterSchema },
+        sorts: { type: "array", items: { type: "object", properties: { field: { type: "string" }, dir: { type: "string", enum: ["asc", "desc"] } }, required: ["field", "dir"] } },
+        search: { type: "string" },
+        viewId: { type: "string", description: "Apply a saved view's filters and sorts." },
+        offset: { type: "number", default: 0 },
+        limit: { type: "number", default: 25, maximum: 100 }
+      },
+      required: ["object"]
+    },
+    mutating: false,
+    handler: (ctx, input) => {
+      const page = listRecords(ctx, str(input, "object"), {
+        filters: input.filters,
+        sorts: input.sorts,
+        search: typeof input.search === "string" ? input.search : void 0,
+        viewId: typeof input.viewId === "string" ? input.viewId : void 0,
+        offset: num(input, "offset", 0),
+        limit: Math.min(100, num(input, "limit", 25))
+      });
+      return { total: page.total, offset: page.offset, hasMore: page.hasMore, records: page.items.map((r) => summarizeRecord(ctx, r)) };
+    }
+  },
+  {
+    name: "get_record",
+    description: "Get one record with every field, its relations (both directions) and its latest activities.",
+    inputSchema: { type: "object", properties: { id: { type: "string" } }, required: ["id"] },
+    mutating: false,
+    handler: (ctx, input) => {
+      const details = getRecordDetails(ctx, str(input, "id"));
+      const activities = listActivities(ctx, { target: details.record.id, limit: 10 }).items.map(summarizeActivity);
+      return { ...summarizeRecord(ctx, details.record, { full: true }), relations: details.relations, related: details.inverse.filter((i) => i.records.length).map((i) => ({ object: i.object, via: i.field, records: i.records.slice(0, 25), count: i.records.length })), activities };
+    }
+  },
+  {
+    name: "create_record",
+    description: "Create a record of an object. Returns the created record.",
+    inputSchema: { type: "object", properties: { object: objectProp, fields: fieldsProp, ownerId: { type: "string", description: "User id owning the record (default: you)." } }, required: ["object", "fields"] },
+    mutating: true,
+    handler: async (ctx, input) => summarizeRecord(ctx, await createRecord(ctx, str(input, "object"), input.fields ?? {}, { ...typeof input.ownerId === "string" ? { ownerId: input.ownerId } : {} }))
+  },
+  {
+    name: "update_record",
+    description: "Update some fields of a record (only the given fields change; null clears a field).",
+    inputSchema: { type: "object", properties: { id: { type: "string" }, fields: fieldsProp, ownerId: { type: ["string", "null"] } }, required: ["id", "fields"] },
+    mutating: true,
+    handler: async (ctx, input) => summarizeRecord(ctx, await updateRecord(ctx, str(input, "id"), input.fields ?? {}, input.ownerId !== void 0 ? { ownerId: input.ownerId } : {}))
+  },
+  {
+    name: "delete_record",
+    description: "Delete a record (soft delete: restorable until the data is compacted).",
+    inputSchema: { type: "object", properties: { id: { type: "string" } }, required: ["id"] },
+    mutating: true,
+    handler: (ctx, input) => deleteRecord(ctx, str(input, "id"))
+  },
+  {
+    name: "merge_records",
+    description: "Merge duplicate records into a primary one: empty fields are filled from the duplicates, relations and activities move to the primary, duplicates are removed.",
+    inputSchema: { type: "object", properties: { primaryId: { type: "string" }, duplicateIds: { type: "array", items: { type: "string" } } }, required: ["primaryId", "duplicateIds"] },
+    mutating: true,
+    handler: async (ctx, input) => {
+      const res = await mergeRecords(ctx, str(input, "primaryId"), input.duplicateIds ?? []);
+      return { record: summarizeRecord(ctx, res.record), merged: res.merged, movedActivities: res.movedActivities };
+    }
+  },
+  {
+    name: "add_note",
+    description: "Add a note (markdown) to a record's timeline.",
+    inputSchema: { type: "object", properties: { recordId: targetSchema, body: { type: "string" }, title: { type: "string" } }, required: ["recordId", "body"] },
+    mutating: true,
+    handler: async (ctx, input) => summarizeActivity(await addNote(ctx, str(input, "recordId"), str(input, "body"), typeof input.title === "string" ? input.title : void 0))
+  },
+  {
+    name: "log_activity",
+    description: "Log a call, email or meeting on one or more records.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        type: { type: "string", enum: ACTIVITY_TYPES.filter((t) => t !== "task") },
+        title: { type: "string" },
+        body: { type: "string" },
+        recordIds: { type: "array", items: { type: "string" } },
+        meta: { type: "object", additionalProperties: true, description: "e.g. { durationMin } for calls, { startAt, endAt } (epoch ms) for meetings." }
+      },
+      required: ["type", "title", "recordIds"]
+    },
+    mutating: true,
+    handler: async (ctx, input) => {
+      const targets = (input.recordIds ?? []).map((id) => ({ object: "", id }));
+      return summarizeActivity(await addActivity(ctx, { type: str(input, "type"), title: str(input, "title"), body: typeof input.body === "string" ? input.body : void 0, targets, meta: input.meta }));
+    }
+  },
+  {
+    name: "create_task",
+    description: "Create a task, optionally attached to records, with a due date and an assignee.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: { type: "string" },
+        body: { type: "string" },
+        dueAt: { type: "string", description: "ISO date or datetime." },
+        assigneeId: { type: "string" },
+        recordIds: { type: "array", items: { type: "string" } }
+      },
+      required: ["title"]
+    },
+    mutating: true,
+    handler: async (ctx, input) => summarizeActivity(
+      await createTask(ctx, {
+        title: str(input, "title"),
+        body: typeof input.body === "string" ? input.body : void 0,
+        dueAt: typeof input.dueAt === "string" ? input.dueAt : void 0,
+        assigneeId: typeof input.assigneeId === "string" ? input.assigneeId : void 0,
+        targets: (input.recordIds ?? []).map((id) => ({ object: "", id }))
+      })
+    )
+  },
+  {
+    name: "complete_task",
+    description: "Mark a task as done (or reopen it with done: false).",
+    inputSchema: { type: "object", properties: { id: { type: "string" }, done: { type: "boolean", default: true } }, required: ["id"] },
+    mutating: true,
+    handler: async (ctx, input) => summarizeActivity(await completeTask(ctx, str(input, "id"), input.done !== false))
+  },
+  {
+    name: "list_tasks",
+    description: "List tasks: open by default, optionally for one assignee / record, overdue only, or due within N days. Sorted by due date.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        assigneeId: { type: "string" },
+        recordId: { type: "string" },
+        status: { type: "string", enum: ["open", "done", "all"], default: "open" },
+        overdue: { type: "boolean" },
+        dueWithinDays: { type: "number" },
+        limit: { type: "number", default: 25, maximum: 100 }
+      }
+    },
+    mutating: false,
+    handler: (ctx, input) => {
+      const page = listTasks(ctx, {
+        assigneeId: typeof input.assigneeId === "string" ? input.assigneeId : void 0,
+        target: typeof input.recordId === "string" ? input.recordId : void 0,
+        status: input.status ?? "open",
+        overdue: input.overdue === true,
+        dueWithinDays: typeof input.dueWithinDays === "number" ? input.dueWithinDays : void 0,
+        limit: Math.min(100, num(input, "limit", 25))
+      });
+      return { total: page.total, tasks: page.items.map(summarizeActivity) };
+    }
+  },
+  {
+    name: "list_activities",
+    description: "A record's timeline (notes, calls, emails, meetings, tasks), most recent first. includeRelated adds activities of linked records (e.g. a company's people and deals).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        recordId: { type: "string" },
+        types: { type: "array", items: { type: "string", enum: ACTIVITY_TYPES } },
+        includeRelated: { type: "boolean" },
+        limit: { type: "number", default: 20, maximum: 100 }
+      }
+    },
+    mutating: false,
+    handler: (ctx, input) => {
+      const page = listActivities(ctx, {
+        target: typeof input.recordId === "string" ? input.recordId : void 0,
+        types: input.types,
+        includeRelated: input.includeRelated === true,
+        limit: Math.min(100, num(input, "limit", 20))
+      });
+      return { total: page.total, activities: page.items.map(summarizeActivity) };
+    }
+  },
+  {
+    name: "move_deal_stage",
+    description: "Move a deal (or any pipeline record) to a stage, by stage id or label. Updates probability; lostReason for lost stages.",
+    inputSchema: { type: "object", properties: { id: { type: "string" }, stage: { type: "string" }, lostReason: { type: "string" } }, required: ["id", "stage"] },
+    mutating: true,
+    handler: async (ctx, input) => summarizeRecord(ctx, await moveStage(ctx, str(input, "id"), str(input, "stage"), { lostReason: typeof input.lostReason === "string" ? input.lostReason : void 0 }))
+  },
+  {
+    name: "pipeline_summary",
+    description: "Pipeline overview: per stage deal count, amount and weighted amount, plus open / weighted / won totals and open deals by close month.",
+    inputSchema: { type: "object", properties: { pipelineId: { type: "string" }, ownerId: { type: "string" } } },
+    mutating: false,
+    handler: (ctx, input) => ({
+      pipelines: listPipelines(ctx).map((p) => ({ id: p.id, name: p.name })),
+      ...forecast(ctx, { pipelineId: typeof input.pipelineId === "string" ? input.pipelineId : void 0, ownerId: typeof input.ownerId === "string" ? input.ownerId : void 0 })
+    })
+  },
+  {
+    name: "run_report",
+    description: `Run a named report. Reports: ${Object.entries(REPORTS).map(([k, v]) => `${k} (${v.description})`).join("; ")}`,
+    inputSchema: {
+      type: "object",
+      properties: { name: { type: "string", enum: Object.keys(REPORTS) }, params: { type: "object", additionalProperties: true, description: "Report parameters, e.g. { months: 6 } or { days: 30 }." } },
+      required: ["name"]
+    },
+    mutating: false,
+    handler: (ctx, input) => runReport(ctx, str(input, "name"), input.params ?? {})
+  },
+  {
+    name: "create_field",
+    description: "Add a custom field to an object (admin only).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        object: objectProp,
+        label: { type: "string" },
+        type: { type: "string", enum: FIELD_TYPES },
+        options: { type: "array", items: { type: "string" }, description: "Option labels for select / multiSelect." },
+        relationObject: { type: "string", description: "Target object for relation fields." },
+        cardinality: { type: "string", enum: ["one", "many"] },
+        description: { type: "string" }
+      },
+      required: ["object", "label", "type"]
+    },
+    mutating: true,
+    handler: (ctx, input) => createField(ctx, str(input, "object"), {
+      label: str(input, "label"),
+      type: str(input, "type"),
+      options: input.options,
+      description: typeof input.description === "string" ? input.description : void 0,
+      ...input.relationObject ? { relation: { object: String(input.relationObject), cardinality: input.cardinality === "many" ? "many" : "one" } } : {}
+    })
+  },
+  {
+    name: "import_csv",
+    description: "Import CSV text into an object. Columns are mapped to fields automatically (or via mapping {header: fieldId}); duplicates (people by email, companies by domain) are updated. Runs as a DRY RUN unless confirm is true — show the report to the user before confirming.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        object: objectProp,
+        csv: { type: "string" },
+        mapping: { type: "object", additionalProperties: { type: "string" } },
+        onDuplicate: { type: "string", enum: ["update", "skip", "create"], default: "update" },
+        confirm: { type: "boolean", default: false }
+      },
+      required: ["object", "csv"]
+    },
+    mutating: true,
+    handler: async (ctx, input) => {
+      const report = await importCsv(ctx, {
+        object: str(input, "object"),
+        csv: String(input.csv ?? ""),
+        mapping: input.mapping,
+        onDuplicate: input.onDuplicate ?? "update",
+        dryRun: input.confirm !== true
+      });
+      return { ...report, rows: report.rows.slice(0, 50), rowsTruncated: report.rows.length > 50 };
+    }
+  },
+  // Automations, lead forms, email drafts (src/ai/automationTools.ts).
+  ...AUTOMATION_FORM_TOOLS,
+  // Modules, appearance, extensions (src/ai/customizeTools.ts).
+  ...CUSTOMIZE_TOOLS,
+  // Files metadata (src/ai/fileTools.ts).
+  ...FILE_TOOLS
+];
+const extraTools = /* @__PURE__ */ new Map();
+const toolListeners = /* @__PURE__ */ new Set();
+const TOOL_NAME_RE = /^[a-z][a-z0-9_]{1,63}$/;
+function registerAiTool(tool) {
+  if (!tool || typeof tool.name !== "string" || !TOOL_NAME_RE.test(tool.name)) throw new Error(`Invalid AI tool name "${String(tool?.name)}" (snake_case, ≤ 64 chars).`);
+  if (typeof tool.handler !== "function") throw new Error(`AI tool "${tool.name}" needs a handler.`);
+  if (!tool.inputSchema || tool.inputSchema.type !== "object") throw new Error(`AI tool "${tool.name}" needs an object inputSchema.`);
+  if (AI_TOOLS.some((t) => t.name === tool.name) || extraTools.has(tool.name)) throw new Error(`AI tool "${tool.name}" already exists.`);
+  extraTools.set(tool.name, { ...tool, mutating: tool.mutating !== false });
+  for (const l of [...toolListeners]) l();
+  return () => {
+    if (extraTools.delete(tool.name)) for (const l of [...toolListeners]) l();
+  };
+}
+function listAiTools() {
+  return extraTools.size ? [...AI_TOOLS, ...extraTools.values()] : AI_TOOLS;
+}
+function subscribeAiTools(listener) {
+  toolListeners.add(listener);
+  return () => toolListeners.delete(listener);
+}
+function findTool(name) {
+  return AI_TOOLS.find((t) => t.name === name) ?? extraTools.get(name);
+}
+function jsonTypeOf(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+function checkToolInput(schema, value, path) {
+  const types = schema.type === void 0 ? [] : Array.isArray(schema.type) ? schema.type : [schema.type];
+  let v = value;
+  if (types.length && v !== null && v !== void 0) {
+    const actual = jsonTypeOf(v);
+    const accepts = (t) => t === actual || t === "integer" && actual === "number" && Number.isInteger(v);
+    if (!types.some(accepts)) {
+      if ((types.includes("number") || types.includes("integer")) && typeof v === "string" && v.trim() !== "" && Number.isFinite(Number(v))) v = Number(v);
+      else if (types.includes("boolean") && (v === "true" || v === "false")) v = v === "true";
+      else throw new OpsError("validation", `${path} must be ${types.map((t) => t === "array" || t === "object" || t === "integer" ? `an ${t}` : `a ${t}`).join(" or ")}, got ${actual === "array" || actual === "object" ? `an ${actual}` : `${actual} ${JSON.stringify(v)}`.slice(0, 80)}.`);
+    }
+  }
+  if (v === null || v === void 0) return v;
+  if (schema.enum && !schema.enum.includes(v)) {
+    throw new OpsError("validation", `${path} must be one of ${schema.enum.map((e) => JSON.stringify(e)).join(", ")}, got ${JSON.stringify(v).slice(0, 80)}.`);
+  }
+  if (Array.isArray(v) && schema.items) {
+    const items = schema.items;
+    return v.map((item, i) => checkToolInput(items, item, `${path}[${i}]`));
+  }
+  if (jsonTypeOf(v) === "object" && (schema.properties || schema.required)) {
+    const obj = { ...v };
+    for (const key of schema.required ?? []) {
+      if (obj[key] === void 0 || obj[key] === null) throw new OpsError("validation", `${path}: missing required "${key}".`);
+    }
+    for (const [key, sub] of Object.entries(schema.properties ?? {})) {
+      if (obj[key] !== void 0) obj[key] = checkToolInput(sub, obj[key], `${path}.${key}`);
+    }
+    return obj;
+  }
+  return v;
+}
+async function callTool(ctx, name, input) {
+  const tool = findTool(name);
+  if (!tool) throw new OpsError("notFound", `Unknown tool "${name}". Tools: ${listAiTools().map((t) => t.name).join(", ")}.`);
+  if (input !== void 0 && input !== null && jsonTypeOf(input) !== "object") throw new OpsError("validation", `${name}: the input must be a JSON object, got ${jsonTypeOf(input) === "array" ? "an array" : `a ${jsonTypeOf(input)}`}.`);
+  const raw = input ?? {};
+  for (const key of tool.inputSchema.required ?? []) {
+    if (raw[key] === void 0 || raw[key] === null) throw new OpsError("validation", `${name}: missing required "${key}".`);
+  }
+  const args = checkToolInput({ ...tool.inputSchema, required: [] }, raw, name);
+  return tool.handler(ctx, args);
+}
+export {
+  AI_TOOLS,
+  callTool,
+  checkToolInput,
+  findTool,
+  listAiTools,
+  registerAiTool,
+  subscribeAiTools,
+  summarizeRecord
+};