qing-client 0.0.10 → 0.0.12

package/lib/client/BaseClient.d.ts

@@ -4,13 +4,18 @@ export declare abstract class BaseClient {
     protected config: ClientConfig;
     protected serviceName: string;
     protected axiosInstance: AxiosInstance;
-    protected userContext?: UserContext;
     protected isFrontendMode: boolean;
     protected serviceBasePath: string;
     protected tokenStorage: TokenStorage;
+    protected projectId?: string;
+    protected appId?: string;
+    protected userContext?: UserContext;
     constructor(config: ClientConfig, serviceName: string);
     initUserContext(context: UserContext): RawAxiosRequestHeaders;
     setUserContext(context: UserContext): this;
+    setProjectId(projectId: string): this;
+    setAppId(appId: string): this;
+    setProjectAndApp(projectId: string, appId: string): this;
     setTokenStorage(storage: TokenStorage): this;
     private getBaseUrl;
     setToken(token: string): Promise<void>;

package/lib/client/BaseClient.js

@@ -24,6 +24,16 @@ class BaseClient {
         this.serviceName = serviceName;
         this.isFrontendMode = !!config.gatewayUrl;
         this.serviceBasePath = `/api/${serviceName}`;
+        // 根据模式设置不同的配置
+        if (this.isFrontendMode) {
+            // 前端模式：使用项目和应用ID
+            this.projectId = config.projectId;
+            this.appId = config.appId;
+        }
+        else {
+            // 后端模式：使用用户上下文
+            this.userContext = config.userContext;
+        }
         // 设置令牌存储
         this.tokenStorage = config.tokenStorage || memoryTokenStorage;
         // 创建Axios实例
@@ -35,16 +45,10 @@ class BaseClient {
                 'Accept': 'application/json'
             }
         });
-        // 添加请求拦截器
+        // 添加请求拦截器 - 只处理认证令牌
         this.axiosInstance.interceptors.request.use(async (config) => {
             let headers = config.headers || {};
-            // 1. 注入用户上下文（后端模式）
-            if (!this.isFrontendMode && this.userContext)
-                headers = {
-                    ...headers,
-                    ...this.initUserContext(this.userContext)
-                };
-            // 2. 注入认证令牌
+            // 只注入认证令牌（两种模式都需要）
             const token = await this.tokenStorage.getToken();
             if (token) {
                 headers['Authorization'] = `Bearer ${token}`;
@@ -59,6 +63,7 @@ class BaseClient {
             };
         });
     }
