nolo-cli 0.1.13 → 0.1.15

package/ai/context/calculateContextUsage.ts

@@ -0,0 +1,133 @@
+// ai/context/calculateContextUsage.ts
+
+/**
+ * 计算 Agent 的 Context 使用情况。
+ * 
+ * 用于：
+ * 1. Agent 编辑页面的 Token 预算可视化
+ * 2. 运行时的 Context 监控
+ * 3. 超标警告
+ */
+
+import { estimateTokenCount, CONTEXT_BUDGET, calcTokenUsagePercent } from "./tokenUtils";
+import { getModelContextWindow } from "../llm/getModelContextWindow";
+import type { ReferenceItem } from "app/types";
+
+export interface ContextUsageBreakdown {
+    // 各部分 Token 使用
+    referencesTokens: number;
+    spaceContextTokens: number;
+    systemPromptTokens: number;
+    historyTokens: number;
+
+    // 总计
+    totalUsed: number;
+    modelContextWindow: number;
+    availableTokens: number;
+
+    // 百分比
+    usedPercent: number;
+    referencesPercent: number;
+
+    // 状态
+    isWarning: boolean;
+    isCritical: boolean;
+    warningMessage?: string;
+}
+
+export interface ContextUsageInput {
+    modelName: string;
+    references?: ReferenceItem[];
+    referencesContent?: string; // 如果已经拼接好的内容
+    spaceContext?: string | null;
+    systemPrompt?: string;
+    historyContext?: string | null;
+}
+
+/**
+ * 计算 Context 使用情况
+ */
+export const calculateContextUsage = (input: ContextUsageInput): ContextUsageBreakdown => {
+    const {
+        modelName,
+        references,
+        referencesContent,
+        spaceContext,
+        systemPrompt,
+        historyContext,
+    } = input;
+
+    // 获取模型的 Context Window
+    const modelContextWindow = getModelContextWindow(modelName);
+
+    // 估算各部分 Token 数
+    // References: 如果提供了 content 直接用，否则根据数量估算
+    let referencesTokens = 0;
+    if (referencesContent) {
+        referencesTokens = estimateTokenCount(referencesContent);
+    } else if (references && references.length > 0) {
+        // 粗略估算：每个 reference 平均 2000 tokens（需要实际获取内容才能精确）
+        referencesTokens = references.length * 2000;
+    }
+
+    const spaceContextTokens = estimateTokenCount(spaceContext || "");
+    const systemPromptTokens = estimateTokenCount(systemPrompt || "");
+    const historyTokens = estimateTokenCount(historyContext || "");
+
+    // 计算总使用量（References + Space 是预分配的，其他是动态的）
+    const preAllocatedTokens = referencesTokens + spaceContextTokens;
+    const totalUsed = preAllocatedTokens + systemPromptTokens + historyTokens;
+    const availableTokens = modelContextWindow - totalUsed;
+
+    // 计算百分比
+    const usedPercent = calcTokenUsagePercent(totalUsed, modelContextWindow);
+    const referencesPercent = calcTokenUsagePercent(preAllocatedTokens, modelContextWindow);
+
+    // 判断状态
+    const isWarning = referencesPercent > CONTEXT_BUDGET.REFERENCES_MAX_PERCENT;
+    const isCritical = usedPercent > 80;
+
+    // 生成警告消息
+    let warningMessage: string | undefined;
+    if (isCritical) {
+        warningMessage = `⚠️ 上下文已使用 ${usedPercent}%，可能影响对话质量。建议减少 References 或 Space 内容。`;
+    } else if (isWarning) {
+        warningMessage = `⚡ References 和 Space 已占用 ${referencesPercent}% 上下文，建议控制在 ${CONTEXT_BUDGET.REFERENCES_MAX_PERCENT}% 以内。`;
+    }
+
+    return {
+        referencesTokens,
+        spaceContextTokens,
+        systemPromptTokens,
+        historyTokens,
+        totalUsed,
+        modelContextWindow,
+        availableTokens,
+        usedPercent,
+        referencesPercent,
+        isWarning,
+        isCritical,
+        warningMessage,
+    };
+};
+
+/**
+ * 快速检查 References 是否超标
+ * 用于 Agent 编辑页面的实时反馈
+ */
+export const checkReferencesOverBudget = (
+    modelName: string,
+    referencesTokens: number
+): { isOver: boolean; percent: number; message?: string } => {
+    const modelContextWindow = getModelContextWindow(modelName);
+    const percent = calcTokenUsagePercent(referencesTokens, modelContextWindow);
+    const isOver = percent > CONTEXT_BUDGET.REFERENCES_MAX_PERCENT;
+
+    return {
+        isOver,
+        percent,
+        message: isOver
+            ? `References 占用 ${percent}%，超过建议上限 ${CONTEXT_BUDGET.REFERENCES_MAX_PERCENT}%`
+            : undefined,
+    };
+};

