@minded-ai/mindedjs 2.0.47 → 3.0.1

package/docs/low-code-editor/nodes.md

@@ -8,7 +8,6 @@ Nodes are the building blocks of MindedJS flows - discrete processing units that
 | --------------------------------------- | -------------- | ---------------------------------------- |
 | [**Trigger**](nodes.md#trigger-nodes)   | Entry Points   | Start flows from various sources         |
 | [**Prompt**](nodes.md#prompt-nodes)     | LLM Processing | Generate responses using language models |
-| [**Thinking**](nodes.md#thinking-nodes) | Internal Logic | Process internal agent logic without user-facing output |
 | [**Tool**](nodes.md#tool-nodes)         | Actions        | Execute external functions and APIs      |
 | [**Junction**](nodes.md#junction-nodes) | Flow Control   | Route and organize flow logic            |
 | [**Jump To**](nodes.md#jump-to-nodes)   | Flow Control   | Jump to specific nodes or subflows       |
@@ -78,11 +77,12 @@ Prompt nodes process input through LLM to generate intelligent responses or invo
 - `humanInTheLoop?: boolean` - When `true`, pauses execution after this node for human input before continuing. Use this property only if you need to gather an input from the user. Usually combined with a `promptCondition` edge to allow for iterative processing over human input.
 - `canStayOnNode?: boolean` - When `true`, allows the node to route back to itself for iterative processing. Usually combined with `humanInTheLoop: true` to allow for iteration over human input.
 - `prompt: string` - The prompt to be sent to the LLM. The prompt is an instruction for what AI message to generate or a (scoped) tool to invoke. This is not general instruction for what the agent should do (e.g. "wait for x").
+- `sendAiMessage?: boolean` - When `false`, the AI response is processed internally without sending to the user. Default: `true`. Set to 'false' for internal calculations, reasoning, or decision-making logic that shouldn't be visible to users.
 
 ### Limitations
 - Prompt nodes can not save information to memory directly. Rather the user & agent messages are stored in the messages array of the state object. Making user's input available to the next prompt nodes or tools in the form of input schema.
 - Image recognition is only supported when a user attaches an image to the message. If you need to extract information from an image, use a tool with agent.llm to process the image. Return the result in the tool response so following prompt nodes can use it.
-- Prompt nodes result in a message being sent to the user. If you do not want to send a message, use a thinking node instead.
+- By default, prompt nodes send a message to the user. Set `sendAiMessage: false` if you want internal processing without user-facing output.
 
 ### Prompt examples
 - "Draft a professional email to the merchant requesting verification of the dispute"
@@ -137,87 +137,25 @@ llmConfig:
     max_tokens: 500
 ```
 
-## Thinking Nodes
+### Internal Processing (No User Message)
 
-Thinking nodes allow your agent to process internal logic and generate outputs that can be used by subsequent nodes (such as tools) without sending messages to the user. Unlike prompt nodes, thinking nodes are designed for internal agent reasoning and decision-making.
-
-### Properties
-- `prompt: string` - The prompt to be sent to the LLM. The prompt is an instruction for what internal AI message to generate without sending it to the user. The output will later be used by subsequent nodes.
-
-### Prompt examples
-- "Based on the order details: {memory.orderItems}, calculate the appropriate refund amount for the missing item. Consider the item price, shipping costs, and any applicable discounts."
-- "Analayze the conversation history and determine the sentiment score (0-100)."
-- "According to the following rules [...], decide whether the customer should receive a refund.
-
-### Key Differences: Thinking vs Prompt Nodes
-
-| Aspect | Prompt Node | Thinking Node |
-|--------|-------------|---------------|
-| **Output Visibility** | Sends messages to the user (visible in conversation) | Internal only (not shown to user) |
-| **Use Case** | User-facing responses, conversations | Internal calculations, reasoning, decision-making |
-| **Event Trigger** | Triggers `AI_MESSAGE` event | Adds response to conversation history (like a tool) |
-| **Configuration** | Supports `humanInTheLoop`, `canStayOnNode` | No user interaction properties |
-| **Display** | Appears as agent message in chat | Appears as function call in playground (similar to tools) |
-
-### When to Use Thinking Nodes
-
-Use thinking nodes for:
-- **Calculations and reasoning**: Determining refund amounts, calculating discounts, analyzing data
-- **Decision-making logic**: Evaluating conditions, making internal choices before taking actions
-- **Information extraction**: Processing and structuring data for use in subsequent nodes
-- **Pre-processing**: Preparing inputs for tools or other nodes
-
-### When to Use Prompt Nodes
-
-Use prompt nodes for:
-- **User communication**: Sending messages, asking questions, providing information
-- **Conversational interactions**: Engaging with users in a dialogue
-- **User-facing responses**: Any output that should be visible to the end user
-
-### Basic Thinking Node
+To process logic internally without sending a message to the user, set `sendAiMessage: false`:
 
 ```yaml
-- type: thinking
+- type: promptNode
   name: calculate-refund-amount
   displayName: Calculate Refund Amount
-  prompt: 'Based on the order details: {memory.orderItems}, calculate the appropriate refund amount for the missing item. Consider the item price, shipping costs, and any applicable discounts.'
+  prompt: 'Based on the order details: {memory.orderItems}, calculate the appropriate refund amount.'
+  sendAiMessage: false
 ```
 
-### Thinking Node with Custom LLM
-
-You can specify a custom LLM configuration for thinking nodes:
-
-```yaml
-- type: thinking
-  name: analyze-customer-sentiment
-  displayName: Analyze Customer Sentiment
-  prompt: 'Analyze the customer message: {memory.customerMessage} and determine the sentiment score (0-100).'
-  llmConfig:
-    name: ChatOpenAI
-    properties:
-      model: gpt-4o
-      temperature: 0
-      max_tokens: 200
-```
-
-### Example: Thinking Node in a Flow
-
-```yaml
-# Calculate refund before processing
-- type: thinking
-  name: determine-refund
-  displayName: Determine Refund Amount
-  prompt: 'Calculate the refund amount for order {memory.orderId}. The customer reported a missing item worth ${memory.itemPrice}. Apply the refund policy: full refund for items under $50, 90% refund for items $50-$200, 80% refund for items over $200.'
-edges: []
-```
-
-### Important Notes
+Use cases for `sendAiMessage: false`:
+- **Internal calculations and reasoning**: Determining refund amounts, calculating discounts, analyzing data
+- **Decision-making logic**: Evaluating conditions before taking actions
+- **Information extraction**: Processing and structuring data for subsequent nodes
+- **Pre-processing**: Preparing inputs for tools or other nodes
 
-- Thinking nodes add their output to the conversation history, making it available to subsequent nodes
-- The output is visible in the playground UI (similar to tool calls) but not sent to end users
-- Thinking nodes do not support `humanInTheLoop` or `canStayOnNode` properties
-- Use memory placeholders (`{memory.propertyName}`) to access state information
-- The LLM response from a thinking node becomes part of the conversation context for following nodes
+The AI response is added to conversation history and available to subsequent nodes, but not sent to the user.
 
 ## Tool Nodes
 

package/docs/sdk/logging.md

@@ -32,18 +32,20 @@ logger.debug('Memory state updated');
 
 ## Structured Logging
 
-Use structured logging with contextual data for better observability:
+Use structured logging with contextual data for better observability. Pass the message as the `msg` property:
 
 ```ts
 // Basic structured logging
-logger.info('Order processed', {
+logger.info({
+  msg: 'Order refunded',
   orderId: 'ORD-123',
   customerId: 'CUST-456',
   amount: 99.99,
 });
 
 // Include session context in tools
-logger.info('Tool execution started', {
+logger.info({
+  msg: 'Tool execution started',
   sessionId: state.sessionId,
   toolName: 'refundOrder',
   orderId: input.orderId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minded-ai/mindedjs",
-  "version": "2.0.47",
+  "version": "3.0.1",
   "description": "MindedJS is a TypeScript library for building agents.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -72,4 +72,4 @@
   "peerDependencies": {
     "playwright": "^1.55.0"
   }
-}
+}

package/src/index.ts

@@ -52,7 +52,6 @@ export type {
   InterfaceTriggerNode,
   ScheduleTriggerNode,
   RpaStep,
-  ThinkingNode
 } from './types/Flows.types';
 export {
   NodeType,

package/src/nodes/addPromptNode.ts

@@ -294,12 +294,16 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
         content: finalAIMessage.content,
         sessionId: state.sessionId,
         node: node.displayName,
+        sendAiMessage: node.sendAiMessage !== false,
       });
 
-      await emit(AgentEvents.AI_MESSAGE, {
-        message: finalAIMessage.content as string,
-        state: state,
-      });
+      // Only emit AI_MESSAGE if sendAiMessage is not explicitly false
+      if (node.sendAiMessage !== false) {
+        await emit(AgentEvents.AI_MESSAGE, {
+          message: finalAIMessage.content as string,
+          state: state,
+        });
+      }
 
       // Set goto to null
       state.goto = null;

package/src/nodes/nodeFactory.ts

@@ -12,7 +12,6 @@ import { Agent } from '../agent';
 import { addJumpToNode } from './addJumpToNode';
 import { addJunctionNode } from './addJunctionNode';
 import { addBrowserTaskNode } from './addBrowserTaskNode';
-import { addThinkingNode } from './addThinkingNode';
 
 export const nodeFactory = async ({
   graph,
@@ -52,9 +51,6 @@ export const nodeFactory = async ({
     case NodeType.BROWSER_TASK:
       await addBrowserTaskNode({ graph, node, agent, llm });
       break;
-    case NodeType.THINKING:
-      await addThinkingNode({ graph, node, tools, llm, emit, agent });
-      break;
     default:
       throw new Error(`Unsupported node type: ${nodeType}`);
   }

package/src/types/Flows.types.ts

@@ -12,7 +12,6 @@ export enum NodeType {
   PROMPT_NODE = 'promptNode',
   JUMP_TO_NODE = 'jumpToNode',
   BROWSER_TASK = 'browserTask',
-  THINKING = 'thinking',
 }
 
 export enum EdgeType {
@@ -124,24 +123,22 @@ export interface SchemaField {
 export type OutputSchemaField = Omit<SchemaField, 'type'> & {
   type: 'string' | 'number' | 'boolean' | 'array' | 'object';
 } & Partial<{
-    items: {
-      type: 'string' | 'number' | 'boolean' | 'object';
-      properties?: any;
-    };
-    properties: any;
-  }>;
+  items: {
+    type: 'string' | 'number' | 'boolean' | 'object';
+    properties?: any;
+  };
+  properties: any;
+}>;
 
 export interface PromptNode extends BaseNode {
   type: NodeType.PROMPT_NODE;
   prompt: string;
   llmConfig?: LLMConfig;
-}
-
-export interface ThinkingNode extends BaseNode {
-  type: NodeType.THINKING;
-  prompt: string;
-  llmConfig?: LLMConfig;
-  outputSchema?: OutputSchemaField[];
+  /**
+   * When false, the AI response is processed internally without sending to the user.
+   * Default: true (AI message is sent to the user)
+   */
+  sendAiMessage?: boolean;
 }
 
 export interface JumpToNode extends BaseNode {
@@ -223,7 +220,7 @@ export interface AppToolNode extends BaseNode, BaseAppNode {
   actionKey: string;
 }
 
-export type Node = TriggerNode | JunctionNode | ToolNode | AppToolNode | PromptNode | JumpToNode | BrowserTaskNode | ThinkingNode;
+export type Node = TriggerNode | JunctionNode | ToolNode | AppToolNode | PromptNode | JumpToNode | BrowserTaskNode;
 
 export interface BaseEdge {
   source: string;

package/src/nodes/addThinkingNode.ts

@@ -1,131 +0,0 @@
-import { RunnableLike } from '@langchain/core/runnables';
-import { NodeType, ThinkingNode } from '../types/Flows.types';
-import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
-import { BaseLanguageModel } from '@langchain/core/language_models/base';
-import { SystemMessage, AIMessage } from '@langchain/core/messages';
-import { Tool } from '../types/Tools.types';
-import { AgentEventRequestPayloads } from '../events/AgentEvents';
-import { EmitSignature, HistoryStep } from '../types/Agent.types';
-import { createLlmInstance } from '../llm/createLlmInstance';
-import { Agent } from '../agent';
-import { logger } from '../utils/logger';
-import { createHistoryStep } from '../utils/history';
-import { compilePrompt } from './compilePrompt';
-import { AnalyticsEventName } from '../types/Analytics.types';
-import { trackAnalyticsEvent } from '../internalTools/analytics';
-import { convertArraySchemaToZod } from '../utils/schemaConverter';
-import { v4 as uuidv4 } from 'uuid';
-
-type AddThinkingNodeParams = {
-  graph: PreCompiledGraph;
-  node: ThinkingNode;
-  llm: BaseLanguageModel;
-  tools: Tool<any, any>[];
-  emit: EmitSignature<any, keyof AgentEventRequestPayloads<any>>;
-  agent: Agent;
-};
-
-export const addThinkingNode = async ({ graph, node, llm, agent }: AddThinkingNodeParams) => {
-  const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    trackAnalyticsEvent(
-      AnalyticsEventName.NODE_EXECUTION,
-      {
-        nodeType: NodeType.THINKING,
-        nodeName: node.name,
-        nodeDisplayName: node.displayName,
-        parameters: {
-          prompt: node.prompt,
-        },
-      },
-      state.sessionId,
-    );
-    await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
-    logger.info({ msg: `[Node] Executing thinking node`, node: node.displayName, sessionId: state.sessionId });
-    const llmToUse = node.llmConfig ? createLlmInstance(node.llmConfig) : llm;
-
-    // unless we want it to be fully agentic. For "thinking", usually it's one pass or a few.
-
-    const compiledPrompt = compilePrompt(node.prompt, { state: state, memory: state.memory, env: process.env });
-    const systemMessage = new SystemMessage(compiledPrompt);
-
-    // We create a temporary message list for this generation
-    // We add the system message for this node
-    const messagesForModel = [...state.messages];
-    messagesForModel.push(systemMessage);
-
-    // Check if we need structured output
-    const useStructuredOutput = node.outputSchema && node.outputSchema.length > 0;
-    let llmWithStructuredOutput = llmToUse;
-
-    if (useStructuredOutput) {
-      const zodSchema = convertArraySchemaToZod(node.outputSchema!);
-      llmWithStructuredOutput = llmToUse.withStructuredOutput(zodSchema, { name: 'extract' });
-    }
-
-    const startTime = Date.now();
-    const result = await llmWithStructuredOutput.invoke(messagesForModel);
-    const endTime = Date.now();
-
-    logger.debug({
-      msg: '[Model] Thinking node execution time',
-      executionTimeMs: endTime - startTime,
-      sessionId: state.sessionId,
-      node: node.displayName,
-    });
-
-    await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId, state);
-
-    // Inject metadata to identify this as a thinking node output
-    const additionalKwargs: Record<string, any> = {
-      mindedMetadata: {
-        nodeType: NodeType.THINKING,
-        nodeDisplayName: node.displayName,
-        prompt: node.prompt,
-      },
-    };
-
-    let messageId: string;
-    let messageContent: string;
-
-    // When structured output is used, result is the raw extracted data (not an AIMessage)
-    // When not used, result is an AIMessage with content and id
-    if (useStructuredOutput) {
-      additionalKwargs.structuredOutput = result;
-      messageId = uuidv4();
-      messageContent = JSON.stringify(result);
-    } else {
-      // result is an AIMessage, preserve its additional_kwargs and id
-      const aiResult = result as AIMessage;
-      Object.assign(additionalKwargs, aiResult.additional_kwargs);
-      messageId = aiResult.id!;
-      messageContent = aiResult.content as string;
-    }
-
-    const messageWithMetadata = new AIMessage({
-      content: messageContent,
-      additional_kwargs: additionalKwargs,
-      id: messageId,
-    });
-
-    // Add to state messages
-    state.messages.push(messageWithMetadata);
-
-    // Add to history
-    state.history.push(
-      createHistoryStep<HistoryStep>(state.history, {
-        type: NodeType.THINKING,
-        nodeId: node.name,
-        nodeDisplayName: node.displayName,
-        raw: messageWithMetadata.content,
-        messageIds: [messageWithMetadata.id!],
-      }),
-    );
-
-    // Clean up: We don't emit AI_MESSAGE.
-    // We set goto to null to proceed to next node (logic condition or step forward)
-    state.goto = null;
-
-    return state;
-  };
-  graph.addNode(node.name, callback);
-};