@librechat/agents 2.0.4 → 2.1.0

package/src/specs/reasoning.test.ts

@@ -0,0 +1,165 @@
+/* eslint-disable no-console */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// src/scripts/cli.test.ts
+import { config } from 'dotenv';
+config();
+import { HumanMessage, BaseMessage, MessageContentText } from '@langchain/core/messages';
+import type { RunnableConfig } from '@langchain/core/runnables';
+import type { StandardGraph } from '@/graphs';
+import type * as t from '@/types';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { capitalizeFirstLetter } from './spec.utils';
+import { GraphEvents, Providers } from '@/common';
+import { getLLMConfig } from '@/utils/llmConfig';
+import { getArgs } from '@/scripts/args';
+import { Run } from '@/run';
+
+const reasoningText = `<think>
+Okay, the user is Jo from New York. I should start by greeting them by name. Let's keep it friendly and open-ended. Maybe mention the weather in New York to make it personal. Then offer help with something specific like plans or questions. Need to keep it concise and welcoming. Check for any typos. Alright, that should work.
+</think>
+Hi Jo! 🌆 How's everything in New York today? Whether you need recommendations for the city, help with a task, or just want to chat, I'm here for it. What's on your mind? 😊`;
+
+const provider = 'Reasoning LLM';
+describe(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
+  jest.setTimeout(30000);
+  let run: Run<t.IState>;
+  let contentParts: t.MessageContentComplex[];
+  let conversationHistory: BaseMessage[];
+  let aggregateContent: t.ContentAggregator;
+  let runSteps: Set<string>;
+
+  const config: Partial<RunnableConfig> & { version: 'v1' | 'v2'; run_id?: string; streamMode: string } = {
+    configurable: {
+      thread_id: 'conversation-num-1',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+    callbacks: [{
+      async handleCustomEvent(event, data, metadata): Promise<void> {
+        if (event !== GraphEvents.ON_MESSAGE_DELTA) {
+          return;
+        }
+        const messageDeltaData = data as t.MessageDeltaEvent;
+
+        // Wait until we see the run step (with timeout for safety)
+        const maxAttempts = 50; // 5 seconds total
+        let attempts = 0;
+        while (!runSteps.has(messageDeltaData.id) && attempts < maxAttempts) {
+          await new Promise(resolve => setTimeout(resolve, 100));
+          attempts++;
+        }
+
+        if (!runSteps.has(messageDeltaData.id)) {
+          console.warn(`Timeout waiting for run step: ${messageDeltaData.id}`);
+        }
+
+        onMessageDeltaSpy(event, data, metadata, run.Graph);
+        aggregateContent({ event, data: messageDeltaData });
+      },
+    }],
+  };
+
+  beforeEach(async () => {
+    conversationHistory = [];
+    const { contentParts: parts, aggregateContent: ac } = createContentAggregator();
+    aggregateContent = ac;
+    runSteps = new Set();
+    contentParts = parts as t.MessageContentComplex[];
+  });
+
+  afterEach(() => {
+    runSteps.clear();
+  });
+
+  const onReasoningDeltaSpy = jest.fn();
+  const onMessageDeltaSpy = jest.fn();
+  const onRunStepSpy = jest.fn();
+
+  afterAll(() => {
+    onReasoningDeltaSpy.mockReset();
+    onMessageDeltaSpy.mockReset();
+    onRunStepSpy.mockReset();
+  });
+
+  const setupCustomHandlers = (): Record<string | GraphEvents, t.EventHandler> => ({
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
+      handle: (event: GraphEvents.ON_RUN_STEP_COMPLETED, data: t.StreamEventData): void => {
+        aggregateContent({ event, data: data as unknown as { result: t.ToolEndEvent; } });
+      }
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (event: GraphEvents.ON_RUN_STEP, data: t.StreamEventData, metadata, graph): void => {
+        const runStepData = data as t.RunStep;
+        runSteps.add(runStepData.id);
+
+        onRunStepSpy(event, runStepData, metadata, graph);
+        aggregateContent({ event, data: runStepData });
+      }
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (event: GraphEvents.ON_RUN_STEP_DELTA, data: t.StreamEventData): void => {
+        aggregateContent({ event, data: data as t.RunStepDeltaEvent });
+      }
+    },
+    [GraphEvents.ON_REASONING_DELTA]: {
+      handle: (event: GraphEvents.ON_REASONING_DELTA, data: t.StreamEventData, metadata, graph): void => {
+        onReasoningDeltaSpy(event, data, metadata, graph);
+        aggregateContent({ event, data: data as t.ReasoningDeltaEvent });
+      }
+    },
+  });
+
+  test(`${capitalizeFirstLetter(provider)}: should process a simple reasoning message`, async () => {
+    const { userName, location } = await getArgs();
+    const llmConfig = getLLMConfig(Providers.OPENAI);
+    const customHandlers = setupCustomHandlers();
+
+    run = await Run.create<t.IState>({
+      runId: 'test-run-id',
+      graphConfig: {
+        type: 'standard',
+        llmConfig,
+        instructions: 'You are a friendly AI assistant. Always address the user by their name.',
+        additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
+      },
+      returnContent: true,
+      customHandlers,
+    });
+
+    run.Graph?.overrideTestModel([reasoningText], 2);
+
+    const userMessage = 'hi';
+    conversationHistory.push(new HumanMessage(userMessage));
+
+    const inputs = {
+      messages: conversationHistory,
+    };
+
+    await run.processStream(inputs, config);
+    expect(contentParts).toBeDefined();
+    expect(contentParts.length).toBe(2);
+    const reasoningContent = reasoningText.match(/<think>(.*)<\/think>/s)?.[0];
+    const content = reasoningText.split(/<\/think>/)[1];
+    expect((contentParts[0] as t.ReasoningContentText).think).toBe(reasoningContent);
+    expect((contentParts[1] as MessageContentText).text).toBe(content);
+
+    const finalMessages = run.getRunMessages();
+    expect(finalMessages).toBeDefined();
+    conversationHistory.push(...finalMessages ?? []);
+    expect(conversationHistory.length).toBeGreaterThan(1);
+
+    expect(onMessageDeltaSpy).toHaveBeenCalled();
+    expect(onMessageDeltaSpy.mock.calls.length).toBeGreaterThan(1);
+    expect((onMessageDeltaSpy.mock.calls[0][3] as StandardGraph).provider).toBeDefined();
+
+    expect(onReasoningDeltaSpy).toHaveBeenCalled();
+    expect(onReasoningDeltaSpy.mock.calls.length).toBeGreaterThan(1);
+    expect((onReasoningDeltaSpy.mock.calls[0][3] as StandardGraph).provider).toBeDefined();
+
+    expect(onRunStepSpy).toHaveBeenCalled();
+    expect(onRunStepSpy.mock.calls.length).toBeGreaterThan(0);
+    expect((onRunStepSpy.mock.calls[0][3] as StandardGraph).provider).toBeDefined();
+
+  });
+});

