illuma-agents 1.0.49 → 1.0.50

package/src/agents/AgentContext.ts

@@ -1,6 +1,5 @@
 /* eslint-disable no-console */
 // src/agents/AgentContext.ts
-import { zodToJsonSchema } from 'zod-to-json-schema';
 import { SystemMessage } from '@langchain/core/messages';
 import { RunnableLambda } from '@langchain/core/runnables';
 import type {
@@ -11,7 +10,9 @@ import type {
 import type { RunnableConfig, Runnable } from '@langchain/core/runnables';
 import type * as t from '@/types';
 import type { createPruneMessages } from '@/messages';
+import { createSchemaOnlyTools } from '@/tools/schema';
 import { ContentTypes, Providers } from '@/common';
+import { toJsonSchema } from '@/utils/schema';
 
 /**
  * Encapsulates agent-specific state that can vary between agents in a multi-agent system
@@ -34,6 +35,7 @@ export class AgentContext {
       toolMap,
       toolEnd,
       toolRegistry,
+      toolDefinitions,
       instructions,
       additional_instructions,
       streamBuffer,
@@ -54,6 +56,7 @@ export class AgentContext {
       tools,
       toolMap,
       toolRegistry,
+      toolDefinitions,
       instructions,
       additionalInstructions: additional_instructions,
       reasoningKey,
@@ -122,6 +125,11 @@ export class AgentContext {
    * Used for tool search and programmatic tool calling.
    */
   toolRegistry?: t.LCToolRegistry;
+  /**
+   * Serializable tool definitions for event-driven execution.
+   * When provided, ToolNode operates in event-driven mode.
+   */
+  toolDefinitions?: t.LCTool[];
   /** Set of tool names discovered via tool search (to be loaded) */
   discoveredToolNames: Set<string> = new Set();
   /** Instructions for this agent */
@@ -207,6 +215,7 @@ export class AgentContext {
     tools,
     toolMap,
     toolRegistry,
+    toolDefinitions,
     instructions,
     additionalInstructions,
     dynamicContext,
@@ -226,6 +235,7 @@ export class AgentContext {
     tools?: t.GraphTools;
     toolMap?: t.ToolMap;
     toolRegistry?: t.LCToolRegistry;
+    toolDefinitions?: t.LCTool[];
     instructions?: string;
     additionalInstructions?: string;
     dynamicContext?: string;
@@ -245,6 +255,7 @@ export class AgentContext {
     this.tools = tools;
     this.toolMap = toolMap;
     this.toolRegistry = toolRegistry;
+    this.toolDefinitions = toolDefinitions;
     this.instructions = instructions;
     this.additionalInstructions = additionalInstructions;
     this.dynamicContext = dynamicContext;
@@ -600,15 +611,10 @@ export class AgentContext {
           genericTool.schema != null &&
           typeof genericTool.schema === 'object'
         ) {
-          const schema = genericTool.schema as {
-            describe: (desc: string) => unknown;
-          };
-          const describedSchema = schema.describe(
-            (genericTool.description as string) || ''
-          );
-          const jsonSchema = zodToJsonSchema(
-            describedSchema as Parameters<typeof zodToJsonSchema>[0],
-            (genericTool.name as string) || ''
+          const jsonSchema = toJsonSchema(
+            genericTool.schema,
+            (genericTool.name as string | undefined) ?? '',
+            (genericTool.description as string | undefined) ?? ''
           );
           const toolName = (genericTool.name as string) || 'unknown';
           const tokens = tokenCounter(
@@ -777,40 +783,70 @@ export class AgentContext {
 
   /**
    * Gets tools that should be bound to the LLM.
-   * Includes:
+   * In event-driven mode (toolDefinitions present, tools empty), creates schema-only tools.
+   * Otherwise filters tool instances based on:
    * 1. Non-deferred tools with allowed_callers: ['direct']
    * 2. Discovered tools (from tool search)
    * @returns Array of tools to bind to model
    */
   getToolsForBinding(): t.GraphTools | undefined {
+    /** Event-driven mode: create schema-only tools from definitions */
+    if (this.toolDefinitions && this.toolDefinitions.length > 0) {
+      return this.getEventDrivenToolsForBinding();
+    }
+
+    /** Traditional mode: filter actual tool instances */
     if (!this.tools || !this.toolRegistry) {
       return this.tools;
     }
 
-    const toolsToInclude = this.tools.filter((tool) => {
+    return this.filterToolsForBinding(this.tools);
+  }
+
+  /** Creates schema-only tools from toolDefinitions for event-driven mode */
+  private getEventDrivenToolsForBinding(): t.GraphTools {
+    if (!this.toolDefinitions) {
+      return [];
+    }
+
+    const defsToInclude = this.toolDefinitions.filter((def) => {
+      const allowedCallers = def.allowed_callers ?? ['direct'];
+      if (!allowedCallers.includes('direct')) {
+        return false;
+      }
+      if (
+        def.defer_loading === true &&
+        !this.discoveredToolNames.has(def.name)
+      ) {
+        return false;
+      }
+      return true;
+    });
+
+    return createSchemaOnlyTools(defsToInclude) as t.GraphTools;
+  }
+
+  /** Filters tool instances for binding based on registry config */
+  private filterToolsForBinding(tools: t.GraphTools): t.GraphTools {
+    return tools.filter((tool) => {
       if (!('name' in tool)) {
-        return true; // No name, include by default
+        return true;
       }
 
       const toolDef = this.toolRegistry?.get(tool.name);
       if (!toolDef) {
-        return true; // Not in registry, include by default
+        return true;
       }
 
-      // Check if discovered (overrides defer_loading)
       if (this.discoveredToolNames.has(tool.name)) {
-        // Discovered tools must still have allowed_callers: ['direct']
         const allowedCallers = toolDef.allowed_callers ?? ['direct'];
         return allowedCallers.includes('direct');
       }
 
-      // Not discovered: must be direct-callable AND not deferred
       const allowedCallers = toolDef.allowed_callers ?? ['direct'];
       return (
         allowedCallers.includes('direct') && toolDef.defer_loading !== true
       );
     });
-
-    return toolsToInclude;
   }
 }

package/src/common/enum.ts

@@ -23,6 +23,8 @@ export enum GraphEvents {
   ON_CONTEXT_ANALYTICS = 'on_context_analytics',
   /** [Custom] Structured output event - emitted when agent returns structured JSON */
   ON_STRUCTURED_OUTPUT = 'on_structured_output',
+  /** [Custom] Request to execute tools - dispatched by ToolNode, handled by host */
+  ON_TOOL_EXECUTE = 'on_tool_execute',
 
   /* Official Events */
 

package/src/graphs/Graph.ts

@@ -66,6 +66,7 @@ import { getChatModelClass, manualToolStreamProviders } from '@/llm/providers';
 import { ToolNode as CustomToolNode, toolsCondition } from '@/tools/ToolNode';
 import { ChatOpenAI, AzureChatOpenAI } from '@/llm/openai';
 import { safeDispatchCustomEvent } from '@/utils/events';
+import { createSchemaOnlyTools } from '@/tools/schema';
 import { AgentContext } from '@/agents/AgentContext';
 import { createFakeStreamingLLM } from '@/llm/fake';
 import { HandlerRegistry } from '@/events';
@@ -524,6 +525,28 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
     currentToolMap?: t.ToolMap;
     agentContext?: AgentContext;
   }): CustomToolNode<t.BaseGraphState> | ToolNode<t.BaseGraphState> {
+    const toolDefinitions = agentContext?.toolDefinitions;
+    const eventDrivenMode =
+      toolDefinitions != null && toolDefinitions.length > 0;
+
+    if (eventDrivenMode) {
+      const schemaTools = createSchemaOnlyTools(toolDefinitions);
+      const toolDefMap = new Map(toolDefinitions.map((def) => [def.name, def]));
+
+      return new CustomToolNode<t.BaseGraphState>({
+        tools: schemaTools as t.GenericTool[],
+        toolMap: new Map(schemaTools.map((tool) => [tool.name, tool])),
+        toolCallStepIds: this.toolCallStepIds,
+        errorHandler: (data, metadata) =>
+          StandardGraph.handleToolCallErrorStatic(this, data, metadata),
+        toolRegistry: agentContext?.toolRegistry,
+        sessions: this.sessions,
+        eventDrivenMode: true,
+        toolDefinitions: toolDefMap,
+        agentId: agentContext?.agentId,
+      });
+    }
+
     return new CustomToolNode<t.BaseGraphState>({
       tools: (currentTools as t.GenericTool[] | undefined) ?? [],
       toolMap: currentToolMap,
@@ -1073,7 +1096,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
           // Get a fresh model WITHOUT tools bound - bindTools() returns RunnableBinding which lacks withStructuredOutput
           // Also disable thinking mode - Anthropic/Bedrock doesn't allow tool_choice with thinking enabled
           const structuredClientOptions = { ...agentContext.clientOptions } as t.ClientOptions;
-          
+
           // Remove thinking configuration for Bedrock
           if (agentContext.provider === Providers.BEDROCK) {
             const bedrockOpts = structuredClientOptions as t.BedrockAnthropicClientOptions;
@@ -1084,7 +1107,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
               bedrockOpts.additionalModelRequestFields = additionalFields;
             }
           }
-          
+
           // Remove thinking configuration for Anthropic
           if (agentContext.provider === Providers.ANTHROPIC) {
             const anthropicOpts = structuredClientOptions as t.AnthropicClientOptions;
@@ -1092,12 +1115,12 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
               delete anthropicOpts.thinking;
             }
           }
-          
+
           const structuredModel = this.getNewModel({
             provider: agentContext.provider,
             clientOptions: structuredClientOptions,
           });
-          
+
           const { structuredResponse, rawMessage } =
             await this.attemptStructuredInvoke(
               {

package/src/graphs/MultiAgentGraph.ts

@@ -1,4 +1,3 @@
-import { z } from 'zod';
 import { tool } from '@langchain/core/tools';
 import { PromptTemplate } from '@langchain/core/prompts';
 import {
@@ -292,7 +291,8 @@ export class MultiAgentGraph extends StandardGraph {
 
       tools.push(
         tool(
-          async (input: Record<string, unknown>, config) => {
+          async (rawInput, config) => {
+            const input = rawInput as Record<string, unknown>;
             const state = getCurrentTaskInput() as t.BaseGraphState;
             const toolCallId =
               (config as ToolRunnableConfig | undefined)?.toolCall?.id ??
@@ -343,13 +343,17 @@ export class MultiAgentGraph extends StandardGraph {
           {
             name: toolName,
             schema: hasHandoffInput
-              ? z.object({
-                [promptKey]: z
-                  .string()
-                  .optional()
-                  .describe(handoffInputDescription as string),
-              })
-              : z.object({}),
+              ? {
+                type: 'object',
+                properties: {
+                  [promptKey]: {
+                    type: 'string',
+                    description: handoffInputDescription as string,
+                  },
+                },
+                required: [],
+              }
+              : { type: 'object', properties: {}, required: [] },
             description: toolDescription,
           }
         )
@@ -371,7 +375,8 @@ export class MultiAgentGraph extends StandardGraph {
 
         tools.push(
           tool(
-            async (input: Record<string, unknown>, config) => {
+            async (rawInput, config) => {
+              const input = rawInput as Record<string, unknown>;
               const toolCallId =
                 (config as ToolRunnableConfig | undefined)?.toolCall?.id ??
                 'unknown';
@@ -470,13 +475,17 @@ export class MultiAgentGraph extends StandardGraph {
             {
               name: toolName,
               schema: hasHandoffInput
-                ? z.object({
-                  [promptKey]: z
-                    .string()
-                    .optional()
-                    .describe(handoffInputDescription as string),
-                })
-                : z.object({}),
+                ? {
+                  type: 'object',
+                  properties: {
+                    [promptKey]: {
+                      type: 'string',
+                      description: handoffInputDescription as string,
+                    },
+                  },
+                  required: [],
+                }
+                : { type: 'object', properties: {}, required: [] },
               description: toolDescription,
             }
           )

package/src/index.ts

@@ -8,15 +8,14 @@ export * from './messages';
 /* Graphs */
 export * from './graphs';
 
-/* Deep Agents */
-export * from './deepagents';
-
 /* Tools */
 export * from './tools/Calculator';
 export * from './tools/CodeExecutor';
 export * from './tools/BrowserTools';
 export * from './tools/ProgrammaticToolCalling';
 export * from './tools/ToolSearch';
+export * from './tools/ToolNode';
+export * from './tools/schema';
 export * from './tools/handlers';
 export * from './tools/search';
 

package/src/scripts/test_code_api.ts

@@ -11,13 +11,13 @@ config();
 import fetch, { RequestInit } from 'node-fetch';
 import { HttpsProxyAgent } from 'https-proxy-agent';
 
-const API_KEY = process.env.LIBRECHAT_CODE_API_KEY ?? '';
+const API_KEY = process.env.CODE_EXECUTOR_API_KEY ?? '';
 const BASE_URL =
-  process.env.LIBRECHAT_CODE_BASEURL ?? 'https://api.librechat.ai/v1';
+  process.env.ILLUMA_CODE_BASEURL ?? 'https://api.illuma.ai/v1';
 const PROXY = process.env.PROXY;
 
 if (!API_KEY) {
-  console.error('LIBRECHAT_CODE_API_KEY not set');
+  console.error('CODE_EXECUTOR_API_KEY not set');
   process.exit(1);
 }
 
@@ -52,7 +52,7 @@ async function makeRequest(
     method: body ? 'POST' : 'GET',
     headers: {
       'Content-Type': 'application/json',
-      'User-Agent': 'LibreChat/1.0',
+      'User-Agent': 'Illuma/1.0',
       'X-API-Key': API_KEY,
     },
   };

package/src/specs/agent-handoffs.test.ts

@@ -1,5 +1,4 @@
 // src/specs/agent-handoffs.test.ts
-import { z } from 'zod';
 import { DynamicStructuredTool } from '@langchain/core/tools';
 import { HumanMessage, ToolMessage } from '@langchain/core/messages';
 import type { ToolCall } from '@langchain/core/messages/tool';
@@ -708,7 +707,7 @@ describe('Agent Handoffs Tests', () => {
       const customTool = new DynamicStructuredTool({
         name: 'custom_tool',
         description: 'A custom tool',
-        schema: z.object({}),
+        schema: { type: 'object', properties: {}, required: [] },
         func: async (): Promise<string> => 'Tool result',
       });