@librechat/agents 3.1.85 → 3.1.87

package/src/session/types.ts

@@ -0,0 +1,275 @@
+import type { RunnableConfig } from '@langchain/core/runnables';
+import type { BaseMessage } from '@langchain/core/messages';
+import type { BaseCheckpointSaver } from '@langchain/langgraph';
+import type * as t from '@/types';
+
+export type JsonPrimitive = string | number | boolean | null;
+
+export type JsonValue =
+  | JsonPrimitive
+  | JsonValue[]
+  | {
+      [key: string]: JsonValue;
+    };
+
+export type JsonObject = {
+  [key: string]: JsonValue;
+};
+
+export type SessionEntryType =
+  | 'message'
+  | 'summary'
+  | 'compaction'
+  | 'checkpoint'
+  | 'label'
+  | 'run_event'
+  | 'session_state';
+
+export interface SessionHeader {
+  type: 'session';
+  version: 1;
+  id: string;
+  timestamp: string;
+  cwd: string;
+  name?: string;
+  parentSession?: string;
+}
+
+export interface SessionEntryBase<TType extends SessionEntryType, TData> {
+  type: TType;
+  id: string;
+  parentId: string | null;
+  timestamp: string;
+  data: TData;
+}
+
+export interface SerializedSessionMessage {
+  messageType: string;
+  content: JsonValue;
+  additionalKwargs?: JsonObject;
+  responseMetadata?: JsonObject;
+  id?: string;
+  name?: string;
+  toolCallId?: string;
+  toolCalls?: JsonValue;
+  usageMetadata?: JsonObject;
+}
+
+export type SessionMessageEntry = SessionEntryBase<
+  'message',
+  {
+    role: string;
+    message: SerializedSessionMessage;
+  }
+>;
+
+export type SessionSummaryEntry = SessionEntryBase<
+  'summary',
+  {
+    text: string;
+    tokenCount?: number;
+    retainedEntryIds: JsonValue[];
+    summarizedEntryIds: JsonValue[];
+    instructions?: string;
+  }
+>;
+
+export type SessionCompactionEntry = SessionEntryBase<
+  'compaction',
+  {
+    summaryEntryId: string;
+    retainedEntryIds: JsonValue[];
+    summarizedEntryIds: JsonValue[];
+  }
+>;
+
+export type SessionCheckpointEntry = SessionEntryBase<
+  'checkpoint',
+  {
+    provider: 'langgraph';
+    source: 'run' | 'resume' | 'reset';
+    threadId: string;
+    runId?: string;
+    checkpointId?: string;
+    checkpointNs?: string;
+    parentCheckpointId?: string;
+    reason?: string;
+  }
+>;
+
+export type SessionLabelEntry = SessionEntryBase<
+  'label',
+  {
+    targetEntryId: string;
+    label: string;
+  }
+>;
+
+export type SessionRunEventEntry = SessionEntryBase<
+  'run_event',
+  {
+    event: string;
+    runId?: string;
+    threadId?: string;
+    payload?: JsonValue;
+  }
+>;
+
+export type SessionStateEntry = SessionEntryBase<
+  'session_state',
+  {
+    leafId: string | null;
+  }
+>;
+
+export type SessionEntry =
+  | SessionMessageEntry
+  | SessionSummaryEntry
+  | SessionCompactionEntry
+  | SessionCheckpointEntry
+  | SessionLabelEntry
+  | SessionRunEventEntry
+  | SessionStateEntry;
+
+export interface SessionTreeNode {
+  entry: SessionEntry;
+  children: SessionTreeNode[];
+}
+
+export interface SessionListItem {
+  id: string;
+  path: string;
+  cwd: string;
+  timestamp: string;
+  name?: string;
+  leafId?: string | null;
+}
+
+export type SessionPosition = 'before' | 'at';
+
+export interface SessionForkOptions {
+  position?: SessionPosition;
+  cwd?: string;
+  name?: string;
+}
+
+export interface SessionBranchOptions {
+  position?: SessionPosition;
+  summarizeAbandoned?: boolean | { instructions?: string };
+}
+
+export interface SessionCompactOptions {
+  instructions?: string;
+  retainRecentTurns?: number;
+}
+
+export interface AgentSessionRunResult {
+  text: string;
+  content: t.MessageContentComplex[];
+  messages: BaseMessage[];
+  usage: AgentSessionUsage;
+  steps: t.RunStep[];
+  interrupt: t.RunInterruptResult | undefined;
+  haltedReason: string | undefined;
+  runId: string;
+  threadId: string;
+}
+
+export interface AgentSessionUsage {
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+}
+
+export interface AgentSessionCheckpointReference {
+  provider: 'langgraph';
+  threadId: string;
+  checkpointId?: string;
+  checkpointNs?: string;
+  parentCheckpointId?: string;
+}
+
+export interface AgentSessionCheckpointLookupOptions {
+  threadId?: string;
+  checkpointNs?: string;
+  config?: RunnableConfig;
+}
+
+export interface AgentSessionCheckpointingOptions {
+  enabled?: boolean;
+  checkpointer?: BaseCheckpointSaver;
+}
+
+export type AgentSessionCheckpointing =
+  | boolean
+  | AgentSessionCheckpointingOptions;
+
+export type AgentSessionInput = string | BaseMessage | BaseMessage[] | t.IState;
+
+export interface AgentSessionRunOptions {
+  runId?: string;
+  threadId?: string;
+  config?: Partial<RunnableConfig> & { version?: 'v1' | 'v2' };
+  streamOptions?: t.EventStreamOptions;
+}
+
+export interface AgentSessionStreamEvent {
+  type:
+    | 'run.started'
+    | 'message.delta'
+    | 'reasoning.delta'
+    | 'tool.started'
+    | 'tool.delta'
+    | 'tool.completed'
+    | 'usage.updated'
+    | 'run.completed'
+    | 'run.failed'
+    | 'run.interrupted'
+    | 'run.halted';
+  sequence: number;
+  runId: string;
+  threadId: string;
+  timestamp: string;
+  data?: JsonValue;
+}
+
+export interface AgentSessionStream
+  extends AsyncIterable<AgentSessionStreamEvent> {
+  toTextStream(): AsyncIterable<string>;
+  finalResult(): Promise<AgentSessionRunResult>;
+}
+
+export interface AgentSessionHandlersResult {
+  contentParts: Array<t.MessageContentComplex | undefined>;
+  steps: t.RunStep[];
+  usage: AgentSessionUsage;
+  events: AgentSessionStreamEvent[];
+  handlers: Record<string, t.EventHandler>;
+}
+
+export type AgentSessionConfig =
+  | {
+      runConfig: t.RunConfig;
+      cwd?: string;
+      sessionPath?: string;
+      sessionId?: string;
+      name?: string;
+      ephemeral?: boolean;
+      checkpointing?: AgentSessionCheckpointing;
+    }
+  | ({
+      runId?: string;
+      cwd?: string;
+      sessionPath?: string;
+      sessionId?: string;
+      name?: string;
+      ephemeral?: boolean;
+      checkpointing?: AgentSessionCheckpointing;
+    } & Omit<t.RunConfig, 'runId'>);
+
+export interface CreateSessionFileOptions {
+  cwd: string;
+  name?: string;
+  parentSession?: string;
+  sessionId?: string;
+}

