nolo-cli 0.1.39 → 0.1.41

package/ai/agent/guidedCreation/types.ts

@@ -0,0 +1,38 @@
+import type { ReferenceItem } from "../../../app/types";
+
+export type GuidedAgentCapabilityId =
+  | "webSearch"
+  | "docs"
+  | "tables"
+  | "agents"
+  | "apps";
+
+export type GuidedAgentReferenceChoice = ReferenceItem & {
+  selected: boolean;
+  reason?: string;
+};
+
+export type GuidedAgentDraft = {
+  name: string;
+  introduction: string;
+  prompt: string;
+  promptSummary: string;
+  provider: string;
+  model: string;
+  isPublic: boolean;
+  capabilityIds: GuidedAgentCapabilityId[];
+  toolIds: string[];
+  references: GuidedAgentReferenceChoice[];
+  tags: string[];
+  unresolved: string[];
+};
+
+export type GuidedAgentAssistantMessage = {
+  id: string;
+  role: "user" | "assistant";
+  content: string;
+};
+
+export type GuidedAgentValidationResult =
+  | { ok: true }
+  | { ok: false; missing: string[] };

package/ai/agent/isLiveAudioOnlyAgent.ts

@@ -0,0 +1,26 @@
+/**
+ * Predicate: does this agent only support live audio mode and
+ * cannot be used through normal text chat completions?
+ *
+ * Returns `true` when the agent's model is a live-preview variant that
+ * will fail if sent through ordinary OpenAI-compatible text completions.
+ */
+export function isLiveAudioOnlyAgent(agent: {
+  defaultInteractionMode?: string;
+  provider?: string;
+  model?: string;
+}): boolean {
+  if (agent.defaultInteractionMode !== "live_audio") return false;
+
+  const provider = String(agent.provider || "").toLowerCase();
+  const model = String(agent.model || "").toLowerCase();
+
+  // Google live-preview models are live-only
+  if (provider === "google" && model.includes("live")) return true;
+
+  // Gemini Live / native audio models are live-only.
+  if (model.includes("live-preview") || model.includes("live-001")) return true;
+  if (model.includes("native-audio")) return true;
+
+  return false;
+}

package/ai/agent/liveAudioModel.ts

@@ -0,0 +1,2 @@
+export const DEFAULT_GOOGLE_LIVE_AUDIO_MODEL =
+  "gemini-2.5-flash-native-audio-preview-12-2025";

package/ai/agent/pageBuilderHandoffRules.ts

