@kevisual/ai 0.0.11 → 0.0.13

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@kevisual/ai",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "AI Center Services",
   "main": "index.js",
   "basename": "/root/ai-center-services",
   "app": {
     "entry": "dist/app.mjs",
-    "key": "ai-center-services",
     "type": "system-app"
   },
   "files": [
@@ -28,7 +27,7 @@
   ],
   "author": "abearxiong <xiongxiao@xiongxiao.me> (https://www.xiongxiao.me)",
   "license": "MIT",
-  "packageManager": "pnpm@10.19.0",
+  "packageManager": "pnpm@10.24.0",
   "type": "module",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
@@ -56,36 +55,37 @@
   "devDependencies": {
     "@kevisual/code-center-module": "0.0.24",
     "@kevisual/mark": "0.0.7",
-    "@kevisual/router": "0.0.30",
+    "@kevisual/router": "0.0.33",
     "@kevisual/types": "^0.0.10",
-    "@kevisual/use-config": "^1.0.19",
-    "@types/bun": "^1.3.0",
+    "@kevisual/use-config": "^1.0.21",
+    "@types/bun": "^1.3.3",
     "@types/crypto-js": "^4.2.2",
     "@types/formidable": "^3.4.6",
     "@types/lodash-es": "^4.17.12",
-    "@types/node": "^24.9.1",
+    "@types/node": "^24.10.1",
     "@vitejs/plugin-basic-ssl": "^2.1.0",
-    "cookie": "^1.0.2",
+    "cookie": "^1.1.1",
     "cross-env": "^10.1.0",
     "crypto-js": "^4.2.0",
-    "dayjs": "^1.11.18",
+    "dayjs": "^1.11.19",
     "dotenv": "^17.2.3",
     "formidable": "^3.5.4",
     "ioredis": "^5.8.2",
     "json5": "^2.2.3",
     "lodash-es": "^4.17.21",
-    "openai": "6.6.0",
-    "pm2": "^6.0.13",
-    "rimraf": "^6.0.1",
-    "rollup": "^4.52.5",
-    "rollup-plugin-dts": "^6.2.3",
+    "openai": "6.9.1",
+    "pm2": "^6.0.14",
+    "rimraf": "^6.1.2",
+    "rollup": "^4.53.3",
+    "rollup-plugin-dts": "^6.3.0",
     "sequelize": "^6.37.7",
     "tape": "^5.9.0",
     "tiktoken": "^1.0.22",
     "typescript": "^5.9.3",
-    "vite": "^7.1.12"
+    "vite": "^7.2.6"
   },
   "dependencies": {
-    "@kevisual/logger": "^0.0.4"
+    "@kevisual/logger": "^0.0.4",
+    "@kevisual/permission": "^0.0.3"
   }
 }

package/src/provider/chat-adapter/kimi.ts

@@ -0,0 +1,10 @@
+import { BaseChat, BaseChatOptions } from '../core/chat.ts';
+
+export type KimiOptions = Partial<BaseChatOptions>;
+export class Kimi extends BaseChat {
+  static BASE_URL = 'https://api.moonshot.cn/v1/';
+  constructor(options: KimiOptions) {
+    const baseURL = options.baseURL || Kimi.BASE_URL;
+    super({ ...(options as BaseChatOptions), baseURL: baseURL });
+  }
+}

package/src/provider/chat-adapter/ollama.ts

@@ -37,11 +37,11 @@ export class Ollama extends BaseChat {
   async listModels(): Promise<{ models: OllamaModel[] }> {
     const _url = new URL(this.baseURL);
     const tagsURL = new URL('/api/tags', _url);
-    return this.openai.get(tagsURL.toString());
+    return this.get(tagsURL.toString());
   }
   async listRunModels(): Promise<{ models: OllamaModel[] }> {
     const _url = new URL(this.baseURL);
     const tagsURL = new URL('/api/ps', _url);
-    return this.openai.get(tagsURL.toString());
+    return this.get(tagsURL.toString());
   }
 }

package/src/provider/chat-adapter/siliconflow.ts

