nolo-cli 0.1.13 → 0.1.14

package/ai/agent/types.ts

@@ -0,0 +1,71 @@
+// 文件路径: ai/agent/types.ts
+
+export interface AgentRuntimeOptions {
+    parallelSessionId?: string;
+    parallelBranchId?: string;
+    parallelLabel?: string;
+    parallelIndex?: number;
+
+    /**
+     * 在本次调用中额外开放给 LLM 的工具名称。
+     * 会与 Agent 本身的 tools 数组合并后再传给 LLM。
+     * 名字要和 toolRegistry 中的 schema.name 对齐，例如 "addTableRow"。
+     */
+    extraTools?: string[];
+
+    /**
+     * 当前调用关注的“编辑目标”，用于后续构造 editingContext。
+     * 这里只定义接口，不涉及任何持久化或具体实现。
+     */
+    editingTarget?: {
+        /**
+         * 语义标签，比如: "table" | "page" | "article" | "code" 等。
+         * 未来可以扩展，但不需要改 Prompt 结构。
+         */
+        kind: string;
+        /**
+         * 可选：具体对象的 key，例如表的 dbKey、页面的 pageKey。
+         * 如果不传，后面可以从全局 state 中推断。
+         */
+        key?: string;
+        /**
+         * 可选：用于补充当前编辑对象的人类可读标题。
+         * 适用于对象不在本地 Redux 中、但调用方已知元数据的场景。
+         */
+        title?: string;
+        /**
+         * 可选：调用方预构造的一段简短说明，供 prompt 构造时使用。
+         */
+        summary?: string;
+        /**
+         * 可选：与当前编辑目标相关的轻量元数据。
+         * 例如应用的 framework、url、fileNames 等。
+         */
+        metadata?: Record<string, unknown>;
+    };
+
+    /**
+     * 本轮调用的图片生成配置，仅作用于这一轮请求。
+     * 会在调用前与 Agent / Dialog 的默认配置合并后传给 LLM。
+     */
+    imageConfigOverride?: {
+        /** 是否在本轮启用图片输出（不写或 true 表示按默认；false 可强制关闭） */
+        enabled?: boolean;
+
+        /** 本轮期望的宽高比，不指定则使用上层（Dialog / Agent / 模型）的默认值 */
+        aspectRatio?:
+        | "1:1"
+        | "2:3"
+        | "3:2"
+        | "3:4"
+        | "4:3"
+        | "4:5"
+        | "5:4"
+        | "9:16"
+        | "16:9"
+        | "21:9";
+
+        /** 本轮期望的分辨率大小，不指定则使用上层默认值 */
+        imageSize?: "1K" | "2K" | "4K";
+    };
+}

package/ai/agent/utils/imageOutput.ts

@@ -0,0 +1,39 @@
+import type { Agent } from "app/types";
+import { getModelInfo } from "ai/llm/getModelContextWindow";
+import { getPublicImageAgentMode } from "./publicImageAgentMode";
+
+const LEGACY_IMAGE_MODELS = new Set([
+  "google/gemini-3-image-preview",
+  "google/gemini-3-pro-image-preview",
+  "google/gemini-3.1-flash-image-preview",
+  "google/gemini-2.5-flash-image",
+]);
+
+export function supportsImageGeneration(agent: Agent): boolean {
+  if ((agent as any).hasImageOutput === true) return true;
+
+  // Move continuous-agent check before model registry early return
+  if (getPublicImageAgentMode(agent as any) === "continuous") return true;
+
+  const modelName = String(agent.model || "").trim();
+  if (!modelName) return false;
+
+  const modelInfo = getModelInfo(modelName);
+  if (modelInfo) {
+    return !!(modelInfo.hasImageOutput ?? (modelInfo as any).supportsImageOutput);
+  }
+
+  const normalized = modelName.toLowerCase();
+  if (LEGACY_IMAGE_MODELS.has(normalized)) return true;
+
+  if ((agent as any).imageConfig?.enabled && agent.hasVision) return true;
+
+  if (getPublicImageAgentMode(agent as any) === "continuous") return true;
+
+  return (
+    normalized.includes("image-preview") ||
+    normalized.includes("flash-image") ||
+    normalized.includes("seedream") ||
+    normalized.includes("flux.")
+  );
+}

package/ai/agent/utils/publicImageAgentMode.ts

