@erxes/api-shared 0.0.0-stage → 3.2.19-1

package/src/core-modules/automations/constants.ts

@@ -0,0 +1,181 @@
+export const AUTOMATION_PROPERTY_OPERATORS = {
+  SET: 'set',
+  CLEAR: 'clear',
+  CONCAT: 'concat',
+  ADD: 'add',
+  SUBTRACT: 'subtract',
+  MULTIPLY: 'multiply',
+  DIVIDE: 'divide',
+  PERCENT: 'percent',
+  ADD_DAY: 'addDay',
+  SUBTRACT_DAY: 'subtractDay',
+  SPLIT: 'split',
+  PUSH: 'push',
+  ADD_TO_SET: 'addToSet',
+  PULL: 'pull',
+  ALL: [
+    'set',
+    'clear',
+    'concat',
+    'add',
+    'subtract',
+    'multiply',
+    'divide',
+    'percent',
+    'addDay',
+    'subtractDay',
+    'split',
+    'push',
+    'addToSet',
+    'pull',
+  ],
+};
+
+export const STATIC_PLACEHOLDER = {
+  '{{ now }}': 0,
+  '{{ tomorrow }}': 1,
+  '{{ nextWeek }}': 7,
+  '{{ nextMonth }}': 30,
+};
+
+export const AUTOMATION_STATUSES = {
+  DRAFT: 'draft',
+  ACTIVE: 'active',
+  ARCHIVED: 'archived',
+} as const;
+
+export const AUTOMATION_CORE_ACTIONS = {
+  DELAY: 'delay',
+  IF: 'if',
+  SPLIT: 'split',
+  FIND_OBJECT: 'findObject',
+  TRANSFORM: 'transform',
+  SET_PROPERTY: 'setProperty',
+  SEND_EMAIL: 'sendEmail',
+  OUTGOING_WEBHOOK: 'outgoingWebhook',
+  MESSAGE_PRO: 'messagePro',
+  WAIT_EVENT: 'waitEvent',
+  AI_AGENT: 'aiAgent',
+  WORKFLOW: 'workflow',
+};
+
+export const AUTOMATION_CORE_TRIGGER_TYPES = {
+  INCOMING_WEBHOOK: 'core:webhooks.incoming',
+  SCHEDULE: 'core:schedules.recurring',
+  USER: 'core:organization.users',
+  CUSTOMER: 'core:contacts.customers',
+  LEAD: 'core:contacts.leads',
+  COMPANY: 'core:contacts.companies',
+};
+
+export enum TAutomationFindObjectType {
+  COMPANY = 'core:contacts.companies',
+  CUSTOMER = 'core:contacts.customers',
+  USER = 'core:organization.users',
+}
+
+export const AUTOMATION_EMAIL_RECIPIENTS_TYPES = [
+  {
+    type: 'customMail',
+    name: 'customMails',
+    label: 'Custom Mails',
+  },
+  {
+    type: 'attributionMail',
+    name: 'attributionMails',
+    label: 'Attribution Mails',
+  },
+  {
+    type: 'segmentBased',
+    name: 'segmentBased',
+    label: 'Trigger Segment Based Mails',
+  },
+  {
+    type: 'teamMember',
+    name: 'teamMemberIds',
+    label: 'Team Members',
+  },
+  {
+    type: 'lead',
+    name: 'leadIds',
+    label: 'Leads',
+  },
+  {
+    type: 'customer',
+    name: 'customerIds',
+    label: 'Customers',
+  },
+  {
+    type: 'company',
+    name: 'companyIds',
+    label: 'Companies',
+  },
+];
+
+/**
+ * Machine readable reason an action failed. Written by the automations service
+ * at the single execution error chokepoint and grouped by execution stats, so
+ * "what kind of failure" is answerable without parsing error messages.
+ */
+// Core actions own their own pause semantics, so deferring them would fight
+// the engine rather than help it.
+export const AUTOMATION_NON_DEFERRABLE_CORE_ACTIONS = [
+  AUTOMATION_CORE_ACTIONS.WORKFLOW,
+  AUTOMATION_CORE_ACTIONS.DELAY,
+  AUTOMATION_CORE_ACTIONS.IF,
+  AUTOMATION_CORE_ACTIONS.SPLIT,
+  AUTOMATION_CORE_ACTIONS.WAIT_EVENT,
+];
+
+/**
+ * Core actions have no plugin to queue work on their behalf, so the engine
+ * reads their deferral straight from here. Empty means nothing is deferred;
+ * add an entry to move a core action off the synchronous path.
+ */
+export const AUTOMATION_CORE_ACTION_DEFERRED: Record<
+  string,
+  { mode: 'standby' | 'ignore'; timeoutMinutes?: number }
+> = {
+  // A provider call can outlast any sane synchronous budget, so the flow parks
+  // on it rather than holding the trigger open.
+  [AUTOMATION_CORE_ACTIONS.AI_AGENT]: { mode: 'standby', timeoutMinutes: 3 },
+};
+
+export const AUTOMATION_DEFERRED_TIMEOUT = {
+  DEFAULT_MINUTES: 10,
+  MAX_MINUTES: 60,
+};
+
+export const AUTOMATION_ERROR_CODES = {
+  // Set explicitly where the failure is thrown
+  CONFIG_INVALID: 'CONFIG_INVALID',
+  NOT_FOUND: 'NOT_FOUND',
+  PLUGIN_NOT_ENABLED: 'PLUGIN_NOT_ENABLED',
+  PLUGIN_ACTION_FAILED: 'PLUGIN_ACTION_FAILED',
+  AI_AGENT_FAILED: 'AI_AGENT_FAILED',
+  WORKFLOW_DEPTH_EXCEEDED: 'WORKFLOW_DEPTH_EXCEEDED',
+  DEFERRED_TIMEOUT: 'DEFERRED_TIMEOUT',
+  // Derived from the outgoing webhook failure phase
+  WEBHOOK_TIMEOUT: 'WEBHOOK_TIMEOUT',
+  WEBHOOK_NETWORK_FAILED: 'WEBHOOK_NETWORK_FAILED',
+  WEBHOOK_BAD_RESPONSE: 'WEBHOOK_BAD_RESPONSE',
+  WEBHOOK_FAILED: 'WEBHOOK_FAILED',
+  // Fallbacks, from the shared error classifier
+  PROVIDER_ERROR: 'PROVIDER_ERROR',
+  INTERNAL_ERROR: 'INTERNAL_ERROR',
+  BUSINESS_ERROR: 'BUSINESS_ERROR',
+  UNKNOWN: 'UNKNOWN',
+} as const;
+
+export type TAutomationErrorCode =
+  (typeof AUTOMATION_ERROR_CODES)[keyof typeof AUTOMATION_ERROR_CODES];
+
+// Never registered as an event trigger, so only a broadcast can start it.
+export const BROADCAST_TRIGGER_TYPE = 'core:broadcast';
+
+// A broadcast hands each run one customer, so it acts as that customer.
+export const BROADCAST_TARGET_TYPE = 'core:contacts.customers';
+
+// The record type a trigger hands its run; usually the trigger's own type.
+export const getTriggerTargetType = (triggerType: string) =>
+  triggerType === BROADCAST_TRIGGER_TYPE ? BROADCAST_TARGET_TYPE : triggerType;

