@librechat/agents 3.0.35 → 3.0.40

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

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import type * as t from '@/types';
+declare const ProgrammaticToolCallingSchema: z.ZodObject<{
+    code: z.ZodString;
+    tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        parameters: z.ZodAny;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description?: string | undefined;
+        parameters?: any;
+    }, {
+        name: string;
+        description?: string | undefined;
+        parameters?: any;
+    }>, "many">>;
+    session_id: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    timeout: number;
+    tools?: {
+        name: string;
+        description?: string | undefined;
+        parameters?: any;
+    }[] | undefined;
+    session_id?: string | undefined;
+}, {
+    code: string;
+    tools?: {
+        name: string;
+        description?: string | undefined;
+        parameters?: any;
+    }[] | undefined;
+    timeout?: number | undefined;
+    session_id?: string | undefined;
+}>;
+/**
+ * Makes an HTTP request to the Code API.
+ * @param endpoint - The API endpoint URL
+ * @param apiKey - The API key for authentication
+ * @param body - The request body
+ * @param proxy - Optional HTTP proxy URL
+ * @returns The parsed API response
+ */
+export declare function makeRequest(endpoint: string, apiKey: string, body: Record<string, unknown>, proxy?: string): Promise<t.ProgrammaticExecutionResponse>;
+/**
+ * Executes tools in parallel when requested by the API.
+ * Uses Promise.all for parallel execution, catching individual errors.
+ * @param toolCalls - Array of tool calls from the API
+ * @param toolMap - Map of tool names to executable tools
+ * @returns Array of tool results
+ */
+export declare function executeTools(toolCalls: t.PTCToolCall[], toolMap: t.ToolMap): Promise<t.PTCToolResult[]>;
+/**
+ * Formats the completed response for the agent.
+ * @param response - The completed API response
+ * @returns Tuple of [formatted string, artifact]
+ */
+export declare function formatCompletedResponse(response: t.ProgrammaticExecutionResponse): [string, t.ProgrammaticExecutionArtifact];
+/**
+ * Creates a Programmatic Tool Calling tool for complex multi-tool workflows.
+ *
+ * This tool enables AI agents to write Python code that orchestrates multiple
+ * tool calls programmatically, reducing LLM round-trips and token usage.
+ *
+ * The tool map must be provided at runtime via config.configurable.toolMap.
+ *
+ * @param params - Configuration parameters (apiKey, baseUrl, maxRoundTrips, proxy)
+ * @returns A LangChain DynamicStructuredTool for programmatic tool calling
+ *
+ * @example
+ * const ptcTool = createProgrammaticToolCallingTool({
+ *   apiKey: process.env.CODE_API_KEY,
+ *   maxRoundTrips: 20
+ * });
+ *
+ * const [output, artifact] = await ptcTool.invoke(
+ *   { code, tools },
+ *   { configurable: { toolMap } }
+ * );
+ */
+export declare function createProgrammaticToolCallingTool(initParams?: t.ProgrammaticToolCallingParams): DynamicStructuredTool<typeof ProgrammaticToolCallingSchema>;
+export {};

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

@@ -13,7 +13,13 @@ export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
     toolCallStepIds?: Map<string, string>;
     errorHandler?: t.ToolNodeConstructorParams['errorHandler'];
     private toolUsageCount;
