@minded-ai/mindedjs 3.1.44 → 3.1.46

package/src/nodes/compilePrompt.ts

@@ -6,6 +6,13 @@ import { HistoryStep, TriggerHistoryStep } from '../types/Agent.types';
 import { State } from '../types/LangGraph.types';
 import { NodeType } from '../types/Flows.types';
 
+// Matches dotted path identifiers — allows letters, digits, `_`, `$`, `.`, `[`, `]`, spaces, and hyphens
+// (spaces/hyphens support node display names like "Greeting Prompt" and trigger keys like "some-key").
+// Implicitly rejects JSON braces (which contain `"` and `:`) since those chars are not in the set.
+const PLACEHOLDER_PATH_CHARS = String.raw`[A-Za-z0-9_.$\[\] -]`;
+const PLACEHOLDER_REGEX = new RegExp(String.raw`\{\s*([A-Za-z_$]${PLACEHOLDER_PATH_CHARS}*)\s*\}`, 'g');
+const SINGLE_PLACEHOLDER_REGEX = new RegExp(String.raw`^\{\s*([A-Za-z_$]${PLACEHOLDER_PATH_CHARS}*)\s*\}$`);
+
 /**
  * Extract node outputs from state.history and state.messages
  * Returns a map of nodeId/nodeDisplayName -> output object
@@ -129,29 +136,72 @@ export type ExtendedContextData = ContextData & {
  */
 export function compileParameter(parameter: string, context: ContextData = {}, inputKey?: string, inputSchema?: ZodSchema): any {
   try {
-    context = extendContextData(context);
+    return compileParameterWithContext(parameter, extendContextData(context), inputKey, inputSchema);
+  } catch (err) {
+    logger.error({ message: 'Error compiling parameter', err, parameter });
+    return parameter;
+  }
+}
 
-    // First, render with EJS
-    let compiledParameter = ejs.render(parameter, context).trim();
+/**
+ * Recursively compile placeholders inside nested objects/arrays.
+ * Top-level strings get full schema-based coercion; nested string leaves are compiled without schema coercion.
+ */
+export function compileValueDeep(value: unknown, context: ContextData = {}, inputKey?: string, inputSchema?: ZodSchema): any {
+  if (typeof value === 'string') return compileParameter(value, context, inputKey, inputSchema);
+  if (!value || typeof value !== 'object') return value;
+  const extCtx = extendContextData(context);
+  return compileValueDeepInternal(value, extCtx);
+}
 