@@ -0,0 +1,75 @@
+export const PAGE_BUILDER_AGENT_PUBLIC_KEY =
+  "agent-pub-01PAGEBUILDR00000000FT7R9G";
+
+export type PageBuilderScenario = {
+  id: string;
+  label: string;
+  userIntent: string;
+  prompt: string;
+};
+
+export const PAGE_BUILDER_SCENARIOS: PageBuilderScenario[] = [
+  {
+    id: "information-display",
+    label: "信息展示",
+    userIntent: "主页、产品介绍、服务介绍、作品集、活动页、报价页",
+    prompt:
+      "帮我做一个独立 AI 产品顾问的个人主页。要看起来专业，包含个人定位、能提供的服务卡片、代表成果卡片、可信背书和联系合作按钮。",
+  },
+  {
+    id: "data-analysis",
+    label: "数据分析",
+    userIntent: "日报、周报、经营看板、质检报告、销售漏斗、反馈分析",
+    prompt:
+      "帮我做一个 AI 客服质检日报，包含核心指标、近 7 天风险趋势、异常会话明细表，以及明天需要跟进的建议。",
+  },
+  {
+    id: "process-guide",
+    label: "流程说明",
+    userIntent: "教程、SOP、onboarding、操作指南、课程步骤、申请流程",
+    prompt:
+      "帮我做一个新员工使用 CRM 的交互教程页面，包含学习目标、操作步骤、示例练习、检查清单和下一步按钮。",
+  },
+  {
+    id: "decision-comparison",
+    label: "决策比较",
+    userIntent: "方案对比、产品选型、候选人对比、竞品分析、采购建议",
+    prompt:
+      "帮我做一个三款 CRM 方案对比页，包含对比维度表格、每个方案的优缺点卡片、评分、适合团队类型和最终推荐。",
+  },
+  {
+    id: "plan-roadmap",
+    label: "计划排布",
+    userIntent: "项目计划、学习计划、健身计划、内容日历、发布节奏",
+    prompt:
+      "帮我做一个 30 天内容发布计划页面，包含阶段目标、每周任务、优先级、里程碑卡片和风险提醒。",
+  },
+  {
+    id: "mixed-pitch",
+    label: "混合长尾",
+    userIntent: "汇报页、融资材料、复杂项目概览，混合展示、数据、计划、对比",
+    prompt:
+      "给一个早期 AI 客服创业项目做一页融资汇报页，包含市场机会、关键数据指标卡、增长趋势图、产品路线、竞品对比表、团队介绍和下一步计划。",
+  },
+];
+
+const scenarioLines = PAGE_BUILDER_SCENARIOS.map(
+  (scenario) => `- ${scenario.label}：${scenario.userIntent}`
+).join("\n");
+
+export const PAGE_BUILDER_HANDOFF_INSTRUCTIONS = `--- 页面生成助手 handoff ---
+当用户需要把内容变成“可看的页面/报告/看板/教程/对比页/计划页”时，可以把本轮交给页面生成助手。
+
+目标 Agent:
+- agentKey: ${PAGE_BUILDER_AGENT_PUBLIC_KEY}
+- 推荐工具: runStreamingAgent
+
+适合 handoff 的视觉意图大类：
+${scenarioLines}
+
+调用边界：
+- 用户明确要求“做成页面 / 看板 / 报告 / 教程 / 主页 / 对比页 / 计划表 / 可视化”时，可以直接 runStreamingAgent。
+- 如果用户只是讨论内容，但你判断“文字回答不如可视化页面”，先询问用户：“这个更适合做成一页可视化页面，要我生成一个可交互版本吗？”
+- 不要把普通问答、闲聊、代码解释、纯文本总结强行交给页面生成助手。
+- handoff 时，把用户原始需求和你已确认的业务上下文一起放进 userInput，不要要求用户理解 React、HTML、代码块或运行时。
+- 页面生成助手只负责生成和修改可交互页面；你仍负责判断、解释、澄清和后续协调。`;

package/ai/agent/persistMessageWithFixedId.ts

@@ -0,0 +1,37 @@
+import { DataType } from "../../create/types";
+import { write } from "../../database/dbSlice";
+import { addUserMessage } from "../../chat/messages/messageSlice";
+import type { Message } from "../../chat/messages/types";
+
+export async function persistMessageWithFixedId(
+  dispatch: any,
+  message: Message
+): Promise<void> {
+  dispatch(addUserMessage(message));
+
+  const { controller, ...messageToWrite } = message;
+
+  try {
+    const writeRequest = dispatch(
+      write({
+        data: {
+          ...messageToWrite,
+          type: DataType.MSG,
+        },
+        customKey: message.dbKey,
+      })
+    );
+
+    if (writeRequest && typeof writeRequest.unwrap === "function") {
+      await writeRequest.unwrap();
+      return;
+    }
+
+    await writeRequest;
+  } catch (error) {
+    console.error(
+      "[persistMessageWithFixedId] Failed to persist fixed-id message:",
+      error
+    );
+  }
+}

package/ai/agent/planSlice.ts

