@minded-ai/mindedjs 1.0.0-ec2-beta-1

package/src/platform/mindedConnectionTypes.ts

@@ -0,0 +1,495 @@
+import type {
+  CheckpointListOptions,
+  CheckpointMetadata,
+  PendingWrite,
+  Checkpoint,
+  ChannelVersions,
+  CheckpointTuple,
+} from '@langchain/langgraph-checkpoint';
+import type { RunnableConfig } from '@langchain/core/runnables';
+import { AgentInvokeParams, TriggerEvent } from '../types/Agent.types';
+import { stateAnnotation } from '../types/LangGraph.types';
+
+export enum mindedConnectionSocketMessageType {
+  OnAppAction = 'on-app-action',
+  GET_SECRETS = 'get-secrets',
+  GET_FLOWS = 'get-flows',
+  GET_PLAYBOOKS = 'get-playbooks',
+  INVOKE = 'invoke',
+  PII_HTTP_REQUEST = 'pii-http-request',
+  // Checkpoints
+  CHECKPOINT_GET_TUPLE = 'checkpoint-get-tuple',
+  CHECKPOINT_PUT = 'checkpoint-put',
+  CHECKPOINT_LIST = 'checkpoint-list',
+  CHECKPOINT_PUT_WRITES = 'checkpoint-put-writes',
+  RESTORE_CHECKPOINT = 'restore-checkpoint',
+  // Voice
+  VOICE_USER_AUDIO = 'voice-user-audio',
+  VOICE_AGENT_AUDIO = 'voice-agent-audio',
+  VOICE_SESSION_START = 'voice-session-start',
+  VOICE_SESSION_END = 'voice-session-end',
+  VOICE_INTERRUPTION = 'voice-interruption',
+  VOICE_PLACEHOLDER_MESSAGES = 'voice-placeholder-messages',
+  VOICE_ESCALATE = 'voice-escalate',
+  // Update state
+  UPDATE_STATE = 'update-state',
+  INTERFACE_FUNCTION_CALL = 'interface-function-call',
+  TIMER_RESET = 'timer-reset',
+  TIMER_CANCEL = 'timer-cancel',
+  TIMER_TRIGGER = 'timer-trigger',
+  RETELL_CALL = 'retell-call',
+  RETELL_GET_CALL = 'retell-get-call',
+  SDK_VERSION_MISMATCH = 'sdk-version-mismatch', // Browser Task
+  CREATE_BROWSER_SESSION = 'create-browser-session',
+  INVOKE_BROWSER_TASK = 'invoke-browser-task',
+  DESTROY_BROWSER_SESSION = 'destroy-browser-session',
+  // Interrupt Session Management
+  INTERRUPT_SESSION_IS_PROCESSED = 'interrupt-session-is-processed',
+  INTERRUPT_SESSION_LOCK = 'interrupt-session-lock',
+  INTERRUPT_SESSION_RELEASE = 'interrupt-session-release',
+  INTERRUPT_SESSION_ENQUEUE = 'interrupt-session-enqueue',
+  INTERRUPT_SESSION_DEQUEUE_ALL = 'interrupt-session-dequeue-all',
+  INTERRUPT_SESSION_DEQUEUE = 'interrupt-session-dequeue',
+  INTERRUPT_SESSION_HAS_MESSAGES = 'interrupt-session-has-messages',
+  INTERRUPT_SESSION_GET_MESSAGES = 'interrupt-session-get-messages',
+  // Tool execution
+  EXECUTE_TOOL = 'execute-tool',
+  VECTORSTORE_QUERY = 'vectorstore-query',
+}
+
+export type mindedConnectionSocketMessageTypeMap = {
+  [mindedConnectionSocketMessageType.OnAppAction]: BasemindedConnectionSocketMessage;
+  [mindedConnectionSocketMessageType.GET_SECRETS]: BasemindedConnectionSocketMessage;
+  [mindedConnectionSocketMessageType.GET_FLOWS]: BasemindedConnectionSocketMessage;
+  [mindedConnectionSocketMessageType.GET_PLAYBOOKS]: BasemindedConnectionSocketMessage;
+  [mindedConnectionSocketMessageType.INVOKE]: InvokeMessage;
+  [mindedConnectionSocketMessageType.CHECKPOINT_GET_TUPLE]: OnCheckpointGetTuple;
+  [mindedConnectionSocketMessageType.CHECKPOINT_PUT]: OnCheckpointPut;
+  [mindedConnectionSocketMessageType.CHECKPOINT_LIST]: OnCheckpointList;
+  [mindedConnectionSocketMessageType.CHECKPOINT_PUT_WRITES]: OnCheckpointPutWrites;
+  [mindedConnectionSocketMessageType.VOICE_USER_AUDIO]: OnVoiceAudioIn;
+  [mindedConnectionSocketMessageType.VOICE_AGENT_AUDIO]: OnVoiceAudioOut;
+  [mindedConnectionSocketMessageType.VOICE_SESSION_START]: OnVoiceSessionStart;
+  [mindedConnectionSocketMessageType.VOICE_SESSION_END]: OnVoiceSessionEnd;
+  [mindedConnectionSocketMessageType.VOICE_INTERRUPTION]: OnVoiceInterruption;
+  [mindedConnectionSocketMessageType.VOICE_ESCALATE]: VoiceEscalate;
+  [mindedConnectionSocketMessageType.VOICE_PLACEHOLDER_MESSAGES]: VoicePlaceholderMessage;
+  [mindedConnectionSocketMessageType.PII_HTTP_REQUEST]: OnPiiHttpRequest;
+  [mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL]: InterfaceFunctionCall;
+  [mindedConnectionSocketMessageType.TIMER_RESET]: TimerResetRequest;
+  [mindedConnectionSocketMessageType.TIMER_CANCEL]: TimerCancelRequest;
+  [mindedConnectionSocketMessageType.TIMER_TRIGGER]: TimerTriggerRequest;
+  [mindedConnectionSocketMessageType.RESTORE_CHECKPOINT]: RestoreCheckpointRequest;
+  [mindedConnectionSocketMessageType.RETELL_CALL]: RetellCall;
+  [mindedConnectionSocketMessageType.RETELL_GET_CALL]: RetellGetCall;
+  [mindedConnectionSocketMessageType.SDK_VERSION_MISMATCH]: SdkVersionMismatchMessage;
+  [mindedConnectionSocketMessageType.UPDATE_STATE]: UpdateStateRequest;
+  [mindedConnectionSocketMessageType.CREATE_BROWSER_SESSION]: CreateBrowserSessionRequest;
+  [mindedConnectionSocketMessageType.INVOKE_BROWSER_TASK]: InvokeBrowserTaskRequest;
+  [mindedConnectionSocketMessageType.DESTROY_BROWSER_SESSION]: DestroyBrowserSessionRequest;
+  // Interrupt Session Management
+  [mindedConnectionSocketMessageType.INTERRUPT_SESSION_IS_PROCESSED]: InterruptSessionIsProcessedRequest;
+  [mindedConnectionSocketMessageType.INTERRUPT_SESSION_LOCK]: InterruptSessionLockRequest;
+  [mindedConnectionSocketMessageType.INTERRUPT_SESSION_RELEASE]: InterruptSessionReleaseRequest;
+  [mindedConnectionSocketMessageType.INTERRUPT_SESSION_ENQUEUE]: InterruptSessionEnqueueRequest;
+  [mindedConnectionSocketMessageType.INTERRUPT_SESSION_DEQUEUE_ALL]: InterruptSessionDequeueAllRequest;
+  [mindedConnectionSocketMessageType.INTERRUPT_SESSION_DEQUEUE]: InterruptSessionDequeueRequest;
+  [mindedConnectionSocketMessageType.INTERRUPT_SESSION_HAS_MESSAGES]: InterruptSessionHasMessagesRequest;
+  [mindedConnectionSocketMessageType.INTERRUPT_SESSION_GET_MESSAGES]: InterruptSessionGetMessagesRequest;
+  [mindedConnectionSocketMessageType.EXECUTE_TOOL]: ExecuteToolRequest;
+  [mindedConnectionSocketMessageType.VECTORSTORE_QUERY]: VectorStoreQueryRequest;
+};
+
+export interface BasemindedConnectionSocketMessage {
+  type: mindedConnectionSocketMessageType;
+}
+
+export interface VoiceEscalate extends BaseVoiceMessage {
+  parameters: any;
+}
+
+export interface BaseSdkConnectionSocketMessageResponseCallbackAck {
+  error?: string;
+}
+
+export interface OnCheckpointPut extends BasemindedConnectionSocketMessage {
+  config: RunnableConfig;
+  checkpoint: Checkpoint;
+  metadata: CheckpointMetadata;
+  newVersions: ChannelVersions;
+}
+
+export interface OnCheckpointPutResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  config: RunnableConfig;
+}
+export interface OnCheckpointPutWrites extends BasemindedConnectionSocketMessage {
+  config: RunnableConfig;
+  writes: PendingWrite[];
+  taskId: string;
+}
+
+export interface OnCheckpointGetTupleResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  tuple?: CheckpointTuple | undefined;
+}
+
+export interface OnCheckpointGetTuple extends BasemindedConnectionSocketMessage {
+  config: RunnableConfig;
+}
+
+export interface OnCheckpointList extends BasemindedConnectionSocketMessage {
+  config: RunnableConfig;
+  options?: CheckpointListOptions;
+}
+
+export interface OnCheckpointListResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  checkpoints?: CheckpointTuple[];
+}
+
+export interface BaseVoiceMessage extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+  timestamp: number;
+}
+
+export interface OnVoiceSessionStart extends BaseVoiceMessage {
+  metadata?: Record<string, any>;
+}
+
+// Voice/Audio event interfaces
+export interface OnVoiceAudioIn extends BaseVoiceMessage {
+  audioData: string; // base64 encoded audio data
+}
+
+export interface OnVoiceAudioOut extends BaseVoiceMessage {
+  audioData: string; // base64 encoded audio data
+}
+
+export interface VoicePlaceholderMessage extends BaseVoiceMessage {
+  message: string;
+}
+
+export interface OnVoiceInterruption extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+  timestamp: number;
+}
+export interface OnVoiceSessionEnd extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+  timestamp: number;
+}
+
+export interface InvokeMessage extends BasemindedConnectionSocketMessage, AgentInvokeParams {
+  type: mindedConnectionSocketMessageType.INVOKE;
+}
+export interface OnPiiHttpRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+  requestId: string;
+  method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+  url: string;
+  headers?: Record<string, string>;
+  params?: Record<string, any>;
+  data?: any;
+}
+
+export interface OnPiiHttpResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  requestId: string;
+  data?: any;
+  status?: number;
+  statusText?: string;
+  headers?: Record<string, string>;
+}
+
+export interface InterfaceFunctionCall extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+  interfaceName: string;
+  functionName: string;
+  functionArgs: Record<string, any>;
+  interfaceParameters: Record<string, any>;
+}
+
+export interface TimerResetRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+  seconds: number;
+  timerName: string;
+  eventArgs: Record<string, any>;
+}
+
+export interface TimerResetResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  success?: boolean;
+}
+
+export interface TimerCancelRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+  timerName: string;
+}
+
+export interface TimerCancelResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  success?: boolean;
+}
+
+export interface TimerTriggerRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+  timerName: string;
+  eventArgs: Record<string, any>;
+}
+
+// Interrupt Session Management Interfaces
+export interface InterruptSessionIsProcessedRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionIsProcessedResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  isProcessed?: boolean;
+}
+
+export interface InterruptSessionLockRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionLockResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  lockAcquired?: boolean;
+}
+
+export interface InterruptSessionReleaseRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionReleaseResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  success?: boolean;
+}
+
+export interface InterruptSessionEnqueueRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+  message: TriggerEvent;
+}
+
+export interface InterruptSessionEnqueueResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  success?: boolean;
+}
+
+export interface InterruptSessionDequeueAllRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionDequeueAllResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  messages?: Array<TriggerEvent>;
+}
+
+export interface InterruptSessionDequeueRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionDequeueResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  message?: TriggerEvent | null;
+}
+
+export interface InterruptSessionHasMessagesRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionHasMessagesResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  hasMessages?: boolean;
+}
+
+export interface InterruptSessionGetMessagesRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionGetMessagesResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  messages?: Array<TriggerEvent>;
+}
+
+// Interrupt Session Management Interfaces
+export interface InterruptSessionIsProcessedRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionIsProcessedResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  isProcessed?: boolean;
+}
+
+export interface InterruptSessionLockRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionReleaseRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionReleaseResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  success?: boolean;
+}
+
+export interface InterruptSessionEnqueueRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+  message: TriggerEvent;
+}
+
+export interface InterruptSessionEnqueueResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  success?: boolean;
+}
+
+export interface InterruptSessionDequeueAllRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionDequeueAllResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  messages?: Array<TriggerEvent>;
+}
+
+export interface InterruptSessionDequeueRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionDequeueResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  message?: TriggerEvent | null;
+}
+
+export interface InterruptSessionHasMessagesRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionHasMessagesResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  hasMessages?: boolean;
+}
+
+export interface InterruptSessionGetMessagesRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionGetMessagesResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  messages?: Array<TriggerEvent>;
+}
+
+export interface RestoreCheckpointRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+  checkpointId: string;
+}
+
+export interface RestoreCheckpointResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  success?: boolean;
+}
+
+export interface RestoreCheckpointRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+  checkpointId: string;
+}
+
+export interface RestoreCheckpointResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  success?: boolean;
+}
+
+export interface RetellCall extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+  callName: string;
+  callAgentId: string;
+  vars: Record<string, any>;
+}
+
+export interface RetellCallResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  result?: any;
+  error?: string;
+}
+
+export interface RetellGetCall extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+  callId: string;
+}
+
+export interface RetellGetCallResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  result?: {
+    isFinish?: boolean;
+    callTranscript?: string;
+  };
+  error?: string;
+}
+
+export interface SdkVersionMismatchMessage extends BasemindedConnectionSocketMessage {
+  type: mindedConnectionSocketMessageType.SDK_VERSION_MISMATCH;
+  currentVersion: string;
+  requiredVersion: string;
+}
+export interface UpdateStateRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+  state: Partial<typeof stateAnnotation.State>;
+}
+
+// Browser Task Messages
+export interface CreateBrowserSessionRequest extends BasemindedConnectionSocketMessage {
+  type: mindedConnectionSocketMessageType.CREATE_BROWSER_SESSION;
+  proxy?: string; // 2-digit country code like 'IL'
+  onPrem?: boolean;
+}
+
+export interface CreateBrowserSessionResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  sessionId?: string;
+  cdpUrl?: string;
+  liveViewUrl?: string;
+}
+
+export interface DestroyBrowserSessionRequest extends BasemindedConnectionSocketMessage {
+  type: mindedConnectionSocketMessageType.DESTROY_BROWSER_SESSION;
+  sessionId: string;
+  onPrem?: boolean;
+}
+
+export interface DestroyBrowserSessionResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  success?: boolean;
+}
+
+export interface InvokeBrowserTaskRequest extends BasemindedConnectionSocketMessage {
+  type: mindedConnectionSocketMessageType.INVOKE_BROWSER_TASK;
+  cdpUrl: string;
+  task: string;
+  sessionId: string;
+  keepAlive?: boolean;
+  hooks?: {
+    name: string;
+    lifecycle_phases?: string[];
+    config?: Record<string, any>;
+  }[]; // Array of hooks to be passed to the browser-use lambda
+  onPrem?: boolean;
+  toolSchemas?: any[];
+  outputSchema?: {
+    name: string;
+    type: 'string' | 'number';
+    description?: string;
+    required?: boolean;
+  }[];
+}
+
+export interface InvokeBrowserTaskResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  result?: any;
+  steps?: any[];
+  recordings?: any[];
+}
+
+export interface ExecuteToolRequest extends BasemindedConnectionSocketMessage {
+  type: mindedConnectionSocketMessageType.EXECUTE_TOOL;
+  toolName: string;
+  toolParams: any;
+  sessionId: string;
+  requestId: string;
+  error?: string;
+  cdpUrl?: string; // Optional CDP URL for browser context
+}
+
+export interface ExecuteToolResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  requestId: string;
+  result?: any;
+  state?: any;
+}
+
+export interface VectorStoreQueryRequest extends BasemindedConnectionSocketMessage {
+  type: mindedConnectionSocketMessageType.VECTORSTORE_QUERY;
+  collectionName: string;
+  query: string;
+  filter?: any;
+  numChunks?: number;
+  minScore?: number;
+}
+
+export interface VectorStoreQueryResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  documents?: Array<{
+    pageContent: string;
+    metadata: Record<string, any>;
+  }>;
+}

