@lobehub/chat 1.53.4 → 1.53.6

package/src/features/Conversation/components/MarkdownElements/remarkPlugins/getNodeContent.test.ts

@@ -0,0 +1,396 @@
+import { toMarkdown } from 'mdast-util-to-markdown';
+import { Parent } from 'unist';
+import { expect } from 'vitest';
+
+import { treeNodeToString } from '@/features/Conversation/components/MarkdownElements/remarkPlugins/getNodeContent';
+
+describe('treeNodeToString', () => {
+  it('with latex', () => {
+    const nodes = [
+      {
+        type: 'paragraph',
+        children: [
+          {
+            type: 'text',
+            value: '设正向数列 ',
+            position: {
+              start: {
+                line: 3,
+                column: 1,
+                offset: 9,
+              },
+              end: {
+                line: 3,
+                column: 7,
+                offset: 15,
+              },
+            },
+          },
+          {
+            type: 'inlineMath',
+            value: '{ a_n }',
+            data: {
+              hName: 'code',
+              hProperties: {
+                className: ['language-math', 'math-inline'],
+              },
+              hChildren: [
+                {
+                  type: 'text',
+                  value: '{ a_n }',
+                },
+              ],
+            },
+            position: {
+              start: {
+                line: 3,
+                column: 7,
+                offset: 15,
+              },
+              end: {
+                line: 3,
+                column: 18,
+                offset: 26,
+              },
+            },
+          },
+          {
+            type: 'text',
+            value: ' 的首项为 ',
+            position: {
+              start: {
+                line: 3,
+                column: 18,
+                offset: 26,
+              },
+              end: {
+                line: 3,
+                column: 24,
+                offset: 32,
+              },
+            },
+          },
+          {
+            type: 'inlineMath',
+            value: '4',
+            data: {
+              hName: 'code',
+              hProperties: {
+                className: ['language-math', 'math-inline'],
+              },
+              hChildren: [
+                {
+                  type: 'text',
+                  value: '4',
+                },
+              ],
+            },
+            position: {
+              start: {
+                line: 3,
+                column: 24,
+                offset: 32,
+              },
+              end: {
+                line: 3,
+                column: 29,
+                offset: 37,
+              },
+            },
+          },
+          {
+            type: 'text',
+            value: ' ，满足 ',
+            position: {
+              start: {
+                line: 3,
+                column: 29,
+                offset: 37,
+              },
+              end: {
+                line: 3,
+                column: 34,
+                offset: 42,
+              },
+            },
+          },
+          {
+            type: 'inlineMath',
+            value: 'a^2_n = a_{n+1} + 3na_n - 3',
+            data: {
+              hName: 'code',
+              hProperties: {
+                className: ['language-math', 'math-inline'],
+              },
+              hChildren: [
+                {
+                  type: 'text',
+                  value: 'a^2_n = a_{n+1} + 3na_n - 3',
+                },
+              ],
+            },
+            position: {
+              start: {
+                line: 3,
+                column: 34,
+                offset: 42,
+              },
+              end: {
+                line: 3,
+                column: 65,
+                offset: 73,
+              },
+            },
+          },
+          {
+            type: 'text',
+            value: '.',
+            position: {
+              start: {
+                line: 3,
+                column: 65,
+                offset: 73,
+              },
+              end: {
+                line: 3,
+                column: 66,
+                offset: 74,
+              },
+            },
+          },
+        ],
+        position: {
+          start: {
+            line: 3,
+            column: 1,
+            offset: 9,
+          },
+          end: {
+            line: 3,
+            column: 66,
+            offset: 74,
+          },
+        },
+      },
+      {
+        type: 'list',
+        ordered: true,
+        start: 1,
+        spread: false,
+        children: [
+          {
+            type: 'listItem',
+            spread: false,
+            checked: null,
+            children: [
+              {
+                type: 'paragraph',
+                children: [
+                  {
+                    type: 'text',
+                    value: '求 ',
+                    position: {
+                      start: {
+                        line: 5,
+                        column: 5,
+                        offset: 80,
+                      },
+                      end: {
+                        line: 5,
+                        column: 7,
+                        offset: 82,
+                      },
+                    },
+                  },
+                  {
+                    type: 'inlineMath',
+                    value: 'a_2',
+                    data: {
+                      hName: 'code',
+                      hProperties: {
+                        className: ['language-math', 'math-inline'],
+                      },
+                      hChildren: [
+                        {
+                          type: 'text',
+                          value: 'a_2',
+                        },
+                      ],
+                    },
+                    position: {
+                      start: {
+                        line: 5,
+                        column: 7,
+                        offset: 82,
+                      },
+                      end: {
+                        line: 5,
+                        column: 14,
+                        offset: 89,
+                      },
+                    },
+                  },
+                  {
+                    type: 'text',
+                    value: ' 和 ',
+                    position: {
+                      start: {
+                        line: 5,
+                        column: 14,
+                        offset: 89,
+                      },
+                      end: {
+                        line: 5,
+                        column: 17,
+                        offset: 92,
+                      },
+                    },
+                  },
+                  {
+                    type: 'inlineMath',
+                    value: 'a_3',
+                    data: {
+                      hName: 'code',
+                      hProperties: {
+                        className: ['language-math', 'math-inline'],
+                      },
+                      hChildren: [
+                        {
+                          type: 'text',
+                          value: 'a_3',
+                        },
+                      ],
+                    },
+                    position: {
+                      start: {
+                        line: 5,
+                        column: 17,
+                        offset: 92,
+                      },
+                      end: {
+                        line: 5,
+                        column: 24,
+                        offset: 99,
+                      },
+                    },
+                  },
+                  {
+                    type: 'text',
+                    value: '，根据前三项的规律猜想该数列的通项公式',
+                    position: {
+                      start: {
+                        line: 5,
+                        column: 24,
+                        offset: 99,
+                      },
+                      end: {
+                        line: 5,
+                        column: 43,
+                        offset: 118,
+                      },
+                    },
+                  },
+                ],
+                position: {
+                  start: {
+                    line: 5,
+                    column: 5,
+                    offset: 80,
+                  },
+                  end: {
+                    line: 5,
+                    column: 43,
+                    offset: 118,
+                  },
+                },
+              },
+            ],
+            position: {
+              start: {
+                line: 5,
+                column: 2,
+                offset: 77,
+              },
+              end: {
+                line: 5,
+                column: 43,
+                offset: 118,
+              },
+            },
+          },
+          {
+            type: 'listItem',
+            spread: false,
+            checked: null,
+            children: [
+              {
+                type: 'paragraph',
+                children: [
+                  {
+                    type: 'text',
+                    value: '用数学归纳法证明你的猜想。',
+                    position: {
+                      start: {
+                        line: 6,
+                        column: 5,
+                        offset: 123,
+                      },
+                      end: {
+                        line: 6,
+                        column: 18,
+                        offset: 136,
+                      },
+                    },
+                  },
+                ],
+                position: {
+                  start: {
+                    line: 6,
+                    column: 5,
+                    offset: 123,
+                  },
+                  end: {
+                    line: 6,
+                    column: 18,
+                    offset: 136,
+                  },
+                },
+              },
+            ],
+            position: {
+              start: {
+                line: 6,
+                column: 2,
+                offset: 120,
+              },
+              end: {
+                line: 6,
+                column: 18,
+                offset: 136,
+              },
+            },
+          },
+        ],
+        position: {
+          start: {
+            line: 5,
+            column: 2,
+            offset: 77,
+          },
+          end: {
+            line: 6,
+            column: 18,
+            offset: 136,
+          },
+        },
+      },
+    ];
+
+    const result = treeNodeToString(nodes as Parent[]);
+
+    expect(result).toEqual(`设正向数列 \${ a_n }$ 的首项为 $4$ ，满足 $a^2_n = a_{n+1} + 3na_n - 3$.
+
+1. 求 $a_2$ 和 $a_3$，根据前三项的规律猜想该数列的通项公式
+2. 用数学归纳法证明你的猜想。`);
+  });
+});