package/src/specs/spec.utils.ts

@@ -0,0 +1,3 @@
+export function capitalizeFirstLetter(string: string): string {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}

package/src/stream.ts

@@ -1,7 +1,7 @@
 // src/stream.ts
 import { nanoid } from 'nanoid';
 import type { AIMessageChunk } from '@langchain/core/messages';
-import type { ToolCall } from '@langchain/core/messages/tool';
+import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
 import type { Graph } from '@/graphs';
 import type * as t from '@/types';
 import { StepTypes, ContentTypes, GraphEvents, ToolCallTypes } from '@/common';
@@ -83,6 +83,7 @@ export const handleToolCalls = (toolCalls?: ToolCall[], metadata?: Record<string
     /* If the previous step exists and is a message creation */
   if (prevStepId && prevRunStep && prevRunStep.type === StepTypes.MESSAGE_CREATION) {
     dispatchToolCallIds(prevStepId);
+    graph.messageStepHasToolCalls.set(prevStepId, true);
     /* If the previous step doesn't exist or is not a message creation */
   } else if (!prevRunStep || prevRunStep.type !== StepTypes.MESSAGE_CREATION) {
     const messageId = getMessageId(stepKey, graph, true) ?? '';
@@ -93,6 +94,7 @@ export const handleToolCalls = (toolCalls?: ToolCall[], metadata?: Record<string
       },
     });
     dispatchToolCallIds(stepId);
