@minded-ai/mindedjs 1.0.53 → 1.0.54

package/dist/platform/piiGateway/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/platform/piiGateway/types.ts"],"names":[],"mappings":""}

package/dist/types/LangGraph.types.d.ts

@@ -26,6 +26,7 @@ export declare const stateAnnotation: import("@langchain/langgraph").AnnotationR
         Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
     };
     history: import("@langchain/langgraph").BinaryOperatorAggregate<FlowHistory[], FlowHistory[]>;
+    sessionId: import("@langchain/langgraph").LastValue<string>;
 }>;
 export type CompiledGraph = CompiledStateGraph<any, any, string>;
 export type PreCompiledGraph = StateGraph<any, any, string>;

package/dist/types/LangGraph.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LangGraph.types.d.ts","sourceRoot":"","sources":["../../src/types/LangGraph.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAc,kBAAkB,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClF,OAAO,EAAE,WAAW,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAEtE,eAAO,MAAM,eAAe;;;;;;kBAclB,MAAM;yBACC,GAAG;;;kBADV,MAAM;yBACC,GAAG;;kBADV,MAAM;yBACC,GAAG;;kBADV,MAAM;yBACC,GAAG;;kBADV,MAAM;yBACC,GAAG;;;;;EAMlB,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC;AACjE,MAAM,MAAM,gBAAgB,GAAG,UAAU,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC"}
+{"version":3,"file":"LangGraph.types.d.ts","sourceRoot":"","sources":["../../src/types/LangGraph.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAc,kBAAkB,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClF,OAAO,EAAE,WAAW,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAEtE,eAAO,MAAM,eAAe;;;;;;kBAclB,MAAM;yBACC,GAAG;;;kBADV,MAAM;yBACC,GAAG;;kBADV,MAAM;yBACC,GAAG;;kBADV,MAAM;yBACC,GAAG;;kBADV,MAAM;yBACC,GAAG;;;;;;EAOlB,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC;AACjE,MAAM,MAAM,gBAAgB,GAAG,UAAU,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC"}

package/dist/types/LangGraph.types.js

@@ -20,5 +20,6 @@ exports.stateAnnotation = langgraph_1.Annotation.Root({
         default: () => [],
         reducer: (a, b) => a.concat(b),
     }),
+    sessionId: (0, langgraph_1.Annotation)(),
 });
 //# sourceMappingURL=LangGraph.types.js.map

package/dist/types/LangGraph.types.js.map

@@ -1 +1 @@
-{"version":3,"file":"LangGraph.types.js","sourceRoot":"","sources":["../../src/types/LangGraph.types.ts"],"names":[],"mappings":";;;AACA,oDAAkF;AAGrE,QAAA,eAAe,GAAG,sBAAU,CAAC,IAAI,CAAC;IAC7C,QAAQ,EAAE,IAAA,sBAAU,EAAqB;QACvC,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE;QACjB,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;KAC/B,CAAC;IACF,MAAM,EAAE,IAAA,sBAAU,EAAM;QACtB,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC;QACnB,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC;KACpC,CAAC;IACF,kBAAkB,EAAE,IAAA,sBAAU,EAAkC;QAC9D,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE;QACjB,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;KAC/B,CAAC;IACF,eAAe,EAAE,CAAA,sBAGR,CAAA;IACT,OAAO,EAAE,IAAA,sBAAU,EAAqB;QACtC,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE;QACjB,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;KAC/B,CAAC;CACH,CAAC,CAAC"}
+{"version":3,"file":"LangGraph.types.js","sourceRoot":"","sources":["../../src/types/LangGraph.types.ts"],"names":[],"mappings":";;;AACA,oDAAkF;AAGrE,QAAA,eAAe,GAAG,sBAAU,CAAC,IAAI,CAAC;IAC7C,QAAQ,EAAE,IAAA,sBAAU,EAAqB;QACvC,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE;QACjB,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;KAC/B,CAAC;IACF,MAAM,EAAE,IAAA,sBAAU,EAAM;QACtB,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC;QACnB,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC;KACpC,CAAC;IACF,kBAAkB,EAAE,IAAA,sBAAU,EAAkC;QAC9D,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE;QACjB,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;KAC/B,CAAC;IACF,eAAe,EAAE,CAAA,sBAGR,CAAA;IACT,OAAO,EAAE,IAAA,sBAAU,EAAqB;QACtC,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE;QACjB,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;KAC/B,CAAC;IACF,SAAS,EAAE,IAAA,sBAAU,GAAU;CAChC,CAAC,CAAC"}