package/ai/context/retention.ts

@@ -0,0 +1,165 @@
+// 文件路径: packages/ai/context/retention.ts
+
+/**
+ * 将 contextRetention slider (1–100) 映射为实际保留比例 R ∈ (0, 1)。
+ *
+ * 分三档线性映射：
+ * - 低保留：  1–30  → 15% ~ 30%
+ * - 中保留： 31–70 → 30% ~ 60%
+ * - 高保留： 71–100 → 60% ~ 85%
+ */
+export const mapRetentionSliderToRatio = (slider: number): number => {
+  const s = Math.min(100, Math.max(1, slider));
+
+  if (s <= 30) {
+    // Low retention: 15% ~ 30%
+    return 0.15 + (0.30 - 0.15) * (s / 30);
+  }
+
+  if (s <= 70) {
+    // Medium retention: 30% ~ 60%
+    return 0.30 + (0.60 - 0.30) * ((s - 30) / 40);
+  }
+
+  // High retention: 60% ~ 85%
+  return 0.60 + (0.85 - 0.60) * ((s - 70) / 30);
+};
+
+/**
+ * 安全系数：只允许历史对话最多占用 contextWindow 的 SAFE_BUFFER_RATIO 部分，
+ * 预留剩余空间给 system prompt / 工具描述等固定开销。
+ */
+export const SAFE_BUFFER_RATIO = 0.9;
+
+/**
+ * 对话负载分档：
+ * - light  ：短句聊天为主
+ * - medium ：中等长度混合
+ * - heavy  ：长代码 / 长文档为主
+ */
+export type ConversationLoad = "light" | "medium" | "heavy";
+
+export interface ContextPlan {
+  /**
+   * 历史总预算（summary + 原始消息），单位：token
+   * 实际不会超过 contextWindow * SAFE_BUFFER_RATIO
+   */
+  historyBudget: number;
+  /**
+   * 历史中分配给「原始消息」的预算，单位：token
+   * 用于 trimMessagesWithSummary 之类的裁剪逻辑。
+   */
+  rawMessageBudget: number;
+  /**
+   * 希望至少保留的「最近尾部消息」的 token 数，用作二次兜底，
+   * 确保短句对话能多保几轮，重内容对话能保住最近几条大块内容。
+   */
+  minTailTokens: number;
+}
+
+const clamp = (v: number, min: number, max: number): number =>
+  Math.min(max, Math.max(min, v));
+
+/**
+ * 统一的上下文使用规划函数：
+ * - 输入：模型 window、用户 slider、现有 summary 长度、近期对话负载分档
+ * - 输出：历史总预算 + 原始消息预算 + 尾部最少保留 token 数
+ *
+ * 约束与策略：
+ * - 历史最多只能占用 contextWindow * SAFE_BUFFER_RATIO
+ * - slider 决定「整体偏好多记还是少记」
+ * - recentLoad 决定在该偏好下的微调：
+ *   - light ：适当放宽，给更多历史空间
+ *   - heavy ：适当收紧，为当前大块内容 / 工具描述预留空间
+ */
+export const planContextUsage = (params: {
+  contextWindow: number;
+  retentionSlider: number;
+  summaryTokens: number;
+  recentLoad: ConversationLoad;
+}): ContextPlan => {
+  const { contextWindow, retentionSlider, summaryTokens, recentLoad } = params;
+
+  const safeWindowLimit = Math.floor(contextWindow * SAFE_BUFFER_RATIO);
+
+  const s = Math.min(100, Math.max(1, retentionSlider));
+  const iq = s / 100; // 0~1，表示用户偏好的“记忆强度”
+
+  const isBigWindow = contextWindow >= 128000; // 例如 128k / 1M 等大模型
+  const isSmallWindow = contextWindow <= 32000; // 例如 8k / 16k 等小模型
+
+  // 基础历史比例（只考虑 slider，不考虑对话负载）
+  // - 小窗口：历史占 35% ~ 70% 的 safeWindow
+  // - 中窗口：历史占 40% ~ 75%
+  // - 大窗口：历史占 65% ~ 90%（尽量吃满大模型上下文）
+  let baseHistoryRatio: number;
+  if (isBigWindow) {
+    baseHistoryRatio = 0.65 + 0.25 * iq; // 0.65 ~ 0.90
+  } else if (isSmallWindow) {
+    baseHistoryRatio = 0.35 + 0.35 * iq; // 0.35 ~ 0.70
+  } else {
+    baseHistoryRatio = 0.40 + 0.35 * iq; // 0.40 ~ 0.75
+  }
+
+  // 1. 历史比例：在 baseHistoryRatio 基础上，根据对话负载做微调
+  let historyRatio = baseHistoryRatio;
+
+  switch (recentLoad) {
+    case "light": {
+      // 短句对话：可以多给一点历史空间，但仍保留少量余量给其他上下文
+      const maxRatio = isBigWindow ? 0.95 : 0.85;
+      historyRatio = clamp(historyRatio * 1.05, 0.3, maxRatio);
+      break;
+    }
+    case "heavy": {
+      // 重内容对话：适当收紧历史比例，为当前大块内容 / 工具描述等预留更多窗口
+      const maxRatio = isBigWindow ? 0.90 : 0.80;
+      historyRatio = clamp(historyRatio * 0.9, 0.3, maxRatio);
+      break;
+    }
+    case "medium":
+    default: {
+      const maxRatio = isBigWindow ? 0.90 : 0.85;
+      historyRatio = clamp(historyRatio, 0.3, maxRatio);
+      break;
+    }
+  }
+
+  const historyBudget = Math.max(
+    0,
+    Math.floor(safeWindowLimit * historyRatio),
+  );
+
+  // 2. 在历史预算里分配给「原始消息」的预算
+  //    - summary 已经占用一部分
+  //    - 同时保证原始消息至少有一部分空间（heavy 用户更多一点）
+  const minRawRatio = recentLoad === "heavy" ? 0.4 : 0.2;
+
+  const rawMessageBudget = Math.max(
+    Math.floor(historyBudget * minRawRatio),
+    historyBudget - summaryTokens,
+    0,
+  );
+
+  // 3. 希望至少保留的尾部 token 数
+  //    - light ：多保几轮短句（不超过 30% window，且上限 8k）
+  //    - heavy ：至少给几条大块代码空间（>= 16k，或 25% window）
+  //    - medium：取中间值
+  let minTailTokens: number;
+
+  if (recentLoad === "light") {
+    minTailTokens = Math.min(
+      Math.floor(safeWindowLimit * 0.3),
+      8000,
+    );
+  } else if (recentLoad === "heavy") {
+    minTailTokens = Math.max(
+      Math.floor(safeWindowLimit * 0.25),
+      16000,
+    );
+  } else {
+    minTailTokens = Math.floor(safeWindowLimit * 0.2);
+  }
+
+  return { historyBudget, rawMessageBudget, minTailTokens };
+};

