@hexabot-ai/api 3.3.0 → 3.3.2

package/dist/workflow/index.d.ts

@@ -23,6 +23,8 @@ export * from './repositories/memory-definition.repository';
 export * from './repositories/memory-record.repository';
 export * from './repositories/mcp-server.repository';
 export * from './contexts/conversational-workflow.context';
+export * from './contexts/workflow-runtime.context';
+export * from './types';
 export * from './services/workflow.service';
 export * from './services/workflow-version.service';
 export * from './services/workflow-run.service';

package/dist/workflow/index.js

@@ -39,6 +39,8 @@ __exportStar(require("./repositories/memory-definition.repository"), exports);
 __exportStar(require("./repositories/memory-record.repository"), exports);
 __exportStar(require("./repositories/mcp-server.repository"), exports);
 __exportStar(require("./contexts/conversational-workflow.context"), exports);
+__exportStar(require("./contexts/workflow-runtime.context"), exports);
+__exportStar(require("./types"), exports);
 __exportStar(require("./services/workflow.service"), exports);
 __exportStar(require("./services/workflow-version.service"), exports);
 __exportStar(require("./services/workflow-run.service"), exports);

package/dist/workflow/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/workflow/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAMA,oDAAkC;AAElC,6EAA2D;AAE3D,sEAAoD;AAEpD,oEAAkD;AAElD,4EAA0D;AAE1D,wEAAsD;AAEtD,qDAAmC;AAEnC,6DAA2C;AAE3C,yDAAuC;AAEvC,8DAA4C;AAE5C,0DAAwC;AAExC,uDAAqC;AAErC,6DAA2C;AAE3C,qEAAmD;AAEnD,iEAA+C;AAE/C,sEAAoD;AAEpD,kEAAgD;AAEhD,+DAA6C;AAE7C,qEAAmD;AAEnD,6EAA2D;AAE3D,yEAAuD;AAEvD,8EAA4D;AAE5D,0EAAwD;AAExD,uEAAqD;AAErD,6EAA2D;AAE3D,8DAA4C;AAE5C,sEAAoD;AAEpD,kEAAgD;AAEhD,uEAAqD;AAErD,mEAAiD;AAEjD,4DAA0C;AAE1C,6DAA2C;AAE3C,gEAA8C;AAE9C,qEAAmD;AAEnD,uEAAqD;AAErD,2EAAyD;AAEzD,mFAAiE;AAEjE,iFAA+D;AAE/D,iFAA+D;AAE/D,sEAAoD;AAEpD,wEAAsD;AAEtD,8DAA4C"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/workflow/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAMA,oDAAkC;AAElC,6EAA2D;AAE3D,sEAAoD;AAEpD,oEAAkD;AAElD,4EAA0D;AAE1D,wEAAsD;AAEtD,qDAAmC;AAEnC,6DAA2C;AAE3C,yDAAuC;AAEvC,8DAA4C;AAE5C,0DAAwC;AAExC,uDAAqC;AAErC,6DAA2C;AAE3C,qEAAmD;AAEnD,iEAA+C;AAE/C,sEAAoD;AAEpD,kEAAgD;AAEhD,+DAA6C;AAE7C,qEAAmD;AAEnD,6EAA2D;AAE3D,yEAAuD;AAEvD,8EAA4D;AAE5D,0EAAwD;AAExD,uEAAqD;AAErD,6EAA2D;AAE3D,sEAAoD;AAEpD,0CAAwB;AAExB,8DAA4C;AAE5C,sEAAoD;AAEpD,kEAAgD;AAEhD,uEAAqD;AAErD,mEAAiD;AAEjD,4DAA0C;AAE1C,6DAA2C;AAE3C,gEAA8C;AAE9C,qEAAmD;AAEnD,uEAAqD;AAErD,2EAAyD;AAEzD,mFAAiE;AAEjE,iFAA+D;AAE/D,iFAA+D;AAE/D,sEAAoD;AAEpD,wEAAsD;AAEtD,8DAA4C"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hexabot-ai/api",
   "private": false,
