@agentscope-ai/agentscope 0.0.2

package/src/model/deepseek-model.test.ts

@@ -0,0 +1,279 @@
+import { DeepSeekChatModel } from './deepseek-model';
+import { ChatResponse } from './response';
+import { createMsg } from '../message';
+
+// Mock fetch for streaming responses
+global.fetch = jest.fn();
+
+describe('DeepSeekChatModel', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    test('Test stream generation with delta output', async () => {
+        // Mock streaming response with multiple chunks (SSE format)
+        // DeepSeek uses OpenAI-compatible API format
+        const mockStreamChunks = [
+            'data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1234567890,"model":"deepseek-reasoner","choices":[{"index":0,"delta":{"reasoning_content":"Analyzing the"},"finish_reason":null}]}\n\n',
+            'data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1234567890,"model":"deepseek-reasoner","choices":[{"index":0,"delta":{"reasoning_content":" weather query"},"finish_reason":null}]}\n\n',
+            'data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1234567890,"model":"deepseek-reasoner","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"id":"call-123","type":"function","function":{"name":"get_current_weather","arguments":"{\\"location\\""}}]},"finish_reason":null}]}\n\n',
+            'data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1234567890,"model":"deepseek-reasoner","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":":\\"Beijing\\"}"}}]},"finish_reason":null}]}\n\n',
+            'data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1234567890,"model":"deepseek-reasoner","choices":[{"index":0,"delta":{},"finish_reason":"tool_calls"}],"usage":{"prompt_tokens":100,"completion_tokens":50,"total_tokens":150}}\n\n',
+            'data: [DONE]\n\n',
+        ];
+
+        const mockReadableStream = new ReadableStream({
+            start(controller) {
+                mockStreamChunks.forEach(chunk =>
+                    controller.enqueue(new TextEncoder().encode(chunk))
+                );
+                controller.close();
+            },
+        });
+
+        (global.fetch as jest.Mock).mockResolvedValue({
+            ok: true,
+            body: mockReadableStream,
+        });
+
+        const model = new DeepSeekChatModel({
+            modelName: 'deepseek-reasoner',
+            apiKey: 'test-api-key',
+        });
+
+        const res = await model.call({
+            messages: [
+                createMsg({
+                    name: 'user',
+                    role: 'user',
+                    content: [{ id: crypto.randomUUID(), type: 'text', text: '查询北京天气' }],
+                }),
+            ],
+            tools: [
+                {
+                    type: 'function',
+                    function: {
+                        name: 'get_current_weather',
+                        description: 'Get the current weather in a given location',
+                        parameters: {
+                            type: 'object',
+                            properties: {
+                                location: {
+                                    type: 'string',
+                                    description: 'The city and state, e.g. San Francisco, CA',
+                                },
+                            },
+                            required: ['location'],
+                        },
+                    },
+                },
+            ],
+        });
+
+        const generator = res as AsyncGenerator<ChatResponse, ChatResponse>;
+        let completeResponse: ChatResponse | undefined;
+        const yieldedChunks: ChatResponse[] = [];
+
+        // Manual iteration to capture both yielded and returned values
+        while (true) {
+            const result = await generator.next();
+            if (result.done) {
+                completeResponse = result.value;
+                break;
+            }
+            yieldedChunks.push(result.value);
+        }
+
+        // Verify we received multiple yielded chunks
+        expect(yieldedChunks.length).toBeGreaterThan(0);
+
+        // Verify the final complete response has correct structure
+        expect(completeResponse.content.length).toBe(2);
+
+        // Check thinking block - should be complete after accumulation
+        const thinkingBlock = completeResponse.content.find(b => b.type === 'thinking');
+        expect(thinkingBlock).toBeDefined();
+        expect(thinkingBlock).toMatchObject({
+            type: 'thinking',
+            thinking: 'Analyzing the weather query',
+        });
+
+        // Check tool_call block - input should be complete after accumulation
+        const toolCallBlock = completeResponse.content.find(b => b.type === 'tool_call');
+        expect(toolCallBlock).toBeDefined();
+        expect(toolCallBlock).toMatchObject({
+            type: 'tool_call',
+            name: 'get_current_weather',
+            id: 'call-123',
+            input: '{"location":"Beijing"}',
+        });
+
+        // Verify usage
+        expect(completeResponse.usage).toBeDefined();
+        expect(completeResponse.usage?.inputTokens).toBe(100);
+        expect(completeResponse.usage?.outputTokens).toBe(50);
+    }, 10000);
+
+    test('Test non-streaming generation', async () => {
+        // Mock non-streaming response
+        const mockResponse = {
+            id: 'chatcmpl-123',
+            object: 'chat.completion',
+            created: 1234567890,
+            model: 'deepseek-reasoner',
+            choices: [
+                {
+                    index: 0,
+                    message: {
+                        role: 'assistant',
+                        reasoning_content: 'Analyzing the weather query',
+                        tool_calls: [
+                            {
+                                id: 'call-123',
+                                type: 'function',
+                                function: {
+                                    name: 'get_current_weather',
+                                    arguments: '{"location":"Beijing"}',
+                                },
+                            },
+                        ],
+                    },
+                    finish_reason: 'tool_calls',
+                },
+            ],
+            usage: {
+                prompt_tokens: 100,
+                completion_tokens: 50,
+                total_tokens: 150,
+            },
+        };
+
+        (global.fetch as jest.Mock).mockResolvedValue({
+            ok: true,
+            json: async () => mockResponse,
+        });
+
+        const model = new DeepSeekChatModel({
+            modelName: 'deepseek-reasoner',
+            apiKey: 'test-api-key',
+            stream: false,
+        });
+
+        const res = await model.call({
+            messages: [
+                createMsg({
+                    name: 'user',
+                    role: 'user',
+                    content: [{ id: crypto.randomUUID(), type: 'text', text: '查询北京天气' }],
+                }),
+            ],
+            tools: [
+                {
+                    type: 'function',
+                    function: {
+                        name: 'get_current_weather',
+                        description: 'Get the current weather in a given location',
+                        parameters: {
+                            type: 'object',
+                            properties: {
+                                location: {
+                                    type: 'string',
+                                    description: 'The city and state, e.g. San Francisco, CA',
+                                },
+                            },
+                            required: ['location'],
+                        },
+                    },
+                },
+            ],
+        });
+
+        const completeResponse = res as ChatResponse;
+
+        // Verify complete response structure
+        expect(completeResponse.content.length).toBe(2);
+
+        // Check thinking block
+        const thinkingBlock = completeResponse.content.find(b => b.type === 'thinking');
+        expect(thinkingBlock).toBeDefined();
+        expect(thinkingBlock).toMatchObject({
+            type: 'thinking',
+            thinking: 'Analyzing the weather query',
+        });
+
+        // Check tool_call block
+        const toolCallBlock = completeResponse.content.find(b => b.type === 'tool_call');
+        expect(toolCallBlock).toBeDefined();
+        expect(toolCallBlock).toMatchObject({
+            type: 'tool_call',
+            name: 'get_current_weather',
+            id: 'call-123',
+            input: '{"location":"Beijing"}',
+        });
+
+        // Verify usage
+        expect(completeResponse.usage).toBeDefined();
+        expect(completeResponse.usage?.inputTokens).toBe(100);
+        expect(completeResponse.usage?.outputTokens).toBe(50);
+    }, 10000);
+
+    test('Test formatToolChoice function', () => {
+        const model = new DeepSeekChatModel({
+            modelName: 'deepseek-chat',
+            apiKey: 'test-api-key',
+        });
+
+        // Test 'auto' case
+        expect(model._formatToolChoice('auto')).toBe('auto');
+
+        // Test 'none' case
+        expect(model._formatToolChoice('none')).toBe('none');
+
+        // Test 'required' case
+        expect(model._formatToolChoice('required')).toBe('required');
+
+        // Test specific function name case
+        expect(model._formatToolChoice('get_current_weather')).toEqual({
+            type: 'function',
+            function: {
+                name: 'get_current_weather',
+            },
+        });
+
+        // Test undefined case (should default to 'auto')
+        expect(model._formatToolChoice(undefined)).toBe('auto');
+    });
+
+    test('Test formatToolSchemas function', () => {
+        const model = new DeepSeekChatModel({
+            modelName: 'deepseek-chat',
+            apiKey: 'test-api-key',
+        });
+
+        const toolSchemas = [
+            {
+                type: 'function' as const,
+                function: {
+                    name: 'get_current_weather',
+                    description: 'Get the current weather in a given location',
+                    parameters: {
+                        type: 'object' as const,
+                        properties: {
+                            location: {
+                                type: 'string',
+                                description: 'The city and state, e.g. San Francisco, CA',
+                            },
+                        },
+                        required: ['location'],
+                    },
+                },
+            },
+        ];
+
+        // Test with tool schemas
+        expect(model._formatToolSchemas(toolSchemas)).toEqual(toolSchemas);
+
+        // Test with undefined (should return empty array)
+        expect(model._formatToolSchemas(undefined)).toEqual([]);
+    });
+});