@@ -31,7 +31,7 @@ export class SiliconFlow extends BaseChat {
     super({ ...(options as BaseChatOptions), baseURL: baseURL });
   }
   async getUsageInfo(): Promise<SiliconFlowUsageResponse> {
-    return this.openai.get('/user/info');
+    return this.get('/user/info');
   }
   async chat(messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[], options?: ChatMessageOptions) {
     const res = await super.chat(messages, options);

package/src/provider/chat-adapter/zhipu.ts

@@ -0,0 +1,10 @@
+import { BaseChat, BaseChatOptions } from '../core/chat.ts';
+
+export type ZhipuOptions = Partial<BaseChatOptions>;
+export class Zhipu extends BaseChat {
+  static BASE_URL = 'https://open.bigmodel.cn/api/paas/v4/';
+  constructor(options: ZhipuOptions) {
+    const baseURL = options.baseURL || Zhipu.BASE_URL;
+    super({ ...(options as BaseChatOptions), baseURL: baseURL });
+  }
+}

package/src/provider/chat.ts

@@ -8,6 +8,8 @@ import { Volces } from './chat-adapter/volces.ts';
 import { DeepSeek } from './chat-adapter/deepseek.ts';
 import { ModelScope } from './chat-adapter/model-scope.ts';
 import { BailianChat } from './chat-adapter/dashscope.ts';
+import { Zhipu } from './chat-adapter/zhipu.ts';
+import { Kimi } from './chat-adapter/kimi.ts';
 
 import { ChatMessage } from './core/type.ts';
 
@@ -18,6 +20,8 @@ export const VolcesProvider = Volces;
 export const DeepSeekProvider = DeepSeek;
 export const ModelScopeProvider = ModelScope;
 export const BailianProvider = BailianChat;
+export const ZhipuProvider = Zhipu;
+export const KimiProvider = Kimi;
 
 export const ChatProviderMap = {
   Ollama: OllamaProvider,
@@ -28,6 +32,8 @@ export const ChatProviderMap = {
   ModelScope: ModelScopeProvider,
   BaseChat: BaseChat,
   Bailian: BailianProvider,
+  Zhipu: ZhipuProvider,
+  Kimi: KimiProvider,
 };
 
 type ProviderManagerConfig = {

package/src/provider/core/chat.ts

@@ -9,6 +9,7 @@ import type {
   EmbeddingMessage,
   EmbeddingMessageComplete,
 } from './type.ts';
+import { AIUtils } from './utils/index.ts';
 
 export type BaseChatOptions<T = Record<string, any>> = {
   /**
@@ -32,14 +33,7 @@ export type BaseChatOptions<T = Record<string, any>> = {
    */
   stream?: boolean;
 } & T;
-export const getIsBrowser = () => {
-  try {
-    // 检查是否存在window对象
-    return typeof window !== 'undefined' && typeof window.document !== 'undefined';
-  } catch (e) {
-    return false;
-  }
-};
+
 export class BaseChat implements BaseChatInterface, BaseChatUsageInterface {
   /**
    * 默认baseURL
@@ -53,67 +47,126 @@ export class BaseChat implements BaseChatInterface, BaseChatUsageInterface {
    * 默认apiKey
    */
   apiKey: string;
-  /**
-   * 是否在浏览器中使用
-   */
-  isBrowser: boolean;
-  /**
-   * openai实例
-   */
-  openai: OpenAI;
-
   prompt_tokens: number;
   total_tokens: number;
   completion_tokens: number;
-
+  responseText: string;
+  utils: AIUtils;
   constructor(options: BaseChatOptions) {
     this.baseURL = options.baseURL;
     this.model = options.model;
     this.apiKey = options.apiKey;
-    // @ts-ignore
-    const DEFAULT_IS_BROWSER = getIsBrowser();
-    this.isBrowser = options.isBrowser ?? DEFAULT_IS_BROWSER;
-    this.openai = new OpenAI({
-      apiKey: this.apiKey,
-      baseURL: this.baseURL,
-      dangerouslyAllowBrowser: options?.dangerouslyAllowBrowser ?? this.isBrowser,
+    this.utils = new AIUtils();
+  }
+  post(url = '', opts: { headers?: Record<string, string>, data?: any } = {}) {
+    let _url = url.startsWith('http') ? url : this.baseURL + url;
+    return fetch(_url, {
+      method: 'POST',
+      ...opts,
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${this.apiKey}`,
+        ...opts.headers,
+      },
+      body: opts?.data ? JSON.stringify(opts.data) : undefined,
     });
   }
+  async get<T = any>(url = '', opts: { headers?: Record<string, string> } = {}): Promise<T> {
+    let _url = url.startsWith('http') ? url : this.baseURL + url;
+    return fetch(_url, {
+      method: 'GET',
+      ...opts,
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${this.apiKey}`,
+        ...opts.headers,
+      },
+    }).then((res) => res.json());
+  }
   /**
    * 聊天
    */
   async chat(messages: ChatMessage[], options?: ChatMessageOptions): Promise<ChatMessageComplete> {
-    const createParams: OpenAI.Chat.Completions.ChatCompletionCreateParams = {
+    const requestBody = {
       model: this.model,
       messages,
       ...options,
       stream: false,
     };
-    const res = (await this.openai.chat.completions.create(createParams)) as ChatMessageComplete;
+
+    const response = await this.post(`${this.baseURL}/chat/completions`, { data: requestBody });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Chat API request failed: ${response.status} ${response.statusText} - ${errorText}`);
+    }
+
+    const res = await response.json() as ChatMessageComplete;
+
     this.prompt_tokens = res.usage?.prompt_tokens ?? 0;
     this.total_tokens = res.usage?.total_tokens ?? 0;
     this.completion_tokens = res.usage?.completion_tokens ?? 0;
+    this.responseText = res.choices[0]?.message?.content || '';
     return res;
   }
   async chatStream(messages: ChatMessage[], options?: ChatMessageOptions) {
-    const createParams: OpenAI.Chat.Completions.ChatCompletionCreateParams = {
+    if (options?.response_format) {
+      throw new Error('response_format is not supported in stream mode');
+    }
+
+    const requestBody = {
       model: this.model,
       messages,
       ...options,
       stream: true,
     };
-    if (createParams.response_format) {
-      throw new Error('response_format is not supported in stream mode');
+
+    const response = await this.post(`${this.baseURL}/chat/completions`, { data: requestBody });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Chat Stream API request failed: ${response.status} ${response.statusText} - ${errorText}`);
     }
-    return this.openai.chat.completions.create(createParams) as unknown as ChatStream;
-  }
 
-  /**
-   * 测试
-   */
-  test() {
-    return this.chat([{ role: 'user', content: 'Hello, world!' }]);
+    const decoder = new TextDecoder();
+    const reader = response.body?.getReader();
+
+    if (!reader) {
+      throw new Error('Response body is not readable');
+    }
+
+    // 创建一个新的 ReadableStream，使用 decoder 解析数据
+    const stream = new ReadableStream({
+      async start(controller) {
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              controller.close();
+              break;
+            }
+            // 检查 value 类型，如果是 Uint8Array 才解码，否则直接使用
+            if (typeof value === 'string') {
+              controller.enqueue(value);
+            } else if (value instanceof Uint8Array) {
+              const text = decoder.decode(value, { stream: true });
+              controller.enqueue(text);
+            } else {
+              controller.enqueue(value);
+            }
+          }
+        } catch (error) {
+          controller.error(error);
+        }
+      },
+      cancel() {
+        reader.releaseLock();
+      }
+    });
+
+    return stream as unknown as ChatStream;
   }
+
   /**
    * 获取聊天使用情况
    * @returns
@@ -125,6 +178,7 @@ export class BaseChat implements BaseChatInterface, BaseChatUsageInterface {
       completion_tokens: this.completion_tokens,
     };
   }
+
   getHeaders(headers?: Record<string, string>) {
     return {
       'Content-Type': 'application/json',
@@ -139,12 +193,23 @@ export class BaseChat implements BaseChatInterface, BaseChatUsageInterface {
    */
   async generateEmbeddingCore(text: string | string[], options?: EmbeddingMessage): Promise<EmbeddingMessageComplete> {
     const embeddingModel = options?.model || this.model;
-    const res = await this.openai.embeddings.create({
+
+    const requestBody = {
       model: embeddingModel,
       input: text,
       encoding_format: 'float',
       ...options,
-    });
+    };
+
+    const response = await this.post(`${this.baseURL}/embeddings`, { data: requestBody });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Embedding API request failed: ${response.status} ${response.statusText} - ${errorText}`);
+    }
+
+    const res = await response.json() as EmbeddingMessageComplete;
+
     this.prompt_tokens += res.usage.prompt_tokens;
     this.total_tokens += res.usage.total_tokens;
     return res;

package/src/provider/core/index.ts

@@ -2,17 +2,6 @@ import { ChatStream } from './type.ts';
 
 // export type { BaseChat, BaseChatOptions } from './chat.ts';
 export * from './chat.ts'
-// export {
-//   ChatMessage,
-//   ChatMessageOptions, //
-//   ChatMessageComplete,
-//   ChatMessageStream,
-//   BaseChatInterface,
-//   BaseChatUsageInterface,
-//   ChatStream,
-//   EmbeddingMessage,
-//   EmbeddingMessageComplete,
-// } from './type.ts';
 export * from './type.ts'
 /**
  *  for await (const chunk of chatStream) {

package/src/provider/core/utils/index.ts

@@ -0,0 +1,192 @@
+export class AIUtils {
+  /**
+   * 从 Markdown 代码块中提取 JSON
+   * @param str 包含 JSON 的字符串
+   * @returns 解析后的对象或 null
+   */
+  extractJsonFromMarkdown(str: string): any | null {
+    // Try to extract JSON from ```json ... ```
+    const jsonRegex = /```json\s*([\s\S]*?)\s*```/;
+    const match = str.match(jsonRegex);
+    let jsonStr = match && match[1] ? match[1] : str;
+
+    try {
+      return JSON.parse(jsonStr);
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * 从 Markdown 代码块中提取代码
+   * @param str Markdown 字符串
+   * @param language 语言类型，不指定则返回所有代码块
+   * @returns 提取的代码字符串或数组
+   */
+  extractCodeFromMarkdown(str: string, language?: string): string | string[] | null {
+    if (language) {
+      const regex = new RegExp(`\`\`\`${language}\\s*([\\s\\S]*?)\\s*\`\`\``, 'g');
+      const matches = str.match(regex);
+      if (!matches) return null;
+      return matches.map(m => m.replace(new RegExp(`\`\`\`${language}\\s*|\\s*\`\`\``, 'g'), '').trim());
+    }
+    
+    const regex = /```[\w]*\s*([\s\S]*?)\s*```/g;
+    const matches = [...str.matchAll(regex)];
+    if (matches.length === 0) return null;
+    return matches.map(m => m[1].trim());
+  }
+
+  /**
+   * 清理 AI 响应中的多余空白和格式
+   * @param str 原始字符串
+   * @returns 清理后的字符串
+   */
+  cleanResponse(str: string): string {
+    return str
+      .trim()
+      .replace(/\n{3,}/g, '\n\n') // 多个换行符替换为两个
+      .replace(/[ \t]+$/gm, ''); // 删除行尾空格
+  }
+
+  /**
+   * 从 AI 响应中提取标签
+   * @param str 响应字符串
+   * @returns 标签数组
+   */
+  extractTags(str: string): string[] {
+    const tagPatterns = [
+      /#(\w+)/g, // #tag 格式
+      /\[(\w+)\]/g, // [tag] 格式
+      /tags?:\s*\[([^\]]+)\]/gi, // tags: [...] 格式
+    ];
+
+    const tags = new Set<string>();
+    
+    for (const pattern of tagPatterns) {
+      const matches = str.matchAll(pattern);
+      for (const match of matches) {
+        if (match[1]) {
+          const extracted = match[1].split(/[,;]/).map(t => t.trim()).filter(Boolean);
+          extracted.forEach(tag => tags.add(tag));
+        }
+      }
+    }
+
+    return Array.from(tags);
+  }
+
+  /**
+   * 从文本中提取 URL
+   * @param str 文本字符串
+   * @returns URL 数组
+   */
+  extractUrls(str: string): string[] {
+    const urlRegex = /(https?:\/\/[^\s]+)/g;
+    const matches = str.match(urlRegex);
+    return matches || [];
+  }
+
+  /**
+   * 分割长文本为指定 token 数量的块
+   * @param text 原始文本
+   * @param maxTokens 每块最大 token 数（粗略估算：1 token ≈ 4 字符）
+   * @returns 文本块数组
+   */
+  chunkText(text: string, maxTokens: number = 1000): string[] {
+    const chunkSize = maxTokens * 4; // 粗略估算
+    const chunks: string[] = [];
+    
+    // 按段落分割
+    const paragraphs = text.split(/\n\n+/);
+    let currentChunk = '';
+    
+    for (const paragraph of paragraphs) {
+      if ((currentChunk + paragraph).length > chunkSize && currentChunk) {
+        chunks.push(currentChunk.trim());
+        currentChunk = paragraph;
+      } else {
+        currentChunk += (currentChunk ? '\n\n' : '') + paragraph;
+      }
+    }
+    
+    if (currentChunk) {
+      chunks.push(currentChunk.trim());
+    }
+    
+    return chunks;
+  }
+
+  /**
+   * 移除 AI 响应中的思考过程（thinking 标签）
+   * @param str 响应字符串
+   * @returns 清理后的字符串
+   */
+  removeThinkingTags(str: string): string {
+    return str
+      .replace(/<thinking>[\s\S]*?<\/thinking>/gi, '')
+      .replace(/\[thinking\][\s\S]*?\[\/thinking\]/gi, '')
+      .trim();
+  }
+
+  /**
+   * 转义特殊字符用于 AI 提示词
+   * @param str 原始字符串
+   * @returns 转义后的字符串
+   */
+  escapeForPrompt(str: string): string {
+    return str
+      .replace(/\\/g, '\\\\')
+      .replace(/`/g, '\\`')
+      .replace(/\$/g, '\\$');
+  }
+
+  /**
+   * 统计文本的大致 token 数量
+   * @param text 文本
+   * @returns 估算的 token 数量
+   */
+  estimateTokens(text: string): number {
+    // 简单估算：中文约 1.5 字符/token，英文约 4 字符/token
+    const chineseChars = (text.match(/[\u4e00-\u9fa5]/g) || []).length;
+    const otherChars = text.length - chineseChars;
+    return Math.ceil(chineseChars / 1.5 + otherChars / 4);
+  }
+
+  /**
+   * 从响应中提取结构化数据（key: value 格式）
+   * @param str 响应字符串
+   * @returns 键值对对象
+   */
+  extractKeyValuePairs(str: string): Record<string, string> {
+    const result: Record<string, string> = {};
+    const lines = str.split('\n');
+    
+    for (const line of lines) {
+      const match = line.match(/^([^:：]+)[：:]\s*(.+)$/);
+      if (match) {
+        const key = match[1].trim();
+        const value = match[2].trim();
+        result[key] = value;
+      }
+    }
+    
+    return result;
+  }
+
+  /**
+   * 验证 AI 响应是否完整（检查截断）
+   * @param str 响应字符串
+   * @returns 是否完整
+   */
+  isResponseComplete(str: string): boolean {
+    const incompleteSigns = [
+      /```[\w]*\s*[\s\S]*?(?<!```)$/, // 未闭合的代码块
+      /\{[\s\S]*(?<!\})$/, // 未闭合的 JSON
+      /\[[\s\S]*(?<!\])$/, // 未闭合的数组
+      /\.{3,}$/, // 结尾省略号
+    ];
+    
+    return !incompleteSigns.some(pattern => pattern.test(str.trim()));
+  }
+}

