@librechat/agents 3.7.2 → 3.7.4

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

@@ -1,5 +1,10 @@
 import type * as t from '@/types';
 export declare function coerceRecordArgs(args: unknown): Record<string, unknown> | undefined;
+/**
+ * Applies only lossless, schema-directed repairs to model-generated arguments.
+ * The host remains responsible for full schema validation and all business rules.
+ */
+export declare function coerceArgsForSchema(args: Record<string, unknown>, schema: t.JsonSchemaType | undefined): Record<string, unknown>;
 export declare function stableStringify(value: unknown): string;
 export declare function recordArgsEqual(left: Record<string, unknown>, right: Record<string, unknown>): boolean;
 export declare function normalizeError(error: unknown): Error;
@@ -28,4 +33,5 @@ export declare 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.7.2",
+  "version": "3.7.4",
   "reova": {
     "enabled": true,
     "endpoint": "https://telemetry.reo.dev/data"

package/src/stream.ts

@@ -736,6 +736,12 @@ function createEagerToolExecutionPlan(args: {
   if (candidateToolCalls.length === 0) {
     return [];
   }
+  const toolSchemas = new Map(
+    agentContext?.toolDefinitions?.map(({ name, parameters }) => [
+      name,
+      parameters,
+    ])
+  );
 
   // Eager execution must preserve ToolNode batch semantics exactly for every
   // unstarted call. If any candidate cannot be planned, fall back for that
@@ -770,6 +776,7 @@ function createEagerToolExecutionPlan(args: {
       ),
     })),
     usageCount: graph.getEagerEventToolUsageCount(agentContext?.agentId),
+    getToolSchema: (toolName) => toolSchemas.get(toolName),
   });
   if (plan == null) {
     return undefined;

package/src/tools/BashProgrammaticToolCalling.ts

@@ -40,6 +40,7 @@ config();
 
 const DEFAULT_MAX_ROUND_TRIPS = 20;
 const DEFAULT_RUN_TIMEOUT_MS = resolveCodeApiRunTimeoutMs();
+const BASH_LAST_BACKGROUND_PID_GUARD = ': &\nwait "$!"';
 
 /** Bash reserved words that get `_tool` suffix when used as function names */
 const BASH_RESERVED = new Set([
@@ -171,6 +172,14 @@ export const BashProgrammaticToolCallingDefinition = {
   schema: BashProgrammaticToolCallingSchema,
 } as const;
 
+function prepareBashProgrammaticCode(code: string): string {
+  /* The Code API's generated Bash wrapper reads `$!` after user code. A user
+   * `set -u` makes that expansion fail when no background process has run.
+   * Seed and reap a no-op job before user code so strict mode remains active
+   * for the payload while the wrapper can safely read its special parameter. */
+  return `${BASH_LAST_BACKGROUND_PID_GUARD}\n${code}`;
+}
+
 function maybeParseJsonResultString(result: unknown): unknown {
   if (typeof result !== 'string') {
     return result;
@@ -320,6 +329,7 @@ export function createBashProgrammaticToolCallingTool(
     async (rawParams, config) => {
       const params = rawParams as ProgrammaticInvocationParams;
       const { code } = params;
+      const preparedCode = prepareBashProgrammaticCode(code);
       const timeout = clampCodeApiRunTimeoutMs(params.timeout, maxRunTimeoutMs);
 
       const toolCall = (config.toolCall ?? {}) as ToolCall &
@@ -417,7 +427,7 @@ export function createBashProgrammaticToolCallingTool(
           EXEC_ENDPOINT,
           {
             lang: 'bash',
-            code,
+            code: preparedCode,
             tools: effectiveTools,
             session_id,
             timeout,

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,