@librechat/agents 1.4.0

package/src/utils/logging.ts

@@ -0,0 +1,48 @@
+// src/utils/logging.ts
+import fs from 'fs';
+import util from 'util';
+
+export function setupLogging(logFileName: string): void {
+  const logFile = fs.createWriteStream(logFileName, { flags: 'a' });
+
+  const originalConsoleLog = console.log;
+  const originalConsoleError = console.error;
+  const originalStdoutWrite = process.stdout.write;
+  const originalStderrWrite = process.stderr.write;
+
+  console.log = function(...args): void {
+    logFile.write(util.format.apply(null, args) + ' ');
+    originalConsoleLog.apply(console, args);
+  };
+
+  console.error = function(...args): void {
+    logFile.write(util.format.apply(null, args) + ' ');
+    originalConsoleError.apply(console, args);
+  };
+
+  process.stdout.write = function(
+    buffer: Uint8Array | string,
+    cb?: ((err?: Error) => void) | string,
+    fd?: ((err?: Error) => void)
+  ): boolean {
+    if (typeof buffer === 'string') {
+      logFile.write(buffer);
+    } else {
+      logFile.write(buffer.toString());
+    }
+    return originalStdoutWrite.call(process.stdout, buffer, cb as BufferEncoding | undefined, fd);
+  };
+
+  process.stderr.write = function(
+    buffer: Uint8Array | string,
+    cb?: ((err?: Error) => void) | string,
+    fd?: ((err?: Error) => void)
+  ): boolean {
+    if (typeof buffer === 'string') {
+      logFile.write(buffer);
+    } else {
+      logFile.write(buffer.toString());
+    }
+    return originalStderrWrite.call(process.stderr, buffer, cb as BufferEncoding | undefined, fd);
+  };
+}

package/src/utils/run.ts

@@ -0,0 +1,91 @@
+import { CallbackManagerForChainRun } from '@langchain/core/callbacks/manager';
+import {
+  mergeConfigs,
+  patchConfig,
+  Runnable,
+  RunnableConfig,
+} from '@langchain/core/runnables';
+import { AsyncLocalStorageProviderSingleton } from '@langchain/core/singletons';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export interface RunnableCallableArgs extends Partial<any> {
+  name?: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  func: (...args: any[]) => any;
+  tags?: string[];
+  trace?: boolean;
+  recurse?: boolean;
+}
+
+export class RunnableCallable<I = unknown, O = unknown> extends Runnable<I, O> {
+  lc_namespace: string[] = ['langgraph'];
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  func: (...args: any[]) => any;
+
+  tags?: string[];
+
+  config?: RunnableConfig;
+
+  trace: boolean = true;
+
+  recurse: boolean = true;
+
+  constructor(fields: RunnableCallableArgs) {
+    super();
+    this.name = fields.name ?? fields.func.name;
+    this.func = fields.func;
+    this.config = fields.tags ? { tags: fields.tags } : undefined;
+    this.trace = fields.trace ?? this.trace;
+    this.recurse = fields.recurse ?? this.recurse;
+  }
+
+  protected async _tracedInvoke(
+    input: I,
+    config?: Partial<RunnableConfig>,
+    runManager?: CallbackManagerForChainRun
+  ): Promise<O> {
+    return new Promise<O>((resolve, reject) => {
+      const childConfig = patchConfig(config, {
+        callbacks: runManager?.getChild(),
+      });
+      void AsyncLocalStorageProviderSingleton.runWithConfig(
+        childConfig,
+        async () => {
+          try {
+            const output = await this.func(input, childConfig);
+            resolve(output);
+          } catch (e) {
+            reject(e);
+          }
+        }
+      );
+    });
+  }
+
+  async invoke(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    input: any,
+    options?: Partial<RunnableConfig> | undefined
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ): Promise<any> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let returnValue: any;
+
+    if (this.trace) {
+      returnValue = await this._callWithConfig(
+        this._tracedInvoke,
+        input,
+        mergeConfigs(this.config, options)
+      );
+    } else {
+      returnValue = await this.func(input, mergeConfigs(this.config, options));
+    }
+
+    if (Runnable.isRunnable(returnValue) && this.recurse) {
+      return await returnValue.invoke(input, options);
+    }
+
+    return returnValue;
+  }
+}