package/src/provider/knowledge-adapter/siliconflow.ts

@@ -7,8 +7,8 @@ export class SiliconFlowKnowledge extends KnowledgeBase {
   }
 
   async rerank(data: RerankOptions) {
-    return this.openai.post('/rerank', {
-      body: data,
+    return this.post('/rerank', {
+      data: data,
     });
   }
 }

package/src/test/aliyun/test.ts

@@ -11,16 +11,49 @@ const ai = new BailianProvider({
 })
 
 
-const res = await ai.chat([
-
-  {
-    role: 'user',
-    content: `1+1等于多少？`
-  },
- 
-],
-)
-console.log('AI Response:', res);
-const content = res.choices[0].message?.content || ''
-
-console.log(util.inspect(res, { depth: null }))
+// const res = await ai.chat([
+
+//   {
+//     role: 'user',
+//     content: `1+1等于多少？`
+//   },
+
+// ],
+// )
+// // console.log('AI Response:', res);
+// const content = res.choices[0].message?.content || ''
+
+// console.log(util.inspect(res, { depth: null }))
+
+// console.log('responseText', ai.responseText)
+
+
+// const res = await ai.chatStream([
+
+//   {
+//     role: 'user',
+//     content: `1+1等于多少？`
+//   },
+
+// ],
+// )
+// // console.log('AI Response:', res);
+// export const readStream = async (chatStream) => {
+//   let buffer = '';
+//   for await (const chunk of chatStream) {
+//     // chunk 已经是解码后的字符串，直接拼接即可
+//     buffer += chunk;
+//   }
+//   console.log('AI Response:', buffer);
+// };
+
+// await readStream(res);
+
+const embe = await ai.generateEmbeddingCore([
+  '你好，世界！',
+  'Hello, world!',
+], {
+  model: 'text-embedding-v4'
+});
+
+console.log('Embedding Response:', util.inspect(embe, { depth: null }));