package/ai/context/tokenUtils.ts

@@ -0,0 +1,78 @@
+// ai/context/tokenUtils.ts
+
+/**
+ * 简单的 Token 估算工具。
+ * 
+ * 规则：
+ * - 中文字符：约 1.5 tokens/字
+ * - 英文及其他字符：约 0.25 tokens/字符（即 4 字符 ≈ 1 token）
+ * 
+ * 这是一个粗略估算，精确值需要使用 tiktoken 等库。
+ */
+
+/**
+ * 估算文本的 Token 数量
+ */
+export const estimateTokenCount = (text: string): number => {
+    if (!text) return 0;
+
+    // 匹配中文字符（包括常用汉字范围）
+    const chineseChars = (text.match(/[\u4e00-\u9fa5\u3400-\u4dbf]/g) || []).length;
+    const otherChars = text.length - chineseChars;
+
+    // 中文 1.5 token/字，其他 0.25 token/字符
+    return Math.ceil(chineseChars * 1.5 + otherChars * 0.25);
+};
+
+/**
+ * 估算多个文本的 Token 总数
+ */
+export const estimateTotalTokens = (texts: (string | undefined | null)[]): number => {
+    return texts.reduce((sum, text) => sum + estimateTokenCount(text || ""), 0);
+};
+
+/**
+ * 格式化 Token 数量为可读字符串
+ * 例如：1500 -> "1.5k", 150000 -> "150k"
+ */
+export const formatTokenCount = (count: number): string => {
+    if (count < 1000) return String(count);
+    if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
+    return `${Math.round(count / 1000)}k`;
+};
+
+/**
+ * 计算 Token 使用百分比
+ */
+export const calcTokenUsagePercent = (used: number, total: number): number => {
+    if (total <= 0) return 0;
+    return Math.min(100, Math.round((used / total) * 100));
+};
+
+/**
+ * Context 分配建议阈值
+ * - References/Space Context 不应超过总量的 40%
+ * - 为对话历史和用户输入预留 40%
+ * - 为系统提示预留 10%
+ * - 为输出预留 10%
+ */
+export const CONTEXT_BUDGET = {
+    REFERENCES_MAX_PERCENT: 40, // References + Space Context 最大占比
+    HISTORY_RESERVE_PERCENT: 40, // 为对话历史预留
+    SYSTEM_RESERVE_PERCENT: 10, // 系统提示预留
+    OUTPUT_RESERVE_PERCENT: 10, // 输出预留
+};
+
+/**
+ * 判断 Token 使用是否超过警告阈值
+ */
+export const isTokenUsageWarning = (usedPercent: number): boolean => {
+    return usedPercent > CONTEXT_BUDGET.REFERENCES_MAX_PERCENT;
+};
+
+/**
+ * 判断 Token 使用是否严重超标
+ */
+export const isTokenUsageCritical = (usedPercent: number): boolean => {
+    return usedPercent > 60; // 超过 60% 可能影响对话历史
+};

