@minded-ai/mindedjs 2.0.0-beta1 → 2.0.1-beta-1

package/src/agent.ts

@@ -424,7 +424,7 @@ export class Agent {
       // Try to acquire lock atomically (unless bypassing session check)
       if (!bypassSessionCheck && !(await this.interruptSessionManager.lock(sessionId))) {
         // Could not acquire lock, session is being processed - enqueue the message
-        logger.info({ msg: 'Enqueuing message', sessionId, triggerBody, triggerName, appName });
+        logger.debug({ msg: 'Enqueuing message', sessionId, triggerBody, triggerName, appName });
         await this.interruptSessionManager.enqueueMessage(sessionId, {
           triggerBody,
           triggerName,
@@ -560,7 +560,7 @@ export class Agent {
         if (nextMessage.appName) {
           invokeParams.appName = nextMessage.appName;
         }
-        logger.info({ msg: 'Invoking next message in the queue', invokeParams });
+        logger.debug({ msg: 'Invoking next message in the queue', invokeParams });
         return await this.invoke(invokeParams);
       }
 

package/src/interrupts/BaseInterruptSessionManager.ts

@@ -32,7 +32,7 @@ export interface InterruptSessionManager {
   enqueueMessage(sessionId: string, message: QueuedMessage): void | Promise<void>;
   dequeueAll(sessionId: string): QueuedMessage[] | Promise<QueuedMessage[]>;
   dequeue(sessionId: string): QueuedMessage | null | Promise<QueuedMessage | null>;
-  checkQueueAndInterrupt(sessionId: string, updateStateObject?: Partial<State>): Promise<boolean>;
+  checkQueueAndInterrupt(sessionId: string, updateStateObject?: State): Promise<boolean>;
 }
 
 export abstract class BaseInterruptSessionManager implements InterruptSessionManager {

package/src/nodes/addPromptNode.ts

@@ -58,134 +58,323 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
       state.messages.unshift(systemMessage);
     }
 
-    const startTime = Date.now();
-    const result: AIMessage = await llmToUse.bindTools(scopedTools).invoke(state.messages);
-    const endTime = Date.now();
-    await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
-    logger.debug({
-      msg: '[Model] Model execution time',
-      executionTimeMs: endTime - startTime,
-      sessionId: state.sessionId,
-      node: node.displayName,
-    });
-    // Check if the result contains tool calls
-    if (result.tool_calls && result.tool_calls.length > 0) {
-      // Execute the tools
-      const toolResults = [];
-
-      for (const toolCall of result.tool_calls) {
-        const matchedTool = scopedTools.find((t) => t.name === toolCall.name);
-        logger.info({
-          msg: `[Model] Calling tool inside prompt node`,
-          tool: matchedTool?.name,
+    // Check if we should use the agentic loop (only when humanInTheLoop is true)
+    const useAgenticLoop = node.humanInTheLoop === true;
+
+    /**
+     * When humanInTheLoop is true: Run an agentic loop that continues invoking the LLM
+     * after tool calls until we get a final AI message without tool calls.
+     *
+     * When humanInTheLoop is false: Return immediately after tool execution without
+     * additional LLM invocations.
+     */
+    const newMessages: any[] = [];
+    const newHistory: any[] = [];
+    let currentMessages = [...state.messages];
+    let finalAIMessage: AIMessage | null = null;
+    let loopCount = 0;
+    const MAX_LOOP_ITERATIONS = 10;
+
+    while (true) {
+      loopCount++;
+
+      // Break if we've reached the maximum number of iterations
+      if (loopCount > MAX_LOOP_ITERATIONS) {
+        logger.warn({
+          msg: '[Model] Reached maximum loop iterations, breaking agentic loop',
+          loopCount,
           sessionId: state.sessionId,
           node: node.displayName,
         });
-        if (matchedTool) {
-          try {
-            // Invoke the LangChain tool directly
-            const startTime = Date.now();
-            const toolResult = await matchedTool.invoke(toolCall);
-            const endTime = Date.now();
-            logger.debug({
-              msg: `[Tool] Tool result inside prompt node`,
-              tool: matchedTool?.name,
-              result: toolResult,
-              executionTimeMs: endTime - startTime,
-              sessionId: state.sessionId,
-              node: node.displayName,
-            });
-            //check for queue after tool call
-            const systemMessageId = uuidv4();
-
-            await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId, {
-              messages: [
-                result,
-                toolResult,
-                new SystemMessage({
-                  id: systemMessageId,
-                  content:
-                    'you called tool when the user send a new message, Consider calling the function again after user message is processed',
-                }),
-              ],
-              history: [
+        break;
+      }
+      const startTime = Date.now();
+
+      const result: AIMessage = await llmToUse.bindTools(scopedTools).invoke([new SystemMessage(compiledPrompt), ...currentMessages]);
+
+      // Always pass accumulated state to interrupt manager
+      // Pass the accumulated messages from this prompt node execution
+      // If empty, pass undefined to avoid empty state updates
+      const interruptState =
+        newMessages.length > 0 || newHistory.length > 0
+          ? {
+              ...state,
+              messages: [...state.messages, ...newMessages],
+              history: [...state.history, ...newHistory],
+            }
+          : undefined;
+      await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId, interruptState);
+
+      const endTime = Date.now();
+
+      logger.debug({
+        msg: '[Model] Model execution time',
+        executionTimeMs: endTime - startTime,
+        sessionId: state.sessionId,
+        node: node.displayName,
+      });
+
+      // Check if the result contains tool calls
+      if (result.tool_calls && result.tool_calls.length > 0) {
+        // Add the tool call message
+        newMessages.push(result);
+        newHistory.push(
+          createHistoryStep<HistoryStep>(state.history, {
+            type: NodeType.TOOL,
+            nodeId: node.name,
+            nodeDisplayName: node.displayName,
+            raw: result,
+            messageIds: [result.id!],
+          }),
+        );
+
+        // Execute the tools
+        // Track how many tool responses we've added for validation
+        const toolResponseStartIndex = newMessages.length;
+
+        // Ensure we process ALL tool calls, even if some fail
+        for (const toolCall of result.tool_calls) {
+          const matchedTool = scopedTools.find((t) => t.name === toolCall.name);
+          logger.info({
+            msg: `[Model] Calling tool inside prompt node`,
+            tool: matchedTool?.name || toolCall.name,
+            toolCallId: toolCall.id,
+            sessionId: state.sessionId,
+            node: node.displayName,
+          });
+
+          if (matchedTool) {
+            try {
+              // Invoke the LangChain tool directly
+              const toolStartTime = Date.now();
+              const toolResult = await matchedTool.invoke(toolCall);
+              const toolEndTime = Date.now();
+
+              logger.debug({
+                msg: `[Tool] Tool result inside prompt node`,
+                tool: matchedTool?.name,
+                result: toolResult,
+                executionTimeMs: toolEndTime - toolStartTime,
+                sessionId: state.sessionId,
+                node: node.displayName,
+              });
+
+              // Add the tool result directly to allMessages
+              newMessages.push(toolResult);
+
+              // Check for queue after tool call
+              const systemMessageId = uuidv4();
+              await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId, {
+                ...state,
+                messages: [
+                  ...state.messages,
+                  ...newMessages,
+                  new SystemMessage({
+                    id: systemMessageId,
+                    content:
+                      'you called tool when the user send a new message, Consider calling the function again after user message is processed',
+                  }),
+                ],
+                history: [
+                  ...state.history,
+                  ...newHistory,
+                  createHistoryStep<HistoryStep>(state.history, {
+                    type: NodeType.TOOL,
+                    nodeId: node.name,
+                    nodeDisplayName: node.displayName,
+                    raw: toolResult,
+                    messageIds: [toolResult.id!, systemMessageId],
+                  }),
+                ],
+              });
+
+              // In v2.0, tools update state by reference, no need to extract state updates
+
+              newHistory.push(
                 createHistoryStep<HistoryStep>(state.history, {
                   type: NodeType.TOOL,
                   nodeId: node.name,
                   nodeDisplayName: node.displayName,
                   raw: toolResult,
-                  messageIds: [toolResult.id!, systemMessageId],
+                  messageIds: [toolResult.id!],
                 }),
-              ],
-            });
-            toolResults.push(toolResult);
-          } catch (err: any) {
-            if (err?.name === 'GraphInterrupt') throw err;
+              );
+            } catch (err: any) {
+              if (err?.name === 'GraphInterrupt') throw err;
+              logger.error({
+                msg: `[Tool] Error executing tool inside prompt node`,
+                tool: toolCall.name,
+                err,
+                sessionId: state.sessionId,
+                node: node.displayName,
+              });
+              const errorMessage = new ToolMessage({
+                content: JSON.stringify({ error: err instanceof Error ? err.message : String(err) }),
+                tool_call_id: toolCall.id!,
+              });
+
+              // Add the error message directly to allMessages
+              newMessages.push(errorMessage);
+
+              // Check for queue after tool error
+              const errorSystemMessageId = uuidv4();
+              await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId, {
+                ...state,
+                messages: [
+                  ...state.messages,
+                  ...newMessages,
+                  new SystemMessage({
+                    id: errorSystemMessageId,
+                    content: 'Tool execution failed. Consider handling the error or calling another function if needed.',
+                  }),
+                ],
+                history: [
+                  ...state.history,
+                  ...newHistory,
+                  createHistoryStep<HistoryStep>(state.history, {
+                    type: NodeType.TOOL,
+                    nodeId: node.name,
+                    nodeDisplayName: node.displayName,
+                    raw: errorMessage,
+                    messageIds: [errorMessage.id!, errorSystemMessageId],
+                  }),
+                ],
+              });
+              newHistory.push(
+                createHistoryStep<HistoryStep>(state.history, {
+                  type: NodeType.TOOL,
+                  nodeId: node.name,
+                  nodeDisplayName: node.displayName,
+                  raw: errorMessage,
+                  messageIds: [errorMessage.id!],
+                }),
+              );
+            }
+          } else {
             logger.error({
-              msg: `[Tool] Error executing tool inside prompt node`,
+              msg: `[Tool] Model called tool but it was not found inside prompt node`,
               tool: toolCall.name,
-              err,
+              toolCallId: toolCall.id,
               sessionId: state.sessionId,
               node: node.displayName,
             });
-            const errorMessage = new ToolMessage({
-              content: JSON.stringify({ error: err instanceof Error ? err.message : String(err) }),
-              tool_call_id: toolCall.id!,
+
+            // IMPORTANT: Create an error message for the missing tool with the correct tool_call_id
+            const missingToolMessage = new ToolMessage({
+              content: JSON.stringify({ error: `Tool '${toolCall.name}' not found` }),
+              tool_call_id: toolCall.id!, // This MUST match the tool_call_id from the AI message
+              name: toolCall.name,
             });
-            toolResults.push(errorMessage);
+
+            newMessages.push(missingToolMessage);
+            newHistory.push(
+              createHistoryStep<HistoryStep>(state.history, {
+                type: NodeType.TOOL,
+                nodeId: node.name,
+                nodeDisplayName: node.displayName,
+                raw: missingToolMessage,
+                messageIds: [missingToolMessage.id!],
+              }),
+            );
           }
-        } else {
+        }
+
+        // Validate that we have responses for ALL tool calls
+        const toolResponseCount = newMessages.length - toolResponseStartIndex;
+        if (toolResponseCount !== result.tool_calls.length) {
           logger.error({
-            msg: `[Tool] Model called tool but it was not found inside prompt node`,
-            tool: toolCall.name,
+            msg: '[Model] Tool response count mismatch',
+            expectedCount: result.tool_calls.length,
+            actualCount: toolResponseCount,
+            toolCallIds: result.tool_calls.map((tc) => tc.id),
             sessionId: state.sessionId,
             node: node.displayName,
           });
         }
+
+        // If humanInTheLoop is false, return immediately after tool execution
+        if (!useAgenticLoop) {
+          // In v2.0, modify state directly
+          state.messages.push(...newMessages);
+          state.history.push(...newHistory);
+          return state;
+        }
+
+        // Otherwise, prepare for next iteration
+        // allMessages now contains all the new messages from this iteration
+        currentMessages = [...state.messages, ...newMessages];
+
+        // Continue the loop to see what the model wants to do next
+        continue;
+      } else {
+        // We got an AI message without tool calls - this is our final response
+        finalAIMessage = result;
+        break;
+      }
+    }
+
+    // Process the final AI message if we have one
+    if (finalAIMessage) {
+      // Add the final AI message to our messages first
+      newMessages.push(finalAIMessage);
+
+      if (finalAIMessage.getType() === 'ai') {
+        logger.info({
+          msg: `[Model] Response`,
+          content: finalAIMessage.content,
+          sessionId: state.sessionId,
+          node: node.displayName,
+        });
+
+        // First add all messages to state
+        state.messages.push(...newMessages);
+
+        // In v2.0, emit AI_MESSAGE for handlers to process
+        // Handlers will modify state directly by reference
+        await emit(AgentEvents.AI_MESSAGE, {
+          message: finalAIMessage.content as string,
+          state: state,
+        });
       }
 
-      state.messages.push(result, ...toolResults);
-      state.history.push(
+      // Set goto to null
+      state.goto = null;
+
+      newHistory.push(
         createHistoryStep<HistoryStep>(state.history, {
-          type: NodeType.TOOL,
+          type: NodeType.PROMPT_NODE,
           nodeId: node.name,
           nodeDisplayName: node.displayName,
-          raw: result,
-          messageIds: [result.id!],
+          raw: finalAIMessage.content,
+          messageIds: [finalAIMessage.id!],
         }),
-        ...toolResults.map((toolResult) =>
-          createHistoryStep<HistoryStep>(state.history, {
-            type: NodeType.TOOL,
-            nodeId: node.name,
-            nodeDisplayName: node.displayName,
-            raw: toolResult,
-            messageIds: [toolResult.id!],
-          }),
-        ),
       );
+
+      // History is added to state
+      state.history.push(...newHistory);
+
       return state;
     }
 
-    // Model text response
-    state.goto = null;
-    state.messages.push(result);
+    // If we hit the loop limit without a final AI message, return what we have
+    if (loopCount > MAX_LOOP_ITERATIONS && newMessages.length > 0) {
+      logger.warn({
+        msg: '[Model] Returning accumulated messages after hitting loop limit',
+        messageCount: newMessages.length,
+        sessionId: state.sessionId,
+        node: node.displayName,
+      });
 
-    if (result.getType() === 'ai') {
-      logger.info({ msg: `[Model] Response`, content: result.content, sessionId: state.sessionId, node: node.displayName });
-      await emit(AgentEvents.AI_MESSAGE, { message: result.content as string, state });
+      state.goto = null;
+      // In v2.0, modify state directly
+      state.messages.push(...newMessages);
+      state.history.push(...newHistory);
+
+      return state;
     }
 
-    state.history.push(
-      createHistoryStep<HistoryStep>(state.history, {
-        type: NodeType.PROMPT_NODE,
-        nodeId: node.name,
-        nodeDisplayName: node.displayName,
-        raw: result.content,
-        messageIds: [result.id!],
-      }),
-    );
-
-    return state;
+    // This should only be reached in unexpected cases
+    throw new Error('Unexpected state: no messages generated in prompt node');
   };
   graph.addNode(node.name, callback);
 };

package/src/playbooks/playbooks.ts

@@ -183,9 +183,9 @@ function getAllYamlFiles(dir: string): string[] {
 /**
  * Combine playbooks into a single string
  */
-export function combinePlaybooks(playbooks: Playbook[]): string | undefined {
+export function combinePlaybooks(playbooks: Playbook[]): string | null {
   if (playbooks.length === 0) {
-    return undefined;
+    return null;
   }
 
   // Combine all playbooks into sections

package/dist/guidelines/guidelinesManager.d.ts

@@ -1,37 +0,0 @@
-import { MindedConnection } from '../platform/mindedConnection';
-export interface Guideline {
-    id: string;
-    name: string;
-    content: string;
-    index?: number;
-}
-export declare class GuidelinesManager {
-    private guidelines;
-    private mindedConnection;
-    constructor(mindedConnection: MindedConnection | null);
-    /**
-     * Load guidelines from directories or platform
-     */
-    loadGuidelines(guidelinesDirectories?: string[]): Promise<Guideline[]>;
-    /**
-     * Load guidelines from local directories
-     */
-    private loadGuidelinesFromDirectories;
-    /**
-     * Recursively get all YAML files in a directory
-     */
-    private getAllYamlFiles;
-    /**
-     * Compile guidelines into a single string with EJS and placeholders
-     */
-    compileGuidelines(params?: Record<string, any>): string;
-    /**
-     * Replace placeholders in {key} format
-     */
-    private replacePlaceholders;
-    /**
-     * Get raw guidelines without compilation
-     */
-    getGuidelines(): Guideline[];
-}
-//# sourceMappingURL=guidelinesManager.d.ts.map

package/dist/guidelines/guidelinesManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"guidelinesManager.d.ts","sourceRoot":"","sources":["../../src/guidelines/guidelinesManager.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAKhE,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,UAAU,CAAmB;IACrC,OAAO,CAAC,gBAAgB,CAA0B;gBAEtC,gBAAgB,EAAE,gBAAgB,GAAG,IAAI;IAIrD;;OAEG;IACU,cAAc,CAAC,qBAAqB,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IA+BnF;;OAEG;IACH,OAAO,CAAC,6BAA6B;IA+BrC;;OAEG;IACH,OAAO,CAAC,eAAe;IAgBvB;;OAEG;IACI,iBAAiB,CAAC,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,GAAG,MAAM;IA0BlE;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAiB3B;;OAEG;IACI,aAAa,IAAI,SAAS,EAAE;CAGpC"}

package/dist/guidelines/guidelinesManager.js

@@ -1,172 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GuidelinesManager = void 0;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const yaml = __importStar(require("js-yaml"));
-const ejs = __importStar(require("ejs"));
-const mindedConnectionTypes_1 = require("../platform/mindedConnectionTypes");
-const config_1 = require("../platform/config");
-const logger_1 = require("../utils/logger");
-class GuidelinesManager {
-    constructor(mindedConnection) {
-        this.guidelines = [];
-        this.mindedConnection = mindedConnection;
-    }
-    /**
-     * Load guidelines from directories or platform
-     */
-    async loadGuidelines(guidelinesDirectories) {
-        const { env, isDeployed } = (0, config_1.getConfig)();
-        if (['sandbox-staging', 'sandbox'].includes(env) && isDeployed && this.mindedConnection) {
-            // Load from platform
-            const response = await this.mindedConnection.awaitEmit(mindedConnectionTypes_1.MindedConnectionSocketMessageType.GET_GUIDELINES, {});
-            if (response === null || response === void 0 ? void 0 : response.error) {
-                throw new Error(`Failed to load guidelines from platform: ${response.error}`);
-            }
-            this.guidelines = (response === null || response === void 0 ? void 0 : response.guidelines) || [];
-        }
-        else if (guidelinesDirectories) {
-            // Load from directories
-            this.guidelines = this.loadGuidelinesFromDirectories(guidelinesDirectories);
-        }
-        // Sort guidelines by index if available
-        this.guidelines.sort((a, b) => {
-            if (a.index !== undefined && b.index !== undefined) {
-                return a.index - b.index;
-            }
-            return 0;
-        });
-        return this.guidelines;
-    }
-    /**
-     * Load guidelines from local directories
-     */
-    loadGuidelinesFromDirectories(directories) {
-        const guidelines = [];
-        for (const directory of directories) {
-            if (!fs.existsSync(directory)) {
-                logger_1.logger.info(`Guidelines directory does not exist: ${directory}`);
-                continue;
-            }
-            const files = this.getAllYamlFiles(directory);
-            for (const file of files) {
-                try {
-                    const fileContent = fs.readFileSync(file, 'utf8');
-                    const guideline = yaml.load(fileContent);
-                    if (guideline && guideline.name && guideline.content) {
-                        guidelines.push(guideline);
-                        logger_1.logger.info(`Loaded guideline: ${guideline.name} from ${file}`);
-                    }
-                    else {
-                        logger_1.logger.warn(`Invalid guideline structure in ${file}`);
-                    }
-                }
-                catch (error) {
-                    logger_1.logger.error(`Failed to load guideline file ${file}: ${error}`);
-                }
-            }
-        }
-        return guidelines;
-    }
-    /**
-     * Recursively get all YAML files in a directory
-     */
-    getAllYamlFiles(dir) {
-        const files = [];
-        const entries = fs.readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                files.push(...this.getAllYamlFiles(fullPath));
-            }
-            else if (entry.name.endsWith('.yaml') || entry.name.endsWith('.yml')) {
-                files.push(fullPath);
-            }
-        }
-        return files;
-    }
-    /**
-     * Compile guidelines into a single string with EJS and placeholders
-     */
-    compileGuidelines(params = {}) {
-        if (this.guidelines.length === 0) {
-            return '';
-        }
-        // Combine all guidelines into sections
-        const sections = this.guidelines.map((guideline) => {
-            return `# ${guideline.name}\n${guideline.content}`;
-        });
-        const combinedGuidelines = sections.join('\n\n');
-        try {
-            // First, render with EJS
-            let compiledGuidelines = ejs.render(combinedGuidelines, params);
-            // Then, replace placeholders in {} format
-            compiledGuidelines = this.replacePlaceholders(compiledGuidelines, params);
-            return compiledGuidelines;
-        }
-        catch (error) {
-            logger_1.logger.error({ message: 'Error compiling guidelines', error });
-            return combinedGuidelines; // Return uncompiled if there's an error
-        }
-    }
-    /**
-     * Replace placeholders in {key} format
-     */
-    replacePlaceholders(text, params) {
-        return text.replace(/\{([^}]+)\}/g, (match, key) => {
-            const keys = key.split('.');
-            let value = params;
-            for (const k of keys) {
-                if (value && typeof value === 'object' && k in value) {
-                    value = value[k];
-                }
-                else {
-                    return match; // Return original if key not found
-                }
-            }
-            return String(value);
-        });
-    }
-    /**
-     * Get raw guidelines without compilation
-     */
-    getGuidelines() {
-        return this.guidelines;
-    }
-}
-exports.GuidelinesManager = GuidelinesManager;
-//# sourceMappingURL=guidelinesManager.js.map