@@ -0,0 +1,259 @@
+// ai/agent/planSlice.ts
+// 管理计划（Plan）的 Redux 状态
+// 支持普通步骤和反思步骤（reflect step）
+
+import { type PayloadAction, createSlice } from "@reduxjs/toolkit";
+import type { RootState } from "../../app/store";
+
+// --- Interfaces ---
+
+export interface PlanState {
+  planDetails: string;
+  currentProgress: number;
+}
+
+// 单个工具调用的接口
+export interface ToolCall {
+  tool_name: string;
+  parameters: any;
+}
+
+// 反思决策的输出结构
+export interface ReflectDecision {
+  action: "continue" | "stop" | "insert_steps";
+  reason: string;
+  steps?: Omit<Step, "status" | "result">[]; // 仅当 action 是 insert_steps 时
+}
+
+// Step 类型：normal 或 reflect
+export type StepType = "normal" | "reflect";
+
+export interface Step {
+  id: string;
+  title: string;
+  type?: StepType; // 默认 "normal"
+  status: "pending" | "in-progress" | "completed" | "failed";
+
+  // normal step 使用
+  calls?: ToolCall[];
+
+  // reflect step 使用
+  reflectInput?: string; // 给反思 LLM 的提示
+
+  // 通用
+  details?: any;
+  result?: any[]; // normal step: 工具调用结果; reflect step: ReflectDecision
+}
+
+// Plan 执行配置
+export interface PlanExecutionConfig {
+  maxReflectCount?: number; // 最多允许多少次 reflect step，默认不限
+  maxTotalSteps?: number; // 最多执行多少个 step（包括动态插入的），默认不限
+  maxTimeMs?: number; // 最大执行时间（毫秒），默认不限
+}
+
+interface PlanSliceState {
+  plan: PlanState | null;
+  steps: Step[];
+  currentStep: string | null;
+  executionConfig: PlanExecutionConfig | null;
+  // 执行统计
+  stats: {
+    reflectCount: number;
+    totalStepsExecuted: number;
+    startTime: number | null;
+  };
+}
+
+// --- Initial State ---
+
+const initialState: PlanSliceState = {
+  plan: null,
+  steps: [],
+  currentStep: null,
+  executionConfig: null,
+  stats: {
+    reflectCount: 0,
+    totalStepsExecuted: 0,
+    startTime: null,
+  },
+};
+
+// --- Slice Definition ---
+
+const planSlice = createSlice({
+  name: "plan",
+  initialState,
+  reducers: {
+    // 设置整个计划的顶层信息
+    setPlan: (state, action: PayloadAction<PlanState>) => {
+      state.plan = action.payload;
+    },
+
+    // 更新计划的整体进度
+    updatePlanProgress: (state, action: PayloadAction<number>) => {
+      if (state.plan) {
+        state.plan.currentProgress = action.payload;
+      }
+    },
+
+    // 清除整个计划
+    clearPlan: (state) => {
+      state.plan = null;
+      state.steps = [];
+      state.currentStep = null;
+      state.executionConfig = null;
+      state.stats = {
+        reflectCount: 0,
+        totalStepsExecuted: 0,
+        startTime: null,
+      };
+    },
+
+    // 设置计划的所有步骤
+    setSteps: (state, action: PayloadAction<Step[]>) => {
+      state.steps = action.payload;
+    },
+
+    // 更新单个步骤的状态或结果
+    updateStep: (
+      state,
+      action: PayloadAction<{ id: string; updates: Partial<Step> }>
+    ) => {
+      const step = state.steps.find((s) => s.id === action.payload.id);
+      if (step) {
+        Object.assign(step, action.payload.updates);
+      }
+    },
+
+    // 设置当前正在执行的步骤ID
+    setCurrentStep: (state, action: PayloadAction<string | null>) => {
+      state.currentStep = action.payload;
+    },
+
+    // 清除所有步骤信息
+    clearSteps: (state) => {
+      state.steps = [];
+      state.currentStep = null;
+    },
+
+    // 新增：在指定步骤之后插入新步骤
+    insertStepsAfter: (
+      state,
+      action: PayloadAction<{
+        afterStepId: string;
+        newSteps: Step[];
+      }>
+    ) => {
+      const { afterStepId, newSteps } = action.payload;
+      const index = state.steps.findIndex((s) => s.id === afterStepId);
+      if (index !== -1) {
+        // 在 afterStepId 之后插入新步骤
+        state.steps.splice(index + 1, 0, ...newSteps);
+      }
+    },
+
+    // 新增：移除指定步骤之后的所有待执行步骤
+    removeStepsAfter: (state, action: PayloadAction<string>) => {
+      const afterStepId = action.payload;
+      const index = state.steps.findIndex((s) => s.id === afterStepId);
+      if (index !== -1) {
+        // 只保留 afterStepId 及之前的步骤，以及已完成的步骤
+        state.steps = state.steps.filter(
+          (s, i) => i <= index || s.status === "completed"
+        );
+      }
+    },
+
+    // 新增：设置执行配置
+    setExecutionConfig: (
+      state,
+      action: PayloadAction<PlanExecutionConfig | null>
+    ) => {
+      state.executionConfig = action.payload;
+    },
+
+    // 新增：更新执行统计
+    updateStats: (
+      state,
+      action: PayloadAction<Partial<PlanSliceState["stats"]>>
+    ) => {
+      Object.assign(state.stats, action.payload);
+    },
+
+    // 新增：增加反思计数
+    incrementReflectCount: (state) => {
+      state.stats.reflectCount += 1;
+    },
+
+    // 新增：增加已执行步骤计数
+    incrementStepsExecuted: (state) => {
+      state.stats.totalStepsExecuted += 1;
+    },
+
+    // 新增：设置开始时间
+    setStartTime: (state, action: PayloadAction<number>) => {
+      state.stats.startTime = action.payload;
+    },
+  },
+  selectors: {
+    selectPlanState: (state: PlanSliceState) => state.plan,
+    selectStepsState: (state: PlanSliceState) => state.steps,
+    selectCurrentStepIdState: (state: PlanSliceState) => state.currentStep,
+    selectExecutionConfigState: (state: PlanSliceState) =>
+      state.executionConfig,
+    selectStatsState: (state: PlanSliceState) => state.stats,
+  },
+});
+
+// --- Exports ---
+
+export const {
+  setPlan,
+  updatePlanProgress,
+  clearPlan,
+  setSteps,
+  updateStep,
+  setCurrentStep,
+  clearSteps,
+  insertStepsAfter,
+  removeStepsAfter,
+  setExecutionConfig,
+  updateStats,
+  incrementReflectCount,
+  incrementStepsExecuted,
+  setStartTime,
+} = planSlice.actions;
+
+export default planSlice.reducer;
+
+// Selectors
+export const selectPlan = (state: RootState): PlanState | null =>
+  state.plan.plan;
+
+export const selectSteps = (state: RootState): Step[] => state.plan.steps;
+
+export const selectCurrentStepId = (state: RootState): string | null =>
+  state.plan.currentStep;
+
+export const selectCurrentStepDetails = (state: RootState): Step | null => {
+  if (!state.plan.currentStep) return null;
+  return (
+    state.plan.steps.find((step) => step.id === state.plan.currentStep) || null
+  );
+};
+
+export const selectExecutionConfig = (
+  state: RootState
+): PlanExecutionConfig | null => state.plan.executionConfig;
+
+export const selectPlanStats = (state: RootState): PlanSliceState["stats"] =>
+  state.plan.stats;
+
+// 新增：获取待执行的步骤
+export const selectPendingSteps = (state: RootState): Step[] =>
+  state.plan.steps.filter((s) => s.status === "pending");
+
+// 新增：获取已完成的步骤
+export const selectCompletedSteps = (state: RootState): Step[] =>
+  state.plan.steps.filter((s) => s.status === "completed");