-    // Then, replace placeholders in {} format
-    // If the result contains only one set of curly braces, get the native value at that key path, e.g., {state.memory.arrayOfStrings} -> state.memory.arrayOfStrings
-    // Otherwise, compile it into a string.
-    const keyPathMatch = compiledParameter.match(/^\{([^}]+)}$/);
-    if (keyPathMatch) {
-      const keyPath = keyPathMatch[1];
-      compiledParameter = getContextValueFromPath(keyPath, context, compiledParameter);
-    } else {
-      compiledParameter = replacePlaceholders(compiledParameter, context);
+function compileValueDeepInternal(value: unknown, context: ExtendedContextData): any {
+  if (typeof value === 'string') {
+    try {
+      return compileParameterWithContext(value, context);
+    } catch (err) {
+      logger.error({ message: 'Error compiling nested parameter', err, value });
+      return value;
     }
+  }
+  if (!value || typeof value !== 'object') return value;
+  if (Array.isArray(value)) return value.map((v) => compileValueDeepInternal(v, context));
+  return Object.fromEntries(Object.entries(value as Record<string, unknown>).map(([k, v]) => [k, compileValueDeepInternal(v, context)]));
+}
 
-    compiledParameter = coerceValueWithZodType(compiledParameter, inputKey, inputSchema);
+/** Shared implementation — expects already-extended context. */
+function compileParameterWithContext(parameter: string, context: ExtendedContextData, inputKey?: string, inputSchema?: ZodSchema): any {
+  let compiledParameter = ejs.render(parameter, context).trim();
 
-    return compiledParameter;
-  } catch (err) {
-    logger.error({ message: 'Error compiling parameter', err, parameter });
-    return parameter; // Return uncompiled if there's an error
+  // Single placeholder → return native value; otherwise replace all placeholders as strings.
+  // Regex matches path identifiers (allows spaces/hyphens for node display names), rejects JSON braces.
+  const keyPathMatch = compiledParameter.match(SINGLE_PLACEHOLDER_REGEX);
+  if (keyPathMatch) {
+    compiledParameter = getContextValueFromPath(keyPathMatch[1].trim(), context, compiledParameter);
+  } else {
+    compiledParameter = replacePlaceholders(compiledParameter, context);
   }
+
+  return coerceValueWithZodType(compiledParameter, inputKey, inputSchema);
+}
+
+/**
+ * Compile node parameters with placeholder replacement and type coercion.
+ * Use getSchemaForToolInference() separately to filter the schema for the LLM.
+ */
+export function compileNodeParameters(
+  parameters: Record<string, any> | undefined,
+  context: ContextData,
+  schema?: ZodSchema,
+): Record<string, any> {
+  const compiledParameters: Record<string, any> = {};
+
+  for (const [key, value] of Object.entries(parameters || {})) {
+    if (value !== '') {
+      compiledParameters[key] = compileValueDeep(value, context, key, schema);
+    }
+  }
+
+  return compiledParameters;
 }
 
 /**
@@ -161,12 +211,8 @@ export function compilePrompt(prompt: string, context: ContextData): string {
   try {
     context = extendContextData(context);
 
-    // First, render with EJS
     let compiledPrompt = ejs.render(prompt, context);
-
-    // Then, replace placeholders in {} format
     compiledPrompt = replacePlaceholders(compiledPrompt, context);
-
     return compiledPrompt;
   } catch (err) {
     logger.error({ message: 'Error compiling prompt', err, prompt });
@@ -215,10 +261,10 @@ function extendContextData(context: ContextData = {}): ExtendedContextData {
  * - {tools.NodeName.field} - node reference with 'tools' prefix (alias)
  */
 function replacePlaceholders(text: string, context: Record<string, any>): string {
-  return text.replace(/\{([^}]+)}/g, (match, keyPath) => {
+  return text.replace(PLACEHOLDER_REGEX, (match, keyPathRaw) => {
+    const keyPath = String(keyPathRaw).trim();
     const value = getContextValueFromPath(keyPath, context, match);
 
-    // In the case of complex values (e.g., arrays or objects), JSON stringify them to ensure all data is preserved.
     if (Array.isArray(value) || (typeof value === 'object' && value !== null)) {
       try {
         return JSON.stringify(value);

package/src/toolsLibrary/browserSessionPersistence.ts

@@ -3,6 +3,7 @@ import { logger } from '../utils/logger';
 import { saveRecord, getRecords } from './storage';
 
 const BROWSER_SESSION_KEY = 'browser-session';
+const STORAGE_OPERATION_TIMEOUT_MS = 3000;
 
 interface Cookie {
   name: string;
@@ -20,11 +21,34 @@ interface LocalStorageEntry {
   data: Record<string, string>;
 }
 
+const withTimeout = async <T>(promise: Promise<T>, timeoutMs: number, operation: string): Promise<T> => {
+  let timeout: NodeJS.Timeout | null = null;
+
+  try {
+    return await Promise.race([
+      promise,
+      new Promise<never>((_, reject) => {
+        timeout = setTimeout(() => {
+          reject(new Error(`${operation} timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+      }),
+    ]);
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  }
+};
+
 /**
  * Extract localStorage from the current page
  */
 const extractLocalStorageFromPage = async (page: Page): Promise<Record<string, string>> => {
-  return await page.evaluate(() => Object.fromEntries(Object.entries(localStorage)));
+  return await withTimeout(
+    page.evaluate(() => Object.fromEntries(Object.entries(localStorage))),
+    STORAGE_OPERATION_TIMEOUT_MS,
+    'Extract localStorage from current page',
+  );
 };
 
 /**
@@ -64,7 +88,11 @@ export const saveSessionDataViaSocket = async (
   sessionId: string,
 ): Promise<void> => {
   try {
-    const cookies = await context.cookies();
+    const cookies = await withTimeout(
+      context.cookies(),
+      STORAGE_OPERATION_TIMEOUT_MS,
+      'Extract browser cookies',
+    );
     const data: Record<string, unknown> = {};
 
     if (cookies && cookies.length > 0) {
@@ -74,10 +102,18 @@ export const saveSessionDataViaSocket = async (
     // Extract localStorage for ALL origins using CDP
     let client;
     try {
-      client = await context.newCDPSession(page);
+      client = await withTimeout(
+        context.newCDPSession(page),
+        STORAGE_OPERATION_TIMEOUT_MS,
+        'Create CDP session for browser session persistence',
+      );
 
       // Enable Target domain to track all frames and their origins
-      await client.send('Target.setDiscoverTargets', { discover: true });
+      await withTimeout(
+        client.send('Target.setDiscoverTargets', { discover: true }),
+        STORAGE_OPERATION_TIMEOUT_MS,
+        'Enable CDP target discovery',
+      );
 
       // Get all targets (frames, workers, etc.)
       type TargetInfo = {
@@ -88,7 +124,11 @@ export const saveSessionDataViaSocket = async (
         attached: boolean;
       };
 
-      const response = await client.send('Target.getTargets');
+      const response = await withTimeout(
+        client.send('Target.getTargets'),
+        STORAGE_OPERATION_TIMEOUT_MS,
+        'Get CDP targets for localStorage persistence',
+      );
       const targetInfos = (response as { targetInfos: TargetInfo[] }).targetInfos;
 
       // Extract unique origins from all page-type targets
@@ -121,12 +161,16 @@ export const saveSessionDataViaSocket = async (
             entries: Array<[string, string]>;
           };
 
-          const storageResponse = await client!.send('DOMStorage.getDOMStorageItems', {
-            storageId: {
-              securityOrigin: origin,
-              isLocalStorage: true,
-            },
-          });
+          const storageResponse = await withTimeout(
+            client!.send('DOMStorage.getDOMStorageItems', {
+              storageId: {
+                securityOrigin: origin,
+                isLocalStorage: true,
+              },
+            }),
+            STORAGE_OPERATION_TIMEOUT_MS,
+            `Extract localStorage for origin ${origin}`,
+          );
           const { entries } = storageResponse as DOMStorageResponse;
 
           if (entries && entries.length > 0) {
@@ -178,7 +222,11 @@ export const saveSessionDataViaSocket = async (
       }
     } finally {
       if (client) {
-        await client.detach().catch(() => { });
+        await withTimeout(
+          client.detach(),
+          STORAGE_OPERATION_TIMEOUT_MS,
+          'Detach CDP session after browser session persistence',
+        ).catch(() => { });
       }
     }
 

package/src/types/Flows.types.ts

@@ -158,6 +158,7 @@ export interface BrowserTaskNode extends BaseNode {
   model?: string;
   inputSchema?: SchemaField[];
   outputSchema?: OutputSchemaField[];
+  parameters?: Record<string, any>;
   autoTrigger?: boolean;
   defaultPayload?: string;
   proxyConfig?: ProxyConfig; // Proxy configuration supporting all proxy types