package/src/features/Conversation/components/MarkdownElements/remarkPlugins/getNodeContent.ts

@@ -0,0 +1,55 @@
+import { toMarkdown } from 'mdast-util-to-markdown';
+import { Parent } from 'unist';
+
+const processNode = (node: any): string => {
+  // 处理数学公式节点
+  if (node.type === 'inlineMath') {
+    return `$${node.value}$`;
+  }
+
+  // 处理带有子节点的容器
+  if (node.children) {
+    const content = node.children.map((element: Parent) => processNode(element)).join('');
+
+    // 处理列表的特殊换行逻辑
+    if (node.type === 'list') {
+      return `\n${content}\n`;
+    }
+
+    // 处理列表项的前缀
+    if (node.type === 'listItem') {
+      const prefix = node.checked !== null ? `[${node.checked ? 'x' : ' '}] ` : '';
+      return `${prefix}${content}`;
+    }
+
+    return content;
+  }
+
+  // 处理文本节点
+  if (node.value) {
+    // 保留原始空白字符处理逻辑
+    return node.value.replaceAll(/^\s+|\s+$/g, ' ');
+  }
+
+  // 兜底使用标准转换
+  return toMarkdown(node);
+};
+
+export const treeNodeToString = (nodes: Parent[]) => {
+  return nodes
+    .map((node) => {
+      // 处理列表的缩进问题
+      if (node.type === 'list') {
+        return node.children
+          .map((item, index) => {
+            const prefix = (node as any).ordered ? `${(node as any).start + index}. ` : '- ';
+            return `${prefix}${processNode(item)}`;
+          })
+          .join('\n');
+      }
+
+      return processNode(node);
+    })
+    .join('\n\n')
+    .trim();
+};