-    constructor({ tools, toolMap, name, tags, errorHandler, toolCallStepIds, handleToolErrors, loadRuntimeTools, }: t.ToolNodeConstructorParams);
+    /** Tools available for programmatic code execution */
+    private programmaticToolMap?;
+    /** Tool definitions for programmatic code execution (sent to Code API) */
+    private programmaticToolDefs?;
+    /** Tool registry for tool search (deferred tools) */
+    private toolRegistry?;
+    constructor({ tools, toolMap, name, tags, errorHandler, toolCallStepIds, handleToolErrors, loadRuntimeTools, programmaticToolMap, programmaticToolDefs, toolRegistry, }: t.ToolNodeConstructorParams);
     /**
      * Returns a snapshot of the current tool usage counts.
      * @returns A ReadonlyMap where keys are tool names and values are their usage counts.

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

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import type * as t from '@/types';
+declare const ToolSearchRegexSchema: z.ZodObject<{
+    query: z.ZodString;
+    fields: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["name", "description", "parameters"]>, "many">>>;
+    max_results: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    fields: ("name" | "description" | "parameters")[];
+    max_results: number;
+}, {
+    query: string;
+    fields?: ("name" | "description" | "parameters")[] | undefined;
+    max_results?: number | undefined;
+}>;
+/**
+ * Escapes special regex characters in a string to use as a literal pattern.
+ * @param pattern - The string to escape
+ * @returns The escaped string safe for use in a RegExp
+ */
+declare function escapeRegexSpecialChars(pattern: string): string;
+/**
+ * Counts the maximum nesting depth of groups in a regex pattern.
+ * @param pattern - The regex pattern to analyze
+ * @returns The maximum nesting depth
+ */
+declare function countNestedGroups(pattern: string): number;
+/**
+ * Detects nested quantifiers that can cause catastrophic backtracking.
+ * Patterns like (a+)+, (a*)*, (a+)*, etc.
+ * @param pattern - The regex pattern to check
+ * @returns True if nested quantifiers are detected
+ */
+declare function hasNestedQuantifiers(pattern: string): boolean;
+/**
+ * Checks if a regex pattern contains potentially dangerous constructs.
+ * @param pattern - The regex pattern to validate
+ * @returns True if the pattern is dangerous
+ */
+declare function isDangerousPattern(pattern: string): boolean;
+/**
+ * Sanitizes a regex pattern for safe execution.
+ * If the pattern is dangerous, it will be escaped to a literal string search.
+ * @param pattern - The regex pattern to sanitize
+ * @returns Object containing the safe pattern and whether it was escaped
+ */
+declare function sanitizeRegex(pattern: string): {
+    safe: string;
+    wasEscaped: boolean;
+};
+/**
+ * Creates a Tool Search Regex tool for discovering tools from a large registry.
+ *
+ * This tool enables AI agents to dynamically discover tools from a large library
+ * without loading all tool definitions into the LLM context window. The agent
+ * can search for relevant tools on-demand using regex patterns.
+ *
+ * The tool registry can be provided either:
+ * 1. At initialization time via params.toolRegistry
+ * 2. At runtime via config.configurable.toolRegistry when invoking
+ *
+ * @param params - Configuration parameters for the tool (toolRegistry is optional)
+ * @returns A LangChain DynamicStructuredTool for tool searching
+ *
+ * @example
+ * // Option 1: Registry at initialization
+ * const tool = createToolSearchRegexTool({ apiKey, toolRegistry });
+ * await tool.invoke({ query: 'expense' });
+ *
+ * @example
+ * // Option 2: Registry at runtime
+ * const tool = createToolSearchRegexTool({ apiKey });
+ * await tool.invoke(
+ *   { query: 'expense' },
+ *   { configurable: { toolRegistry, onlyDeferred: true } }
+ * );
+ */
+declare function createToolSearchRegexTool(initParams?: t.ToolSearchRegexParams): DynamicStructuredTool<typeof ToolSearchRegexSchema>;
+export { createToolSearchRegexTool, sanitizeRegex, escapeRegexSpecialChars, isDangerousPattern, countNestedGroups, hasNestedQuantifiers, };

package/dist/types/types/graph.d.ts

@@ -4,7 +4,7 @@ import type { BaseMessage, AIMessageChunk, SystemMessage } from '@langchain/core
 import type { RunnableConfig, Runnable } from '@langchain/core/runnables';
 import type { ChatGenerationChunk } from '@langchain/core/outputs';
 import type { GoogleAIToolType } from '@langchain/google-common';
