@librechat/agents 3.7.3 → 3.7.4

package/src/tools/ToolNode.ts

@@ -71,6 +71,8 @@ import {
 } from '@/tools/intentArg';
 import {
   buildToolExecutionRequestPlan,
+  coerceArgsForSchema,
+  coerceRecordArgs,
   resolveRuntimeSessionHint,
   recordArgsEqual,
 } from '@/tools/eagerEventExecution';
@@ -1129,6 +1131,26 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
     );
   }
 
+  private getToolParameterSchema(
+    toolName: string
+  ): t.JsonSchemaType | undefined {
+    return (
+      this.toolDefinitions?.get(toolName)?.parameters ??
+      this.toolRegistry?.get(toolName)?.parameters
+    );
+  }
+
+  private coerceEventToolArgs(
+    toolName: string,
+    args: unknown
+  ): Record<string, unknown> {
+    const recordArgs = coerceRecordArgs(args);
+    return coerceArgsForSchema(
+      recordArgs ?? (args as Record<string, unknown>),
+      this.getToolParameterSchema(toolName)
+    );
+  }
+
   /** Serializes the live caller projection for event-driven hosts. */
   private getCallerCapabilityProjectionSnapshot(): t.CallerCapabilityProjectionSnapshot {
     return createCallerCapabilityProjectionSnapshot(
@@ -2758,7 +2780,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
       return {
         call,
         stepId: this.toolCallStepIds?.get(call.id!) ?? '',
-        args: resolvedArgs,
+        args: this.coerceEventToolArgs(call.name, resolvedArgs),
         batchIndex: batchIndices?.[i],
       };
     });
@@ -3002,7 +3024,10 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
               entry.call.name
             ),
           });
-          entry.args = resolved as Record<string, unknown>;
+          entry.args = this.coerceEventToolArgs(
+            entry.call.name,
+            resolved as Record<string, unknown>
+          );
           if (entry.call.id != null) {
             if (unresolved.length > 0) {
               unresolvedByCallId.set(entry.call.id, unresolved);
@@ -3012,7 +3037,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
           }
           return;
         }
-        entry.args = nextArgs;
+        entry.args = this.coerceEventToolArgs(entry.call.name, nextArgs);
       };
 
       const askEntries: Array<{
@@ -3369,6 +3394,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
         }),
         usageCount: this.toolUsageCount,
         invalidArgsBehavior: 'error-result',
+        getToolSchema: (toolName) => this.getToolParameterSchema(toolName),
         recordTurn: (toolName, reservedTurn, callId) => {
           this.recordEventToolPlanningTurn(
             toolName,

package/src/tools/eagerEventExecution.ts

@@ -19,6 +19,89 @@ export function coerceRecordArgs(
   return args as Record<string, unknown>;
 }
 
+const INTEGER_STRING = /^-?(?:0|[1-9]\d*)$/;
+const NUMBER_STRING = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+
+function coerceValueForSchema(
+  value: unknown,
+  schema: t.JsonSchemaType | undefined
+): unknown {
+  if (schema == null) {
+    return value;
+  }
+
+  if (schema.type === 'integer' && typeof value === 'string') {
+    if (!INTEGER_STRING.test(value)) {
+      return value;
+    }
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) ? parsed : value;
+  }
+
+  if (
+    (schema.type === 'number' || schema.type === 'float') &&
+    typeof value === 'string'
+  ) {
+    if (!NUMBER_STRING.test(value)) {
+      return value;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && String(parsed) === value
+      ? parsed
+      : value;
+  }
+
+  if (schema.type === 'boolean' && typeof value === 'string') {
+    if (value === 'true') {
+      return true;
+    }
+    if (value === 'false') {
+      return false;
+    }
+    return value;
+  }
+
+  if (schema.type === 'array' && Array.isArray(value)) {
+    return value.map((item) => coerceValueForSchema(item, schema.items));
+  }
+
+  if (
+    schema.type !== 'object' ||
+    value == null ||
+    typeof value !== 'object' ||
+    Array.isArray(value)
+  ) {
+    return value;
+  }
+
+  const record = value as Record<string, unknown>;
+  const additionalProperties =
+    typeof schema.additionalProperties === 'object'
+      ? schema.additionalProperties
+      : undefined;
+
+  return Object.fromEntries(
+    Object.entries(record).map(([key, entry]) => [
+      key,
+      coerceValueForSchema(
+        entry,
+        schema.properties?.[key] ?? additionalProperties
+      ),
+    ])
+  );
+}
+
+/**
+ * Applies only lossless, schema-directed repairs to model-generated arguments.
+ * The host remains responsible for full schema validation and all business rules.
+ */
+export function coerceArgsForSchema(
+  args: Record<string, unknown>,
+  schema: t.JsonSchemaType | undefined
+): Record<string, unknown> {
+  return coerceValueForSchema(args, schema) as Record<string, unknown>;
+}
+
 export function stableStringify(value: unknown): string {
   if (Array.isArray(value)) {
     return `[${value.map((item) => stableStringify(item)).join(',')}]`;
@@ -87,6 +170,7 @@ export function buildToolExecutionRequestPlan(args: {
   usageCount: Map<string, number>;
   invalidArgsBehavior?: 'abort' | 'error-result';
   recordTurn?: (toolName: string, turn: number, callId: string) => void;
+  getToolSchema?: (toolName: string) => t.JsonSchemaType | undefined;
 }): ToolExecutionRequestPlan | undefined {
   const invalidArgsBehavior = args.invalidArgsBehavior ?? 'abort';
   const prepared: Array<{
@@ -103,8 +187,8 @@ export function buildToolExecutionRequestPlan(args: {
     if (toolCall.id == null || toolCall.id === '' || toolCall.name === '') {
       return undefined;
     }
-    const coercedArgs = coerceRecordArgs(toolCall.args);
-    if (coercedArgs == null) {
+    const recordArgs = coerceRecordArgs(toolCall.args);
+    if (recordArgs == null) {
       if (invalidArgsBehavior === 'abort') {
         return undefined;
       }
@@ -120,6 +204,10 @@ export function buildToolExecutionRequestPlan(args: {
       });
       continue;
     }
+    const coercedArgs = coerceArgsForSchema(
+      recordArgs,
+      args.getToolSchema?.(toolCall.name)
+    );
     prepared.push({
       id: toolCall.id,
       name: toolCall.name,