package/src/platform/models/mindedChatOpenAI.ts

@@ -0,0 +1,49 @@
+import { ChatOpenAI, ChatOpenAIFields } from '@langchain/openai';
+import { getConfig } from '../config';
+
+export interface BaseParallelChatFields {
+  /**
+   * Number of parallel requests to make. Defaults to 1 (no parallelization).
+   * When > 1, multiple identical requests are sent and the fastest response is used.
+   */
+  numParallelRequests?: number;
+
+  /**
+   * Whether to log timing information for parallel requests
+   */
+  logTimings?: boolean;
+}
+
+export interface MindedChatOpenAIFields extends ChatOpenAIFields, BaseParallelChatFields {}
+
+export class MindedChatOpenAI extends ChatOpenAI {
+  private numParallelRequests: number;
+  private logTimings: boolean;
+
+  constructor(fields?: MindedChatOpenAIFields) {
+    const { token, baseUrl } = getConfig();
+    const mindedBaseUrl = `${baseUrl}/sdk/llmGateway/chatOpenAI`;
+    if (!token) {
+      throw new Error('Minded token not found');
+    }
+
+    // Store parallel configuration
+    const numParallelRequests = fields?.numParallelRequests || 1;
+    const logTimings = fields?.logTimings || false;
+
+    super({
+      ...fields,
+      apiKey: token,
+      configuration: {
+        baseURL: mindedBaseUrl,
+        defaultHeaders: {
+          'X-Parallel-Requests': numParallelRequests.toString(),
+          'X-Log-Timings': logTimings.toString(),
+        },
+      },
+    });
+
+    this.numParallelRequests = numParallelRequests;
+    this.logTimings = logTimings;
+  }
+}

