illuma-agents 1.0.23 → 1.0.24

package/src/run.ts

@@ -4,8 +4,6 @@ import { CallbackHandler } from '@langfuse/langchain';
 import { PromptTemplate } from '@langchain/core/prompts';
 import { RunnableLambda } from '@langchain/core/runnables';
 import { AzureChatOpenAI, ChatOpenAI } from '@langchain/openai';
-import { MemorySaver } from '@langchain/langgraph-checkpoint';
-import { Command } from '@langchain/langgraph';
 import type {
   MessageContentComplex,
   BaseMessage,
@@ -24,7 +22,6 @@ import { StandardGraph } from '@/graphs/Graph';
 import { HandlerRegistry } from '@/events';
 import { isOpenAILike } from '@/utils/llm';
 import { isPresent } from '@/utils/misc';
-import type { BrowserInterrupt, BrowserActionResult } from '@/tools/BrowserInterruptTools';
 
 export const defaultOmitOptions = new Set([
   'stream',
@@ -39,35 +36,11 @@ export const defaultOmitOptions = new Set([
   'additionalModelRequestFields',
 ]);
 
-/** Global checkpointer store for browser mode (keyed by runId) */
-const browserCheckpointers = new Map<string, MemorySaver>();
-
-/**
- * Get or create a checkpointer for browser mode
- */
-export function getBrowserCheckpointer(runId: string): MemorySaver {
-  let checkpointer = browserCheckpointers.get(runId);
-  if (!checkpointer) {
-    checkpointer = new MemorySaver();
-    browserCheckpointers.set(runId, checkpointer);
-  }
-  return checkpointer;
-}
-
-/**
- * Clean up a browser checkpointer when done
- */
-export function cleanupBrowserCheckpointer(runId: string): void {
-  browserCheckpointers.delete(runId);
-}
-
 export class Run<_T extends t.BaseGraphState> {
   id: string;
   private tokenCounter?: t.TokenCounter;
   private handlerRegistry?: HandlerRegistry;
   private indexTokenCountMap?: Record<string, number>;
-  /** Whether this run is in browser extension mode */
-  browserMode: boolean = false;
   graphRunnable?: t.CompiledStateWorkflow;
   Graph: StandardGraph | MultiAgentGraph | undefined;
   returnContent: boolean = false;
@@ -81,7 +54,6 @@ export class Run<_T extends t.BaseGraphState> {
     this.id = runId;
     this.tokenCounter = config.tokenCounter;
     this.indexTokenCountMap = config.indexTokenCountMap;
-    this.browserMode = config.browserMode ?? false;
 
     const handlerRegistry = new HandlerRegistry();
 
@@ -101,24 +73,16 @@ export class Run<_T extends t.BaseGraphState> {
 
     /** Handle different graph types */
     if (config.graphConfig.type === 'multi-agent') {
-      // For multi-agent, browser mode checkpointer support not yet implemented
       this.graphRunnable = this.createMultiAgentGraph(config.graphConfig);
       if (this.Graph) {
         this.Graph.handlerRegistry = handlerRegistry;
       }
     } else {
       /** Default to legacy graph for 'standard' or undefined type */
-      // In browser mode, inject checkpointer into compileOptions BEFORE creating the graph
-      const graphConfig = { ...config.graphConfig };
-      if (this.browserMode) {
-        const checkpointer = getBrowserCheckpointer(runId);
-        graphConfig.compileOptions = {
-          ...graphConfig.compileOptions,
-          checkpointer,
-        };
-      }
-      this.graphRunnable = this.createLegacyGraph(graphConfig);
+      this.graphRunnable = this.createLegacyGraph(config.graphConfig);
       if (this.Graph) {
+        this.Graph.compileOptions =
+          config.graphConfig.compileOptions ?? this.Graph.compileOptions;
         this.Graph.handlerRegistry = handlerRegistry;
       }
     }
@@ -489,225 +453,4 @@ export class Run<_T extends t.BaseGraphState> {
       );
     }
   }
-
-  /**
-   * Process stream with browser interrupt support.
-   * Uses streamEvents() like processStream to emit SSE events,
-   * then checks for interrupts after stream completes.
-   */
-  async *processBrowserStream(
-    inputs: t.IState,
-    config: Partial<RunnableConfig> & { version: 'v1' | 'v2'; run_id?: string },
-    streamOptions?: t.EventStreamOptions
-  ): AsyncGenerator<
-    | { type: 'event'; data: unknown }
-    | { type: 'interrupt'; data: BrowserInterrupt }
-    | { type: 'done'; data?: MessageContentComplex[] }
-  > {
-    if (this.graphRunnable == null) {
-      throw new Error(
-        'Run not initialized. Make sure to use Run.create() to instantiate the Run.'
-      );
-    }
-    if (!this.Graph) {
-      throw new Error(
-        'Graph not initialized. Make sure to use Run.create() to instantiate the Run.'
-      );
-    }
-
-    this.Graph.resetValues(streamOptions?.keepContent);
-
-    if (!this.id) {
-      throw new Error('Run ID not provided');
-    }
-
-    config.run_id = this.id;
-    // Set up thread_id for checkpointing (required for interrupt/resume)
-    config.configurable = Object.assign(config.configurable ?? {}, {
-      run_id: this.id,
-      thread_id: this.id, // Use run ID as thread ID for browser sessions
-    });
-
-    // Set up callbacks for SSE event emission (same as processStream)
-    const customEventCallback = this.createCustomEventCallback();
-
-    const baseCallbacks = (config.callbacks as t.ProvidedCallbacks) ?? [];
-    const streamCallbacks = streamOptions?.callbacks
-      ? this.getCallbacks(streamOptions.callbacks)
-      : [];
-
-    config.callbacks = baseCallbacks.concat(streamCallbacks).concat({
-      [Callback.CUSTOM_EVENT]: customEventCallback,
-    });
-
-    // Use streamEvents like processStream to emit proper SSE events
-    const stream = this.graphRunnable.streamEvents(inputs, config, {
-      raiseError: true,
-      ignoreCustomEvent: true,
-    });
-
-    let wasInterrupted = false;
-
-    try {
-      for await (const event of stream) {
-        const { data, metadata, ...info } = event;
-        const eventName: t.EventName = info.event;
-
-        // Skip custom events as they're handled by our callback
-        if (eventName === GraphEvents.ON_CUSTOM_EVENT) {
-          continue;
-        }
-
-        const handler = this.handlerRegistry?.getHandler(eventName);
-        if (handler) {
-          await handler.handle(eventName, data, metadata, this.Graph);
-        }
-
-        // Also yield the event for the caller to process
-        yield { type: 'event', data: event };
-      }
-    } catch (error) {
-      // streamEvents may throw when interrupt happens
-      // Check if this is an interrupt-related termination
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      if (errorMessage.includes('interrupt') || errorMessage.includes('GraphInterrupt')) {
-        wasInterrupted = true;
-      } else {
-        throw error;
-      }
-    }
-
-    // After stream completes, check for pending interrupts using getState
-    // The checkpointer stores the interrupt state
-    try {
-      const state = await this.graphRunnable.getState(config);
-      if (state?.tasks) {
-        for (const task of state.tasks) {
-          if (task.interrupts && task.interrupts.length > 0) {
-            for (const interruptInfo of task.interrupts) {
-              if (interruptInfo.value?.type === 'browser_interrupt') {
-                yield { type: 'interrupt', data: interruptInfo.value as BrowserInterrupt };
-                return; // Stop after yielding interrupt
-              }
-            }
-          }
-        }
-      }
-    } catch (stateError) {
-      // getState may fail if no checkpointer - that's ok for non-browser flows
-      console.debug('[processBrowserStream] Could not get state:', stateError);
-    }
-
-    // Stream completed without interrupt
-    if (this.returnContent) {
-      yield { type: 'done', data: this.Graph.getContentParts() };
-    } else {
-      yield { type: 'done' };
-    }
-  }
-
-  /**
-   * Resume a browser stream after interrupt.
-   * Call this with the result from the browser extension.
-   * Uses streamEvents() to emit proper SSE events during resume.
-   */
-  async *resumeBrowserStream(
-    result: BrowserActionResult,
-    config: Partial<RunnableConfig> & { version: 'v1' | 'v2'; run_id?: string },
-    streamOptions?: t.EventStreamOptions
-  ): AsyncGenerator<
-    | { type: 'event'; data: unknown }
-    | { type: 'interrupt'; data: BrowserInterrupt }
-    | { type: 'done'; data?: MessageContentComplex[] }
-  > {
-    if (this.graphRunnable == null) {
-      throw new Error(
-        'Run not initialized. Make sure to use Run.create() to instantiate the Run.'
-      );
-    }
-    if (!this.Graph) {
-      throw new Error(
-        'Graph not initialized. Make sure to use Run.create() to instantiate the Run.'
-      );
-    }
-
-    if (!this.id) {
-      throw new Error('Run ID not provided');
-    }
-
-    config.run_id = this.id;
-    config.configurable = Object.assign(config.configurable ?? {}, {
-      run_id: this.id,
-      thread_id: this.id,
-    });
-
-    // Set up callbacks for SSE event emission (same as processStream)
-    const customEventCallback = this.createCustomEventCallback();
-
-    const baseCallbacks = (config.callbacks as t.ProvidedCallbacks) ?? [];
-    const streamCallbacks = streamOptions?.callbacks
-      ? this.getCallbacks(streamOptions.callbacks)
-      : [];
-
-    config.callbacks = baseCallbacks.concat(streamCallbacks).concat({
-      [Callback.CUSTOM_EVENT]: customEventCallback,
-    });
-
-    // Use Command to resume with the browser result
-    const resumeCommand = new Command({ resume: result });
-
-    // Use streamEvents for proper SSE event emission
-    const stream = this.graphRunnable.streamEvents(resumeCommand, config, {
-      raiseError: true,
-      ignoreCustomEvent: true,
-    });
-
-    try {
-      for await (const event of stream) {
-        const { data, metadata, ...info } = event;
-        const eventName: t.EventName = info.event;
-
-        if (eventName === GraphEvents.ON_CUSTOM_EVENT) {
-          continue;
-        }
-
-        const handler = this.handlerRegistry?.getHandler(eventName);
-        if (handler) {
-          await handler.handle(eventName, data, metadata, this.Graph);
-        }
-
-        yield { type: 'event', data: event };
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      if (!errorMessage.includes('interrupt') && !errorMessage.includes('GraphInterrupt')) {
-        throw error;
-      }
-    }
-
-    // Check for additional interrupts after resume
-    try {
-      const state = await this.graphRunnable.getState(config);
-      if (state?.tasks) {
-        for (const task of state.tasks) {
-          if (task.interrupts && task.interrupts.length > 0) {
-            for (const interruptInfo of task.interrupts) {
-              if (interruptInfo.value?.type === 'browser_interrupt') {
-                yield { type: 'interrupt', data: interruptInfo.value as BrowserInterrupt };
-                return;
-              }
-            }
-          }
-        }
-      }
-    } catch (stateError) {
-      console.debug('[resumeBrowserStream] Could not get state:', stateError);
-    }
-
-    if (this.returnContent) {
-      yield { type: 'done', data: this.Graph.getContentParts() };
-    } else {
-      yield { type: 'done' };
-    }
-  }
 }

package/src/types/run.ts

@@ -115,14 +115,6 @@ export type RunConfig = {
   returnContent?: boolean;
   tokenCounter?: TokenCounter;
   indexTokenCountMap?: Record<string, number>;
-  /** 
-   * Enable browser extension mode with interrupt-based tool execution.
-   * When true:
-   * - Uses MemorySaver checkpointer for pause/resume
-   * - Browser tools will interrupt execution and wait for extension results
-   * - Extension must call resume endpoint with Command to continue
-   */
-  browserMode?: boolean;
 };
 
 export type ProvidedCallbacks =