+    graph.messageStepHasToolCalls.set(prevStepId, true);
   }
   graph.dispatchRunStep(stepKey, {
     type: StepTypes.TOOL_CALLS,
@@ -105,27 +107,25 @@ export class ChatModelStreamHandler implements t.EventHandler {
     if (!graph) {
       throw new Error('Graph not found');
     }
-
-    const chunk = data.chunk as AIMessageChunk | undefined;
-    const content = chunk?.content;
-
     if (!graph.config) {
       throw new Error('Config not found in graph');
     }
-
-    if (!chunk) {
+    if (!data.chunk) {
       console.warn(`No chunk found in ${event} event`);
       return;
     }
 
-    let hasToolCalls = false;
-    const hasToolCallChunks = (chunk.tool_call_chunks && chunk.tool_call_chunks.length > 0) ?? false;
+    const chunk = data.chunk as Partial<AIMessageChunk>;
+    const content = (chunk.additional_kwargs?.[graph.reasoningKey] as string | undefined) ?? chunk.content;
+    this.handleReasoning(chunk, graph);
 
+    let hasToolCalls = false;
     if (chunk.tool_calls && chunk.tool_calls.length > 0 && chunk.tool_calls.every((tc) => tc.id)) {
       hasToolCalls = true;
       handleToolCalls(chunk.tool_calls, metadata, graph);
     }
 
+    const hasToolCallChunks = (chunk.tool_call_chunks && chunk.tool_call_chunks.length > 0) ?? false;
     const isEmptyContent = typeof content === 'undefined' || !content.length || typeof content === 'string' && !content;
     const isEmptyChunk = isEmptyContent && !hasToolCallChunks;
     const chunkId = chunk.id ?? '';
@@ -149,13 +149,7 @@ export class ChatModelStreamHandler implements t.EventHandler {
       && chunk.tool_call_chunks
       && chunk.tool_call_chunks.length
       && typeof chunk.tool_call_chunks[0]?.index === 'number') {
-      const prevStepId = graph.getStepIdByKey(stepKey, graph.contentData.length - 1);
-      const prevRunStep = graph.getRunStep(prevStepId);
-      const stepId = graph.getStepIdByKey(stepKey, prevRunStep?.index);
-      graph.dispatchRunStepDelta(stepId, {
-        type: StepTypes.TOOL_CALLS,
-        tool_calls: chunk.tool_call_chunks,
-      });
+      this.handleToolCallChunks({ graph, stepKey, toolCallChunks: chunk.tool_call_chunks });
     }
 
     if (isEmptyContent) {
@@ -200,32 +194,106 @@ hasToolCallChunks: ${hasToolCallChunks}
     } else if (hasToolCallChunks && (chunk.tool_call_chunks?.some((tc) => tc.args === content) ?? false)) {
       return;
     } else if (typeof content === 'string') {
+      if (graph.currentTokenType === ContentTypes.TEXT) {
+        graph.dispatchMessageDelta(stepId, {
+          content: [{
+            type: ContentTypes.TEXT,
+            text: content,
+          }],
+        });
+      } else {
+        graph.dispatchReasoningDelta(stepId, {
+          content: [{
+            type: ContentTypes.THINK,
+            think: content,
+          }],
+        });
+      }
+    } else if (content.every((c) => c.type?.startsWith(ContentTypes.TEXT))) {
       graph.dispatchMessageDelta(stepId, {
+        content,
+      });
+    }
+  }
+  handleToolCallChunks = ({
+    graph,
+    stepKey,
+    toolCallChunks,
+  }: {
+    graph: Graph;
+    stepKey: string;
+    toolCallChunks: ToolCallChunk[],
+  }): void => {
+    const prevStepId = graph.getStepIdByKey(stepKey, graph.contentData.length - 1);
+    const prevRunStep = graph.getRunStep(prevStepId);
+    const _stepId = graph.getStepIdByKey(stepKey, prevRunStep?.index);
+    /** Edge Case: Tool Call Run Step or `tool_call_ids` never dispatched */
+    const tool_calls: ToolCall[] | undefined =
+    prevStepId && prevRunStep && prevRunStep.type === StepTypes.MESSAGE_CREATION
+      ? []
+      : undefined;
+    /** Edge Case: `id` and `name` fields cannot be empty strings */
+    for (const toolCallChunk of toolCallChunks) {
+      if (toolCallChunk.name === '') {
+        toolCallChunk.name = undefined;
+      }
+      if (toolCallChunk.id === '') {
+        toolCallChunk.id = undefined;
+      } else if (tool_calls != null && toolCallChunk.id != null && toolCallChunk.name != null) {
+        tool_calls.push({
+          args: {},
+          id: toolCallChunk.id,
+          name: toolCallChunk.name,
+          type: ToolCallTypes.TOOL_CALL,
+        });
+      }
+    }
+
+    let stepId: string = _stepId;
+    const alreadyDispatched = prevRunStep?.type === StepTypes.MESSAGE_CREATION && graph.messageStepHasToolCalls.has(prevStepId);
+    if (!alreadyDispatched && tool_calls?.length === toolCallChunks.length) {
+      graph.dispatchMessageDelta(prevStepId, {
         content: [{
-          type: 'text',
-          text: content,
+          type: ContentTypes.TEXT,
+          text: '',
+          tool_call_ids: tool_calls.map((tc) => tc.id ?? ''),
         }],
       });
-    } else if (content.every((c) => c.type?.startsWith('text'))) {
-      graph.dispatchMessageDelta(stepId, {
-        content,
+      graph.messageStepHasToolCalls.set(prevStepId, true);
+      stepId = graph.dispatchRunStep(stepKey, {
+        type: StepTypes.TOOL_CALLS,
+        tool_calls,
       });
     }
+    graph.dispatchRunStepDelta(stepId, {
+      type: StepTypes.TOOL_CALLS,
+      tool_calls: toolCallChunks,
+    });
+  };
+  handleReasoning(chunk: Partial<AIMessageChunk>, graph: Graph): void {
+    const reasoning_content = chunk.additional_kwargs?.[graph.reasoningKey] as string | undefined;
+    if (reasoning_content != null && reasoning_content && (chunk.content == null || chunk.content === '')) {
+      graph.currentTokenType = ContentTypes.THINK;
+      graph.tokenTypeSwitch = 'reasoning';
+      return;
+    } else if (graph.tokenTypeSwitch === 'reasoning' && graph.currentTokenType !== ContentTypes.TEXT && chunk.content != null && chunk.content !== '') {
+      graph.currentTokenType = ContentTypes.TEXT;
+      graph.tokenTypeSwitch = 'content';
+    } else if (chunk.content != null && typeof chunk.content === 'string' && chunk.content.includes('<think>')) {
+      graph.currentTokenType = ContentTypes.THINK;
+      graph.tokenTypeSwitch = 'content';
+    } else if (graph.lastToken != null && graph.lastToken.includes('</think>')) {
+      graph.currentTokenType = ContentTypes.TEXT;
+      graph.tokenTypeSwitch = 'content';
+    }
+    if (typeof chunk.content !== 'string') {
+      return;
+    }
+    graph.lastToken = chunk.content;
   }
 }
 
-export type ContentAggregatorResult = {
-  stepMap: Map<string, t.RunStep | undefined>;
-  contentParts: Array<t.MessageContentComplex | undefined>;
-  aggregateContent: ({ event, data }: {
-    event: GraphEvents;
-    data: t.RunStep | t.MessageDeltaEvent | t.RunStepDeltaEvent | {
-        result: t.ToolEndEvent;
-    };
-}) => void
-};
-
-export function createContentAggregator(): ContentAggregatorResult {
+export function createContentAggregator(): t.ContentAggregatorResult {
   const contentParts: Array<t.MessageContentComplex | undefined> = [];
   const stepMap = new Map<string, t.RunStep>();
   const toolCallIdMap = new Map<string, string>();
@@ -349,7 +417,7 @@ export function createContentAggregator(): ContentAggregatorResult {
       const reasoningDelta = data as t.ReasoningDeltaEvent;
       const runStep = stepMap.get(reasoningDelta.id);
       if (!runStep) {
-        console.warn('No run step or runId found for message delta event');
+        console.warn('No run step or runId found for reasoning delta event');
         return;
       }
 
@@ -374,13 +442,13 @@ export function createContentAggregator(): ContentAggregatorResult {
       ) {
 
         runStepDelta.delta.tool_calls.forEach((toolCallDelta) => {
-          const toolCallId = toolCallIdMap.get(runStepDelta.id) ?? '';
+          const toolCallId = toolCallIdMap.get(runStepDelta.id);
 
           const contentPart: t.MessageContentComplex = {
             type: ContentTypes.TOOL_CALL,
             tool_call: {
-              name: toolCallDelta.name ?? '',
               args: toolCallDelta.args ?? '',
+              name: toolCallDelta.name,
               id: toolCallId,
             },
           };

package/src/tools/CodeExecutor.ts

@@ -1,5 +1,7 @@
 import { z } from 'zod';
 import { config } from 'dotenv';
+import fetch, { RequestInit } from 'node-fetch';
+import { HttpsProxyAgent } from 'https-proxy-agent';
 import { tool, DynamicStructuredTool } from '@langchain/core/tools';
 import { getEnvironmentVariable } from '@langchain/core/utils/env';
 import type * as t from '@/types';
@@ -71,7 +73,7 @@ Usage:
       };
 
       try {
-        const response = await fetch(EXEC_ENDPOINT, {
+        const fetchOptions: RequestInit = {
           method: 'POST',
           headers: {
             'Content-Type': 'application/json',
@@ -79,8 +81,12 @@ Usage:
             'X-API-Key': apiKey,
           },
           body: JSON.stringify(postData),
-        });
+        };
 
+        if (process.env.PROXY != null && process.env.PROXY !== '') {
+          fetchOptions.agent = new HttpsProxyAgent(process.env.PROXY);
+        }
+        const response = await fetch(EXEC_ENDPOINT, fetchOptions);
         if (!response.ok) {
           throw new Error(`HTTP error! status: ${response.status}`);
         }

package/src/types/llm.ts

@@ -1,5 +1,6 @@
 // src/types/llm.ts
 import { ChatOllama } from '@langchain/ollama';
+import { ChatDeepSeek } from '@langchain/deepseek';
 import { ChatAnthropic } from '@langchain/anthropic';
 import { ChatMistralAI } from '@langchain/mistralai';
 import { ChatBedrockConverse } from '@langchain/aws';
@@ -12,6 +13,7 @@ import type { ChatOpenAIFields, OpenAIChatInput, AzureOpenAIInput } from '@langc
 import type { BedrockChatFields } from '@langchain/community/chat_models/bedrock/web';
 import type { GoogleGenerativeAIChatInput } from '@langchain/google-genai';
 import type { ChatVertexAIInput } from '@langchain/google-vertexai';
+import type { ChatDeepSeekCallOptions } from '@langchain/deepseek';
 import type { ChatBedrockConverseInput } from '@langchain/aws';
 import type { ChatMistralAIInput } from '@langchain/mistralai';
 import type { StructuredTool } from '@langchain/core/tools';
@@ -41,32 +43,35 @@ export type VertexAIClientOptions = ChatVertexAIInput;
 export type BedrockClientOptions = BedrockChatFields;
 export type BedrockConverseClientOptions = ChatBedrockConverseInput;
 export type GoogleClientOptions = GoogleGenerativeAIChatInput;
+export type DeepSeekClientOptions = ChatDeepSeekCallOptions;
 
-export type ClientOptions = OpenAIClientOptions | AzureClientOptions | OllamaClientOptions | AnthropicClientOptions | MistralAIClientOptions | VertexAIClientOptions | BedrockClientOptions | BedrockConverseClientOptions | GoogleClientOptions;
+export type ClientOptions = OpenAIClientOptions | AzureClientOptions | OllamaClientOptions | AnthropicClientOptions | MistralAIClientOptions | VertexAIClientOptions | BedrockClientOptions | BedrockConverseClientOptions | GoogleClientOptions | DeepSeekClientOptions;
 
 export type LLMConfig = {
   provider: Providers;
 } & ClientOptions;
 
 export type ProviderOptionsMap = {
-  [Providers.OPENAI]: OpenAIClientOptions;
   [Providers.AZURE]: AzureClientOptions;
+  [Providers.OPENAI]: OpenAIClientOptions;
   [Providers.OLLAMA]: OllamaClientOptions;
+  [Providers.GOOGLE]: GoogleClientOptions;
+  [Providers.VERTEXAI]: VertexAIClientOptions;
+  [Providers.DEEPSEEK]: DeepSeekClientOptions;
   [Providers.ANTHROPIC]: AnthropicClientOptions;
   [Providers.MISTRALAI]: MistralAIClientOptions;
-  [Providers.VERTEXAI]: VertexAIClientOptions;
   [Providers.BEDROCK_LEGACY]: BedrockClientOptions;
   [Providers.BEDROCK]: BedrockConverseClientOptions;
-  [Providers.GOOGLE]: GoogleClientOptions;
 };
 
 export type ChatModelMap = {
   [Providers.OPENAI]: ChatOpenAI;
   [Providers.OLLAMA]: ChatOllama;
   [Providers.AZURE]: AzureChatOpenAI;
+  [Providers.DEEPSEEK]: ChatDeepSeek;
+  [Providers.VERTEXAI]: ChatVertexAI;
   [Providers.ANTHROPIC]: ChatAnthropic;
   [Providers.MISTRALAI]: ChatMistralAI;
-  [Providers.VERTEXAI]: ChatVertexAI;
   [Providers.BEDROCK_LEGACY]: BedrockChat;
   [Providers.BEDROCK]: ChatBedrockConverse;
   [Providers.GOOGLE]: ChatGoogleGenerativeAI;

package/src/types/stream.ts

@@ -3,6 +3,7 @@ import type OpenAITypes from 'openai';
 import type { MessageContentImageUrl, MessageContentText, ToolMessage, BaseMessage } from '@langchain/core/messages';
 import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
 import type { LLMResult, Generation } from '@langchain/core/outputs';
+import type { ToolEndEvent } from '@/types/tools';
 import { StepTypes, ContentTypes, GraphEvents } from '@/common/enum';
 
 export type HandleLLMEnd = (output: LLMResult, runId: string, parentRunId?: string, tags?: string[]) => void;
@@ -239,4 +240,16 @@ export type SplitStreamHandlers = Partial<{
   [GraphEvents.ON_RUN_STEP]: ({ event, data}: { event: GraphEvents, data: RunStep }) => void;
   [GraphEvents.ON_MESSAGE_DELTA]: ({ event, data}: { event: GraphEvents, data: MessageDeltaEvent }) => void;
   [GraphEvents.ON_REASONING_DELTA]: ({ event, data}: { event: GraphEvents, data: ReasoningDeltaEvent }) => void;
-}>
+}>
+
+export type ContentAggregator = ({ event, data }: {
+  event: GraphEvents;
+  data: RunStep | MessageDeltaEvent | RunStepDeltaEvent | {
+      result: ToolEndEvent;
+  };
+}) => void;
+export type ContentAggregatorResult = {
+  stepMap: Map<string, RunStep | undefined>;
+  contentParts: Array<MessageContentComplex | undefined>;
+  aggregateContent: ContentAggregator;
+};

package/src/utils/llmConfig.ts

@@ -5,12 +5,22 @@ import type * as t from '@/types';
 export const llmConfigs: Record<string, t.LLMConfig | undefined> = {
   [Providers.OPENAI]: {
     provider: Providers.OPENAI,
-    model: 'gpt-4o',
+    model: 'gpt-4o-mini',
     temperature: 0.7,
     streaming: true,
     streamUsage: true,
     // disableStreaming: true,
   },
+  alibaba: {
+    provider: Providers.OPENAI,
+    streaming: true,
+    streamUsage: true,
+    model: 'qwen-max',
+    openAIApiKey: process.env.ALIBABA_API_KEY,
+    configuration: {
+      baseURL: 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1',
+    },
+  },
   [Providers.AZURE]: {
     provider: Providers.AZURE,
     temperature: 0.7,
@@ -29,6 +39,12 @@ export const llmConfigs: Record<string, t.LLMConfig | undefined> = {
     streamUsage: true,
     baseUrl: 'http://host.docker.internal:11434'
   },
+  [Providers.DEEPSEEK]: {
+    provider: Providers.DEEPSEEK,
+    model: 'deepseek-reasoner',
+    streaming: true,
+    streamUsage: true,
+  },
   [Providers.ANTHROPIC]: {
     provider: Providers.ANTHROPIC,
     model: 'claude-3-5-sonnet-20240620',