package/src/platform/models/parallelWrapper.ts

@@ -0,0 +1,141 @@
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { BaseMessage } from '@langchain/core/messages';
+import { ChatGenerationChunk, ChatResult } from '@langchain/core/outputs';
+import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import { logger } from '../../utils/logger';
+
+export interface BaseParallelChatFields {
+  /**
+   * Number of parallel requests to make. Defaults to 1 (no parallelization).
+   * When > 1, multiple identical requests are sent and the fastest response is used.
+   */
+  numParallelRequests?: number;
+
+  /**
+   * Whether to log timing information for parallel requests
+   */
+  logTimings?: boolean;
+}
+
+/**
+ * Creates a wrapped version of a chat model with parallel request capabilities
+ */
+export function createParallelWrapper<T extends BaseChatModel>(model: T, fields?: BaseParallelChatFields): T {
+  const numParallelRequests = fields?.numParallelRequests || 1;
+  const logTimings = fields?.logTimings || false;
+
+  // If parallel requests are disabled, return the original model
+  if (numParallelRequests <= 1) {
+    return model;
+  }
+
+  // Helper function that returns a promise that resolves with the second fulfilled promise
+  const promiseSecondFulfillment = <T>(promises: Promise<T>[]): Promise<T> => {
+    return new Promise((resolve) => {
+      let fulfillCount = 0;
+
+      for (const p of promises) {
+        Promise.resolve(p)
+          .then((value) => {
+            fulfillCount++;
+            if (fulfillCount === 2) {
+              resolve(value);
+            }
+          })
+          .catch(() => {
+            // Ignoring rejections for second fulfillment tracking
+          });
+      }
+    });
+  };
+
+  // Store original methods
+  const originalGenerate = model._generate.bind(model);
+  const originalStream = model._streamResponseChunks.bind(model);
+
+  // Override _generate
+  model._generate = async function (messages: BaseMessage[], options?: any, runManager?: CallbackManagerForLLMRun): Promise<ChatResult> {
+    const startTime = Date.now();
+
+    // Create array of identical requests
+    const requests = Array.from({ length: numParallelRequests }, () => originalGenerate(messages, options, runManager));
+
+    let fastestRequestTime = 0;
+    let secondFastestRequestTime = 0;
+
+    // Race all requests and return the fastest
+    const racePromise = Promise.race(requests).then((result) => {
+      fastestRequestTime = (Date.now() - startTime) / 1000.0;
+
+      if (logTimings) {
+        logger.debug({
+          msg: '[Model] Fastest request completed',
+          requestTime: fastestRequestTime,
+          numParallelRequests: numParallelRequests,
+        });
+      }
+
+      return result;
+    });
+
+    // Track second fastest if we have 3+ requests
+    if (requests.length >= 3) {
+      promiseSecondFulfillment(requests)
+        .then(() => {
+          secondFastestRequestTime = (Date.now() - startTime) / 1000.0;
+        })
+        .catch(() => {
+          // Ignore errors in timing tracking
+        });
+    }
+
+    // Track all completion times if we have 2+ requests
+    if (requests.length >= 2 && logTimings) {
+      Promise.all(requests)
+        .then(() => {
+          const allFinishTime = (Date.now() - startTime) / 1000.0;
+          const timeSaved = allFinishTime - fastestRequestTime;
+          const timeSavedFromSecond = secondFastestRequestTime > 0 ? secondFastestRequestTime - fastestRequestTime : 0;
+
+          logger.debug({
+            msg: '[Model] Time saved using parallel requests',
+            fastestRequestTime,
+            secondFastestRequestTime: secondFastestRequestTime || 'N/A',
+            allFinishTime,
+            timeSaved,
+            timeSavedFromSecond,
+            numParallelRequests: numParallelRequests,
+          });
+        })
+        .catch(() => {
+          // Ignore errors in timing tracking
+        });
+    }
+
+    return racePromise;
+  };
+
+  // Override _streamResponseChunks
+  model._streamResponseChunks = async function* (
+    messages: BaseMessage[],
+    options?: any,
+    runManager?: CallbackManagerForLLMRun,
+  ): AsyncGenerator<ChatGenerationChunk> {
+    // For streaming, we'll use the original implementation
+    // Parallel streaming is more complex and may not provide the same benefits
+    if (numParallelRequests > 1 && logTimings) {
+      logger.debug({
+        msg: '[Model] Streaming mode - using single request',
+        reason: 'Parallel streaming not implemented',
+      });
+    }
+
+    yield* originalStream(messages, options, runManager);
+  };
+
+  // Add properties for testing
+  (model as any).numParallelRequests = numParallelRequests;
+  (model as any).logTimings = logTimings;
+
+  return model;
+}