package/src/libs/agent-runtime/providerTestUtils.test.ts

@@ -0,0 +1,123 @@
+import OpenAI from 'openai';
+import { describe, expect, it, vi } from 'vitest';
+
+import { testProvider } from './providerTestUtils';
+
+describe('testProvider', () => {
+  it('should run provider tests correctly', () => {
+    class MockRuntime {
+      baseURL: string;
+      client: any;
+
+      constructor({
+        apiKey,
+        baseURL = 'https://default.test',
+      }: {
+        apiKey?: string;
+        baseURL?: string;
+      }) {
+        if (!apiKey) throw { errorType: 'InvalidAPIKey' };
+        this.baseURL = baseURL;
+        this.client = {
+          chat: {
+            completions: {
+              create: vi.fn().mockResolvedValue(new ReadableStream()),
+            },
+          },
+        };
+      }
+
+      async chat(params: any) {
+        return this.client.chat.completions.create(params);
+      }
+    }
+
+    testProvider({
+      Runtime: MockRuntime,
+      bizErrorType: 'TestBizError',
+      chatDebugEnv: 'TEST_DEBUG',
+      chatModel: 'test-model',
+      defaultBaseURL: 'https://default.test',
+      invalidErrorType: 'InvalidAPIKey',
+      provider: 'TestProvider',
+    });
+  });
+
+  it('should handle OpenAI API errors correctly', async () => {
+    class MockRuntime {
+      baseURL: string;
+      client: any;
+
+      constructor({ apiKey }: { apiKey?: string }) {
+        if (!apiKey) throw { errorType: 'InvalidAPIKey' };
+        this.baseURL = 'test';
+        this.client = {
+          chat: {
+            completions: {
+              create: vi.fn().mockRejectedValue(
+                new OpenAI.APIError(
+                  400,
+                  {
+                    error: { message: 'Test Error' },
+                    status: 400,
+                  },
+                  'Test Error',
+                  {},
+                ),
+              ),
+            },
+          },
+        };
+      }
+
+      async chat(params: any) {
+        return this.client.chat.completions.create(params);
+      }
+    }
+
+    testProvider({
+      Runtime: MockRuntime,
+      bizErrorType: 'TestBizError',
+      chatDebugEnv: 'TEST_DEBUG',
+      chatModel: 'test-model',
+      defaultBaseURL: 'test',
+      invalidErrorType: 'InvalidAPIKey',
+      provider: 'TestProvider',
+    });
+  });
+
+  it('should handle debug stream correctly', () => {
+    class MockRuntime {
+      baseURL: string;
+      client: any;
+
+      constructor({ apiKey }: { apiKey?: string }) {
+        if (!apiKey) throw { errorType: 'InvalidAPIKey' };
+        this.baseURL = 'test';
+        this.client = {
+          chat: {
+            completions: {
+              create: vi.fn().mockResolvedValue({
+                tee: () => [new ReadableStream(), { toReadableStream: () => new ReadableStream() }],
+              }),
+            },
+          },
+        };
+      }
+
+      async chat(params: any) {
+        return this.client.chat.completions.create(params);
+      }
+    }
+
+    testProvider({
+      Runtime: MockRuntime,
+      bizErrorType: 'TestBizError',
+      chatDebugEnv: 'TEST_DEBUG',
+      chatModel: 'test-model',
+      defaultBaseURL: 'test',
+      invalidErrorType: 'InvalidAPIKey',
+      provider: 'TestProvider',
+    });
+  });
+});