@@ -0,0 +1,26 @@
+import type { PublicImageAgentMode } from "app/types";
+
+export type { PublicImageAgentMode };
+
+export const getPublicImageAgentMode = (
+  agent?: Partial<{
+    imageWorkflow: PublicImageAgentMode;
+    provider: string;
+    model: string;
+    imageConfig: { enabled?: boolean } | null;
+  }>
+): PublicImageAgentMode | null => {
+  if (!agent) return null;
+  if (agent.imageWorkflow) return agent.imageWorkflow;
+  return null;
+};
+
+export const getPublicImageAgentDefaultProfile = (mode: PublicImageAgentMode) => {
+  if (mode === "generate") {
+    return { quality: "medium", size: "1024x1024", outputFormat: "png" } as const;
+  }
+  if (mode === "edit") {
+    return { quality: "medium", size: "auto", outputFormat: "png" } as const;
+  }
+  return { quality: "low", size: "auto", outputFormat: "png" } as const;
+};

package/ai/agent/utils/sortUtils.ts

@@ -0,0 +1,250 @@
+// packages/ai/agent/utils/sortUtils.ts
+import type { Agent } from "app/types";
+
+export interface SortMeta {
+  createdAtMs: number;
+  publishedAtMs: number;
+  outputPriceNum: number;
+  useCount: number;
+  rating: number;
+  favoriteCount: number;
+  completenessScore: number;
+  recommendedScore: number;
+}
+
+export type MAgent = Agent & { __sort?: SortMeta };
+
+export const RECOMMENDED_COMPLETENESS_WEIGHTS = {
+  name: 0.1,
+  introduction: 0.45,
+  cover: 0.2,
+  tags: 0.15,
+  tools: 0.1,
+  greeting: 0.1,
+} as const;
+
+export const RECOMMENDED_FRESHNESS_BUCKETS = [
+  { maxAgeDays: 3, score: 1 },
+  { maxAgeDays: 7, score: 0.7 },
+  { maxAgeDays: 21, score: 0.35 },
+  { maxAgeDays: 45, score: 0.15 },
+] as const;
+
+export const RECOMMENDED_COLD_START_BUCKETS = [
+  { maxFavoriteCount: 0, maxAgeDays: 7, score: 0.75 },
+  { maxFavoriteCount: 2, maxAgeDays: 14, score: 0.35 },
+] as const;
+
+export const RECOMMENDED_SCORE_WEIGHTS = {
+  favoriteLogWeight: 4,
+  freshnessWeight: 2,
+  completenessWeight: 1.5,
+} as const;
+
+export function toNumber(n: unknown, fallback: number) {
+  const v = typeof n === "number" ? n : parseFloat(String(n));
+  return Number.isFinite(v) ? v : fallback;
+}
+
+export function toTimeMs(t: unknown) {
+  if (typeof t === "number") return t;
+  const n = Date.parse(String(t ?? 0));
+  return Number.isFinite(n) ? n : 0;
+}
+
+export function firstFiniteNumber(...values: unknown[]): number | undefined {
+  for (const value of values) {
+    const parsed = typeof value === "number" ? value : parseFloat(String(value));
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return undefined;
+}
+
+function hasNonEmptyText(value: unknown) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+function getCompletenessScore(agent?: Agent) {
+  if (!agent) return 0;
+
+  let score = 0;
+  if (hasNonEmptyText(agent.name)) score += RECOMMENDED_COMPLETENESS_WEIGHTS.name;
+  if (hasNonEmptyText(agent.introduction)) {
+    score += RECOMMENDED_COMPLETENESS_WEIGHTS.introduction;
+  }
+  if (hasNonEmptyText(agent.cover)) score += RECOMMENDED_COMPLETENESS_WEIGHTS.cover;
+  if (Array.isArray(agent.tags) && agent.tags.length > 0) {
+    score += RECOMMENDED_COMPLETENESS_WEIGHTS.tags;
+  }
+  if (Array.isArray(agent.tools) && agent.tools.length > 0) {
+    score += RECOMMENDED_COMPLETENESS_WEIGHTS.tools;
+  }
+  if (
+    hasNonEmptyText(agent.greeting) ||
+    (agent.greeting &&
+      typeof agent.greeting === "object" &&
+      hasNonEmptyText((agent.greeting as { text?: string }).text))
+  ) {
+    score += RECOMMENDED_COMPLETENESS_WEIGHTS.greeting;
+  }
+  return score;
+}
+
+function getFreshnessScore(ageDays: number) {
+  for (const bucket of RECOMMENDED_FRESHNESS_BUCKETS) {
+    if (ageDays <= bucket.maxAgeDays) return bucket.score;
+  }
+  return 0;
+}
+
+function getColdStartBoost(ageDays: number, favoriteCount: number) {
+  for (const bucket of RECOMMENDED_COLD_START_BUCKETS) {
+    if (favoriteCount <= bucket.maxFavoriteCount && ageDays <= bucket.maxAgeDays) {
+      return bucket.score;
+    }
+  }
+  return 0;
+}
+
+export function getRecommendedScore({
+  favoriteCount,
+  publishedAtMs,
+  completenessScore,
+}: {
+  favoriteCount: number;
+  publishedAtMs: number;
+  completenessScore: number;
+}) {
+  const ageMs = Math.max(0, Date.now() - publishedAtMs);
+  const ageDays = ageMs / (24 * 60 * 60 * 1000);
+  const freshnessScore = getFreshnessScore(ageDays);
+  const coldStartBoost = getColdStartBoost(ageDays, favoriteCount);
+
+  // Intentionally exclude useCount/dialogCount here until those signals are
+  // written consistently across the public-agent pipeline.
+  return Math.log1p(Math.max(0, favoriteCount)) *
+    RECOMMENDED_SCORE_WEIGHTS.favoriteLogWeight +
+    freshnessScore * RECOMMENDED_SCORE_WEIGHTS.freshnessWeight +
+    completenessScore * RECOMMENDED_SCORE_WEIGHTS.completenessWeight +
+    coldStartBoost;
+}
+
+/**
+ * 根据本地与远程条目构建排序元信息
+ */
+export function buildSortMeta(local?: Agent, remote?: Agent): SortMeta {
+  const createdAtMs = Math.max(
+    toTimeMs(remote?.updatedAt ?? remote?.createdAt),
+    toTimeMs(local?.updatedAt ?? local?.createdAt)
+  );
+  const publishedAtMs = Math.max(
+    toTimeMs(remote?.createdAt),
+    toTimeMs(local?.createdAt)
+  );
+
+  const outputPriceNum = firstFiniteNumber(
+    (remote as any)?.outputPrice,
+    (local as any)?.outputPrice
+  );
+
+  const useCount = firstFiniteNumber(
+    (remote as any)?.metrics?.useCount,
+    (local as any)?.metrics?.useCount,
+    (remote as any)?.dialogCount,
+    (local as any)?.dialogCount
+  );
+
+  const rating = firstFiniteNumber(
+    (remote as any)?.metrics?.rating,
+    (local as any)?.metrics?.rating,
+    (remote as any)?.messageCount,
+    (local as any)?.messageCount
+  );
+
+  const favoriteCount = firstFiniteNumber(
+    (remote as any)?.metrics?.favoriteCount,
+    (local as any)?.metrics?.favoriteCount
+  );
+
+  const completenessScore = Math.max(
+    getCompletenessScore(local),
+    getCompletenessScore(remote)
+  );
+  const normalizedFavoriteCount = Number.isFinite(favoriteCount) ? favoriteCount : 0;
+  const normalizedPublishedAtMs = publishedAtMs || createdAtMs;
+  const recommendedScore = getRecommendedScore({
+    favoriteCount: normalizedFavoriteCount,
+    publishedAtMs: normalizedPublishedAtMs,
+    completenessScore,
+  });
+
+  return {
+    createdAtMs,
+    publishedAtMs: normalizedPublishedAtMs,
+    outputPriceNum: Number.isFinite(outputPriceNum)
+      ? outputPriceNum
+      : Number.POSITIVE_INFINITY,
+    useCount: Number.isFinite(useCount) ? useCount : 0,
+    rating: Number.isFinite(rating) ? rating : 0,
+    favoriteCount: normalizedFavoriteCount,
+    completenessScore,
+    recommendedScore,
+  };
+}
+
+/**
+ * 统一的智能体排序逻辑
+ */
+export const sortAgents = (
+  agents: Agent[],
+  sortBy:
+    | "recommended"
+    | "newest"
+    | "popular"
+    | "rating"
+    | "outputPriceAsc"
+    | "outputPriceDesc"
+    | "favorite"
+    | string
+): Agent[] => {
+  const arr = agents.map((agent) => {
+    const typed = agent as MAgent;
+    return typed.__sort ? typed : { ...typed, __sort: buildSortMeta(agent) };
+  });
+
+  arr.sort((a, b) => {
+    const sa = a.__sort!;
+    const sb = b.__sort!;
+    let diff = 0;
+
+    switch (sortBy) {
+      case "recommended":
+        diff = sb.recommendedScore - sa.recommendedScore;
+        break;
+      case "popular":
+        diff = sb.useCount - sa.useCount;
+        break;
+      case "rating":
+        diff = sb.rating - sa.rating;
+        break;
+      case "favorite":
+        diff = sb.favoriteCount - sa.favoriteCount;
+        break;
+      case "outputPriceAsc":
+        diff = sa.outputPriceNum - sb.outputPriceNum;
+        break;
+      case "outputPriceDesc":
+        diff = sb.outputPriceNum - sa.outputPriceNum;
+        break;
+      case "newest":
+      default:
+        diff = sb.createdAtMs - sa.createdAtMs;
+        break;
+    }
+
+    if (diff !== 0) return diff;
+    return String(a.id).localeCompare(String(b.id));
+  });
+
+  return arr;
+};

package/ai/agent/web/referencePickerUtils.ts

@@ -0,0 +1,146 @@
+export interface ReferencePickerSpaceItem {
+  id: string;
+  name: string;
+  isCurrent: boolean;
+}
+
+export interface ReferencePickerContentItem {
+  dbKey: string;
+  title: string;
+  spaceId: string;
+  spaceName: string;
+  contentType?: string;
+  skillSummary?: {
+    isSkill: true;
+    skillId?: string;
+    name?: string;
+    description?: string;
+    toolNames?: string[];
+    triggerMode?: "explicit" | "required" | "recommended";
+  } | null;
+}
+
+export const ALL_SPACES_ID = "__all_spaces__";
+
+export const buildReferencePickerSpaceItems = ({
+  currentSpace,
+  allMemberSpaces,
+  allSpacesLabel,
+}: {
+  currentSpace?: { id: string; name: string } | null;
+  allMemberSpaces: Array<{ spaceId: string; spaceName: string }>;
+  allSpacesLabel: string;
+}) => {
+  const items: ReferencePickerSpaceItem[] = [
+    {
+      id: ALL_SPACES_ID,
+      name: allSpacesLabel,
+      isCurrent: false,
+    },
+  ];
+  const nameMap = new Map<string, string>();
+
+  if (currentSpace) {
+    items.push({
+      id: currentSpace.id,
+      name: currentSpace.name,
+      isCurrent: true,
+    });
+    nameMap.set(currentSpace.id, currentSpace.name);
+  }
+
+  const others = allMemberSpaces
+    .filter((space) => space.spaceId !== currentSpace?.id)
+    .sort((a, b) => a.spaceName.localeCompare(b.spaceName))
+    .map((space) => {
+      nameMap.set(space.spaceId, space.spaceName);
+      return {
+        id: space.spaceId,
+        name: space.spaceName,
+        isCurrent: false,
+      };
+    });
+
+  items.push(...others);
+
+  return { items, nameMap };
+};
+
+export const buildReferencePickerContents = ({
+  contentsObj,
+  spaceId,
+  spaceName,
+  unnamedLabel,
+}: {
+  contentsObj: Record<string, any>;
+  spaceId: string;
+  spaceName: string;
+  unnamedLabel: string;
+}): ReferencePickerContentItem[] =>
+  Object.entries(contentsObj)
+    .filter(([dbKey, value]) => !dbKey.startsWith("dialog-") && value)
+    .map(([dbKey, value]: [string, any]) => ({
+      dbKey,
+      title: value?.title || unnamedLabel,
+      spaceId,
+      spaceName,
+      contentType: value?.type,
+      skillSummary: value?.skillSummary ?? null,
+    }));
+
+export const filterReferencePickerContents = ({
+  spacesData,
+  activeSpaceId,
+  searchQuery,
+  pickerMode,
+  skillCandidateMap,
+}: {
+  spacesData: Map<string, ReferencePickerContentItem[]>;
+  activeSpaceId: string;
+  searchQuery: string;
+  pickerMode: "skill" | "knowledge" | "instruction";
+  skillCandidateMap: Map<string, boolean>;
+}) => {
+  const trimmedQuery = searchQuery.trim().toLowerCase();
+  const scopedContents =
+    activeSpaceId === ALL_SPACES_ID
+      ? Array.from(spacesData.values()).flat()
+      : spacesData.get(activeSpaceId) || [];
+
+  const searchedContents = trimmedQuery
+    ? scopedContents.filter((item) => {
+        const title = item.title.toLowerCase();
+        const key = item.dbKey.toLowerCase();
+        const space = item.spaceName.toLowerCase();
+        return (
+          title.includes(trimmedQuery) ||
+          key.includes(trimmedQuery) ||
+          space.includes(trimmedQuery)
+        );
+      })
+    : scopedContents;
+
+  if (pickerMode !== "skill") {
+    return searchedContents;
+  }
+
+  return searchedContents.filter(
+    (item) =>
+      item.contentType === "page" &&
+      (item.skillSummary?.isSkill || skillCandidateMap.get(item.dbKey))
+  );
+};
+
+export const collectPendingSkillCandidates = ({
+  contents,
+  skillCandidateMap,
+}: {
+  contents: ReferencePickerContentItem[];
+  skillCandidateMap: Map<string, boolean>;
+}) =>
+  contents.filter(
+    (item) =>
+      item.contentType === "page" &&
+      !item.skillSummary?.isSkill &&
+      !skillCandidateMap.has(item.dbKey)
+  );