package/ai/agent/referenceUtils.ts

@@ -0,0 +1,229 @@
+import type { AppDispatch } from "../../app/store";
+import type { ReferenceItem } from "../../app/types";
+import { read } from "../../database/dbSlice";
+import {
+  extractRuntimePageCapabilities,
+  resolveSkillGraphFromRoots,
+  type SkillRuntimePageLike,
+} from "../skills/referenceRuntime";
+
+export type ResolvedReferenceAssets = {
+  references: ReferenceItem[];
+  referencedTools: string[];
+  recommendedSkillTools: string[];
+  recommendedSkillHints: string[];
+  skillPromptPatches: string[];
+  contentByKey: Map<string, any>;
+};
+
+export type ResolvedContentTools = {
+  tools: string[];
+  recommendedSkillTools: string[];
+  recommendedSkillHints: string[];
+  skillPromptPatches: string[];
+  contentByKey: Map<string, any>;
+};
+
+const loadContentsByKeys = async (
+  keys: string[],
+  dispatch: AppDispatch,
+  preloaded?: Map<string, any>
+): Promise<Map<string, any>> => {
+  const contentByKey = new Map<string, SkillRuntimePageLike>();
+  const uniqueKeys = Array.from(new Set(keys.filter(Boolean)));
+  await Promise.all(
+    uniqueKeys.map(async (dbKey) => {
+      if (preloaded?.has(dbKey)) {
+        const content = preloaded.get(dbKey);
+        if (content) contentByKey.set(dbKey, content);
+        return;
+      }
+      try {
+        const content = await dispatch(read({ dbKey })).unwrap();
+        if (content) contentByKey.set(dbKey, content);
+      } catch {
+        // ignore missing content
+      }
+    })
+  );
+  return contentByKey;
+};
+
+export const resolveReferenceAssets = async (
+references: ReferenceItem[] | undefined,
+dispatch: AppDispatch)
+: Promise<ResolvedReferenceAssets> => {
+  if (!Array.isArray(references) || references.length === 0) {
+    return {
+      references: [],
+      referencedTools: [],
+      recommendedSkillTools: [],
+      recommendedSkillHints: [],
+      skillPromptPatches: [],
+      contentByKey: new Map(),
+    };
+  }
+
+  const entries = await Promise.all(
+    references.
+    filter((ref) => ref?.dbKey).
+    map(async (ref) => {
+      try {
+        const content = await dispatch(read({ dbKey: ref.dbKey })).unwrap();
+        return { ref, content };
+      } catch {
+        return { ref, content: null };
+      }
+    })
+  );
+
+  const contentByKey = new Map<string, any>();
+  const toolSet = new Set<string>();
+  const recommendedToolSet = new Set<string>();
+  const recommendedSkillHints = new Set<string>();
+  const skillPromptPatches = new Set<string>();
+  const normalizedReferences: ReferenceItem[] = [];
+  const hardSkillKeys = new Set<string>();
+  const softSkillKeys = new Set<string>();
+
+  for (const { ref, content } of entries) {
+    if (content) {
+      contentByKey.set(ref.dbKey, content);
+    }
+
+    const capabilities = extractRuntimePageCapabilities(content);
+    for (const tool of capabilities.directTools) {
+      toolSet.add(tool);
+    }
+    for (const tool of capabilities.hardSkillTools) {
+      toolSet.add(tool);
+    }
+    for (const hint of capabilities.softSkillHints) {
+      recommendedSkillHints.add(hint);
+    }
+    for (const patch of capabilities.promptPatches) {
+      skillPromptPatches.add(patch);
+    }
+    for (const skillKey of capabilities.hardSkillKeys) {
+      hardSkillKeys.add(skillKey);
+    }
+    for (const skillKey of capabilities.softSkillKeys) {
+      softSkillKeys.add(skillKey);
+    }
+
+    normalizedReferences.push({
+      ...ref,
+      type: capabilities.shouldUpgradeReference ? "instruction" : ref.type,
+    });
+  }
+
+  const resolvedSkillLinks = await resolveSkillGraphFromRoots({
+    roots: [
+      ...Array.from(hardSkillKeys).map((identifier) => ({ identifier, mode: "required" as const })),
+      ...Array.from(softSkillKeys).map((identifier) => ({ identifier, mode: "recommended" as const })),
+    ],
+    loadPage: async (identifier) => {
+      const loaded = await loadContentsByKeys([identifier], dispatch, contentByKey);
+      return loaded.get(identifier) ?? null;
+    },
+    contentByKey,
+  });
+  resolvedSkillLinks.contentByKey.forEach((value, key) => contentByKey.set(key, value));
+  for (const tool of resolvedSkillLinks.requiredTools) {
+    toolSet.add(tool);
+  }
+  for (const tool of resolvedSkillLinks.recommendedTools) {
+    recommendedToolSet.add(tool);
+  }
+  for (const hint of resolvedSkillLinks.recommendedSkillHints) {
+    recommendedSkillHints.add(hint);
+  }
+  for (const patch of resolvedSkillLinks.skillPromptPatches) {
+    skillPromptPatches.add(patch);
+  }
+
+  return {
+    references: normalizedReferences,
+    referencedTools: Array.from(toolSet),
+    recommendedSkillTools: Array.from(recommendedToolSet),
+    recommendedSkillHints: Array.from(recommendedSkillHints),
+    skillPromptPatches: Array.from(skillPromptPatches),
+    contentByKey
+  };
+};
+
+export const resolveToolsFromKeys = async (
+keys: string[],
+dispatch: AppDispatch,
+preloaded?: Map<string, any>)
+: Promise<ResolvedContentTools> => {
+  if (!Array.isArray(keys) || keys.length === 0) {
+    return {
+      tools: [],
+      recommendedSkillTools: [],
+      recommendedSkillHints: [],
+      skillPromptPatches: [],
+      contentByKey: new Map(),
+    };
+  }
+
+  const contentByKey = await loadContentsByKeys(keys, dispatch, preloaded);
+  const toolSet = new Set<string>();
+  const recommendedToolSet = new Set<string>();
+  const recommendedSkillHints = new Set<string>();
+  const skillPromptPatches = new Set<string>();
+  const hardSkillKeys = new Set<string>();
+  const softSkillKeys = new Set<string>();
+
+  for (const content of contentByKey.values()) {
+    const capabilities = extractRuntimePageCapabilities(content);
+    for (const tool of [...capabilities.directTools, ...capabilities.hardSkillTools]) {
+      toolSet.add(tool);
+    }
+    for (const hint of capabilities.softSkillHints) {
+      recommendedSkillHints.add(hint);
+    }
+    for (const patch of capabilities.promptPatches) {
+      skillPromptPatches.add(patch);
+    }
+    for (const skillKey of capabilities.hardSkillKeys) {
+      hardSkillKeys.add(skillKey);
+    }
+    for (const skillKey of capabilities.softSkillKeys) {
+      softSkillKeys.add(skillKey);
+    }
+  }
+
+  const resolvedSkillLinks = await resolveSkillGraphFromRoots({
+    roots: [
+      ...Array.from(hardSkillKeys).map((identifier) => ({ identifier, mode: "required" as const })),
+      ...Array.from(softSkillKeys).map((identifier) => ({ identifier, mode: "recommended" as const })),
+    ],
+    loadPage: async (identifier) => {
+      const loaded = await loadContentsByKeys([identifier], dispatch, contentByKey);
+      return loaded.get(identifier) ?? null;
+    },
+    contentByKey,
+  });
+  resolvedSkillLinks.contentByKey.forEach((value, key) => contentByKey.set(key, value));
+  for (const tool of resolvedSkillLinks.requiredTools) {
+    toolSet.add(tool);
+  }
+  for (const tool of resolvedSkillLinks.recommendedTools) {
+    recommendedToolSet.add(tool);
+  }
+  for (const hint of resolvedSkillLinks.recommendedSkillHints) {
+    recommendedSkillHints.add(hint);
+  }
+  for (const patch of resolvedSkillLinks.skillPromptPatches) {
+    skillPromptPatches.add(patch);
+  }
+
+  return {
+    tools: Array.from(toolSet),
+    recommendedSkillTools: Array.from(recommendedToolSet),
+    recommendedSkillHints: Array.from(recommendedSkillHints),
+    skillPromptPatches: Array.from(skillPromptPatches),
+    contentByKey
+  };
+};