package/src/model/deepseek-model.ts

@@ -0,0 +1,401 @@
+import { ChatModelBase, ChatModelOptions, ChatModelRequestOptions } from './base';
+import { ChatResponse } from './response';
+import { DataBlock, TextBlock, ThinkingBlock, ToolCallBlock } from '../message';
+import { ToolChoice, ToolSchema } from '../type';
+import { ChatUsage } from './usage';
+import { _parseStreamedResponse } from '../_utils';
+import { DeepSeekChatFormatter } from '../formatter';
+
+interface _DeepSeekStreamChunk {
+    choices?: {
+        delta?: {
+            content?: string;
+            reasoning_content?: string;
+            tool_calls?: {
+                index: number;
+                id?: string;
+                function?: {
+                    name?: string;
+                    arguments?: string;
+                };
+            }[];
+        };
+        finish_reason?: string | null;
+    }[];
+    usage?: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+    };
+}
+
+interface DeepSeekThinkingConfig {
+    /**
+     * Whether to enable thinking or not.
+     */
+    enableThinking: boolean;
+}
+
+interface DeepSeekChatModelOptions extends ChatModelOptions {
+    /**
+     * The API key for authenticating with DeepSeek API.
+     */
+    apiKey: string;
+
+    /**
+     * Thinking configuration for DeepSeek models.
+     */
+    thinkingConfig?: DeepSeekThinkingConfig;
+
+    /**
+     * Preset generation parameters to include in each request.
+     * These parameters will be merged with the request-specific parameters.
+     */
+    presetGenParams?: Record<string, unknown>;
+
+    /**
+     * Preset headers that will be included in each request.
+     */
+    presetHeaders?: Record<string, unknown>;
+}
+
+/**
+ * The DeepSeek API chat model.
+ */
+export class DeepSeekChatModel extends ChatModelBase {
+    apiURL: string;
+    protected apiKey: string;
+    protected presetGenParams: Record<string, unknown> | undefined;
+    protected presetHeaders: Record<string, unknown> | undefined;
+    protected thinkingConfig: DeepSeekThinkingConfig;
+
+    /**
+     * Initializes a new instance of the DeepSeekChatModel class.
+     *
+     * @param options - The DeepSeek chat model options.
+     * @param options.modelName - The name of the model to use.
+     * @param options.apiKey - The API key for authentication.
+     * @param options.stream - Whether to use streaming responses. Default is true.
+     * @param options.thinkingConfig - Thinking configuration.
+     * @param options.maxRetries - The maximum number of retries for failed requests. Default is 0.
+     * @param options.fallbackModelName - The fallback model name to use if the primary model fails.
+     * @param options.presetGenParams - Preset generation parameters to include in each request.
+     * @param options.presetHeaders - Preset headers that will be included in each request.
+     * @param options.formatter
+     */
+    constructor({
+        modelName,
+        apiKey,
+        stream = true,
+        thinkingConfig,
+        maxRetries = 0,
+        fallbackModelName,
+        presetGenParams,
+        presetHeaders,
+        formatter,
+    }: DeepSeekChatModelOptions) {
+        // If no formatter is provided, create a default DeepSeekChatFormatter
+        const defaultFormatter = formatter || new DeepSeekChatFormatter();
+        super({
+            modelName,
+            stream,
+            maxRetries,
+            fallbackModelName,
+            formatter: defaultFormatter,
+        } as ChatModelOptions);
+
+        this.apiKey = apiKey;
+        this.thinkingConfig = thinkingConfig || { enableThinking: false };
+        this.presetGenParams = presetGenParams;
+        this.presetHeaders = presetHeaders;
+        this.apiURL = 'https://api.deepseek.com/chat/completions';
+    }
+
+    /**
+     * Calls the DeepSeek API with the given parameters.
+     *
+     * @param modelName - The name of the model to use.
+     * @param options - The chat model options.
+     * @returns A promise that resolves to either a ChatResponse or an AsyncGenerator of ChatResponses.
+     */
+    async _callAPI(
+        modelName: string,
+        options: ChatModelRequestOptions<Record<string, unknown>>
+    ): Promise<ChatResponse | AsyncGenerator<ChatResponse, ChatResponse>> {
+        // Set up request data
+        const data = {
+            model: modelName,
+            messages: options.messages,
+            tools: this._formatToolSchemas(options.tools),
+            tool_choice: this._formatToolChoice(options.toolChoice),
+            thinking: this.thinkingConfig.enableThinking
+                ? { type: 'enabled' }
+                : { type: 'disabled' },
+            stream: this.stream,
+            ...(this.presetGenParams ?? {}),
+        } as Record<string, unknown>;
+
+        // Set up headers
+        const headers: Record<string, unknown> = {
+            Authorization: `Bearer ${this.apiKey}`,
+            'Content-Type': 'application/json',
+            ...this.presetHeaders,
+        };
+
+        // Counting the time cost
+        const startTime = Date.now();
+        const response = await fetch(this.apiURL, {
+            method: 'POST',
+            headers: headers as HeadersInit,
+            body: JSON.stringify(data),
+        });
+
+        if (!response.ok) {
+            throw new Error(
+                `DeepSeek API request failed with status ${response.status}: ${await response.text()}`
+            );
+        }
+
+        if (this.stream) {
+            // Handle the streaming response
+            return this._parseDeepSeekStreamedResponse(response, startTime);
+        }
+
+        // Handle the non-streaming response
+        const blocks: Array<TextBlock | ToolCallBlock | ThinkingBlock | DataBlock> = [];
+        const res = await response.json();
+        const choice = res.choices[0];
+
+        if (choice.message.reasoning_content) {
+            blocks.push({
+                id: crypto.randomUUID(),
+                type: 'thinking',
+                thinking: choice.message.reasoning_content,
+            });
+        }
+        if (choice.message.content) {
+            blocks.push({ id: crypto.randomUUID(), type: 'text', text: choice.message.content });
+        }
+        if (choice.message.tool_calls && Array.isArray(choice.message.tool_calls)) {
+            choice.message.tool_calls.forEach((toolCall: object) => {
+                if (
+                    'id' in toolCall &&
+                    'function' in toolCall &&
+                    typeof toolCall.function === 'object' &&
+                    toolCall.function &&
+                    'name' in toolCall.function &&
+                    'arguments' in toolCall.function
+                ) {
+                    const inputString = String(toolCall.function.arguments);
+                    blocks.push({
+                        type: 'tool_call',
+                        id: String(toolCall.id),
+                        name: String(toolCall.function.name),
+                        input: inputString,
+                    });
+                }
+            });
+        }
+
+        const usage = res.usage
+            ? {
+                  type: 'chat_usage',
+                  inputTokens: res.usage.prompt_tokens || 0,
+                  outputTokens: res.usage.completion_tokens || 0,
+                  time: (Date.now() - startTime) / 1000,
+              }
+            : undefined;
+
+        return {
+            type: 'chat',
+            id: crypto.randomUUID(),
+            createdAt: new Date().toISOString(),
+            content: blocks,
+            usage,
+        } as ChatResponse;
+    }
+
+    /**
+     * The method to format the tool choice parameter.
+     *
+     * @param toolChoice - The tool choice option.
+     * @returns The formatted tool choice.
+     */
+    _formatToolChoice(
+        toolChoice?: ToolChoice
+    ): 'auto' | 'none' | 'required' | Record<string, unknown> {
+        if (toolChoice) {
+            if (toolChoice === 'auto') return 'auto';
+            if (toolChoice === 'none') return 'none';
+            if (this.thinkingConfig?.enableThinking) {
+                console.log(
+                    `The deepseek reasoning model does not support tool choice options '${toolChoice}'. 'auto' will be used instead.`
+                );
+                return 'auto';
+            }
+            if (toolChoice === 'required') return 'required';
+            return {
+                type: 'function',
+                function: {
+                    name: toolChoice,
+                },
+            };
+        }
+        return 'auto';
+    }
+
+    /**
+     * Parses a streamed response from DeepSeek API specifically for chat responses.
+     * An async generator that yields delta ChatResponse objects as they are received.
+     *
+     * @param response - The fetch response object.
+     * @param startTime - The start time of the request for usage calculation.
+     * @returns An async generator yielding delta ChatResponse objects, and returns the complete ChatResponse.
+     */
+    async *_parseDeepSeekStreamedResponse(
+        response: Response,
+        startTime: number
+    ): AsyncGenerator<ChatResponse, ChatResponse> {
+        const asyncGenerator = _parseStreamedResponse<_DeepSeekStreamChunk>(response);
+
+        let accText: string = '';
+        let accThinking: string = '';
+        // Store accumulated input strings for each tool call
+        const accToolInputs: Map<string, string> = new Map();
+        // Store tool call metadata (id, name)
+        const toolCallMeta: Map<string, { id: string; name: string }> = new Map();
+        let lastUsage: ChatUsage | undefined = undefined;
+
+        for await (const jsonObj of asyncGenerator) {
+            if (jsonObj.choices && jsonObj.choices.length > 0) {
+                const choice = jsonObj.choices[0];
+
+                // Delta data for this chunk
+                let deltaText: string = '';
+                let deltaThinking: string = '';
+                const deltaToolCalls: Map<string, ToolCallBlock> = new Map();
+
+                if (choice.delta?.content) {
+                    deltaText = choice.delta.content;
+                    accText += deltaText;
+                }
+                if (choice.delta?.reasoning_content) {
+                    deltaThinking = choice.delta.reasoning_content;
+                    accThinking += deltaThinking;
+                }
+                if (choice.delta?.tool_calls) {
+                    choice.delta.tool_calls.forEach(toolCall => {
+                        const index = toolCall.index.toString();
+
+                        // Initialize metadata if not exists
+                        if (!toolCallMeta.has(index)) {
+                            toolCallMeta.set(index, { id: '', name: '' });
+                        }
+                        if (!accToolInputs.has(index)) {
+                            accToolInputs.set(index, '');
+                        }
+
+                        // Update the tool use id
+                        if (toolCall.id) {
+                            toolCallMeta.get(index)!.id = toolCall.id;
+                        }
+                        // Update the tool use name
+                        if (toolCall.function?.name) {
+                            toolCallMeta.get(index)!.name = toolCall.function.name;
+                        }
+                        // Update the tool use input
+                        if (toolCall.function?.arguments) {
+                            const deltaArgs = toolCall.function.arguments;
+                            accToolInputs.set(index, accToolInputs.get(index)! + deltaArgs);
+
+                            // Create delta tool call with incremental input
+                            const meta = toolCallMeta.get(index)!;
+                            deltaToolCalls.set(index, {
+                                type: 'tool_call',
+                                id: meta.id,
+                                name: meta.name,
+                                input: deltaArgs,
+                            });
+                        }
+                    });
+                }
+
+                // Create a delta ChatResponse object
+                const deltaBlocks = this._accDataToBlocks(deltaText, deltaThinking, deltaToolCalls);
+                lastUsage = jsonObj.usage
+                    ? {
+                          type: 'chat_usage',
+                          inputTokens: jsonObj.usage.prompt_tokens || 0,
+                          outputTokens: jsonObj.usage.completion_tokens || 0,
+                          time: (Date.now() - startTime) / 1000,
+                      }
+                    : undefined;
+
+                yield {
+                    type: 'chat',
+                    id: crypto.randomUUID(),
+                    createdAt: new Date().toISOString(),
+                    content: deltaBlocks,
+                    usage: lastUsage,
+                } as ChatResponse;
+            }
+        }
+        // Build final tool calls with complete JSON strings
+        const finalToolCalls: Map<string, ToolCallBlock> = new Map();
+        toolCallMeta.forEach((meta, index) => {
+            finalToolCalls.set(index, {
+                type: 'tool_call',
+                id: meta.id,
+                name: meta.name,
+                input: accToolInputs.get(index) || '{}',
+            });
+        });
+
+        const blocks = this._accDataToBlocks(accText, accThinking, finalToolCalls);
+        return {
+            type: 'chat',
+            id: crypto.randomUUID(),
+            createdAt: new Date().toISOString(),
+            content: blocks,
+            usage: lastUsage,
+        } as ChatResponse;
+    }
+
+    /**
+     * Convert data into blocks
+     *
+     * @param text - The text response from the llm API
+     * @param thinking - The thinking response
+     * @param toolCalls - The tool calls
+     * @returns An array of blocks
+     */
+    _accDataToBlocks(
+        text: string,
+        thinking: string,
+        toolCalls: Map<string, ToolCallBlock>
+    ): (TextBlock | ThinkingBlock | ToolCallBlock)[] {
+        const blocks: (TextBlock | ThinkingBlock | ToolCallBlock)[] = [];
+        if (thinking) {
+            blocks.push({ id: crypto.randomUUID(), type: 'thinking', thinking: thinking });
+        }
+        if (text) {
+            blocks.push({ id: crypto.randomUUID(), type: 'text', text: text });
+        }
+        // Push the tool calls into the blocks
+        if (toolCalls.size > 0) {
+            toolCalls.forEach(value => {
+                blocks.push(value);
+            });
+        }
+
+        return blocks;
+    }
+
+    /**
+     * Format the tool schemas to the expected API format for DeepSeek API.
+     * @param tools
+     * @returns The formatted tool schemas.
+     */
+    _formatToolSchemas(tools: ToolSchema[] | undefined): ToolSchema[] {
+        return tools || [];
+    }
+}

package/src/model/index.ts

@@ -0,0 +1,7 @@
+export { ChatModelBase } from './base';
+export { ChatResponse } from './response';
+export { ChatUsage } from './usage';
+export { DashScopeChatModel } from './dashscope-model';
+export { DeepSeekChatModel } from './deepseek-model';
+export { OllamaChatModel } from './ollama-model';
+export { OpenAIChatModel } from './openai-model';