package/ai/index.ts

@@ -1 +1 @@
-export const test = 1;
+console.log('Hello via Bun!');

package/ai/llm/agentCapabilities.ts

@@ -0,0 +1,74 @@
+import {
+  findModelConfig,
+  getProviderByModelName,
+} from "./providers";
+
+type AgentCapabilityConfig = {
+  apiSource?: string | null;
+  provider?: string | null;
+  model?: string | null;
+  hasVision?: boolean | null;
+  useServerProxy?: boolean | null;
+};
+
+const isCustomAgent = (agent: AgentCapabilityConfig): boolean => {
+  const apiSource = agent.apiSource?.toLowerCase();
+  const provider = agent.provider?.toLowerCase();
+  return apiSource === "custom" || provider === "custom";
+};
+
+const lookupKnownModelVision = (
+  provider: string | null,
+  model: string,
+): boolean | undefined => {
+  if (!model) return undefined;
+
+  if (provider) {
+    const direct = findModelConfig(provider, model);
+    if (direct) return direct.hasVision;
+  }
+
+  const detected = getProviderByModelName(model);
+  if (detected) {
+    return findModelConfig(detected, model)?.hasVision;
+  }
+
+  if (!provider && model.includes("/")) {
+    const slash = model.indexOf("/");
+    const modelProvider = model.slice(0, slash).toLowerCase();
+    const modelName = model.slice(slash + 1);
+    const nested = findModelConfig(modelProvider, modelName);
+    if (nested) return nested.hasVision;
+  }
+
+  return undefined;
+};
+
+export const resolveAgentImageInputSupport = (
+  agent: AgentCapabilityConfig | null | undefined,
+): boolean => {
+  if (!agent) return true;
+
+  const provider = agent.provider?.trim().toLowerCase() || null;
+  const model = agent.model?.trim() || "";
+  const custom = isCustomAgent(agent);
+  const catalogHasVision = lookupKnownModelVision(
+    custom ? null : provider,
+    model,
+  );
+
+  if (!custom && catalogHasVision !== undefined) {
+    return catalogHasVision;
+  }
+
+  if (custom) {
+    if (catalogHasVision === true) return true;
+    return true;
+  }
+
+  if (typeof agent.hasVision === "boolean") {
+    return agent.hasVision;
+  }
+
+  return true;
+};

package/ai/llm/calculateGeminiImageTokens.ts

