@librechat/agents 3.1.67-dev.4 → 3.1.68

package/dist/types/types/tools.d.ts

@@ -1,8 +1,7 @@
 import type { StructuredToolInterface } from '@langchain/core/tools';
 import type { RunnableToolLike } from '@langchain/core/runnables';
 import type { ToolCall } from '@langchain/core/messages/tool';
-import type { HookRegistry } from '@/hooks';
-import type { MessageContentComplex, ToolErrorData } from './stream';
+import type { ToolErrorData } from './stream';
 import { EnvVar } from '@/common';
 /** Replacement type for `import type { ToolCall } from '@langchain/core/messages/tool'` in order to have stringified args typed */
 export type CustomToolCall = {
@@ -40,12 +39,6 @@ export type ToolNodeOptions = {
     agentId?: string;
     /** Tool names that must be executed directly (via runTool) even in event-driven mode (e.g., graph-managed handoff tools) */
     directToolNames?: Set<string>;
-    /**
-     * Hook registry for PreToolUse/PostToolUse lifecycle hooks.
-     * Only fires for event-driven tool calls (`dispatchToolEvents`). Tools
-     * routed through `directToolNames` bypass hook dispatch entirely.
-     */
-    hookRegistry?: HookRegistry;
     /** Max context tokens for the agent — used to compute tool result truncation limits. */
     maxContextTokens?: number;
     /**
@@ -161,25 +154,6 @@ export type ToolExecuteBatchRequest = {
     /** Promise rejector - handler calls this on fatal error */
     reject: (error: Error) => void;
 };
-/**
- * A message injected into graph state by any tool execution handler.
- * Generic mechanism: any tool returning `injectedMessages` in its `ToolExecuteResult`
- * will have these appended to state after the ToolMessage for this call.
- */
-export type InjectedMessage = {
-    /** 'user' for skill body injection, 'system' for context hints.
-     *  Both are converted to HumanMessage at runtime; the original role
-     *  is preserved in additional_kwargs.role. */
-    role: 'user' | 'system';
-    /** Message content: string for simple text, array for complex multi-part content */
-    content: string | MessageContentComplex[];
-    /** When true, the message is framework-internal: not shown in UI, not counted as a user turn */
-    isMeta?: boolean;
-    /** Origin tag for downstream consumers (UI, pruner, compaction) */
-    source?: 'skill' | 'hook' | 'system';
-    /** Only set when source is 'skill', for compaction preservation */
-    skillName?: string;
-};
 /** Result for a single tool call in event-driven execution */
 export type ToolExecuteResult = {
     /** Matches ToolCallRequest.id */
@@ -192,13 +166,6 @@ export type ToolExecuteResult = {
     status: 'success' | 'error';
     /** Error message if status is 'error' */
     errorMessage?: string;
-    /**
-     * Messages to inject into graph state after the ToolMessage for this call.
-     * Placed after tool results to respect provider message ordering (tool_call -> tool_result adjacency).
-     * The host's message formatter may merge injected user messages with the preceding tool_result turn.
-     * Generic mechanism: any tool execution handler can use this.
-     */
-    injectedMessages?: InjectedMessage[];
 };
 /** Map of tool names to tool definitions */
 export type LCToolRegistry = Map<string, LCTool>;
@@ -299,10 +266,6 @@ export type ProgrammaticExecutionArtifact = {
     session_id?: string;
     files?: FileRefs;
 };
-/** Parameters for creating a bash execution tool (same API as CodeExecutor, bash-only) */
-export type BashExecutionToolParams = CodeExecutionToolParams;
-/** Parameters for creating a bash programmatic tool calling tool (same API as PTC, bash-only) */
-export type BashProgrammaticToolCallingParams = ProgrammaticToolCallingParams;
 /**
  * Initialization parameters for the PTC tool
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.1.67-dev.4",
+  "version": "3.1.68",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -61,9 +61,6 @@
     "tool": "node --trace-warnings -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/tools.ts --provider 'bedrock' --name 'Jo' --location 'New York, NY'",
     "search": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/search.ts --provider 'bedrock' --name 'Jo' --location 'New York, NY'",
     "tool_search": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/tool_search.ts",
-    "subagent": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/multi-agent-subagent.ts",
-    "subagent:events": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/subagent-event-driven-debug.ts",
-    "subagent:tools": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/subagent-tools-debug.ts",
     "programmatic_exec": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/programmatic_exec.ts",
     "code_exec_ptc": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/code_exec_ptc.ts --provider 'openAI' --name 'Jo' --location 'New York, NY'",
     "programmatic_exec_agent": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/programmatic_exec_agent.ts --provider 'openAI' --name 'Jo' --location 'New York, NY'",
@@ -80,7 +77,6 @@
     "multi-agent-chain": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/multi-agent-chain.ts",
     "multi-agent-sequence": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/multi-agent-sequence.ts",
     "multi-agent-conditional": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/multi-agent-conditional.ts",
-    "multi-agent-subagent": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/multi-agent-subagent.ts",
     "multi-agent-supervisor": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/multi-agent-supervisor.ts",
     "test-handoff-preamble": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/test-handoff-preamble.ts",
     "multi-agent-list-handoff": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/test-multi-agent-list-handoff.ts",

package/src/agents/AgentContext.ts

@@ -55,8 +55,6 @@ export class AgentContext {
       contextPruningConfig,
       maxToolResultChars,
       toolSchemaTokens,
-      subagentConfigs,
-      maxSubagentDepth,
     } = agentConfig;
 
     const agentContext = new AgentContext({
@@ -84,10 +82,6 @@ export class AgentContext {
       maxToolResultChars,
     });
 
-    agentContext._sourceInputs = agentConfig;
-    agentContext.subagentConfigs = subagentConfigs;
-    agentContext.maxSubagentDepth = maxSubagentDepth;
-
     if (initialSummary?.text != null && initialSummary.text !== '') {
       agentContext.setInitialSummary(
         initialSummary.text,
@@ -204,12 +198,6 @@ export class AgentContext {
   toolDefinitions?: t.LCTool[];
   /** Set of tool names discovered via tool search (to be loaded) */
   discoveredToolNames: Set<string> = new Set();
-  /** Original AgentInputs used to create this context — used for self-spawn subagent resolution. */
-  _sourceInputs?: t.AgentInputs;
-  /** Subagent configurations for hierarchical delegation. */
-  subagentConfigs?: t.SubagentConfig[];
-  /** Maximum subagent nesting depth. */
-  maxSubagentDepth?: number;
   /** Instructions for this agent */
   instructions?: string;
   /** Additional instructions for this agent */
@@ -697,20 +685,8 @@ export class AgentContext {
     let toolTokens = 0;
     const countedToolNames = new Set<string>();
 
-    /**
-     * Iterate both `tools` (user-provided instance tools) and `graphTools`
-     * (graph-managed tools like handoff + subagent). `graphTools` is often
-     * populated after `fromConfig()` kicks off the initial calculation, so
-     * callers that mutate `graphTools` must re-trigger this method to
-     * refresh `toolSchemaTokens`.
-     */
-    const instanceTools: t.GraphTools = [
-      ...((this.tools as t.GenericTool[] | undefined) ?? []),
-      ...((this.graphTools as t.GenericTool[] | undefined) ?? []),
-    ];
-
-    if (instanceTools.length > 0) {
-      for (const tool of instanceTools) {
+    if (this.tools && this.tools.length > 0) {
+      for (const tool of this.tools) {
         const genericTool = tool as Record<string, unknown>;
         if (
           genericTool.schema != null &&

package/src/common/enum.ts

@@ -27,8 +27,6 @@ export enum GraphEvents {
   ON_SUMMARIZE_DELTA = 'on_summarize_delta',
   /** [Custom] Emitted when the summarize node completes with the final summary */
   ON_SUMMARIZE_COMPLETE = 'on_summarize_complete',
-  /** [Custom] Progress update from a running subagent (wraps child-graph events so hosts can display activity separately from parent). */
-  ON_SUBAGENT_UPDATE = 'on_subagent_update',
   /** [Custom] Diagnostic logging event for context management observability */
   ON_AGENT_LOG = 'on_agent_log',
 
@@ -184,21 +182,8 @@ export enum Constants {
   MCP_DELIMITER = '_mcp_',
   /** Anthropic server tool ID prefix (web_search, code_execution, etc.) */
   ANTHROPIC_SERVER_TOOL_PREFIX = 'srvtoolu_',
-  SKILL_TOOL = 'skill',
-  READ_FILE = 'read_file',
-  BASH_TOOL = 'bash_tool',
-  BASH_PROGRAMMATIC_TOOL_CALLING = 'run_tools_with_bash',
-  SUBAGENT = 'subagent',
 }
 
-/** Tool names that use the code execution environment (shared session, file tracking). */
-export const CODE_EXECUTION_TOOLS: ReadonlySet<string> = new Set([
-  Constants.EXECUTE_CODE,
-  Constants.BASH_TOOL,
-  Constants.PROGRAMMATIC_TOOL_CALLING,
-  Constants.BASH_PROGRAMMATIC_TOOL_CALLING,
-]);
-
 export enum TitleMethod {
   STRUCTURED = 'structured',
   FUNCTIONS = 'functions',

package/src/graphs/Graph.ts

@@ -1,6 +1,5 @@
 /* eslint-disable no-console */
 import { nanoid } from 'nanoid';
-import { tool } from '@langchain/core/tools';
 import { ToolNode } from '@langchain/langgraph/prebuilt';
 import { Runnable, RunnableConfig } from '@langchain/core/runnables';
 import { ToolMessage, AIMessageChunk } from '@langchain/core/messages';
@@ -40,8 +39,6 @@ import {
   joinKeys,
   sleep,
 } from '@/utils';
-import { SubagentExecutor, resolveSubagentConfigs } from '@/tools/subagent';
-import { buildSubagentToolParams } from '@/tools/SubagentTool';
 import { ToolNode as CustomToolNode, toolsCondition } from '@/tools/ToolNode';
 import { safeDispatchCustomEvent, emitAgentLog } from '@/utils/events';
 import { attemptInvoke, tryFallbackProviders } from '@/llm/invoke';
@@ -56,7 +53,6 @@ import { isThinkingEnabled } from '@/llm/request';
 import { initializeModel } from '@/llm/init';
 import { HandlerRegistry } from '@/events';
 import { ChatOpenAI } from '@/llm/openai';
-import type { HookRegistry } from '@/hooks';
 
 const { AGENT, TOOLS, SUMMARIZE } = GraphNodeKeys;
 
@@ -127,7 +123,6 @@ export abstract class Graph<
   /** Set of invoked tool call IDs from non-message run steps completed mid-run, if any */
   invokedToolIds?: Set<string>;
   handlerRegistry: HandlerRegistry | undefined;
-  hookRegistry: HookRegistry | undefined;
   /**
    * Tool session contexts for automatic state persistence across tool invocations.
    * Keyed by tool name (e.g., Constants.EXECUTE_CODE).
@@ -152,7 +147,6 @@ export abstract class Graph<
     this.prelimMessageIdsByStepKey = new Map();
     this.invokedToolIds = undefined;
     this.handlerRegistry = undefined;
-    this.hookRegistry = undefined;
     this.sessions.clear();
   }
 }
@@ -512,7 +506,6 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         agentId: agentContext?.agentId,
         toolCallStepIds: this.toolCallStepIds,
         toolRegistry: agentContext?.toolRegistry,
-        hookRegistry: this.hookRegistry,
         directToolNames: directToolNames.size > 0 ? directToolNames : undefined,
         maxContextTokens: agentContext?.maxContextTokens,
         maxToolResultChars: agentContext?.maxToolResultChars,
@@ -1155,111 +1148,6 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       throw new Error(`Agent context not found for agentId: ${agentId}`);
     }
 
-    /**
-     * Depth countdown across graph boundaries: the parent's `maxSubagentDepth`
-     * becomes this executor's `maxDepth`. When the child graph is constructed,
-     * `buildChildInputs()` decrements `maxSubagentDepth` on the child's
-     * `AgentInputs` (only when `allowNested: true`; otherwise subagentConfigs
-     * are stripped entirely). The child graph's own `createAgentNode()` then
-     * reads the decremented value here and creates a narrower executor —
-     * recursion is bounded even though each graph has its own separate
-     * executor instance.
-     */
-    const effectiveSubagentDepth = agentContext.maxSubagentDepth ?? 1;
-    if (
-      agentContext.subagentConfigs != null &&
-      agentContext.subagentConfigs.length > 0 &&
-      effectiveSubagentDepth > 0
-    ) {
-      const resolvedConfigs = resolveSubagentConfigs(
-        agentContext.subagentConfigs,
-        agentContext
-      );
-      if (resolvedConfigs.length > 0) {
-        const getParentHandlerRegistry = (): HandlerRegistry | undefined =>
-          this.handlerRegistry;
-        const executor = new SubagentExecutor({
-          configs: new Map(resolvedConfigs.map((c) => [c.type, c])),
-          parentSignal: this.signal,
-          hookRegistry: this.hookRegistry,
-          /** Lazy — Run wires the registry onto the graph AFTER
-           *  `createWorkflow()` runs, so a direct capture here would be
-           *  `undefined` at construction time. */
-          parentHandlerRegistry: getParentHandlerRegistry,
-          parentRunId: this.runId ?? '',
-          parentAgentId: agentContext.agentId,
-          tokenCounter: agentContext.tokenCounter,
-          maxDepth: effectiveSubagentDepth,
-          createChildGraph: (input): StandardGraph => new StandardGraph(input),
-        });
-
-        const subagentTool = tool(async (rawInput, config) => {
-          const input = rawInput as {
-            description?: string;
-            subagent_type?: string;
-          };
-          const description =
-            typeof input.description === 'string' &&
-            input.description.trim().length > 0
-              ? input.description
-              : 'No task description provided';
-          const subagentType =
-            typeof input.subagent_type === 'string' ? input.subagent_type : '';
-          const threadId = config.configurable?.thread_id as string | undefined;
-          /**
-           * When the tool is dispatched from an LLM's `tool_call`, LangChain
-           * threads the originating `ToolCall` onto the RunnableConfig as
-           * `config.toolCall` (see `ToolRunnableConfig` in
-           * `@langchain/core/tools` — internal but stable since ≥0.3.x).
-           * Surfacing its id lets hosts correlate `SubagentUpdateEvent`s
-           * back to the parent's `tool_call_id` deterministically — no
-           * temporal heuristics needed. If a future LangChain version
-           * changes the threading, the type-guarded read falls back to
-           * `undefined` and the correlation degrades gracefully.
-           */
-          const toolCall = (config as { toolCall?: { id?: string } }).toolCall;
-          const parentToolCallId =
-            typeof toolCall?.id === 'string' ? toolCall.id : undefined;
-          const result = await executor.execute({
-            description,
-            subagentType,
-            threadId,
-            parentToolCallId,
-          });
-          return result.content;
-        }, buildSubagentToolParams(resolvedConfigs));
-
-        if (!agentContext.graphTools) {
-          agentContext.graphTools = [];
-        }
-        (agentContext.graphTools as t.GenericTool[]).push(subagentTool);
-
-        /**
-         * Refresh toolSchemaTokens to include the subagent tool's schema.
-         * `calculateInstructionTokens()` was kicked off in `fromConfig()`
-         * before graphTools was populated, so its result did not count this
-         * tool. Without this retrigger, token-budget/pruning logic
-         * underestimates prompt overhead.
-         */
-        if (agentContext.tokenCounter) {
-          const { tokenCounter, baseIndexTokenCountMap } = agentContext;
-          agentContext.tokenCalculationPromise = agentContext
-            .calculateInstructionTokens(tokenCounter)
-            .then(() => {
-              agentContext.updateTokenMapWithInstructions(
-                baseIndexTokenCountMap
-              );
-            })
-            .catch((err) => {
-              console.error(
-                'Error recalculating instruction tokens after subagent tool injection:',
-                err
-              );
-            });
-        }
-      }
-    }
-
     const agentNode = `${AGENT}${agentId}` as const;
     const toolNode = `${TOOLS}${agentId}` as const;
     const summarizeNode = `${SUMMARIZE}${agentId}` as const;
@@ -1315,7 +1203,6 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
             },
             runId: this.runId,
             isMultiAgent: this.isMultiAgentGraph(),
-            hookRegistry: this.hookRegistry,
             dispatchRunStep: async (runStep, nodeConfig) => {
               this.contentData.push(runStep);
               this.contentIndexMap.set(runStep.id, runStep.index);

package/src/graphs/MultiAgentGraph.ts

@@ -59,11 +59,50 @@ export class MultiAgentGraph extends StandardGraph {
   constructor(input: t.MultiAgentGraphInput) {
     super(input);
     this.edges = input.edges;
+    this.validateEdgeAgents();
     this.categorizeEdges();
     this.analyzeGraph();
     this.createHandoffTools();
   }
 
+  /**
+   * Fails fast when an edge references an agent that is not in
+   * `agentContexts`. Without this check, the underlying LangGraph
+   * `StateGraph.compile()` would throw the opaque
+   * `Found edge ending at unknown node "<id>"` error after graph
+   * construction — far from the true root cause.
+   *
+   * This catches the common misuse of passing `edges` into a multi-agent
+   * config without also passing the corresponding sub-agent configs in
+   * `agents` (e.g. a host that forgot to pre-load handoff targets).
+   */
+  private validateEdgeAgents(): void {
+    const known = new Set(this.agentContexts.keys());
+    const unknown = new Set<string>();
+    for (const edge of this.edges) {
+      const participants = [
+        ...(Array.isArray(edge.from) ? edge.from : [edge.from]),
+        ...(Array.isArray(edge.to) ? edge.to : [edge.to]),
+      ];
+      for (const id of participants) {
+        if (typeof id === 'string' && !known.has(id)) {
+          unknown.add(id);
+        }
+      }
+    }
+    if (unknown.size === 0) {
+      return;
+    }
+    const missing = Array.from(unknown)
+      .map((id) => `"${id}"`)
+      .join(', ');
+    throw new Error(
+      `MultiAgentGraph: edges reference agent(s) not present in agents: [${missing}]. ` +
+        'Ensure every agent referenced by an edge is also included in the `agents` array, ' +
+        'or filter orphaned edges before constructing the graph.'
+    );
+  }
+
   /**
    * Categorize edges into handoff and direct types
    */

package/src/graphs/__tests__/MultiAgentGraph.test.ts

@@ -0,0 +1,91 @@
+// src/graphs/__tests__/MultiAgentGraph.test.ts
+import { MultiAgentGraph } from '../MultiAgentGraph';
+import { Providers } from '@/common';
+import type * as t from '@/types';
+
+describe('MultiAgentGraph.validateEdgeAgents', () => {
+  const makeAgent = (agentId: string): t.AgentInputs => ({
+    agentId,
+    provider: Providers.OPENAI,
+    instructions: 'test',
+  });
+
+  it('constructs without error when every edge endpoint has a matching agent', () => {
+    const input: t.MultiAgentGraphInput = {
+      runId: 'r1',
+      agents: [makeAgent('A'), makeAgent('B')],
+      edges: [{ from: 'A', to: 'B', edgeType: 'handoff' }],
+    };
+
+    expect(() => new MultiAgentGraph(input)).not.toThrow();
+  });
+
+  it('throws a descriptive error when an edge `to` points at an unknown agent', () => {
+    const input: t.MultiAgentGraphInput = {
+      runId: 'r1',
+      agents: [makeAgent('A')],
+      edges: [{ from: 'A', to: 'MISSING', edgeType: 'handoff' }],
+    };
+
+    expect(() => new MultiAgentGraph(input)).toThrow(/MISSING/);
+    expect(() => new MultiAgentGraph(input)).toThrow(
+      /edges reference agent\(s\) not present in agents/
+    );
+  });
+
+  it('throws when an edge `from` points at an unknown agent', () => {
+    const input: t.MultiAgentGraphInput = {
+      runId: 'r1',
+      agents: [makeAgent('A')],
+      edges: [{ from: 'MISSING', to: 'A', edgeType: 'handoff' }],
+    };
+
+    expect(() => new MultiAgentGraph(input)).toThrow(/MISSING/);
+  });
+
+  it('reports all unknown agent ids in a single error', () => {
+    const input: t.MultiAgentGraphInput = {
+      runId: 'r1',
+      agents: [makeAgent('A')],
+      edges: [
+        { from: 'A', to: 'B', edgeType: 'handoff' },
+        { from: 'A', to: 'C', edgeType: 'handoff' },
+      ],
+    };
+
+    let thrown: Error | undefined;
+    try {
+      new MultiAgentGraph(input);
+    } catch (err) {
+      thrown = err as Error;
+    }
+    expect(thrown).toBeDefined();
+    expect(thrown!.message).toMatch(/"B"/);
+    expect(thrown!.message).toMatch(/"C"/);
+  });
+
+  it('handles array `from` / `to` fields', () => {
+    const valid: t.MultiAgentGraphInput = {
+      runId: 'r1',
+      agents: [makeAgent('A'), makeAgent('B'), makeAgent('C')],
+      edges: [{ from: ['A'], to: ['B', 'C'], edgeType: 'direct' }],
+    };
+    expect(() => new MultiAgentGraph(valid)).not.toThrow();
+
+    const invalid: t.MultiAgentGraphInput = {
+      runId: 'r1',
+      agents: [makeAgent('A'), makeAgent('B')],
+      edges: [{ from: ['A'], to: ['B', 'C'], edgeType: 'direct' }],
+    };
+    expect(() => new MultiAgentGraph(invalid)).toThrow(/"C"/);
+  });
+
+  it('accepts an empty edges array (single-agent case with no handoffs)', () => {
+    const input: t.MultiAgentGraphInput = {
+      runId: 'r1',
+      agents: [makeAgent('A')],
+      edges: [],
+    };
+    expect(() => new MultiAgentGraph(input)).not.toThrow();
+  });
+});

package/src/index.ts

@@ -14,14 +14,7 @@ export * from './summarization';
 /* Tools */
 export * from './tools/Calculator';
 export * from './tools/CodeExecutor';
-export * from './tools/BashExecutor';
 export * from './tools/ProgrammaticToolCalling';
-export * from './tools/BashProgrammaticToolCalling';
-export * from './tools/SkillTool';
-export * from './tools/SubagentTool';
-export * from './tools/subagent';
-export * from './tools/ReadFile';
-export * from './tools/skillCatalog';
 export * from './tools/ToolSearch';
 export * from './tools/ToolNode';
 export * from './tools/schema';
@@ -32,9 +25,6 @@ export * from './tools/search';
 export * from './common';
 export * from './utils';
 
-/* Hooks */
-export * from './hooks';
-
 /* Types */
 export type * from './types';
 

package/src/messages/format.ts

@@ -797,39 +797,18 @@ function contentPartCharLength(part: MessageContentComplex): number {
   return len;
 }
 
-/** Extracts the skillName from a skill tool_call's args (string or object). */
-function extractSkillName(args: unknown): string | undefined {
-  let parsed: Record<string, unknown> | undefined;
-  if (typeof args === 'string') {
-    try {
-      parsed = JSON.parse(args) as Record<string, unknown>;
-    } catch {
-      /* malformed args — skip */
-    }
-  } else {
-    parsed = args as Record<string, unknown> | undefined;
-  }
-  const name = parsed?.skillName;
-  return typeof name === 'string' && name !== '' ? name : undefined;
-}
-
 /**
  * Formats an array of messages for LangChain, handling tool calls and creating ToolMessage instances.
  *
  * @param payload - The array of messages to format.
  * @param indexTokenCountMap - Optional map of message indices to token counts.
  * @param tools - Optional set of tool names that are allowed in the request.
- * @param skills - Optional map of skill name to body for reconstructing skill HumanMessages.
  * @returns - Object containing formatted messages and updated indexTokenCountMap if provided.
  */
 export const formatAgentMessages = (
   payload: TPayload,
   indexTokenCountMap?: Record<number, number | undefined>,
-  tools?: Set<string>,
-  /** Pre-resolved skill bodies keyed by skill name. When present, HumanMessages
-   *  are reconstructed after skill ToolMessages to restore skill instructions
-   *  that were only in LangGraph state during the original run. */
-  skills?: Map<string, string>
+  tools?: Set<string>
 ): {
   messages: Array<HumanMessage | AIMessage | SystemMessage | ToolMessage>;
   indexTokenCountMap?: Record<number, number>;
@@ -923,7 +902,6 @@ export const formatAgentMessages = (
      * - Dynamically expand the set when tool_search results are encountered
      */
     let processedMessage = message;
-    let pendingSkillNames: Set<string> | undefined;
     if (discoveredTools) {
       const content = message.content;
       if (content != null && Array.isArray(content)) {
@@ -972,17 +950,8 @@ export const formatAgentMessages = (
           }
 
           if (discoveredTools.has(toolName)) {
+            /** Valid tool - keep it */
             filteredContent.push(part);
-            if (
-              toolName === Constants.SKILL_TOOL &&
-              skills?.size != null &&
-              skills.size > 0
-            ) {
-              const skillName = extractSkillName(part.tool_call.args) ?? '';
-              if (skillName) {
-                (pendingSkillNames ??= new Set()).add(skillName);
-              }
-            }
           } else {
             /** Invalid tool - convert to string for context preservation */
             if (
@@ -1058,25 +1027,6 @@ export const formatAgentMessages = (
       }
     }
 
-    /** When tools filtering is off, still detect skill tool_calls for body reconstruction */
-    if (!discoveredTools && skills?.size != null && skills.size > 0) {
-      const content = processedMessage.content;
-      if (Array.isArray(content)) {
-        for (const part of content) {
-          if (
-            part.type !== ContentTypes.TOOL_CALL ||
-            part.tool_call?.name !== Constants.SKILL_TOOL
-          ) {
-            continue;
-          }
-          const skillName = extractSkillName(part.tool_call.args) ?? '';
-          if (skillName) {
-            (pendingSkillNames ??= new Set()).add(skillName);
-          }
-        }
-      }
-    }
-
     const formattedMessages = formatAssistantMessage(processedMessage);
     if (sourceMessageId != null && sourceMessageId !== '') {
       for (const formattedMessage of formattedMessages) {
@@ -1085,29 +1035,9 @@ export const formatAgentMessages = (
     }
     messages.push(...formattedMessages);
 
-    // Capture index range BEFORE skill body injection so injected
-    // HumanMessages are excluded from the assistant's token distribution.
+    // Update the index mapping for this assistant message
+    // Store all indices that were created from this original message
     const endMessageIndex = messages.length;
-
-    if (pendingSkillNames?.size != null && pendingSkillNames.size > 0) {
-      for (const skillName of pendingSkillNames) {
-        const body = skills?.get(skillName) ?? '';
-        if (body) {
-          messages.push(
-            new HumanMessage({
-              content: body,
-              additional_kwargs: {
-                role: 'user',
-                isMeta: true,
-                source: 'skill',
-                skillName,
-              },
-            })
-          );
-        }
-      }
-    }
-
     const resultIndices = [];
     for (let j = startMessageIndex; j < endMessageIndex; j++) {
       resultIndices.push(j);