@librechat/agents 3.2.2 → 3.2.31

package/src/tools/search/jina-reranker.test.ts

@@ -1,18 +1,72 @@
-import { JinaReranker } from './rerankers';
+import axios from 'axios';
+
+import { createReranker, JinaReranker } from './rerankers';
 import { createDefaultLogger } from './utils';
 
+type AxiosErrorFixture = Error & {
+  isAxiosError: true;
+  code: string;
+  config: {
+    data: string;
+    headers: {
+      Authorization: string;
+    };
+    method: string;
+    url: string;
+  };
+  response: {
+    data: {
+      details?: string;
+      message: string;
+    };
+    status: number;
+  };
+};
+
+const getApiUrl = (reranker: JinaReranker): string => {
+  const descriptor = Object.getOwnPropertyDescriptor(reranker, 'apiUrl');
+  if (typeof descriptor?.value === 'string') {
+    return descriptor.value;
+  }
+  throw new Error('Expected JinaReranker apiUrl to be initialized.');
+};
+
+const createAxiosErrorFixture = (
+  url: string,
+  responseData: AxiosErrorFixture['response']['data']
+): AxiosErrorFixture =>
+  Object.assign(new Error('Request failed with status code 500'), {
+    isAxiosError: true as const,
+    code: 'ERR_BAD_RESPONSE',
+    config: {
+      data: JSON.stringify({ documents: ['document1', 'document2'] }),
+      headers: {
+        Authorization: 'Bearer test-key',
+      },
+      method: 'post',
+      url,
+    },
+    response: {
+      data: responseData,
+      status: 500,
+    },
+  });
+
 describe('JinaReranker', () => {
   const mockLogger = createDefaultLogger();
-  
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
   describe('constructor', () => {
     it('should use default API URL when no apiUrl is provided', () => {
       const reranker = new JinaReranker({
         apiKey: 'test-key',
         logger: mockLogger,
       });
-      
-      // Access private property for testing
-      const apiUrl = (reranker as any).apiUrl;
+
+      const apiUrl = getApiUrl(reranker);
       expect(apiUrl).toBe('https://api.jina.ai/v1/rerank');
     });
 
@@ -23,25 +77,24 @@ describe('JinaReranker', () => {
         apiUrl: customUrl,
         logger: mockLogger,
       });
-      
-      const apiUrl = (reranker as any).apiUrl;
+
+      const apiUrl = getApiUrl(reranker);
       expect(apiUrl).toBe(customUrl);
     });
 
     it('should use environment variable JINA_API_URL when available', () => {
       const originalEnv = process.env.JINA_API_URL;
       process.env.JINA_API_URL = 'https://env-jina-endpoint.com/v1/rerank';
-      
+
       const reranker = new JinaReranker({
         apiKey: 'test-key',
         logger: mockLogger,
       });
-      
-      const apiUrl = (reranker as any).apiUrl;
+
+      const apiUrl = getApiUrl(reranker);
       expect(apiUrl).toBe('https://env-jina-endpoint.com/v1/rerank');
-      
-      // Restore original environment
-      if (originalEnv) {
+
+      if (typeof originalEnv === 'string') {
         process.env.JINA_API_URL = originalEnv;
       } else {
         delete process.env.JINA_API_URL;
@@ -51,19 +104,18 @@ describe('JinaReranker', () => {
     it('should prioritize explicit apiUrl over environment variable', () => {
       const originalEnv = process.env.JINA_API_URL;
       process.env.JINA_API_URL = 'https://env-jina-endpoint.com/v1/rerank';
-      
+
       const customUrl = 'https://explicit-jina-endpoint.com/v1/rerank';
       const reranker = new JinaReranker({
         apiKey: 'test-key',
         apiUrl: customUrl,
         logger: mockLogger,
       });
-      
-      const apiUrl = (reranker as any).apiUrl;
+
+      const apiUrl = getApiUrl(reranker);
       expect(apiUrl).toBe(customUrl);
-      
-      // Restore original environment
-      if (originalEnv) {
+
+      if (typeof originalEnv === 'string') {
         process.env.JINA_API_URL = originalEnv;
       } else {
         delete process.env.JINA_API_URL;
@@ -79,27 +131,80 @@ describe('JinaReranker', () => {
         apiUrl: customUrl,
         logger: mockLogger,
       });
-      
-      const logSpy = jest.spyOn(mockLogger, 'debug');
-      
-      try {
-        await reranker.rerank('test query', ['document1', 'document2'], 2);
-      } catch (error) {
-        // Expected to fail due to missing API key, but we can check the log
-      }
-      
+
+      const logSpy = jest
+        .spyOn(mockLogger, 'debug')
+        .mockImplementation(() => mockLogger);
+      jest.spyOn(mockLogger, 'error').mockImplementation(() => mockLogger);
+      jest
+        .spyOn(axios, 'post')
+        .mockRejectedValueOnce(new Error('Network error'));
+
+      await reranker.rerank('test query', ['document1', 'document2'], 2);
+
       expect(logSpy).toHaveBeenCalledWith(
-        expect.stringContaining(`Reranking 2 chunks with Jina using API URL: ${customUrl}`)
+        expect.stringContaining(
+          `Reranking 2 chunks with Jina using API URL: ${customUrl}`
+        )
+      );
+    });
+
+    it('should log compact Axios errors without request internals', async () => {
+      const customUrl = 'https://test-jina-endpoint.com/v1/rerank?api_key=hidden';
+      const reranker = new JinaReranker({
+        apiKey: 'test-key',
+        apiUrl: customUrl,
+        logger: mockLogger,
+      });
+      const errorSpy = jest
+        .spyOn(mockLogger, 'error')
+        .mockImplementation(() => mockLogger);
+      jest.spyOn(mockLogger, 'debug').mockImplementation(() => mockLogger);
+      jest.spyOn(axios, 'isAxiosError').mockReturnValue(true);
+      jest.spyOn(axios, 'post').mockRejectedValueOnce(
+        createAxiosErrorFixture(customUrl, {
+          message: 'upstream failed',
+          details: 'x'.repeat(5000),
+        })
+      );
+
+      const result = await reranker.rerank(
+        'test query',
+        ['document1', 'document2'],
+        2
+      );
+
+      expect(result).toEqual([
+        { text: 'document1', score: 0 },
+        { text: 'document2', score: 0 },
+      ]);
+      expect(errorSpy).toHaveBeenCalledWith(
+        'Error using Jina reranker',
+        expect.objectContaining({
+          code: 'ERR_BAD_RESPONSE',
+          message: 'Request failed with status code 500',
+          method: 'POST',
+          name: 'Error',
+          responseDataSummary: 'object(2)',
+          status: 500,
+          url: 'https://test-jina-endpoint.com/v1/rerank',
+        })
       );
-      
-      logSpy.mockRestore();
+
+      const metadata = errorSpy.mock.calls.flat()[1];
+      const serializedMetadata = JSON.stringify(metadata);
+
+      expect(serializedMetadata).not.toContain('upstream failed');
+      expect(serializedMetadata).not.toContain('Authorization');
+      expect(serializedMetadata).not.toContain('api_key');
+      expect(serializedMetadata).not.toContain('document1');
+      expect(serializedMetadata).not.toContain('test-key');
+      expect(serializedMetadata.length).toBeLessThan(500);
     });
   });
 });
 
 describe('createReranker', () => {
-  const { createReranker } = require('./rerankers');
-  
   it('should create JinaReranker with jinaApiUrl when provided', () => {
     const customUrl = 'https://custom-jina-endpoint.com/v1/rerank';
     const reranker = createReranker({
@@ -107,9 +212,12 @@ describe('createReranker', () => {
       jinaApiKey: 'test-key',
       jinaApiUrl: customUrl,
     });
-    
+
     expect(reranker).toBeInstanceOf(JinaReranker);
-    const apiUrl = (reranker as any).apiUrl;
+    if (!(reranker instanceof JinaReranker)) {
+      throw new Error('Expected createReranker to return a JinaReranker.');
+    }
+    const apiUrl = getApiUrl(reranker);
     expect(apiUrl).toBe(customUrl);
   });
 
@@ -118,9 +226,12 @@ describe('createReranker', () => {
       rerankerType: 'jina',
       jinaApiKey: 'test-key',
     });
-    
+
     expect(reranker).toBeInstanceOf(JinaReranker);
-    const apiUrl = (reranker as any).apiUrl;
+    if (!(reranker instanceof JinaReranker)) {
+      throw new Error('Expected createReranker to return a JinaReranker.');
+    }
+    const apiUrl = getApiUrl(reranker);
     expect(apiUrl).toBe('https://api.jina.ai/v1/rerank');
   });
 });

package/src/tools/search/rerankers.ts

@@ -1,6 +1,13 @@
 import axios from 'axios';
 import type * as t from './types';
-import { createDefaultLogger } from './utils';
+import { createDefaultLogger, formatErrorForLog } from './utils';
+
+const DEFAULT_JINA_API_URL = 'https://api.jina.ai/v1/rerank';
+
+const getDefaultJinaApiUrl = (): string =>
+  process.env.JINA_API_URL != null && process.env.JINA_API_URL !== ''
+    ? process.env.JINA_API_URL
+    : DEFAULT_JINA_API_URL;
 
 export abstract class BaseReranker {
   protected apiKey: string | undefined;
@@ -32,7 +39,7 @@ export class JinaReranker extends BaseReranker {
 
   constructor({
     apiKey = process.env.JINA_API_KEY,
-    apiUrl = process.env.JINA_API_URL || 'https://api.jina.ai/v1/rerank',
+    apiUrl = getDefaultJinaApiUrl(),
     logger,
   }: {
     apiKey?: string;
@@ -107,7 +114,7 @@ export class JinaReranker extends BaseReranker {
         return this.getDefaultRanking(documents, topK);
       }
     } catch (error) {
-      this.logger.error('Error using Jina reranker:', error);
+      this.logger.error('Error using Jina reranker', formatErrorForLog(error));
       // Fallback to default ranking on error
       return this.getDefaultRanking(documents, topK);
     }
@@ -174,7 +181,10 @@ export class CohereReranker extends BaseReranker {
         return this.getDefaultRanking(documents, topK);
       }
     } catch (error) {
-      this.logger.error('Error using Cohere reranker:', error);
+      this.logger.error(
+        'Error using Cohere reranker',
+        formatErrorForLog(error)
+      );
       // Fallback to default ranking on error
       return this.getDefaultRanking(documents, topK);
     }

package/src/tools/search/tavily-search.ts

@@ -3,7 +3,7 @@ import type * as t from './types';
 
 const DEFAULT_TAVILY_TIMEOUT = 15000;
 
-const TAVILY_COUNTRY_ALIASES: Record<string, string> = {
+const TAVILY_COUNTRY_ALIASES: Partial<Record<string, string>> = {
   ba: 'bosnia and herzegovina',
   cg: 'congo',
   cz: 'czech republic',
@@ -319,7 +319,7 @@ export const createTavilyAPI = (
       if (tavilyCountry != null) {
         payload.country = tavilyCountry;
       }
-      if (type === 'images' || options?.includeImages) {
+      if (type === 'images' || options?.includeImages === true) {
         payload.include_images = true;
       }
       if (options?.includeAnswer != null) {

package/src/tools/search/types.ts

@@ -1,5 +1,5 @@
-import type { Logger as WinstonLogger } from 'winston';
 import type { RunnableConfig } from '@langchain/core/runnables';
+import type { Logger as WinstonLogger } from 'winston';
 import type { BaseReranker } from './rerankers';
 import { DATE_RANGE } from './schema';
 

package/src/tools/search/utils.ts

@@ -1,7 +1,23 @@
 /* eslint-disable no-console */
 
+import { isAxiosError } from 'axios';
+
+import type { AxiosError } from 'axios';
 import type * as t from './types';
 
+const LOG_VALUE_MAX_LENGTH = 2048;
+
+export interface SafeErrorLog {
+  message: string;
+  name?: string;
+  code?: string;
+  status?: number;
+  method?: string;
+  url?: string;
+  responseDataSummary?: string;
+  value?: string;
+}
+
 /**
  * Singleton instance of the default logger
  */
@@ -24,6 +40,83 @@ export const createDefaultLogger = (): t.Logger => {
   return defaultLoggerInstance;
 };
 
+const truncateLogValue = (value: string): string =>
+  value.length <= LOG_VALUE_MAX_LENGTH
+    ? value
+    : `${value.slice(0, LOG_VALUE_MAX_LENGTH)}... [truncated]`;
+
+const summarizeLogValue = (value: unknown): string => {
+  if (value === null) {
+    return 'null';
+  }
+  if (Array.isArray(value)) {
+    return `array(${value.length})`;
+  }
+  if (typeof value === 'string') {
+    return `string(${value.length})`;
+  }
+  if (typeof value === 'object') {
+    return `object(${Object.keys(value).length})`;
+  }
+  return typeof value;
+};
+
+const sanitizeUrlForLog = (url: string): string => {
+  try {
+    const parsed = new URL(url);
+    return truncateLogValue(`${parsed.origin}${parsed.pathname}`);
+  } catch {
+    return truncateLogValue(url.split('?')[0].split('#')[0]);
+  }
+};
+
+const formatAxiosErrorForLog = (
+  error: AxiosError<unknown, unknown>
+): SafeErrorLog => {
+  const log: SafeErrorLog = {
+    message: error.message,
+    name: error.name,
+  };
+  const { code, config, response, status } = error;
+  const responseStatus = response?.status ?? status;
+  const method = config?.method;
+  const url = config?.url;
+
+  if (typeof code === 'string' && code !== '') {
+    log.code = code;
+  }
+  if (responseStatus != null) {
+    log.status = responseStatus;
+  }
+  if (typeof method === 'string' && method !== '') {
+    log.method = method.toUpperCase();
+  }
+  if (typeof url === 'string' && url !== '') {
+    log.url = sanitizeUrlForLog(url);
+  }
+  if (typeof response?.data !== 'undefined') {
+    log.responseDataSummary = summarizeLogValue(response.data);
+  }
+
+  return log;
+};
+
+export const formatErrorForLog = (error: unknown): SafeErrorLog => {
+  if (isAxiosError<unknown, unknown>(error)) {
+    return formatAxiosErrorForLog(error);
+  }
+  if (error instanceof Error) {
+    return {
+      message: error.message,
+      name: error.name,
+    };
+  }
+  return {
+    message: String(error),
+    value: summarizeLogValue(error),
+  };
+};
+
 export const fileExtRegex =
   /\.(pdf|jpe?g|png|gif|svg|webp|bmp|ico|tiff?|avif|heic|doc[xm]?|xls[xm]?|ppt[xm]?|zip|rar|mp[34]|mov|avi|wav)(?:\?.*)?$/i;
 
@@ -33,16 +126,13 @@ export const getDomainName = (
   logger?: t.Logger
 ): string | undefined => {
   try {
-    const sourceUrl = metadata?.sourceURL;
-    const metadataUrl = metadata?.url;
-    const url =
-      typeof sourceUrl === 'string'
-        ? sourceUrl
-        : typeof metadataUrl === 'string'
-          ? metadataUrl
-          : link || '';
+    const sourceUrl =
+      typeof metadata?.sourceURL === 'string' ? metadata.sourceURL : undefined;
+    const metadataUrl =
+      typeof metadata?.url === 'string' ? metadata.url : undefined;
+    const url = sourceUrl ?? metadataUrl ?? link;
     const domain = new URL(url).hostname.replace(/^www\./, '');
-    if (domain) {
+    if (domain !== '') {
       return domain;
     }
   } catch (e) {

package/src/tools/subagent/SubagentExecutor.ts

@@ -1,8 +1,8 @@
 import { nanoid } from 'nanoid';
-import { BaseCallbackHandler } from '@langchain/core/callbacks/base';
 import { HumanMessage } from '@langchain/core/messages';
-import type { BaseMessage } from '@langchain/core/messages';
+import { BaseCallbackHandler } from '@langchain/core/callbacks/base';
 import type { Callbacks } from '@langchain/core/callbacks/manager';
+import type { BaseMessage } from '@langchain/core/messages';
 import type {
   AgentInputs,
   MessageDeltaEvent,
@@ -23,8 +23,8 @@ import type {
 import type { AggregatedHookResult, HookRegistry } from '@/hooks';
 import type { AgentContext } from '@/agents/AgentContext';
 import type { StandardGraph } from '@/graphs/Graph';
-import { GraphEvents, Callback, StepTypes } from '@/common';
 import type { HandlerRegistry } from '@/events';
+import { GraphEvents, Callback, StepTypes } from '@/common';
 import { executeHooks } from '@/hooks';
 
 const DEFAULT_MAX_TURNS = 25;
@@ -797,7 +797,9 @@ function sanitizeToolCallForUpdate(
   return sanitized;
 }
 
-function sanitizeRunStepUpdateData(data: unknown): SanitizedRunStep | undefined {
+function sanitizeRunStepUpdateData(
+  data: unknown
+): SanitizedRunStep | undefined {
   if (!isObjectLike(data)) {
     return undefined;
   }
@@ -879,7 +881,9 @@ function sanitizeReasoningDeltaUpdateData(
   return sanitized;
 }
 
-function sanitizeStepDetails(stepDetails: unknown): SanitizedStepDetails | undefined {
+function sanitizeStepDetails(
+  stepDetails: unknown
+): SanitizedStepDetails | undefined {
   if (!isObjectLike(stepDetails)) {
     return undefined;
   }
@@ -929,7 +933,9 @@ function sanitizeToolCallDelta(
   return sanitized;
 }
 
-function sanitizeStepCompleted(data: unknown): SanitizedStepCompleted | undefined {
+function sanitizeStepCompleted(
+  data: unknown
+): SanitizedStepCompleted | undefined {
   if (!isObjectLike(data)) {
     return undefined;
   }

package/src/types/graph.ts

@@ -1,24 +1,14 @@
 // src/types/graph.ts
-import type { START, StateGraph, StateGraphArgs } from '@langchain/langgraph';
-import type { BindToolsInput } from '@langchain/core/language_models/chat_models';
 import type {
   BaseMessage,
   AIMessageChunk,
   SystemMessage,
 } from '@langchain/core/messages';
+import type { BindToolsInput } from '@langchain/core/language_models/chat_models';
+import type { START, StateGraph, StateGraphArgs } from '@langchain/langgraph';
 import type { RunnableConfig, Runnable } from '@langchain/core/runnables';
 import type { ChatGenerationChunk } from '@langchain/core/outputs';
 import type { GoogleAIToolType } from '@langchain/google-common';
-import type {
-  ToolMap,
-  ToolEndEvent,
-  GenericTool,
-  LCTool,
-  ToolExecuteBatchRequest,
-} from '@/types/tools';
-import type { Providers, Callback, GraphNodeKeys } from '@/common';
-import type { StandardGraph, MultiAgentGraph } from '@/graphs';
-import type { ClientOptions } from '@/types/llm';
 import type {
   SummarizationNodeInput,
   SummarizeCompleteEvent,
@@ -26,12 +16,22 @@ import type {
   SummarizeStartEvent,
   SummarizeDeltaEvent,
 } from '@/types/summarize';
+import type {
+  ToolMap,
+  ToolEndEvent,
+  GenericTool,
+  LCTool,
+  ToolExecuteBatchRequest,
+} from '@/types/tools';
 import type {
   RunStep,
   RunStepDeltaEvent,
   MessageDeltaEvent,
   ReasoningDeltaEvent,
 } from '@/types/stream';
+import type { Providers, Callback, GraphNodeKeys } from '@/common';
+import type { StandardGraph, MultiAgentGraph } from '@/graphs';
+import type { ClientOptions } from '@/types/llm';
 import type { TokenCounter } from '@/types/run';
 
 /** Interface for bound model with stream and invoke methods */
@@ -445,6 +445,14 @@ export interface LangfuseConfig {
   baseUrl?: string;
   toolNodeTracing?: LangfuseToolNodeTracingConfig;
   toolOutputTracing?: LangfuseToolOutputTracingConfig;
+  /**
+   * When true, derive the run's root Langfuse trace id deterministically from
+   * its `runId` (`sha256(runId)` → 32 hex chars, matching `@langfuse/tracing`
+   * `createTraceId`) instead of a random id. This lets external systems attach
+   * scores or observations to the trace afterwards by regenerating the same id
+   * from the run/message id, without a trace lookup. Default: random ids.
+   */
+  deterministicTraceId?: boolean;
 }
 
 export interface AgentInputs {

package/src/types/llm.ts

@@ -1,27 +1,27 @@
 // src/types/llm.ts
 import { ChatMistralAI } from '@langchain/mistralai';
-import type {
-  BindToolsInput,
-  BaseChatModelParams,
-} from '@langchain/core/language_models/chat_models';
 import type {
   OpenAIChatInput,
   ChatOpenAIFields,
   AzureOpenAIInput,
   ClientOptions as OAIClientOptions,
 } from '@langchain/openai';
+import type {
+  BindToolsInput,
+  BaseChatModelParams,
+} from '@langchain/core/language_models/chat_models';
 import type { GoogleGenerativeAIChatInput } from '@langchain/google-genai';
 import type { ChatVertexAIInput } from '@langchain/google-vertexai';
-import type { ChatDeepSeekInput } from '@langchain/deepseek';
-import type { ChatOpenRouterCallOptions } from '@/llm/openrouter';
 import type { ChatBedrockConverseInput } from '@langchain/aws';
 import type { ChatMistralAIInput } from '@langchain/mistralai';
+import type { ChatDeepSeekInput } from '@langchain/deepseek';
 import type { RequestOptions } from '@google/generative-ai';
 import type { StructuredTool } from '@langchain/core/tools';
 import type { AnthropicInput } from '@langchain/anthropic';
 import type { Runnable } from '@langchain/core/runnables';
 import type { OpenAI as OpenAIClient } from 'openai';
 import type { ChatXAIInput } from '@langchain/xai';
+import type { ChatOpenRouterCallOptions } from '@/llm/openrouter';
 import {
   AzureChatOpenAI,
   ChatDeepSeek,
@@ -92,6 +92,7 @@ export type BedrockAnthropicClientOptions = BedrockAnthropicInput;
 export type GoogleClientOptions = GoogleGenerativeAIChatInput & {
   customHeaders?: RequestOptions['customHeaders'];
   thinkingConfig?: GoogleThinkingConfig;
+  includeServerSideToolInvocations?: boolean;
 };
 export type DeepSeekClientOptions = Partial<ChatDeepSeekInput>;
 export type XAIClientOptions = ChatXAIInput;

package/src/types/messages.ts

@@ -1,5 +1,5 @@
-import type Anthropic from '@anthropic-ai/sdk';
 import type { BaseMessage } from '@langchain/core/messages';
+import type Anthropic from '@anthropic-ai/sdk';
 export type AnthropicMessages = Array<AnthropicMessage | BaseMessage>;
 export type AnthropicMessage = Anthropic.MessageParam;
 

package/src/types/run.ts

@@ -1,13 +1,9 @@
 // src/types/run.ts
-import type * as z from 'zod';
+import type { Callbacks } from '@langchain/core/callbacks/manager';
+import type { RunnableConfig } from '@langchain/core/runnables';
 import type { BaseMessage } from '@langchain/core/messages';
 import type { StructuredTool } from '@langchain/core/tools';
-import type { RunnableConfig } from '@langchain/core/runnables';
-import type { Callbacks } from '@langchain/core/callbacks/manager';
-import type * as s from '@/types/stream';
-import type * as e from '@/common/enum';
-import type * as g from '@/types/graph';
-import type * as l from '@/types/llm';
+import type * as z from 'zod';
 import type {
   ToolSessionMap,
   ToolExecutionConfig,
@@ -16,6 +12,10 @@ import type {
 } from '@/types/tools';
 import type { HumanInTheLoopConfig } from '@/types/hitl';
 import type { HookRegistry } from '@/hooks';
+import type * as s from '@/types/stream';
+import type * as e from '@/common/enum';
+import type * as g from '@/types/graph';
+import type * as l from '@/types/llm';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type ZodObjectAny = z.ZodObject<any, any, any, any>;

package/src/types/stream.ts

@@ -1,5 +1,4 @@
 // src/types/stream.ts
-import type OpenAITypes from 'openai';
 import type {
   MessageContentImageUrl,
   MessageContentText,
@@ -8,8 +7,9 @@ import type {
 } from '@langchain/core/messages';
 import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
 import type { LLMResult, Generation } from '@langchain/core/outputs';
-import type { AnthropicContentBlock } from '@/llm/anthropic/types';
 import type { Command } from '@langchain/langgraph';
+import type OpenAITypes from 'openai';
+import type { AnthropicContentBlock } from '@/llm/anthropic/types';
 import type { SummarizeCompleteEvent } from '@/types/summarize';
 import type { ToolEndEvent } from '@/types/tools';
 import { StepTypes, ContentTypes, GraphEvents } from '@/common/enum';