-  "version": "3.3.0",
+  "version": "3.3.2",
   "description": "Hexabot is a solution for creating and managing chatbots across multiple channels, leveraging AI for advanced conversational capabilities. It provides a user-friendly interface for building, training, and deploying chatbots with integrated support for various messaging platforms.",
   "author": "Hexastack",
   "license": "FCL-1.0-ALv2",
@@ -93,8 +93,8 @@
     "typeorm": "^0.3.29",
     "yaml": "^2.8.3",
     "zod": "^4.3.6",
-    "@hexabot-ai/agentic": "3.2.0",
-    "@hexabot-ai/types": "3.1.0"
+    "@hexabot-ai/agentic": "3.2.2",
+    "@hexabot-ai/types": "3.1.2"
   },
   "devDependencies": {
     "@compodoc/compodoc": "^1.2.1",
@@ -143,7 +143,7 @@
     "tsconfig-paths": "^4.2.0",
     "tsconfig-paths-jest": "^0.0.1",
     "typescript": "^5.8.3",
-    "@hexabot-ai/frontend": "3.3.0"
+    "@hexabot-ai/frontend": "3.3.2"
   },
   "optionalDependencies": {
     "@css-inline/css-inline-linux-arm64-musl": "^0.14.1",

package/src/bindings/index.ts

@@ -8,4 +8,6 @@ export * from './bindings.module';
 
 export * from './base-binding-kind';
 
+export * from './runtime-bindings';
+
 export * from './create-binding-kind';

package/src/extensions/actions/ai/ai-base.action.ts

@@ -7,17 +7,10 @@
 import { createOpenAI } from '@ai-sdk/openai';
 import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
 import { ProviderV2, ProviderV3 } from '@ai-sdk/provider';
-import {
-  IncomingMessageType,
-  Message,
-  StdIncomingMessage,
-  StdOutgoingMessage,
-  Thread,
-} from '@hexabot-ai/types';
+import { StdIncomingMessage, StdOutgoingMessage } from '@hexabot-ai/types';
 import {
   LanguageModel,
   LanguageModelUsage,
-  ModelMessage,
   ToolSet,
   hasToolCall,
   stepCountIs,
@@ -31,11 +24,15 @@ import { WorkflowRuntimeContext } from '@/workflow/contexts/workflow-runtime.con
 import { McpToolBindingDefinitions } from '@/workflow/types';
 
 import {
-  AiCommonSettings,
-  AiPromptInput,
-  DEFAULT_AI_MESSAGES_LIMIT,
-  DEFAULT_AI_PROMPT,
-} from './ai-schemas';
+  buildMemoryPrompt,
+  buildPrompt,
+  formatMemoryValue,
+  normalizeMessagesForModel,
+  resolveMemoryBindingSlugs,
+  resolveMessageContent,
+  type PromptPayload,
+} from './ai-prompt.helpers';
+import { AiCommonSettings, AiPromptInput } from './ai-schemas';
 
 export type { AiCommonSettings, AiPromptInput } from './ai-schemas';
 
@@ -55,16 +52,6 @@ export type LanguageModelProvider =
   | ProviderV3
   | ProviderV2;
 
-type PromptPayload =
-  | {
-      prompt: string;
-      system?: string;
-    }
-  | {
-      messages: ModelMessage[];
-      system?: string;
-    };
-
 export abstract class AiBaseAction<
   I,
   O,
@@ -374,254 +361,40 @@ export abstract class AiBaseAction<
   protected resolveMessageContent(
     payload: StdOutgoingMessage | StdIncomingMessage,
   ) {
-    if (!payload) {
-      return undefined;
-    }
-
-    const data = payload.data as Record<string, unknown>;
-
-    if (typeof data.text === 'string') {
-      return data.text;
-    }
-
-    if (typeof data.serializedText === 'string') {
-      return data.serializedText;
-    }
-
-    if (
-      payload.type === IncomingMessageType.location &&
-      typeof data.coordinates === 'object' &&
-      data.coordinates !== null &&
-      'lat' in data.coordinates &&
-      'lon' in data.coordinates
-    ) {
-      const { lat, lon } = data.coordinates as { lat: number; lon: number };
-
-      return `location:${lat},${lon}`;
-    }
-
-    try {
-      return JSON.stringify(data);
-    } catch {
-      return String(payload);
-    }
+    return resolveMessageContent(payload);
   }
 
   protected normalizeMessagesForModel(
-    messages: Message[],
+    messages: Parameters<typeof normalizeMessagesForModel>[0],
     subscriberId: string,
-  ): ModelMessage[] {
-    type ConversationMessage = {
-      role: Extract<ModelMessage['role'], 'user' | 'assistant'>;
-      content: string;
-      createdAt: Date;
-    };
-
-    const normalized: ConversationMessage[] = messages
-      .map((message) => {
-        const content = this.resolveMessageContent(message.message);
-
-        if (!content) {
-          return undefined;
-        }
-
-        const role: ConversationMessage['role'] =
-          message.sender === subscriberId ? 'user' : 'assistant';
-
-        return {
-          role,
-          content,
-          createdAt: message.createdAt,
-        };
-      })
-      .filter((message): message is ConversationMessage => Boolean(message));
-
-    return normalized
-      .sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime())
-      .map(({ role, content }) => ({ role, content }));
+  ) {
+    return normalizeMessagesForModel(messages, subscriberId);
   }
 