@@ -0,0 +1,57 @@
+// src/calcGeminiImageTokens.ts
+
+/**
+ * Gemini 图片 token 计算（粗略公式版）
+ *
+ * 规则：
+ * - 若宽高都 <= 384，则直接按 1 个图块：258 tokens
+ * - 否则：
+ *   - uRaw = floor( min(width, height) / 1.5 )
+ *   - u = clamp(uRaw, 256, 768)
+ *   - tilesX = ceil(width  / u)
+ *   - tilesY = ceil(height / u)
+ *   - tiles  = tilesX * tilesY
+ *   - tokens = tiles * 258
+ */
+
+export const GEMINI_IMAGE_TILE_TOKENS = 258;
+export const GEMINI_SMALL_IMAGE_THRESHOLD = 384;
+export const GEMINI_MIN_TILE_SIZE = 256;
+export const GEMINI_MAX_TILE_SIZE = 768;
+
+const clamp = (value: number, min: number, max: number): number =>
+    Math.min(Math.max(value, min), max);
+
+const ceilDiv = (numerator: number, denominator: number): number =>
+    Math.ceil(numerator / denominator);
+
+/**
+ * 计算单张图片的 token 数（适用于 Gemini 1.5 / 2.0 / 2.5 的粗略估算）
+ */
+export const calculateGeminiImageTokens = (
+    width: number,
+    height: number,
+): number => {
+    if (!Number.isFinite(width) || !Number.isFinite(height)) {
+        throw new TypeError('width 和 height 必须是有限数字');
+    }
+    if (width <= 0 || height <= 0) {
+        throw new RangeError('width 和 height 必须为正数');
+    }
+
+    // 情况 1：小图（两个维度都 <= 384）
+    if (width <= GEMINI_SMALL_IMAGE_THRESHOLD && height <= GEMINI_SMALL_IMAGE_THRESHOLD) {
+        return GEMINI_IMAGE_TILE_TOKENS;
+    }
+
+    // 情况 2：大图，按粗略公式计算图块数量
+    const minSide = Math.min(width, height);
+    const rawUnit = Math.floor(minSide / 1.5);
+    const unit = clamp(rawUnit, GEMINI_MIN_TILE_SIZE, GEMINI_MAX_TILE_SIZE);
+
+    const tilesX = ceilDiv(width, unit);
+    const tilesY = ceilDiv(height, unit);
+    const tiles = tilesX * tilesY;
+
+    return tiles * GEMINI_IMAGE_TILE_TOKENS;
+};

package/ai/llm/deepinfra.ts

@@ -0,0 +1,28 @@
+// ai/llm/deepinfra.ts
+export const deepinfraModels = [
+  {
+    name: "moonshotai/Kimi-K2.5",
+    displayName: "MoonshotAI: Kimi K2.5 (DeepInfra)",
+    hasVision: true,
+    price: {
+      input: 0.45 * 8,
+      output: 2.25 * 8,
+      inputCacheHit: 0.07 * 8,
+    },
+    maxOutputTokens: 262144,
+    contextWindow: 262144,
+    supportsTool: true,
+  },
+  {
+    name: "zai-org/GLM-5.1",
+    displayName: "Z.AI: GLM 5.1 (DeepInfra)",
+    hasVision: false,
+    price: {
+      input: 1.26 * 8,
+      output: 3.96 * 8,
+      inputCacheHit: 0.26 * 8,
+    },
+    contextWindow: 202752,
+    supportsTool: true,
+  },
+];

package/ai/llm/fireworks.ts

@@ -0,0 +1,68 @@
+// ai/llm/fireworks.ts
+import {
+    FIREWORKS_KIMI_CURRENT_MODEL,
+    FIREWORKS_KIMI_LATEST_MODEL,
+} from "./kimi";
+
+export const fireworksModels = [
+    // --- MoonshotAI Models (Kimi) ---
+    {
+        name: FIREWORKS_KIMI_LATEST_MODEL,
+        displayName: "MoonshotAI: Kimi Latest",
+        hasVision: true,
+        price: {
+            input: 0.95 * 8,
+            output: 4.0 * 8,
+            cachingRead: 0.16 * 8,
+        },
+        maxOutputTokens: 262144,
+        contextWindow: 262144,
+        supportsTool: true,
+    },
+    {
+        name: FIREWORKS_KIMI_CURRENT_MODEL,
+        displayName: "MoonshotAI: Kimi K2.6",
+        hasVision: true,
+        price: {
+            input: 0.95 * 8,
+            output: 4.0 * 8,
+            cachingRead: 0.16 * 8,
+        },
+        maxOutputTokens: 262144,
+        contextWindow: 262144,
+        supportsTool: true,
+    },
+    {
+        name: "accounts/fireworks/models/minimax-m2p7",
+        displayName: "MiniMax: MiniMax M2.7",
+        hasVision: true,
+        price: {
+            input: 0.3 * 8,
+            output: 1.2 * 8,
+            cachingRead: 0.06 * 8,
+        },
+        supportsTool: true,
+    },
+    {
+        name: "accounts/fireworks/models/qwen3p6-plus",
+        displayName: "Qwen: Qwen 3.6 Plus",
+        hasVision: true,
+        price: {
+            input: 0.5 * 8,
+            output: 3.0 * 8,
+            cachingRead: 0.1 * 8,
+        },
+        supportsTool: true,
+    },
+    {
+        name: "accounts/fireworks/models/glm-5p1",
+        displayName: "Z.AI: GLM 5.1",
+        hasVision: true,
+        price: {
+            input: 1.0 * 8,
+            output: 3.2 * 8,
+            cachingRead: 0.2 * 8,
+        },
+        supportsTool: true,
+    },
+];