tabby-ai-assistant 1.0.13 → 1.0.16

package/src/types/ai.types.ts

@@ -6,7 +6,8 @@
 export enum MessageRole {
     USER = 'user',
     ASSISTANT = 'assistant',
-    SYSTEM = 'system'
+    SYSTEM = 'system',
+    TOOL = 'tool'      // 工具结果角色（部分 AI 需要）
 }
 
 // 聊天消息
@@ -140,7 +141,7 @@ export interface ValidationResult {
 
 // API消息接口（支持压缩标记）
 export interface ApiMessage {
-    role: 'user' | 'assistant' | 'system';
+    role: 'user' | 'assistant' | 'system' | 'tool' | 'function';
     content: string | ContentBlock[];
     ts: number;  // 时间戳（毫秒）
 
@@ -148,6 +149,11 @@ export interface ApiMessage {
     isSummary?: boolean;        // 是否为摘要消息
     condenseId?: string;        // 摘要ID
     condenseParent?: string;    // 被哪个摘要压缩
+    summaryMeta?: {             // 摘要元数据
+        originalMessageCount: number;
+        tokensCost: number;
+        compressionRatio: number;
+    };
 
     // 截断相关元数据
     isTruncationMarker?: boolean;  // 是否为截断标记
@@ -245,6 +251,16 @@ export interface ExtendedChatMessage extends ChatMessage {
     tokenUsage?: TokenUsage;
 }
 
+// 压缩后的检查点数据接口
+export interface CompressedCheckpointData {
+    compressed: boolean;
+    compressionRatio: number;
+    originalSize: number;
+    compressedSize: number;
+    messages?: ApiMessage[]; // 可选，用于即时访问
+    messagesJson: string; // 压缩后的JSON字符串
+}
+
 // 检查点接口
 export interface Checkpoint {
     id: string;
@@ -253,6 +269,11 @@ export interface Checkpoint {
     summary: string;
     createdAt: number;  // 时间戳（毫秒）
     tokenUsage: TokenUsage;
+    compressedData?: CompressedCheckpointData; // 压缩数据（可选）
+
+    // 新增字段
+    tags?: string[];      // 标签列表
+    isArchived?: boolean; // 是否已归档
 }
 
 // ============================================================================
@@ -261,7 +282,7 @@ export interface Checkpoint {
 
 // 流式事件类型
 export interface StreamEvent {
-    type: 'text_delta' | 'tool_use_start' | 'tool_use_delta' | 'tool_use_end' | 'message_end' | 'error';
+    type: 'text_delta' | 'tool_use_start' | 'tool_use_delta' | 'tool_use_end' | 'tool_result' | 'tool_error' | 'message_end' | 'error';
     // 文本增量
     textDelta?: string;
     // 工具调用（完整时才有）
@@ -270,8 +291,140 @@ export interface StreamEvent {
         name: string;
         input: any;
     };
+    // 工具结果（tool_result 事件）
+    result?: {
+        tool_use_id: string;
+        content: string;
+        is_error?: boolean;
+    };
     // 错误信息
     error?: string;
     // 最终消息（message_end 时）
     message?: ChatMessage;
 }
+
+// ============================================================================
+// Agent 循环相关类型定义
+// ============================================================================
+
+// 工具调用接口
+export interface ToolCall {
+    id: string;
+    name: string;
+    input: any;
+}
+
+// 工具结果接口
+export interface ToolResult {
+    tool_use_id: string;
+    name?: string;        // 工具名称
+    content: string;
+    is_error?: boolean;
+}
+
+// Agent 事件类型
+export type AgentEventType =
+    | 'text_delta'           // 文本增量
+    | 'tool_use_start'       // 工具开始
+    | 'tool_use_end'         // 工具调用结束（收集参数）
+    | 'tool_executing'       // 工具正在执行
+    | 'tool_executed'        // 工具执行完成（带结果）
+    | 'tool_error'           // 工具执行错误
+    | 'round_start'          // 新一轮开始
+    | 'round_end'            // 一轮结束
+    | 'agent_complete'       // Agent 循环完成
+    | 'error';               // 错误
+
+// Agent 流式事件
+export interface AgentStreamEvent {
+    type: AgentEventType;
+
+    // text_delta 事件
+    textDelta?: string;
+
+    // 工具相关事件
+    toolCall?: {
+        id: string;
+        name: string;
+        input: any;
+    };
+
+    // tool_executed/tool_error 事件
+    toolResult?: {
+        tool_use_id: string;
+        content: string;
+        is_error?: boolean;
+        duration?: number;
+    };
+
+    // round_start/round_end 事件
+    round?: number;
+
+    // agent_complete 事件
+    reason?: TerminationReason;
+    totalRounds?: number;
+    terminationMessage?: string;  // 可选的终止详情消息
+
+    // error 事件
+    error?: string;
+
+    // message_end 保留
+    message?: ChatMessage;
+}
+
+// Agent 循环配置
+export interface AgentLoopConfig {
+    maxRounds?: number;           // 最大轮数，默认 15
+    timeoutMs?: number;           // 默认 120000 (2分钟)
+    repeatThreshold?: number;     // 默认 3 次
+    failureThreshold?: number;    // 默认 2 次
+    enableTaskComplete?: boolean; // 默认 true
+    onRoundStart?: (round: number) => void;
+    onRoundEnd?: (round: number) => void;
+    onAgentComplete?: (reason: string, totalRounds: number) => void;
+}
+
+// ============================================================================
+// 智能 Agent 终止相关类型定义
+// ============================================================================
+
+// 终止原因枚举
+export type TerminationReason =
+    | 'task_complete'      // AI 主动调用 task_complete 工具
+    | 'no_tools'           // 本轮无工具调用
+    | 'summarizing'        // 检测到 AI 正在总结
+    | 'repeated_tool'      // 重复调用相同工具
+    | 'high_failure_rate'  // 连续失败率过高
+    | 'timeout'            // 总时间超时
+    | 'max_rounds'         // 达到最大轮数（安全保底）
+    | 'user_cancel';       // 用户取消
+
+// Agent 状态追踪
+export interface AgentState {
+    currentRound: number;
+    startTime: number;
+    toolCallHistory: ToolCallRecord[];
+    lastAiResponse: string;
+    isActive: boolean;
+}
+
+// 工具调用记录
+export interface ToolCallRecord {
+    name: string;
+    input: any;
+    inputHash: string;  // 用于快速比较
+    success: boolean;
+    timestamp: number;
+}
+
+// 终止检测结果
+export interface TerminationResult {
+    shouldTerminate: boolean;
+    reason: TerminationReason;
+    message?: string;
+}
+
+// 扩展 ToolResult 添加任务完成标记
+export interface ExtendedToolResult extends ToolResult {
+    isTaskComplete?: boolean;  // 特殊标记：task_complete 工具调用
+}

package/src/utils/cost.utils.ts

@@ -0,0 +1,249 @@
+/**
+ * API成本计算工具类
+ * 提供各AI提供商的API调用成本估算功能
+ */
+
+/**
+ * AI提供商类型
+ */
+export type AIProvider = 'openai' | 'anthropic' | 'minimax' | 'glm' | 'openai-compatible';
+
+/**
+ * 模型定价信息
+ */
+export interface ModelPricing {
+    provider: AIProvider;
+    model: string;
+    inputPricePerMillion: number;  // 每百万输入token的价格（美元）
+    outputPricePerMillion: number; // 每百万输出token的价格（美元）
+}
+
+/**
+ * Token使用信息
+ */
+export interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+}
+
+/**
+ * 成本计算结果
+ */
+export interface CostResult {
+    inputCost: number;       // 输入成本（美元）
+    outputCost: number;      // 输出成本（美元）
+    totalCost: number;       // 总成本（美元）
+    inputPricePerMillion: number;
+    outputPricePerMillion: number;
+}
+
+/**
+ * 默认模型定价表（2024年最新价格）
+ */
+const DEFAULT_PRICING: ModelPricing[] = [
+    // OpenAI
+    { provider: 'openai', model: 'gpt-4', inputPricePerMillion: 30, outputPricePerMillion: 60 },
+    { provider: 'openai', model: 'gpt-4-turbo', inputPricePerMillion: 10, outputPricePerMillion: 30 },
+    { provider: 'openai', model: 'gpt-4o', inputPricePerMillion: 5, outputPricePerMillion: 15 },
+    { provider: 'openai', model: 'gpt-3.5-turbo', inputPricePerMillion: 0.5, outputPricePerMillion: 1.5 },
+
+    // Anthropic
+    { provider: 'anthropic', model: 'claude-3-5-sonnet-20241022', inputPricePerMillion: 3, outputPricePerMillion: 15 },
+    { provider: 'anthropic', model: 'claude-3-opus-20240229', inputPricePerMillion: 15, outputPricePerMillion: 75 },
+    { provider: 'anthropic', model: 'claude-3-haiku-20240307', inputPricePerMillion: 0.25, outputPricePerMillion: 1.25 },
+
+    // Minimax (智谱AI)
+    { provider: 'minimax', model: 'abab6.5s-chat', inputPricePerMillion: 0.3, outputPricePerMillion: 0.3 },
+    { provider: 'minimax', model: 'abab6.5-chat', inputPricePerMillion: 0.5, outputPricePerMillion: 0.5 },
+    { provider: 'minimax', model: 'abab5.5-chat', inputPricePerMillion: 1, outputPricePerMillion: 1 },
+
+    // GLM (智谱AI)
+    { provider: 'glm', model: 'glm-4', inputPricePerMillion: 0.5, outputPricePerMillion: 1.5 },
+    { provider: 'glm', model: 'glm-4v', inputPricePerMillion: 0.5, outputPricePerMillion: 1.5 },
+    { provider: 'glm', model: 'glm-3-turbo', inputPricePerMillion: 0.1, outputPricePerMillion: 0.1 },
+];
+
+// 自定义定价表（可扩展）
+let customPricing: ModelPricing[] = [];
+
+/**
+ * 设置自定义模型定价
+ */
+export function setCustomPricing(pricing: ModelPricing[]): void {
+    customPricing = [...pricing];
+}
+
+/**
+ * 获取模型定价信息
+ */
+export function getModelPricing(provider: AIProvider, model: string): ModelPricing | undefined {
+    // 首先查找自定义定价
+    const custom = customPricing.find(p => p.provider === provider && p.model === model);
+    if (custom) {
+        return custom;
+    }
+
+    // 然后查找默认定价
+    const defaultPricing = DEFAULT_PRICING.find(p => p.provider === provider && p.model === model);
+
+    if (defaultPricing) {
+        return defaultPricing;
+    }
+
+    // 返回该提供商的通用定价
+    return getDefaultPricingForProvider(provider);
+}
+
+/**
+ * 获取提供商的默认定价
+ */
+function getDefaultPricingForProvider(provider: AIProvider): ModelPricing | undefined {
+    const providerDefaults: Record<AIProvider, Partial<ModelPricing>> = {
+        'openai': { inputPricePerMillion: 5, outputPricePerMillion: 15 },
+        'anthropic': { inputPricePerMillion: 3, outputPricePerMillion: 15 },
+        'minimax': { inputPricePerMillion: 0.5, outputPricePerMillion: 0.5 },
+        'glm': { inputPricePerMillion: 0.5, outputPricePerMillion: 1 },
+        'openai-compatible': { inputPricePerMillion: 1, outputPricePerMillion: 2 }
+    };
+
+    const defaults = providerDefaults[provider];
+    if (defaults) {
+        return {
+            provider,
+            model: 'default',
+            inputPricePerMillion: defaults.inputPricePerMillion ?? 1,
+            outputPricePerMillion: defaults.outputPricePerMillion ?? 2
+        };
+    }
+
+    return undefined;
+}
+
+/**
+ * 计算API调用成本
+ * @param provider AI提供商
+ * @param model 模型名称
+ * @param usage Token使用情况
+ * @returns 成本计算结果
+ */
+export function calculateCost(
+    provider: AIProvider,
+    model: string,
+    usage: TokenUsage
+): CostResult {
+    const pricing = getModelPricing(provider, model);
+
+    if (!pricing) {
+        // 未知提供商，返回零成本
+        return {
+            inputCost: 0,
+            outputCost: 0,
+            totalCost: 0,
+            inputPricePerMillion: 0,
+            outputPricePerMillion: 0
+        };
+    }
+
+    const inputCost = (usage.inputTokens / 1000000) * pricing.inputPricePerMillion;
+    const outputCost = (usage.outputTokens / 1000000) * pricing.outputPricePerMillion;
+
+    return {
+        inputCost: Math.round(inputCost * 1000000) / 1000000, // 保留6位小数
+        outputCost: Math.round(outputCost * 1000000) / 1000000,
+        totalCost: Math.round((inputCost + outputCost) * 1000000) / 1000000,
+        inputPricePerMillion: pricing.inputPricePerMillion,
+        outputPricePerMillion: pricing.outputPricePerMillion
+    };
+}
+
+/**
+ * 计算摘要生成成本
+ */
+export function calculateSummaryCost(
+    provider: AIProvider,
+    model: string,
+    originalMessageCount: number,
+    tokensUsed: number
+): CostResult {
+    // 摘要生成主要是输入成本
+    const pricing = getModelPricing(provider, model);
+
+    if (!pricing) {
+        return {
+            inputCost: 0,
+            outputCost: 0,
+            totalCost: 0,
+            inputPricePerMillion: 0,
+            outputPricePerMillion: 0
+        };
+    }
+
+    // 估算摘要的输入和输出token（假设输出占输入的5%）
+    const estimatedInputTokens = tokensUsed;
+    const estimatedOutputTokens = Math.floor(tokensUsed * 0.05);
+
+    return calculateCost(provider, model, {
+        inputTokens: estimatedInputTokens,
+        outputTokens: estimatedOutputTokens
+    });
+}
+
+/**
+ * 格式化成本为可读字符串
+ */
+export function formatCost(cost: number): string {
+    if (cost < 0.001) {
+        return `$${(cost * 1000000).toFixed(2)}`;
+    } else if (cost < 1) {
+        return `$${cost.toFixed(4)}`;
+    } else {
+        return `$${cost.toFixed(2)}`;
+    }
+}
+
+/**
+ * 格式化成本详细信息
+ */
+export function formatCostDetail(result: CostResult): string {
+    const parts: string[] = [];
+
+    if (result.inputCost > 0) {
+        parts.push(`输入: ${formatCost(result.inputCost)}`);
+    }
+    if (result.outputCost > 0) {
+        parts.push(`输出: ${formatCost(result.outputCost)}`);
+    }
+
+    return parts.join(', ') + ` (总计: ${formatCost(result.totalCost)})`;
+}
+
+/**
+ * 估算消息的Token数量
+ */
+export function estimateTokenCount(text: string): number {
+    // 粗略估算：1个Token约等于4个字符（英文）
+    // 中文：1个Token约等于1.5个字符
+    const chineseCharCount = (text.match(/[\u4e00-\u9fa5]/g) || []).length;
+    const englishCharCount = text.length - chineseCharCount;
+
+    return Math.ceil(chineseCharCount / 1.5 + englishCharCount / 4);
+}
+
+/**
+ * 计算批量请求的总成本
+ */
+export function calculateBatchCost(
+    provider: AIProvider,
+    model: string,
+    requests: TokenUsage[]
+): CostResult {
+    const totalUsage = requests.reduce(
+        (acc, usage) => ({
+            inputTokens: acc.inputTokens + usage.inputTokens,
+            outputTokens: acc.outputTokens + usage.outputTokens
+        }),
+        { inputTokens: 0, outputTokens: 0 }
+    );
+
+    return calculateCost(provider, model, totalUsage);
+}