package/src/specs/custom-event-await.test.ts

@@ -22,6 +22,95 @@ describe('Custom event handler awaitHandlers behavior', () => {
     version: 'v2' as const,
   };
 
+  it('does not redispatch SDK custom events yielded by streamEvents', async () => {
+    const handledEvents: GraphEvents[] = [];
+    const customHandlers: Record<string | GraphEvents, t.EventHandler> = {
+      [GraphEvents.ON_MESSAGE_DELTA]: {
+        handle: (event: GraphEvents): void => {
+          handledEvents.push(event);
+        },
+      },
+    };
+
+    const run = await Run.create<t.IState>({
+      runId: 'test-custom-events-skip-stream-loop',
+      graphConfig: {
+        type: 'standard',
+        llmConfig,
+      },
+      skipCleanup: true,
+      customHandlers,
+    });
+
+    async function* streamEvents(): AsyncGenerator<t.StreamEvent> {
+      yield {
+        event: GraphEvents.ON_MESSAGE_DELTA,
+        name: 'custom-event',
+        run_id: 'custom-event-run',
+        metadata: {},
+        data: {},
+      };
+    }
+
+    run.graphRunnable = { streamEvents } as unknown as t.CompiledStateWorkflow;
+
+    await run.processStream({ messages: [new HumanMessage('hello')] }, config);
+
+    expect(handledEvents).toEqual([]);
+  });
+
+  it('dispatches message deltas through the graph handler registry', async () => {
+    const handledEvents: Array<{
+      data: t.MessageDeltaEvent;
+      metadata?: Record<string, unknown>;
+    }> = [];
+    const customHandlers: Record<string | GraphEvents, t.EventHandler> = {
+      [GraphEvents.ON_MESSAGE_DELTA]: {
+        handle: (_event, data, metadata): void => {
+          handledEvents.push({
+            data: data as t.MessageDeltaEvent,
+            metadata,
+          });
+        },
+      },
+    };
+
+    const run = await Run.create<t.IState>({
+      runId: 'test-message-delta-direct-dispatch',
+      graphConfig: {
+        type: 'standard',
+        llmConfig,
+      },
+      skipCleanup: true,
+      customHandlers,
+    });
+    if (!run.Graph) {
+      throw new Error('Expected graph to be initialized');
+    }
+
+    const metadata = { thread_id: 'thread_direct', langgraph_step: 1 };
+    run.Graph.config = { configurable: { thread_id: 'thread_direct' } };
+    await run.Graph.dispatchMessageDelta(
+      'step_direct',
+      {
+        content: [{ type: ContentTypes.TEXT, text: 'hello' }],
+      },
+      metadata
+    );
+
+    expect(handledEvents).toEqual([
+      {
+        data: {
+          id: 'step_direct',
+          delta: {
+            content: [{ type: ContentTypes.TEXT, text: 'hello' }],
+          },
+        },
+        metadata,
+      },
+    ]);
+  });
+
   it('should fully aggregate all content before processStream returns', async () => {
     const longResponse =
       'The quick brown fox jumps over the lazy dog and then runs across the field to find shelter from the rain';

package/src/specs/summarization.test.ts

@@ -428,7 +428,7 @@ const hasAnthropic = process.env.ANTHROPIC_API_KEY != null;
 
     // Turn 7: absolute minimum context if still nothing
     if (spies.onSummarizeStartSpy.mock.calls.length === 0) {
-      ({ run, contentParts } = await createRun(2200));
+      ({ run, contentParts } = await createRun(1200));
       await runTurn({ run, conversationHistory }, 'What is 1+1?', streamConfig);
       logTurn('T7', conversationHistory);
     }