package/dist/types/Tools.types.d.ts

@@ -1,19 +1,21 @@
 import { z } from 'zod';
-import { FlowHistory } from './Agent.types';
+import { Agent } from '../';
+import { stateAnnotation } from './LangGraph.types';
 export interface Tool<Input extends z.ZodSchema, Memory> {
     name: string;
     description: string;
     input: Input;
     isGlobal?: boolean;
-    execute: ({ input, memory, triggerInvocations }: {
-        input: z.infer<Input>;
-        memory: Memory;
-        triggerInvocations?: Array<FlowHistory>;
-    }) => Promise<{
+    execute: (input: ToolExecuteInput<Input>) => Promise<{
         memory?: Partial<Memory>;
         result?: any;
     } | void>;
 }
+export interface ToolExecuteInput<Input extends z.ZodSchema> {
+    input: z.infer<Input>;
+    state: typeof stateAnnotation.State;
+    agent: Agent;
+}
 export interface AppActionRunnerInput {
     appName: string;
     actionName: string;

package/dist/types/Tools.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Tools.types.d.ts","sourceRoot":"","sources":["../../src/types/Tools.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,MAAM,WAAW,IAAI,CAAC,KAAK,SAAS,CAAC,CAAC,SAAS,EAAE,MAAM;IACrD,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,kBAAkB,EAAE,EAAE;QAAE,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,kBAAkB,CAAC,EAAE,KAAK,CAAC,WAAW,CAAC,CAAA;KAAE,KAAK,OAAO,CAAC;QAAE,MAAM,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;QAAC,MAAM,CAAC,EAAE,GAAG,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;CACpM;AAGD,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB"}
+{"version":3,"file":"Tools.types.d.ts","sourceRoot":"","sources":["../../src/types/Tools.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC;AAC5B,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,MAAM,WAAW,IAAI,CAAC,KAAK,SAAS,CAAC,CAAC,SAAS,EAAE,MAAM;IACrD,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,CAAC,KAAK,EAAE,gBAAgB,CAAC,KAAK,CAAC,KAAK,OAAO,CAAC;QAAE,MAAM,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;QAAC,MAAM,CAAC,EAAE,GAAG,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;CACzG;AAED,MAAM,WAAW,gBAAgB,CAAC,KAAK,SAAS,CAAC,CAAC,SAAS;IACzD,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACtB,KAAK,EAAE,OAAO,eAAe,CAAC,KAAK,CAAC;IACpC,KAAK,EAAE,KAAK,CAAC;CACd;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minded-ai/mindedjs",
-  "version": "1.0.53",
+  "version": "1.0.54",
   "description": "MindedJS is a TypeScript library for building agents.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -53,4 +53,4 @@
     "uuid": "^11.1.0",
     "zod": "^3.24.4"
   }
-}
+}

package/src/agent.ts

@@ -23,6 +23,7 @@ import { BaseMessage, HumanMessage } from '@langchain/core/messages';
 import triggerTypeToDefaultMessage from './triggers/triggerTypeToDefaultMessage';
 import appActionRunnerToolCreator from './internalTools/appActionRunnerTool';
 import { wait } from './utils/wait';
+import { PIIGateway, PIIGatewayInstance } from './platform/piiGateway';
 
 type CreateAgentParams<Memory> = {
   memorySchema: z.ZodSchema;
@@ -63,6 +64,17 @@ export class Agent {
   // Cache for secrets to avoid repeated API calls
   private secretsCache: Record<string, string> | null = null;
 
+  // PII gateway instance
+  private _piiGateway: PIIGatewayInstance | null = null;
+
+  // PII gateway instance getter
+  public get piiGateway(): PIIGatewayInstance {
+    if (!this._piiGateway) {
+      throw new Error('Minded connection is not established when trying to get PII gateway');
+    }
+    return this._piiGateway;
+  }
+
   // Event handlers storage keyed by event name. Handlers can optionally return a value.
   private eventHandlers: {
     [K in keyof AgentEventRequestPayloads<z.infer<typeof this.memorySchema>>]?: Array<
@@ -118,6 +130,9 @@ export class Agent {
         this.mindedConnection = new MindedConnection();
         await this.mindedConnection.start();
 
+        // Initialize PII gateway
+        this._piiGateway = new PIIGateway(this.mindedConnection);
+
         this.mindedConnection.on(MindedConnectionSocketMessageType.OnAppTrigger, async (message: BaseMindedConnectionSocketMessage) => {
           const trigger = message as OnAppTrigger;
           await this.invoke({
@@ -241,6 +256,7 @@ export class Agent {
         tools: this.tools,
         llm: this.llm,
         emit: this.emit.bind(this),
+        agent: this,
       });
     });
 
@@ -269,19 +285,20 @@ export class Agent {
     });
 
     // Add edges
-    edgeFactory({ graph, edges, nodes: nodesObject, tools: this.tools, llm: this.llm });
+    edgeFactory({ graph, edges, nodes: nodesObject, tools: this.tools, llm: this.llm, agent: this });
 
     // Compile the graph
     return graph.compile({ checkpointer: this.checkpointer }) as CompiledGraph;
   }
 
-  private initGraphState(): typeof stateAnnotation.State {
+  private initGraphState(state: typeof stateAnnotation.State): typeof stateAnnotation.State {
     return {
       messages: [],
       memory: {} as z.infer<typeof this.memorySchema>,
       triggerMetadata: null,
       history: [],
       triggerInvocations: [] as Array<TriggerInvocationHistory>,
+      sessionId: state.sessionId || uuidv4(), // Preserve existing sessionId or generate new one
     };
   }
 
@@ -327,6 +344,7 @@ export class Agent {
     await this.waitForInitialization();
     let messages: Array<BaseMessage> = [];
     let memoryUpdate = {};
+    sessionId = sessionId ?? uuidv4();
     if (triggerName === KnownTriggerNames.DASHBOARD_MESSAGE) {
       messages.push(new HumanMessage(triggerBody.content));
     } else {
@@ -354,6 +372,7 @@ export class Agent {
         }
       }
     }
+
     const triggerInvocation = { appName, triggerName, triggerBody };
     const history = [
       {
@@ -362,23 +381,26 @@ export class Agent {
       },
     ];
     console.log(`Invoking trigger ${triggerName} with session ${sessionId}`);
-    const config = { configurable: { thread_id: sessionId || uuidv4(), recursionLimit: 3 } };
+    const config = { configurable: { thread_id: sessionId, recursionLimit: 3 } };
+
     const state = await this.compiledGraph.getState(config);
     // Resume interruption
     if (state.tasks?.[0]?.interrupts?.length > 0) {
       console.log('Resuming interruption');
       const res = await this.compiledGraph.invoke(
         new Command({
-          resume: { memory: memoryUpdate, messages, history, triggerInvocations: [triggerInvocation] },
+          resume: { memory: memoryUpdate, messages, history, triggerInvocations: [triggerInvocation], sessionId },
         }),
         config,
       );
+
       return res;
     } else {
       const res = await this.compiledGraph.invoke(
-        { messages, memory: memoryUpdate, history, triggerInvocations: [triggerInvocation] },
+        { messages, memory: memoryUpdate, history, triggerInvocations: [triggerInvocation], sessionId },
         config,
       );
+
       return res;
     }
   }

package/src/edges/edgeFactory.ts

@@ -7,6 +7,7 @@ import { createDirectEdge } from './createDirectEdge';
 import { addHumanInTheLoopNode, buildHumanInTheLoopNodeName } from '../nodes/addHumanInTheLoopNode';
 import { addToolRunNode, buildToolRunNodeName } from '../nodes/addToolRunNode';
 import { Tool } from '../types/Tools.types';
+import { Agent } from '../agent';
 
 type EdgesBySource = {
   stepForward?: StepForwardEdge;
@@ -20,12 +21,14 @@ export const edgeFactory = ({
   nodes,
   tools,
   llm,
+  agent,
 }: {
   graph: PreCompiledGraph;
   edges: Edge[];
   nodes: Record<string, Node>;
   tools: Tool<any, any>[];
   llm: BaseLanguageModel;
+  agent: Agent;
 }) => {
   /**
    * Creates a combined router that handles edge priority: step forward > logical > prompt
@@ -71,7 +74,7 @@ export const edgeFactory = ({
     }
 
     if (nodes[source]?.type === NodeType.TOOL) {
-      addToolRunNode({ graph, tools, llm, toolNode: nodes[source] as ToolNode, attachedToNodeName: source });
+      addToolRunNode({ graph, tools, llm, toolNode: nodes[source] as ToolNode, attachedToNodeName: source, agent });
       effectiveSource = buildToolRunNodeName(source);
     }
 

package/src/index.ts

@@ -3,6 +3,9 @@ import events from './events';
 
 export { Agent, events };
 
+// HTTP module for PII masking - only public API
+export type { PIIGatewayInstance, HttpRequestConfig, HttpResponse } from './platform/piiGateway';
+
 export type {
   Flow,
   Node,
@@ -18,7 +21,15 @@ export type {
   ToolNode,
   AppToolNode,
 } from './types/Flows.types';
-export { NodeType, TriggerType, EdgeType, AppNodeMetadata, AppNodeMetadataType, NodeMetadata, KnownTriggerNames } from './types/Flows.types';
-export type { Tool } from './types/Tools.types';
+export {
+  NodeType,
+  TriggerType,
+  EdgeType,
+  AppNodeMetadata,
+  AppNodeMetadataType,
+  NodeMetadata,
+  KnownTriggerNames,
+} from './types/Flows.types';
+export type { Tool, ToolExecuteInput } from './types/Tools.types';
 export { FlowHistoryType, FlowHistory, TriggerInvocationHistory, AppActionInvocationHistory } from './types/Agent.types';
-export type { Environment } from './types/Platform.types';
+export type { Environment } from './types/Platform.types';

package/src/internalTools/appActionRunnerTool.ts

@@ -5,66 +5,69 @@ import { Tool } from '../types/Tools.types';
 import { z } from 'zod';
 
 const typeToZodMap = {
-    string: z.string(),
-    number: z.number(),
-    boolean: z.boolean(),
-    array: z.array(z.any()),
-    object: z.record(z.any()),
-    any: z.any()
+  string: z.string(),
+  number: z.number(),
+  boolean: z.boolean(),
+  array: z.array(z.any()),
+  object: z.record(z.any()),
+  any: z.any(),
 } as const;
 
 const convertToZodSchema = (schema: Record<string, { type: string; example?: any }>) => {
-    const zodSchema: Record<string, z.ZodType> = {};
-    for (const [key, { type }] of Object.entries(schema)) {
-        const zodType = typeToZodMap[type.toLowerCase() as keyof typeof typeToZodMap] ?? z.string();
-        zodSchema[key] = zodType;
-    }
-    return z.object(zodSchema);
+  const zodSchema: Record<string, z.ZodType> = {};
+  for (const [key, { type }] of Object.entries(schema)) {
+    const zodType = typeToZodMap[type.toLowerCase() as keyof typeof typeToZodMap] ?? z.string();
+    zodSchema[key] = zodType;
+  }
+  return z.object(zodSchema);
 };
 
 const createdTools: Record<string, Tool<any, any>> = {};
 
 const appActionRunnerToolCreator = (schema: ActionInputParam[], nodeTitle: string, mindedConnection: MindedConnection): Tool<any, any> => {
-    const zodSchema = convertToZodSchema(schema.reduce(
-        (acc, param) => {
-            if (param.required) {
-                acc[param.name] = { type: param.type, example: param.example };
-            }
-            return acc;
-        },
-        {} as Record<string, { type: string; example?: any }>,
-    ));
-    type InputType = z.infer<typeof zodSchema>;
-    // Create a description that includes examples
-    const description = `Run ${nodeTitle} action. Example input: ${JSON.stringify(
-        schema.reduce((acc, param) => {
-            if (param.example !== undefined) {
-                acc[param.name] = param.example;
-            }
-            return acc;
-        }, {} as Record<string, any>),
-        null,
-        2
-    )}`;
+  const zodSchema = convertToZodSchema(
+    schema.reduce((acc, param) => {
+      if (param.required) {
+        acc[param.name] = { type: param.type, example: param.example };
+      }
+      return acc;
+    }, {} as Record<string, { type: string; example?: any }>),
+  );
+  type InputType = z.infer<typeof zodSchema>;
+  // Create a description that includes examples
+  const description = `Run ${nodeTitle} action. Example input: ${JSON.stringify(
+    schema.reduce((acc, param) => {
+      if (param.example !== undefined) {
+        acc[param.name] = param.example;
+      }
+      return acc;
+    }, {} as Record<string, any>),
+    null,
+    2,
+  )}`;
 
-    const tool = {
-        name: nodeTitle,
-        description,
-        input: zodSchema,
-        execute: async ({ input }: { input: InputType }) => {
-            const response = await mindedConnection.awaitEmit(MindedConnectionSocketMessageType.OnAppAction, {
-                nodeTitle,
-                actionInput: input,
-            }, 20000);
-            return response as { result?: any };
+  const tool = {
+    name: nodeTitle,
+    description,
+    input: zodSchema,
+    execute: async ({ input }: { input: InputType }) => {
+      const response = await mindedConnection.awaitEmit(
+        MindedConnectionSocketMessageType.OnAppAction,
+        {
+          nodeTitle,
+          actionInput: input,
         },
-    };
-    createdTools[nodeTitle] = tool;
-    return tool;
-}
+        20000,
+      );
+      return response as { result?: any };
+    },
+  };
+  createdTools[nodeTitle] = tool;
+  return tool;
+};
 
 export const getAppActionRunnerTool = (nodeTitle: string) => {
-    return createdTools[nodeTitle];
-}
+  return createdTools[nodeTitle];
+};
 
-export default appActionRunnerToolCreator;
+export default appActionRunnerToolCreator;

package/src/nodes/addAppToolNode.ts

@@ -7,15 +7,18 @@ import { z } from 'zod';
 import { LLMProviders } from '../types/LLM.types';
 import { getAppActionRunnerTool } from '../internalTools/appActionRunnerTool';
 import { FlowHistoryType } from '../types/Agent.types';
+import { Agent } from '../agent';
 
 export const addAppToolNode = async ({
   graph,
   node,
   llm,
+  agent,
 }: {
   graph: PreCompiledGraph;
   node: AppToolNode;
   llm: (typeof LLMProviders)[keyof typeof LLMProviders];
+  agent: Agent;
 }) => {
   const appRunnerTool = getAppActionRunnerTool(node.name);
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
@@ -23,7 +26,7 @@ export const addAppToolNode = async ({
 
     const executeWrapper = async (input: z.infer<typeof appRunnerTool.input>) => {
       try {
-        const response = await appRunnerTool.execute({ input, memory: state.memory, triggerInvocations: state.triggerInvocations });
+        const response = await appRunnerTool.execute({ input, state, agent });
         return response || {};
       } catch (error) {
         console.error('Error executing tool', error);

package/src/nodes/addPromptNode.ts

@@ -10,6 +10,7 @@ import { AgentEventRequestPayloads, AgentEvents } from '../events/AgentEvents';
 import { EmitSignature } from '../types/Agent.types';
 import { createLlmInstance } from '../llm/createLlmInstance';
 import extractToolMemoryResponse from '../utils/extractToolMemoryResponse';
+import { Agent } from '../agent';
 
 type AddPromptNodeParams = {
   graph: PreCompiledGraph;
@@ -17,9 +18,10 @@ type AddPromptNodeParams = {
   llm: BaseLanguageModel;
   tools: Tool<any, any>[];
   emit: EmitSignature<any, keyof AgentEventRequestPayloads<any>>;
+  agent: Agent;
 };
 
-export const addPromptNode = async ({ graph, node, llm, tools, emit }: AddPromptNodeParams) => {
+export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: AddPromptNodeParams) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State, { configurable }) => {
     console.log(`Executing prompt node ${node.name}`);
     const llmToUse = node.llmConfig ? createLlmInstance(node.llmConfig) : llm;
@@ -27,7 +29,7 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit }: AddPrompt
     const globalTools = tools
       .filter((tool) => tool.isGlobal)
       .map((tool) =>
-        langchainTool((input: z.infer<typeof tool.input>) => tool.execute({ input, memory: state.memory }), {
+        langchainTool((input: z.infer<typeof tool.input>) => tool.execute({ input, state, agent }), {
           name: tool.name,
           description: tool.description,
           schema: tool.input,
@@ -88,4 +90,4 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit }: AddPrompt
     };
   };
   graph.addNode(node.name, callback);
-};
+};

package/src/nodes/addToolRunNode.ts

@@ -7,6 +7,7 @@ import { tool as langchainTool } from '@langchain/core/tools';
 import { ToolMessage } from '@langchain/core/messages';
 import { z } from 'zod';
 import extractToolMemoryResponse from '../utils/extractToolMemoryResponse';
+import { Agent } from '../agent';
 
 type AddToolRunNodeParams = {
   graph: PreCompiledGraph;
@@ -14,11 +15,12 @@ type AddToolRunNodeParams = {
   llm: (typeof LLMProviders)[keyof typeof LLMProviders];
   toolNode: ToolNode;
   attachedToNodeName: string;
+  agent: Agent;
 };
 
 export const buildToolRunNodeName = (nodeName: string) => `${nodeName}_toolRun`;
 
-export const addToolRunNode = async ({ graph, tools, toolNode, attachedToNodeName }: AddToolRunNodeParams) => {
+export const addToolRunNode = async ({ graph, tools, toolNode, attachedToNodeName, agent }: AddToolRunNodeParams) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
     const matchedTool = tools.find((tool) => tool.name === toolNode.toolName);
     if (!matchedTool) {
@@ -27,7 +29,7 @@ export const addToolRunNode = async ({ graph, tools, toolNode, attachedToNodeNam
 
     const executeWrapper = async (input: z.infer<typeof matchedTool.input>) => {
       try {
-        const response = await matchedTool.execute({ input, memory: state.memory, triggerInvocations: state.triggerInvocations });
+        const response = await matchedTool.execute({ input, state, agent });
         return response || {};
       } catch (error) {
         console.error('Error executing tool', error);

package/src/nodes/nodeFactory.ts

@@ -9,9 +9,10 @@ import { EmitSignature } from '../types/Agent.types';
 import { addAppToolNode } from './addAppToolNode';
 import { addTriggerNode } from './addTriggerNode';
 import { LLMProviders } from '../types/LLM.types';
+import { Agent } from '../agent';
 
 const addJunctionNode = ({ graph, node }: { graph: PreCompiledGraph; node: JunctionNode }) => {
-  const callback: RunnableLike = async () => { };
+  const callback: RunnableLike = async () => {};
   graph.addNode(node.name, callback);
 };
 
@@ -21,12 +22,14 @@ export const nodeFactory = ({
   tools,
   llm,
   emit,
+  agent,
 }: {
   graph: PreCompiledGraph;
   node: Node;
   tools: Tool<any, any>[];
-  llm: typeof LLMProviders[keyof typeof LLMProviders];
+  llm: (typeof LLMProviders)[keyof typeof LLMProviders];
   emit: EmitSignature<any, keyof AgentEventRequestPayloads<any>>;
+  agent: Agent;
 }) => {
   const nodeType = node.type;
   switch (nodeType) {
@@ -40,10 +43,10 @@ export const nodeFactory = ({
       addJunctionNode({ graph, node });
       break;
     case NodeType.APP_TOOL:
-      addAppToolNode({ graph, node, llm });
+      addAppToolNode({ graph, node, llm, agent });
       break;
     case NodeType.PROMPT_NODE:
-      addPromptNode({ graph, node, tools, llm, emit });
+      addPromptNode({ graph, node, tools, llm, emit, agent });
       break;
     default:
       throw new Error(`Unsupported node type: ${nodeType}`);

package/src/platform/mindedConnectionTypes.ts

@@ -17,6 +17,7 @@ export enum MindedConnectionSocketMessageType {
   CHECKPOINT_PUT_WRITES = 'checkpoint-put-writes',
   GET_SECRETS = 'get-secrets',
   GET_FLOWS = 'get-flows',
+  PII_HTTP_REQUEST = 'pii-http-request',
 }
 
 export interface BaseMindedConnectionSocketMessage {
@@ -66,3 +67,21 @@ export interface OnCheckpointList extends BaseMindedConnectionSocketMessage {
 export interface OnCheckpointListResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
   checkpoints?: CheckpointTuple[];
 }
+
+export interface OnPiiHttpRequest extends BaseMindedConnectionSocketMessage {
+  sessionId: string;
+  requestId: string;
+  method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+  url: string;
+  headers?: Record<string, string>;
+  params?: Record<string, any>;
+  data?: any;
+}
+
+export interface OnPiiHttpResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  requestId: string;
+  data?: any;
+  status?: number;
+  statusText?: string;
+  headers?: Record<string, string>;
+}

package/src/platform/piiGateway/gateway.ts

@@ -0,0 +1,97 @@
+import { v4 as uuidv4 } from 'uuid';
+import { MindedConnection } from '../mindedConnection';
+import { MindedConnectionSocketMessageType, OnPiiHttpRequest, OnPiiHttpResponse } from '../mindedConnectionTypes';
+import { HttpRequestConfig, HttpResponse, PIIGatewayInstance } from './types';
+
+export class PIIGateway implements PIIGatewayInstance {
+  private mindedConnection: MindedConnection;
+
+  constructor(mindedConnection: MindedConnection) {
+    this.mindedConnection = mindedConnection;
+  }
+
+  private async makeRequest<T = any>(
+    sessionId: string,
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS',
+    url: string,
+    data?: any,
+    config?: HttpRequestConfig,
+  ): Promise<HttpResponse<T>> {
+    if (!this.mindedConnection?.isConnected) {
+      throw new Error('Minded connection is not established. PII-secured HTTP requests require a connection to the Minded platform.');
+    }
+
+    try {
+      const requestId = uuidv4();
+      const requestPayload: OnPiiHttpRequest = {
+        type: MindedConnectionSocketMessageType.PII_HTTP_REQUEST,
+        requestId,
+        method,
+        url,
+        headers: config?.headers as Record<string, string>,
+        params: config?.params,
+        data,
+        sessionId,
+      };
+
+      const response = await this.mindedConnection.awaitEmit<OnPiiHttpRequest, OnPiiHttpResponse>(
+        MindedConnectionSocketMessageType.PII_HTTP_REQUEST,
+        requestPayload,
+        30000, // 30 second timeout for HTTP requests
+      );
+
+      if (response.error) {
+        throw new Error(`HTTP request failed: ${response.error}`);
+      }
+
+      // Verify that the response requestId matches our request
+      if (response.requestId && response.requestId !== requestId) {
+        console.warn(`Response requestId (${response.requestId}) does not match request requestId (${requestId})`);
+      }
+
+      // Return generic HttpResponse format
+      return {
+        data: response.data,
+        status: response.status || 200,
+        statusText: response.statusText || 'OK',
+        headers: response.headers || {},
+        config: config || {},
+      };
+    } catch (error) {
+      throw new Error(`Secure HTTP request failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  async get<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
+    return this.makeRequest<T>(sessionId, 'GET', url, undefined, config);
+  }
+
+  async post<T = any>(sessionId: string, url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
+    return this.makeRequest<T>(sessionId, 'POST', url, data, config);
+  }
+
+  async put<T = any>(sessionId: string, url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
+    return this.makeRequest<T>(sessionId, 'PUT', url, data, config);
+  }
+
+  async delete<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
+    return this.makeRequest<T>(sessionId, 'DELETE', url, undefined, config);
+  }
+
+  async patch<T = any>(sessionId: string, url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
+    return this.makeRequest<T>(sessionId, 'PATCH', url, data, config);
+  }
+
+  async head<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
+    return this.makeRequest<T>(sessionId, 'HEAD', url, undefined, config);
+  }
+
+  async options<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
+    return this.makeRequest<T>(sessionId, 'OPTIONS', url, undefined, config);
+  }
+
+  async request<T = any>(sessionId: string, config: HttpRequestConfig): Promise<HttpResponse<T>> {
+    const method = (config.method?.toUpperCase() || 'GET') as any;
+    return this.makeRequest<T>(sessionId, method, config.url || '', config.data, config);
+  }
+}

package/src/platform/piiGateway/index.ts

@@ -0,0 +1,5 @@
+// Export types
+export type { HttpRequestConfig, HttpResponse, PIIGatewayInstance } from './types';
+
+// Export core gateway class and creation function
+export { PIIGateway } from './gateway';