+    // 后端模式：用户上下文相关方法
     initUserContext(context) {
         return {
             'v-user-id': context.userId,
@@ -66,9 +71,42 @@ class BaseClient {
             'v-project-id': context.projectId
         };
     }
-    // 设置用户上下文（后端模式使用）
     setUserContext(context) {
-        this.userContext = context;
+        if (!this.isFrontendMode) {
+            this.userContext = context;
+        }
+        else {
+            console.warn('setUserContext() 仅在后端模式下有效');
+        }
+        return this;
+    }
+    // 前端模式：项目和应用相关方法
+    setProjectId(projectId) {
+        if (this.isFrontendMode) {
+            this.projectId = projectId;
+        }
+        else {
+            console.warn('setProjectId() 仅在前端模式下有效');
+        }
+        return this;
+    }
+    setAppId(appId) {
+        if (this.isFrontendMode) {
+            this.appId = appId;
+        }
+        else {
+            console.warn('setAppId() 仅在前端模式下有效');
+        }
+        return this;
+    }
+    setProjectAndApp(projectId, appId) {
+        if (this.isFrontendMode) {
+            this.projectId = projectId;
+            this.appId = appId;
+        }
+        else {
+            console.warn('setProjectAndApp() 仅在前端模式下有效');
+        }
         return this;
     }
     // 设置令牌存储（可在运行时更换存储策略）
@@ -101,16 +139,31 @@ class BaseClient {
     async clearToken() {
         await this.tokenStorage.clearToken();
     }
-    // 统一请求方法 - 处理标准API响应
+    // 统一请求方法
     async request(path, options = { method: 'GET' }) {
         try {
             const fullPath = this.isFrontendMode
                 ? `${this.serviceBasePath}${path}`
                 : path;
             let headers = options.headers || {};
-            const context = options.userContext || this.userContext;
-            if (context) {
-                headers = { ...headers, ...this.initUserContext(context) };
+            // 根据模式添加不同的头信息
+            if (this.isFrontendMode) {
+                // 前端模式：添加项目和应用ID头
+                const projectId = options.projectId || this.projectId;
+                const appId = options.appId || this.appId;
+                if (projectId) {
+                    headers['x-project-id'] = projectId;
+                }
+                if (appId) {
+                    headers['x-app-id'] = appId;
+                }
+            }
+            else {
+                // 后端模式：添加用户上下文头
+                const context = options.userContext || this.userContext;
+                if (context) {
+                    headers = { ...headers, ...this.initUserContext(context) };
+                }
             }
             const response = await this.axiosInstance.request({
                 url: fullPath,
@@ -133,16 +186,36 @@ class BaseClient {
             return this.handleApiError(error, path);
         }
     }
-    // 分页请求方法 - 处理分页API响应
+    // 分页请求方法
     async paginatedRequest(path, options = { method: 'GET' }) {
         try {
             const fullPath = this.isFrontendMode
                 ? `${this.serviceBasePath}${path}`
                 : path;
+            let headers = options.headers || {};
+            // 根据模式添加不同的头信息
+            if (this.isFrontendMode) {
+                // 前端模式：添加项目和应用ID头
+                const projectId = options.projectId || this.projectId;
+                const appId = options.appId || this.appId;
+                if (projectId) {
+                    headers['x-project-id'] = projectId;
+                }
+                if (appId) {
+                    headers['x-app-id'] = appId;
+                }
+            }
+            else {
+                // 后端模式：添加用户上下文头
+                const context = options.userContext || this.userContext;
+                if (context) {
+                    headers = { ...headers, ...this.initUserContext(context) };
+                }
+            }
             const response = await this.axiosInstance.request({
                 url: fullPath,
                 method: options.method,
-                headers: options.headers,
+                headers,
                 params: options.params,
                 data: options.body
             });
@@ -150,7 +223,7 @@ class BaseClient {
             if (!response.data.success) {
                 throw new Error(response.data.message || `业务请求失败`);
             }
-            // 返回分页数据 - 直接返回整个data部分
+            // 返回分页数据
             return response.data;
         }
         catch (error) {

package/lib/client/index.d.ts

@@ -11,6 +11,12 @@ export declare class Client {
     readonly user: UserService;
     readonly token: TokenService;
     readonly aigc: AigcService;
+    protected isFrontendMode: boolean;
     constructor(config: ClientConfig);
     setUserContext(context: UserContext): this;
+    setProjectId(projectId: string): this;
+    setAppId(appId: string): this;
+    setProjectAndApp(projectId: string, appId: string): this;
+    setToken(token: string): Promise<void>;
+    clearToken(): Promise<void>;
 }

package/lib/client/index.js

@@ -9,19 +9,84 @@ const UserService_1 = require("../srvice/UserService");
 class Client {
     constructor(config) {
         this.config = config;
+        this.isFrontendMode = !!config.gatewayUrl;
         this.auth = new AuthService_1.AuthService(config);
         this.msg = new MsgService_1.MsgService(config);
         this.user = new UserService_1.UserService(config);
         this.token = new TokenService_1.TokenService(config);
         this.aigc = new AigcService_1.AigcService(config);
     }
+    // 后端模式：设置用户上下文
     setUserContext(context) {
-        this.auth.setUserContext(context);
-        this.msg.setUserContext(context);
-        this.user.setUserContext(context);
-        this.token.setUserContext(context);
-        this.aigc.setUserContext(context);
+        if (!this.isFrontendMode) {
+            this.auth.setUserContext(context);
+            this.msg.setUserContext(context);
+            this.user.setUserContext(context);
+            this.token.setUserContext(context);
+            this.aigc.setUserContext(context);
+        }
+        else {
+            console.warn('setUserContext() 仅在后端模式下有效');
+        }
         return this;
     }
+    // 前端模式：设置项目ID
+    setProjectId(projectId) {
+        if (this.isFrontendMode) {
+            this.auth.setProjectId(projectId);
+            this.msg.setProjectId(projectId);
+            this.user.setProjectId(projectId);
+            this.token.setProjectId(projectId);
+            this.aigc.setProjectId(projectId);
+        }
+        else {
+            console.warn('setProjectId() 仅在前端模式下有效');
+        }
+        return this;
+    }
+    // 前端模式：设置应用ID
+    setAppId(appId) {
+        if (this.isFrontendMode) {
+            this.auth.setAppId(appId);
+            this.msg.setAppId(appId);
+            this.user.setAppId(appId);
+            this.token.setAppId(appId);
+            this.aigc.setAppId(appId);
+        }
+        else {
+            console.warn('setAppId() 仅在前端模式下有效');
+        }
+        return this;
+    }
+    // 前端模式：同时设置项目和应用ID
+    setProjectAndApp(projectId, appId) {
+        if (this.isFrontendMode) {
+            this.auth.setProjectAndApp(projectId, appId);
+            this.msg.setProjectAndApp(projectId, appId);
+            this.user.setProjectAndApp(projectId, appId);
+            this.token.setProjectAndApp(projectId, appId);
+            this.aigc.setProjectAndApp(projectId, appId);
+        }
+        else {
+            console.warn('setProjectAndApp() 仅在前端模式下有效');
+        }
+        return this;
+    }
+    // 设置认证令牌（两种模式都需要）
+    async setToken(token) {
+        await this.auth.setToken(token);
+        await this.msg.setToken(token);
+        await this.user.setToken(token);
+        await this.token.setToken(token);
+        await this.aigc.setToken(token);
+    }
+    // 清除认证令牌（两种模式都需要）
+    async clearToken() {
+        await this.auth.clearToken();
+        await this.msg.clearToken();
+        await this.user.clearToken();
+        await this.token.clearToken();
+        await this.aigc.clearToken();
+    }
 }
 exports.Client = Client;

package/lib/srvice/AiService.d.ts

@@ -0,0 +1,73 @@
+import { BaseClient } from "../client/BaseClient";
+import { ClientConfig, RequestOptions } from "../types";
+import { ChatCompletionRequest, ChatCompletionResponse, ProviderListItem, ProviderDetail, ModelListItem, ModelDetail, CreateSessionRequest, SessionResponse, SessionListResponse, CreateAssistantRequest, AssistantResponse, AssistantListResponse, UpdateAssistantRequest, AddMessageRequest, BatchDeleteSessionsResponse, SessionStatistics, AssistantModelsResponse, PaginatedSessionMessageResponse } from "../types/ai";
+export declare class AiService extends BaseClient {
+    constructor(config: ClientConfig);
+    chatCompletion(request: ChatCompletionRequest, options?: RequestOptions): Promise<ChatCompletionResponse>;
+    getChatModels(options?: RequestOptions): Promise<{
+        models: ModelListItem[];
+    }>;
+    createSession(request: CreateSessionRequest, options?: RequestOptions): Promise<SessionResponse>;
+    getSessions(params?: {
+        page?: number;
+        limit?: number;
+        status?: 'active' | 'ended';
+    }, options?: RequestOptions): Promise<SessionListResponse>;
+    getSession(sessionId: string, options?: RequestOptions): Promise<SessionResponse>;
+    updateSession(sessionId: string, request: any, options?: RequestOptions): Promise<SessionResponse>;
+    endSession(sessionId: string, options?: RequestOptions): Promise<SessionResponse>;
+    deleteSession(sessionId: string, options?: RequestOptions): Promise<void>;
+    getSessionModel(sessionId: string, options?: RequestOptions): Promise<{
+        currentModel: string;
+        availableModels: string[];
+        providerName: string;
+    }>;
+    getActiveSessions(options?: RequestOptions): Promise<{
+        sessions: SessionResponse[];
+    }>;
+    createAssistant(request: CreateAssistantRequest, options?: RequestOptions): Promise<AssistantResponse>;
+    getAssistants(params?: {
+        page?: number;
+        limit?: number;
+    }, options?: RequestOptions): Promise<AssistantListResponse>;
+    getAssistant(assistantId: string, options?: RequestOptions): Promise<AssistantResponse>;
+    updateAssistant(assistantId: string, request: UpdateAssistantRequest, options?: RequestOptions): Promise<AssistantResponse>;
+    deleteAssistant(assistantId: string, options?: RequestOptions): Promise<void>;
+    getAccessibleAssistants(options?: RequestOptions): Promise<{
+        assistants: AssistantResponse[];
+    }>;
+    getPopularAssistants(limit?: number, options?: RequestOptions): Promise<{
+        assistants: AssistantResponse[];
+    }>;
+    incrementAssistantUsage(assistantId: string, options?: RequestOptions): Promise<AssistantResponse>;
+    duplicateAssistant(assistantId: string, newName: string, options?: RequestOptions): Promise<AssistantResponse>;
+    getProviders(options?: RequestOptions): Promise<{
+        providers: ProviderListItem[];
+    }>;
+    getProvider(providerKey: string, options?: RequestOptions): Promise<ProviderDetail>;
+    getAccessibleProviders(options?: RequestOptions): Promise<{
+        providers: ProviderListItem[];
+    }>;
+    getModels(params?: {
+        provider?: string;
+        capability?: string;
+    }, options?: RequestOptions): Promise<{
+        models: ModelListItem[];
+    }>;
+    getModel(modelId: string, options?: RequestOptions): Promise<ModelDetail>;
+    getModelsByProvider(providerKey: string, options?: RequestOptions): Promise<{
+        models: ModelListItem[];
+    }>;
+    getAccessibleModels(options?: RequestOptions): Promise<{
+        models: ModelListItem[];
+    }>;
+    getSessionMessages(sessionId: string, params?: {
+        page?: number;
+        limit?: number;
+    }, options?: RequestOptions): Promise<PaginatedSessionMessageResponse>;
+    addMessageToSession(sessionId: string, request: AddMessageRequest, options?: RequestOptions): Promise<SessionResponse>;
+    deleteSessionsBatch(sessionIds: string[], options?: RequestOptions): Promise<BatchDeleteSessionsResponse>;
+    switchSessionModel(sessionId: string, modelName: string, options?: RequestOptions): Promise<SessionResponse>;
+    getSessionStatistics(timeRange?: 'today' | 'week' | 'month' | 'year', options?: RequestOptions): Promise<SessionStatistics>;
+    getAssistantModels(assistantId: string, options?: RequestOptions): Promise<AssistantModelsResponse>;
+}

package/lib/srvice/AiService.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiService = void 0;
+// src/srvice/AiService.ts
+const BaseClient_1 = require("../client/BaseClient");
+class AiService extends BaseClient_1.BaseClient {
+    constructor(config) {
+        super(config, 'ai');
+    }
+    // ==================== Chat对话接口 ====================
+    // 聊天补全（非流式）
+    async chatCompletion(request, options) {
+        return this.request('/chat/completion', {
+            ...options,
+            method: 'POST',
+            body: request
+        });
+    }
+    // 获取聊天可用模型
+    async getChatModels(options) {
+        return this.request('/chat/models', {
+            ...options,
+            method: 'GET'
+        });
+    }
+    // ==================== Session管理接口 ====================
+    // 创建会话
+    async createSession(request, options) {
+        return this.request('/session', {
+            ...options,
+            method: 'POST',
+            body: request
+        });
+    }
+    // 获取用户会话列表
+    async getSessions(params, options) {
+        return this.request('/session', {
+            ...options,
+            method: 'GET',
+            params
+        });
+    }
+    // 获取会话详情
+    async getSession(sessionId, options) {
+        return this.request(`/session/${sessionId}`, {
+            ...options,
+            method: 'GET'
+        });
+    }
+    // 更新会话
+    async updateSession(sessionId, request, options) {
+        return this.request(`/session/${sessionId}`, {
+            ...options,
+            method: 'PUT',
+            body: request
+        });
+    }
+    // 结束会话
+    async endSession(sessionId, options) {
+        return this.request(`/session/${sessionId}/end`, {
+            ...options,
+            method: 'POST'
+        });
+    }
+    // 删除会话
+    async deleteSession(sessionId, options) {
+        return this.request(`/session/${sessionId}`, {
+            ...options,
+            method: 'DELETE'
+        });
+    }
+    // 获取会话模型信息
+    async getSessionModel(sessionId, options) {
+        return this.request(`/session/${sessionId}/model`, {
+            ...options,
+            method: 'GET'
+        });
+    }
+    // 获取用户活跃会话
+    async getActiveSessions(options) {
+        return this.request('/session/active', {
+            ...options,
+            method: 'GET'
+        });
+    }
+    // ==================== Assistant管理接口 ====================
+    // 创建助手
+    async createAssistant(request, options) {
+        return this.request('/assistant', {
+            ...options,
+            method: 'POST',
+            body: request
+        });
+    }
+    // 获取助手列表
+    async getAssistants(params, options) {
+        return this.request('/assistant', {
+            ...options,
+            method: 'GET',
+            params
+        });
+    }
+    // 获取助手详情
+    async getAssistant(assistantId, options) {
+        return this.request(`/assistant/${assistantId}`, {
+            ...options,
+            method: 'GET'
+        });
+    }
+    // 更新助手
+    async updateAssistant(assistantId, request, options) {
+        return this.request(`/assistant/${assistantId}`, {
+            ...options,
+            method: 'PUT',
+            body: request
+        });
+    }
+    // 删除助手
+    async deleteAssistant(assistantId, options) {
+        return this.request(`/assistant/${assistantId}`, {
+            ...options,
+            method: 'DELETE'
+        });
+    }
+    // 获取可访问的助手
+    async getAccessibleAssistants(options) {
+        return this.request('/assistant/accessible', {
+            ...options,
+            method: 'GET'
+        });
+    }
+    // 获取热门助手
+    async getPopularAssistants(limit, options) {
+        return this.request('/assistant/popular', {
+            ...options,
+            method: 'GET',
+            params: limit ? { limit } : undefined
+        });
+    }
+    // 增加助手使用次数
+    async incrementAssistantUsage(assistantId, options) {
+        return this.request(`/assistant/${assistantId}/usage`, {
+            ...options,
+            method: 'POST'
+        });
+    }
+    // 复制助手
+    async duplicateAssistant(assistantId, newName, options) {
+        return this.request(`/assistant/${assistantId}/duplicate`, {
+            ...options,
+            method: 'POST',
+            body: { newName }
+        });
+    }
+    // ==================== Provider管理接口 ====================
+    // 获取服务商列表
+    async getProviders(options) {
+        return this.request('/provider', {
+            ...options,
+            method: 'GET'
+        });
+    }
+    // 获取服务商详情
+    async getProvider(providerKey, options) {
+        return this.request(`/provider/${providerKey}`, {
+            ...options,
+            method: 'GET'
+        });
+    }
+    // 获取当前用户可访问的服务商
+    async getAccessibleProviders(options) {
+        return this.request('/provider/accessible/me', {
+            ...options,
+            method: 'GET'
+        });
+    }
+    // ==================== Model管理接口 ====================
+    // 获取模型列表
+    async getModels(params, options) {
+        return this.request('/model', {
+            ...options,
+            method: 'GET',
+            params
+        });
+    }
+    // 获取模型详情
+    async getModel(modelId, options) {
+        return this.request(`/model/${modelId}`, {
+            ...options,
+            method: 'GET'
+        });
+    }
+    // 按服务商获取模型列表
+    async getModelsByProvider(providerKey, options) {
+        return this.request(`/model/by-provider/${providerKey}`, {
+            ...options,
+            method: 'GET'
+        });
+    }
+    // 获取当前用户可访问的模型
+    async getAccessibleModels(options) {
+        return this.request('/model/accessible/me', {
+            ...options,
+            method: 'GET'
+        });
+    }
+    // 获取会话消息历史
+    async getSessionMessages(sessionId, params, options) {
+        return this.request(`/session/${sessionId}/messages`, {
+            ...options,
+            method: 'GET',
+            params
+        });
+    }
+    // 添加消息到会话
+    async addMessageToSession(sessionId, request, options) {
+        return this.request(`/session/${sessionId}/message`, {
+            ...options,
+            method: 'POST',
+            body: request
+        });
+    }
+    // 批量删除会话
+    async deleteSessionsBatch(sessionIds, options) {
+        return this.request('/session/batch', {
+            ...options,
+            method: 'DELETE',
+            body: { sessionIds }
+        });
+    }
+    // 切换会话模型
+    async switchSessionModel(sessionId, modelName, options) {
+        const request = { modelName };
+        return this.request(`/session/${sessionId}/model`, {
+            ...options,
+            method: 'PUT',
+            body: request
+        });
+    }
+    // 获取会话统计信息
+    async getSessionStatistics(timeRange, options) {
+        return this.request('/session/statistics', {
+            ...options,
+            method: 'GET',
+            params: timeRange ? { timeRange } : undefined
+        });
+    }
+    // 获取助手可用模型
+    async getAssistantModels(assistantId, options) {
+        return this.request(`/assistant/${assistantId}/models`, {
+            ...options,
+            method: 'GET'
+        });
+    }
+}
+exports.AiService = AiService;