-import type { ToolMap, ToolEndEvent, GenericTool } from '@/types/tools';
+import type { ToolMap, ToolEndEvent, GenericTool, LCTool } from '@/types/tools';
 import type { Providers, Callback, GraphNodeKeys } from '@/common';
 import type { StandardGraph, MultiAgentGraph } from '@/graphs';
 import type { ClientOptions } from '@/types/llm';
@@ -248,4 +248,10 @@ export interface AgentInputs {
     reasoningKey?: 'reasoning_content' | 'reasoning';
     /** Format content blocks as strings (for legacy compatibility i.e. Ollama/Azure Serverless) */
     useLegacyContent?: boolean;
+    /**
+     * Tool definitions for all tools, including deferred and programmatic.
+     * Used for tool search and programmatic tool calling.
+     * Maps tool name to LCTool definition.
+     */
+    toolRegistry?: Map<string, LCTool>;
 }

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

@@ -25,6 +25,12 @@ export type ToolNodeOptions = {
     loadRuntimeTools?: ToolRefGenerator;
     toolCallStepIds?: Map<string, string>;
     errorHandler?: (data: ToolErrorData, metadata?: Record<string, unknown>) => Promise<void>;
+    /** Tools available for programmatic code execution (allowed_callers includes 'code_execution') */
+    programmaticToolMap?: ToolMap;
+    /** Tool definitions for programmatic code execution (sent to Code API for stub generation) */
+    programmaticToolDefs?: LCTool[];
+    /** Tool registry for tool search (deferred tool definitions) */
+    toolRegistry?: LCToolRegistry;
 };
 export type ToolNodeConstructorParams = ToolRefs & ToolNodeOptions;
 export type ToolEndEvent = {
@@ -59,3 +65,133 @@ export type ExecuteResult = {
     stderr: string;
     files?: FileRefs;
 };
+/** JSON Schema type definition for tool parameters */
+export type JsonSchemaType = {
+    type: 'string' | 'number' | 'integer' | 'float' | 'boolean' | 'array' | 'object';
+    enum?: string[];
+    items?: JsonSchemaType;
+    properties?: Record<string, JsonSchemaType>;
+    required?: string[];
+    description?: string;
+    additionalProperties?: boolean | JsonSchemaType;
+};
+/**
+ * Specifies which contexts can invoke a tool (inspired by Anthropic's allowed_callers)
+ * - 'direct': Only callable directly by the LLM (default if omitted)
+ * - 'code_execution': Only callable from within programmatic code execution
+ */
+export type AllowedCaller = 'direct' | 'code_execution';
+/** Tool definition with optional deferred loading and caller restrictions */
+export type LCTool = {
+    name: string;
+    description?: string;
+    parameters?: JsonSchemaType;
+    /** When true, tool is not loaded into context initially (for tool search) */
+    defer_loading?: boolean;
+    /**
+     * Which contexts can invoke this tool.
+     * Default: ['direct'] (only callable directly by LLM)
+     * Options: 'direct', 'code_execution'
+     */
+    allowed_callers?: AllowedCaller[];
+};
+/** Map of tool names to tool definitions */
+export type LCToolRegistry = Map<string, LCTool>;
+/** Parameters for creating a Tool Search Regex tool */
+export type ToolSearchRegexParams = {
+    apiKey?: string;
+    toolRegistry?: LCToolRegistry;
+    onlyDeferred?: boolean;
+    baseUrl?: string;
+    [key: string]: unknown;
+};
+/** Simplified tool metadata for search purposes */
+export type ToolMetadata = {
+    name: string;
+    description: string;
+    parameters?: JsonSchemaType;
+};
+/** Individual search result for a matching tool */
+export type ToolSearchResult = {
+    tool_name: string;
+    match_score: number;
+    matched_field: string;
+    snippet: string;
+};
+/** Response from the tool search operation */
+export type ToolSearchResponse = {
+    tool_references: ToolSearchResult[];
+    total_tools_searched: number;
+    pattern_used: string;
+};
+/** Artifact returned alongside the formatted search results */
+export type ToolSearchArtifact = {
+    tool_references: ToolSearchResult[];
+    metadata: {
+        total_searched: number;
+        pattern: string;
+        error?: string;
+    };
+};
+/**
+ * Tool call requested by the Code API during programmatic execution
+ */
+export type PTCToolCall = {
+    /** Unique ID like "call_001" */
+    id: string;
+    /** Tool name */
+    name: string;
+    /** Input parameters */
+    input: Record<string, any>;
+};
+/**
+ * Tool result sent back to the Code API
+ */
+export type PTCToolResult = {
+    /** Matches PTCToolCall.id */
+    call_id: string;
+    /** Tool execution result (any JSON-serializable value) */
+    result: any;
+    /** Whether tool execution failed */
+    is_error: boolean;
+    /** Error details if is_error=true */
+    error_message?: string;
+};
+/**
+ * Response from the Code API for programmatic execution
+ */
+export type ProgrammaticExecutionResponse = {
+    status: 'tool_call_required' | 'completed' | 'error' | unknown;
+    session_id?: string;
+    /** Present when status='tool_call_required' */
+    continuation_token?: string;
+    tool_calls?: PTCToolCall[];
+    /** Present when status='completed' */
+    stdout?: string;
+    stderr?: string;
+    files?: FileRefs;
+    /** Present when status='error' */
+    error?: string;
+};
+/**
+ * Artifact returned by the PTC tool
+ */
+export type ProgrammaticExecutionArtifact = {
+    session_id?: string;
+    files?: FileRefs;
+};
+/**
+ * Initialization parameters for the PTC tool
+ */
+export type ProgrammaticToolCallingParams = {
+    /** Code API key (or use CODE_API_KEY env var) */
+    apiKey?: string;
+    /** Code API base URL (or use CODE_BASEURL env var) */
+    baseUrl?: string;
+    /** Safety limit for round-trips (default: 20) */
+    maxRoundTrips?: number;
+    /** HTTP proxy URL */
+    proxy?: string;
+    /** Environment variable key for API key */
+    [key: string]: unknown;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.0.35",
+  "version": "3.0.40",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -53,6 +53,10 @@
     "memory": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/memory.ts --provider 'openAI' --name 'Jo' --location 'New York, NY'",
     "tool": "node --trace-warnings -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/tools.ts --provider 'openrouter' --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_regex": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/tool_search_regex.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'",
     "ant_web_search": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/ant_web_search.ts --name 'Jo' --location 'New York, NY'",
     "ant_web_search_edge_case": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/ant_web_search_edge_case.ts --name 'Jo' --location 'New York, NY'",
     "ant_web_search_error_edge_case": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/ant_web_search_error_edge_case.ts --name 'Jo' --location 'New York, NY'",

package/src/agents/AgentContext.ts

@@ -13,6 +13,19 @@ import type * as t from '@/types';
 import type { createPruneMessages } from '@/messages';
 import { ContentTypes, Providers } from '@/common';
 
+/**
+ * Checks if a tool allows the specified caller type.
+ * Default is 'direct' only if allowed_callers is not specified.
+ */
+function toolAllowsCaller(
+  toolDef: t.LCTool | undefined,
+  caller: t.AllowedCaller
+): boolean {
+  if (!toolDef) return false;
+  const allowedCallers = toolDef.allowed_callers ?? ['direct'];
+  return allowedCallers.includes(caller);
+}
+
 /**
  * Encapsulates agent-specific state that can vary between agents in a multi-agent system
  */
@@ -32,6 +45,7 @@ export class AgentContext {
       tools,
       toolMap,
       toolEnd,
+      toolRegistry,
       instructions,
       additional_instructions,
       streamBuffer,
@@ -48,6 +62,7 @@ export class AgentContext {
       streamBuffer,
       tools,
       toolMap,
+      toolRegistry,
       instructions,
       additionalInstructions: additional_instructions,
       reasoningKey,
@@ -102,6 +117,11 @@ export class AgentContext {
   tools?: t.GraphTools;
   /** Tool map for this agent */
   toolMap?: t.ToolMap;
+  /**
+   * Tool definitions registry (includes deferred and programmatic tool metadata).
+   * Used for tool search and programmatic tool calling.
+   */
+  toolRegistry?: t.LCToolRegistry;
   /** Instructions for this agent */
   instructions?: string;
   /** Additional instructions for this agent */
@@ -137,6 +157,7 @@ export class AgentContext {
     tokenCounter,
     tools,
     toolMap,
+    toolRegistry,
     instructions,
     additionalInstructions,
     reasoningKey,
@@ -152,6 +173,7 @@ export class AgentContext {
     tokenCounter?: t.TokenCounter;
     tools?: t.GraphTools;
     toolMap?: t.ToolMap;
+    toolRegistry?: t.LCToolRegistry;
     instructions?: string;
     additionalInstructions?: string;
     reasoningKey?: 'reasoning_content' | 'reasoning';
@@ -167,6 +189,7 @@ export class AgentContext {
     this.tokenCounter = tokenCounter;
     this.tools = tools;
     this.toolMap = toolMap;
+    this.toolRegistry = toolRegistry;
     this.instructions = instructions;
     this.additionalInstructions = additionalInstructions;
     if (reasoningKey) {
@@ -320,4 +343,67 @@ export class AgentContext {
     // Add tool tokens to existing instruction tokens (which may already include system message tokens)
     this.instructionTokens += toolTokens;
   }
+
+  /**
+   * Gets a map of tools that allow programmatic (code_execution) calling.
+   * Filters toolMap based on toolRegistry's allowed_callers settings.
+   * @returns ToolMap containing only tools that allow code_execution
+   */
+  getProgrammaticToolMap(): t.ToolMap {
+    const programmaticMap: t.ToolMap = new Map();
+
+    if (!this.toolMap) {
+      return programmaticMap;
+    }
+
+    for (const [name, tool] of this.toolMap) {
+      const toolDef = this.toolRegistry?.get(name);
+      if (toolAllowsCaller(toolDef, 'code_execution')) {
+        programmaticMap.set(name, tool);
+      }
+    }
+
+    return programmaticMap;
+  }
+
+  /**
+   * Gets tool definitions for tools that allow programmatic calling.
+   * Used to send to the Code API for stub generation.
+   * @returns Array of LCTool definitions for programmatic tools
+   */
+  getProgrammaticToolDefs(): t.LCTool[] {
+    if (!this.toolRegistry) {
+      return [];
+    }
+
+    const defs: t.LCTool[] = [];
+    for (const [_name, toolDef] of this.toolRegistry) {
+      if (toolAllowsCaller(toolDef, 'code_execution')) {
+        defs.push(toolDef);
+      }
+    }
+
+    return defs;
+  }
+
+  /**
+   * Gets the tool registry for deferred tools (for tool search).
+   * @param onlyDeferred If true, only returns tools with defer_loading=true
+   * @returns LCToolRegistry with tool definitions
+   */
+  getDeferredToolRegistry(onlyDeferred: boolean = true): t.LCToolRegistry {
+    const registry: t.LCToolRegistry = new Map();
+
+    if (!this.toolRegistry) {
+      return registry;
+    }
+
+    for (const [name, toolDef] of this.toolRegistry) {
+      if (!onlyDeferred || toolDef.defer_loading === true) {
+        registry.set(name, toolDef);
+      }
+    }
+
+    return registry;
+  }
 }

package/src/common/enum.ts

@@ -159,6 +159,8 @@ export enum Callback {
 export enum Constants {
   OFFICIAL_CODE_BASEURL = 'https://api.librechat.ai/v1',
   EXECUTE_CODE = 'execute_code',
+  TOOL_SEARCH_REGEX = 'tool_search_regex',
+  PROGRAMMATIC_TOOL_CALLING = 'programmatic_code_execution',
   WEB_SEARCH = 'web_search',
   CONTENT_AND_ARTIFACT = 'content_and_artifact',
   LC_TRANSFER_TO_ = 'lc_transfer_to_',

package/src/events.ts

@@ -9,7 +9,7 @@ import type { MultiAgentGraph, StandardGraph } from '@/graphs';
 import type { Logger } from 'winston';
 import type * as t from '@/types';
 import { handleToolCalls } from '@/tools/handlers';
-import { Providers } from '@/common';
+import { Constants, Providers } from '@/common';
 
 export class HandlerRegistry {
   private handlers: Map<string, t.EventHandler> = new Map();
@@ -112,6 +112,10 @@ export class ToolEndHandler implements t.EventHandler {
         return;
       }
 
+      if (metadata[Constants.PROGRAMMATIC_TOOL_CALLING] === true) {
+        return;
+      }
+
       if (this.callback) {
         await this.callback(toolEndData, metadata);
       }

package/src/graphs/Graph.ts

@@ -443,9 +443,11 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
   initializeTools({
     currentTools,
     currentToolMap,
+    agentContext,
   }: {
     currentTools?: t.GraphTools;
     currentToolMap?: t.ToolMap;
+    agentContext?: AgentContext;
   }): CustomToolNode<t.BaseGraphState> | ToolNode<t.BaseGraphState> {
     return new CustomToolNode<t.BaseGraphState>({
       tools: (currentTools as t.GenericTool[] | undefined) ?? [],
@@ -453,6 +455,9 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       toolCallStepIds: this.toolCallStepIds,
       errorHandler: (data, metadata) =>
         StandardGraph.handleToolCallErrorStatic(this, data, metadata),
+      toolRegistry: agentContext?.toolRegistry,
+      programmaticToolMap: agentContext?.getProgrammaticToolMap(),
+      programmaticToolDefs: agentContext?.getProgrammaticToolDefs(),
     });
   }
 
@@ -705,7 +710,8 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         formatAnthropicArtifactContent(finalMessages);
       } else if (
         isLatestToolMessage &&
-        (isOpenAILike(agentContext.provider) ||
+        ((isOpenAILike(agentContext.provider) &&
+          agentContext.provider !== Providers.DEEPSEEK) ||
           isGoogleLike(agentContext.provider))
       ) {
         formatArtifactPayload(finalMessages);
@@ -878,6 +884,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         this.initializeTools({
           currentTools: agentContext.tools,
           currentToolMap: agentContext.toolMap,
+          agentContext,
         })
       )
       .addEdge(START, agentNode)

package/src/index.ts

@@ -11,6 +11,8 @@ export * from './graphs';
 /* Tools */
 export * from './tools/Calculator';
 export * from './tools/CodeExecutor';
+export * from './tools/ProgrammaticToolCalling';
+export * from './tools/ToolSearchRegex';
 export * from './tools/handlers';
 export * from './tools/search';
 

package/src/instrumentation.ts

@@ -11,7 +11,7 @@ if (
     publicKey: process.env.LANGFUSE_PUBLIC_KEY,
     secretKey: process.env.LANGFUSE_SECRET_KEY,
     baseUrl: process.env.LANGFUSE_BASE_URL,
-    environment: process.env.NODE_ENV ?? 'development',
+    environment: process.env.LANGFUSE_TRACING_ENVIRONMENT ?? process.env.NODE_ENV ?? 'development',
   });
 
   const sdk = new NodeSDK({

package/src/llm/google/llm.spec.ts

@@ -1,6 +1,8 @@
 import { config } from 'dotenv';
 config();
-import { test } from '@jest/globals';
+import { test, jest } from '@jest/globals';
+
+jest.setTimeout(90000);
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import {