-  protected async buildPrompt(
+  protected buildPrompt(
     input: AiPromptInput,
     context: C,
     selectedMemorySlugs: string[] = [],
   ): Promise<PromptPayload> {
-    const promptPayload = { system: input.system };
-    const memoryPrompt = this.buildMemoryPrompt(context, selectedMemorySlugs);
-    if (memoryPrompt) {
-      promptPayload.system = promptPayload.system
-        ? `${promptPayload.system}\n\n${memoryPrompt}`
-        : memoryPrompt;
-    }
-
-    if (input.input_mode === 'prompt') {
-      const prompt = input.prompt ?? DEFAULT_AI_PROMPT;
-
-      return {
-        prompt,
-        system: promptPayload.system,
-      };
-    }
-
-    if (input.input_mode === 'history') {
-      const messagesLimit = input.messages_limit ?? DEFAULT_AI_MESSAGES_LIMIT;
-
-      if (messagesLimit < 1) {
-        throw new Error(
-          'Input mode "history" requires a positive "messages_limit" value.',
-        );
-      }
-
-      const subscriberId = context.initiatorId;
-      if (!subscriberId) {
-        throw new Error(
-          'A subscriber id is required to load previous messages for this action.',
-        );
-      }
-      const threadId = context.threadId;
-      if (!threadId) {
-        throw new Error(
-          'A thread id is required to load previous messages for this action.',
-        );
-      }
-
-      const messageService = context.services.message;
-      if (!messageService) {
-        throw new Error(
-          'Message service is unavailable in the workflow context.',
-        );
-      }
-
-      const history = await messageService.findLastMessages(
-        { id: threadId } as Thread,
-        messagesLimit,
-      );
-      const messages = this.normalizeMessagesForModel(history, subscriberId);
-
-      return { messages, system: promptPayload.system };
-    }
-
-    throw new Error(
-      'An "input_mode" of either "prompt" or "history" is required to build the model request.',
-    );
+    return buildPrompt(input, context, selectedMemorySlugs);
   }
 
   protected resolveMemoryBindingSlugs(
     context: C,
     memoryBindings?: RuntimeBindings['memory'],
   ): string[] {
-    if (!memoryBindings || Object.keys(memoryBindings).length === 0) {
-      return [];
-    }
-
-    const memoryStore = context.memoryStore;
-    if (!memoryStore) {
-      return [];
-    }
-
-    const idToSlug = new Map<string, string>();
-    for (const [slug, definition] of memoryStore.definitionCache.entries()) {
-      if (definition.id) {
-        idToSlug.set(definition.id, slug);
-      }
-    }
-
-    const selectedSlugs = new Set<string>();
-    for (const [defName, binding] of Object.entries(memoryBindings)) {
-      const definitionId = binding.settings?.definition_id;
-      const slug =
-        typeof definitionId === 'string'
-          ? idToSlug.get(definitionId)
-          : undefined;
-      if (!slug) {
-        throw new Error(
-          `Unable to resolve memory definition "${String(definitionId)}" from bindings.memory.${defName}.settings.definition_id.`,
-        );
-      }
-
-      selectedSlugs.add(slug);
-    }
-
-    return Array.from(selectedSlugs);
+    return resolveMemoryBindingSlugs(context, memoryBindings);
   }
 
   protected buildMemoryPrompt(
     context: C,
     selectedMemorySlugs: string[] = [],
   ): string | undefined {
-    if (selectedMemorySlugs.length === 0) {
-      return undefined;
-    }
-
-    const memoryStore = context.memoryStore;
-    if (!memoryStore) {
-      return undefined;
-    }
-
-    const { definitionCache, instances } = memoryStore;
-    if (!definitionCache || definitionCache.size === 0) {
-      return undefined;
-    }
-
-    const sections: string[] = [];
-    const selectedSlugSet = new Set(selectedMemorySlugs);
-    for (const [slug, definition] of definitionCache.entries()) {
-      if (!selectedSlugSet.has(slug)) {
-        continue;
-      }
-
-      const instance = instances[slug];
-      if (!instance) {
-        continue;
-      }
-
-      const lines: string[] = [];
-      for (const field of instance.fields({ includeAdditional: true })) {
-        if (field.value === undefined) {
-          continue;
-        }
-
-        const label = (field.title ?? field.name).trim();
-        const value = this.formatMemoryValue(field.value);
-        lines.push(`- ${label}: ${value}`);
-      }
-
-      if (lines.length === 0) {
-        continue;
-      }
-
-      sections.push(`## ${definition.name}\n${lines.join('\n')}`);
-    }
-
-    if (sections.length === 0) {
-      return undefined;
-    }
-
-    return `# Working Memory\n${sections.join('\n\n')}`;
+    return buildMemoryPrompt(context, selectedMemorySlugs);
   }
 
   protected formatMemoryValue(value: unknown): string {
-    if (typeof value === 'string') {
-      return value;
-    }
-
-    if (typeof value === 'number' || typeof value === 'boolean') {
-      return String(value);
-    }
-
-    if (value === null) {
-      return 'null';
-    }
-
-    if (value instanceof Date) {
-      return value.toISOString();
-    }
-
-    try {
-      return JSON.stringify(value);
-    } catch {
-      return String(value);
-    }
+    return formatMemoryValue(value);
   }
 
   protected safeStringify(value: unknown): string {

package/src/extensions/actions/ai/ai-prompt.helpers.ts

@@ -0,0 +1,299 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import {
+  IncomingMessageType,
+  Message,
+  StdIncomingMessage,
+  StdOutgoingMessage,
+  Thread,
+} from '@hexabot-ai/types';
+import { ModelMessage } from 'ai';
+
+import { RuntimeBindings } from '@/bindings/runtime-bindings';
+import { WorkflowRuntimeContext } from '@/workflow/contexts/workflow-runtime.context';
+
+import {
+  AiPromptInput,
+  DEFAULT_AI_MESSAGES_LIMIT,
+  DEFAULT_AI_PROMPT,
+} from './ai-schemas';
+
+/**
+ * Shared prompt + working-memory builders used by every AI-flavored action
+ * (`ai_agent`, `generate_*`, and the sandboxed `ai_coding_agent`) so they build
+ * the model request from a direct prompt or conversation history, and inject
+ * selected memory, in exactly the same way. `AiBaseAction` delegates to these;
+ * actions that do not extend it (the coding agent runs on a different engine)
+ * import them directly.
+ */
+
+export type PromptPayload =
+  | { prompt: string; system?: string }
+  | { messages: ModelMessage[]; system?: string };
+
+export function resolveMessageContent(
+  payload: StdOutgoingMessage | StdIncomingMessage,
+): string | undefined {
+  if (!payload) {
+    return undefined;
+  }
+
+  const data = payload.data as Record<string, unknown>;
+
+  if (typeof data.text === 'string') {
+    return data.text;
+  }
+
+  if (typeof data.serializedText === 'string') {
+    return data.serializedText;
+  }
+
+  if (
+    payload.type === IncomingMessageType.location &&
+    typeof data.coordinates === 'object' &&
+    data.coordinates !== null &&
+    'lat' in data.coordinates &&
+    'lon' in data.coordinates
+  ) {
+    const { lat, lon } = data.coordinates as { lat: number; lon: number };
+
+    return `location:${lat},${lon}`;
+  }
+
+  try {
+    return JSON.stringify(data);
+  } catch {
+    return String(payload);
+  }
+}
+
+export function normalizeMessagesForModel(
+  messages: Message[],
+  subscriberId: string,
+): ModelMessage[] {
+  type ConversationMessage = {
+    role: Extract<ModelMessage['role'], 'user' | 'assistant'>;
+    content: string;
+    createdAt: Date;
+  };
+
+  const normalized: ConversationMessage[] = messages
+    .map((message) => {
+      const content = resolveMessageContent(message.message);
+
+      if (!content) {
+        return undefined;
+      }
+
+      const role: ConversationMessage['role'] =
+        message.sender === subscriberId ? 'user' : 'assistant';
+
+      return {
+        role,
+        content,
+        createdAt: message.createdAt,
+      };
+    })
+    .filter((message): message is ConversationMessage => Boolean(message));
+
+  return normalized
+    .sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime())
+    .map(({ role, content }) => ({ role, content }));
+}
+
+export function formatMemoryValue(value: unknown): string {
+  if (typeof value === 'string') {
+    return value;
+  }
+
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return String(value);
+  }
+
+  if (value === null) {
+    return 'null';
+  }
+
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+export function buildMemoryPrompt(
+  context: WorkflowRuntimeContext,
+  selectedMemorySlugs: string[] = [],
+): string | undefined {
+  if (selectedMemorySlugs.length === 0) {
+    return undefined;
+  }
+
+  const memoryStore = context.memoryStore;
+  if (!memoryStore) {
+    return undefined;
+  }
+
+  const { definitionCache, instances } = memoryStore;
+  if (!definitionCache || definitionCache.size === 0) {
+    return undefined;
+  }
+
+  const sections: string[] = [];
+  const selectedSlugSet = new Set(selectedMemorySlugs);
+  for (const [slug, definition] of definitionCache.entries()) {
+    if (!selectedSlugSet.has(slug)) {
+      continue;
+    }
+
+    const instance = instances[slug];
+    if (!instance) {
+      continue;
+    }
+
+    const lines: string[] = [];
+    for (const field of instance.fields({ includeAdditional: true })) {
+      if (field.value === undefined) {
+        continue;
+      }
+
+      const label = (field.title ?? field.name).trim();
+      const value = formatMemoryValue(field.value);
+      lines.push(`- ${label}: ${value}`);
+    }
+
+    if (lines.length === 0) {
+      continue;
+    }
+
+    sections.push(`## ${definition.name}\n${lines.join('\n')}`);
+  }
+
+  if (sections.length === 0) {
+    return undefined;
+  }
+
+  return `# Working Memory\n${sections.join('\n\n')}`;
+}
+
+export function resolveMemoryBindingSlugs(
+  context: WorkflowRuntimeContext,
+  memoryBindings?: RuntimeBindings['memory'],
+): string[] {
+  if (!memoryBindings || Object.keys(memoryBindings).length === 0) {
+    return [];
+  }
+
+  const memoryStore = context.memoryStore;
+  if (!memoryStore) {
+    return [];
+  }
+
+  const idToSlug = new Map<string, string>();
+  for (const [slug, definition] of memoryStore.definitionCache.entries()) {
+    if (definition.id) {
+      idToSlug.set(definition.id, slug);
+    }
+  }
+
+  const selectedSlugs = new Set<string>();
+  for (const [defName, binding] of Object.entries(memoryBindings)) {
+    const definitionId = binding.settings?.definition_id;
+    const slug =
+      typeof definitionId === 'string' ? idToSlug.get(definitionId) : undefined;
+    if (!slug) {
+      throw new Error(
+        `Unable to resolve memory definition "${String(definitionId)}" from bindings.memory.${defName}.settings.definition_id.`,
+      );
+    }
+
+    selectedSlugs.add(slug);
+  }
+
+  return Array.from(selectedSlugs);
+}
+
+/**
+ * Merge an optional working-memory section into the system prompt so selected
+ * memory is presented consistently regardless of the action's input mode.
+ */
+export function mergeMemoryIntoSystem(
+  context: WorkflowRuntimeContext,
+  system: string | undefined,
+  selectedMemorySlugs: string[] = [],
+): string | undefined {
+  const memoryPrompt = buildMemoryPrompt(context, selectedMemorySlugs);
+  if (!memoryPrompt) {
+    return system;
+  }
+
+  return system ? `${system}\n\n${memoryPrompt}` : memoryPrompt;
+}
+
+export async function buildPrompt(
+  input: AiPromptInput,
+  context: WorkflowRuntimeContext,
+  selectedMemorySlugs: string[] = [],
+): Promise<PromptPayload> {
+  const system = mergeMemoryIntoSystem(
+    context,
+    input.system,
+    selectedMemorySlugs,
+  );
+
+  if (input.input_mode === 'prompt') {
+    const prompt = input.prompt ?? DEFAULT_AI_PROMPT;
+
+    return { prompt, system };
+  }
+
+  if (input.input_mode === 'history') {
+    const messagesLimit = input.messages_limit ?? DEFAULT_AI_MESSAGES_LIMIT;
+
+    if (messagesLimit < 1) {
+      throw new Error(
+        'Input mode "history" requires a positive "messages_limit" value.',
+      );
+    }
+
+    const subscriberId = context.initiatorId;
+    if (!subscriberId) {
+      throw new Error(
+        'A subscriber id is required to load previous messages for this action.',
+      );
+    }
+    const threadId = context.threadId;
+    if (!threadId) {
+      throw new Error(
+        'A thread id is required to load previous messages for this action.',
+      );
+    }
+
+    const messageService = context.services.message;
+    if (!messageService) {
+      throw new Error(
+        'Message service is unavailable in the workflow context.',
+      );
+    }
+
+    const history = await messageService.findLastMessages(
+      { id: threadId } as Thread,
+      messagesLimit,
+    );
+    const messages = normalizeMessagesForModel(history, subscriberId);
+
+    return { messages, system };
+  }
+
+  throw new Error(
+    'An "input_mode" of either "prompt" or "history" is required to build the model request.',
+  );
+}

package/src/extensions/index.ts

@@ -20,6 +20,10 @@ export * from './channels/web/inbound';
 
 export * from './helpers/local-storage/index.helper';
 
+export * from './actions/ai/ai-prompt.helpers';
+
+export * from './actions/ai/ai-schemas';
+
 export * from './actions/ai/model.binding';
 
 export * from './actions/ai/tools.binding';

package/src/license/types/license-quota.ts

@@ -45,7 +45,7 @@ export const LICENSE_QUOTA_LIMITS: Record<
     unlimited: 25,
   },
   workflows: {
-    community: 3,
+    community: 10,
     starter: 25,
     pro: 150,
     unlimited: null,