package/src/core-modules/automations/definitions/aiAgents.ts

@@ -0,0 +1,343 @@
+import { Schema } from 'mongoose';
+import { nanoid } from 'nanoid';
+
+// One uploaded file usually mixes three kinds of text: rules that shape how the
+// agent answers, examples it should imitate, and facts it may quote. Only the
+// last may ever reach retrieval, so the split is per section, not per file.
+export type TAiAgentFileSectionRole = 'behavior' | 'content' | 'example';
+
+export interface IAiAgentFileSection {
+  // Derived from the section's heading path, so it survives content edits.
+  key: string;
+  name: string;
+  role: TAiAgentFileSectionRole;
+  // Set once by the indexer; a human edit clears it and is never overwritten.
+  detected?: boolean;
+}
+
+export interface IAiAgentFile {
+  id: string;
+  key: string;
+  name: string;
+  size?: number;
+  type?: string;
+  uploadedAt?: Date | string;
+  purpose?: 'core' | 'knowledge' | 'policy' | 'examples';
+  sections?: IAiAgentFileSection[];
+  status?: 'uploaded' | 'indexing' | 'indexed' | 'failed';
+  chunkCount?: number;
+  indexedAt?: Date | string;
+  contentHash?: string;
+  indexError?: string;
+  versions?: IAiAgentFileVersion[];
+}
+
+export interface IAiAgentFileVersion {
+  key: string;
+  name: string;
+  size?: number;
+  type?: string;
+  uploadedAt?: Date | string;
+}
+
+export interface IAiAgentConnectionConfig {
+  apiKey?: string;
+  baseUrl?: string;
+  headers?: Record<string, string>;
+  [key: string]: any;
+}
+
+export interface ICloudflareAiGatewayAgentConnection {
+  provider: 'cloudflare-ai-gateway';
+  model: string;
+  config: IAiAgentConnectionConfig & {
+    accountId?: string;
+    gatewayId?: string;
+    gatewayToken?: string;
+    mode?: 'compat' | 'openai-provider';
+  };
+}
+
+export interface IOpenAIAgentConnection {
+  provider: 'openai';
+  model: string;
+  config: IAiAgentConnectionConfig;
+}
+
+export interface IKimiAgentConnection {
+  provider: 'kimi';
+  model: string;
+  config: IAiAgentConnectionConfig;
+}
+
+export interface IKimiCodingAgentConnection {
+  provider: 'kimi-code';
+  model: string;
+  config: IAiAgentConnectionConfig;
+}
+
+export interface IGrokAgentConnection {
+  provider: 'grok';
+  model: string;
+  config: IAiAgentConnectionConfig;
+}
+
+export type IAiAgentConnection =
+  | ICloudflareAiGatewayAgentConnection
+  | IOpenAIAgentConnection
+  | IKimiAgentConnection
+  | IKimiCodingAgentConnection
+  | IGrokAgentConnection;
+
+export interface ILegacyAiAgentConnectionConfig {
+  apiKey?: string;
+  baseUrl?: string;
+  headers?: Record<string, string>;
+  accountId?: string;
+  gatewayId?: string;
+  gatewayToken?: string;
+  mode?: 'compat' | 'openai-provider';
+  cloudflare?: {
+    accountId?: string;
+    gatewayId?: string;
+    gatewayToken?: string;
+    mode?: 'compat' | 'openai-provider';
+  };
+  [key: string]: any;
+}
+
+export interface IAiAgentRuntime {
+  temperature: number;
+  maxTokens: number;
+  timeoutMs: number;
+}
+
+export interface IAiAgentRetrieval {
+  enabled: boolean;
+  mode: 'prompt' | 'tool';
+  strategy: 'keyword' | 'vector' | 'hybrid';
+  topK: number;
+  maxContextBytes: number;
+  minScore?: number;
+}
+
+export interface IAiAgentKnowledgeSource {
+  pluginName: string;
+  moduleName: string;
+  key: string;
+  scope?: 'all' | 'selected';
+  sourceIds: string[];
+  config?: Record<string, unknown>;
+}
+
+export interface IAiAgentTool {
+  pluginName: string;
+  moduleName: string;
+  key: string;
+  enabled?: boolean;
+  config?: Record<string, unknown>;
+}
+
+export interface IAiAgentContext {
+  systemPrompt: string;
+  retrieval?: IAiAgentRetrieval;
+  files: IAiAgentFile[];
+  knowledgeSources?: IAiAgentKnowledgeSource[];
+  tools?: IAiAgentTool[];
+}
+
+export interface IAiAgent {
+  name: string;
+  description: string;
+  connection: IAiAgentConnection;
+  runtime: IAiAgentRuntime;
+  context: IAiAgentContext;
+}
+
+export interface AiAgentDocument extends IAiAgent {
+  _id: string;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+const aiAgentFileVersionSchema = new Schema<IAiAgentFileVersion>(
+  {
+    key: { type: String, required: true },
+    name: { type: String, required: true },
+    size: { type: Number },
+    type: { type: String },
+    uploadedAt: { type: Date },
+  },
+  { _id: false },
+);
+
+const aiAgentFileSectionSchema = new Schema<IAiAgentFileSection>(
+  {
+    key: { type: String, required: true },
+    name: { type: String, required: true },
+    role: {
+      type: String,
+      enum: ['behavior', 'content', 'example'],
+      required: true,
+    },
+    detected: { type: Boolean },
+  },
+  { _id: false },
+);
+
+const aiAgentFileSchema = new Schema<IAiAgentFile>(
+  {
+    id: { type: String, required: true },
+    key: { type: String, required: true },
+    name: { type: String, required: true },
+    size: { type: Number },
+    type: { type: String },
+    uploadedAt: { type: Date },
+    purpose: {
+      type: String,
+      enum: ['core', 'knowledge', 'policy', 'examples'],
+      default: 'knowledge',
+    },
+    sections: {
+      type: [aiAgentFileSectionSchema],
+      default: () => [],
+    },
+    status: {
+      type: String,
+      enum: ['uploaded', 'indexing', 'indexed', 'failed'],
+      default: 'uploaded',
+    },
+    chunkCount: { type: Number },
+    indexedAt: { type: Date },
+    contentHash: { type: String },
+    indexError: { type: String },
+    versions: {
+      type: [aiAgentFileVersionSchema],
+      default: () => [],
+    },
+  },
+  { _id: false },
+);
+
+const aiAgentConnectionSchema = new Schema<IAiAgentConnection>(
+  {
+    provider: {
+      type: String,
+      required: true,
+      enum: ['cloudflare-ai-gateway', 'openai', 'kimi', 'kimi-code', 'grok'],
+      default: 'cloudflare-ai-gateway',
+    },
+    model: { type: String, required: true, default: 'openai/gpt-5-mini' },
+    config: {
+      type: Object,
+      default: () => ({}),
+    },
+  },
+  { _id: false },
+);
+
+const aiAgentRuntimeSchema = new Schema<IAiAgentRuntime>(
+  {
+    temperature: { type: Number, default: 0.2 },
+    maxTokens: { type: Number, default: 2000 },
+    timeoutMs: { type: Number, default: 15000 },
+  },
+  { _id: false },
+);
+
+const aiAgentKnowledgeSourceSchema = new Schema<IAiAgentKnowledgeSource>(
+  {
+    pluginName: { type: String, required: true },
+    moduleName: { type: String, required: true },
+    key: { type: String, required: true },
+    scope: { type: String, enum: ['all', 'selected'] },
+    sourceIds: { type: [String], default: () => [] },
+    config: {
+      type: Object,
+      default: () => ({}),
+    },
+  },
+  { _id: false },
+);
+
+const aiAgentToolSchema = new Schema<IAiAgentTool>(
+  {
+    pluginName: { type: String, required: true },
+    moduleName: { type: String, required: true },
+    key: { type: String, required: true },
+    enabled: { type: Boolean, default: true },
+    config: {
+      type: Object,
+      default: () => ({}),
+    },
+  },
+  { _id: false },
+);
+
+const aiAgentContextSchema = new Schema<IAiAgentContext>(
+  {
+    systemPrompt: { type: String, default: '' },
+    retrieval: {
+      enabled: { type: Boolean, default: true },
+      mode: {
+        type: String,
+        enum: ['prompt', 'tool'],
+        default: 'prompt',
+      },
+      strategy: {
+        type: String,
+        enum: ['keyword', 'vector', 'hybrid'],
+        default: 'keyword',
+      },
+      topK: { type: Number, default: 5 },
+      maxContextBytes: { type: Number, default: 8000 },
+      minScore: { type: Number },
+    },
+    files: {
+      type: [aiAgentFileSchema],
+      default: () => [],
+    },
+    knowledgeSources: {
+      type: [aiAgentKnowledgeSourceSchema],
+      default: () => [],
+    },
+    tools: {
+      type: [aiAgentToolSchema],
+      default: () => [],
+    },
+  },
+  { _id: false },
+);
+
+export const aiAgentSchema = new Schema<AiAgentDocument>(
+  {
+    _id: {
+      type: String,
+      default: () => nanoid(),
+    },
+    name: { type: String, required: true, trim: true },
+    description: { type: String, default: '' },
+    connection: {
+      type: aiAgentConnectionSchema,
+      required: true,
+    },
+    runtime: {
+      type: aiAgentRuntimeSchema,
+      default: () => ({}),
+    },
+    context: {
+      type: aiAgentContextSchema,
+      default: () => ({}),
+    },
+  },
+  { timestamps: true },
+);
+
+aiAgentSchema.index(
+  {
+    'context.knowledgeSources.pluginName': 1,
+    'context.knowledgeSources.moduleName': 1,
+    'context.knowledgeSources.key': 1,
+  },
+  { name: 'ai_agent_knowledge_source_config_lookup' },
+);