nolo-cli 0.6.1 → 0.8.0-alpha.10

package/chunk-POCFIDGQ.js

@@ -0,0 +1,562 @@
+import {
+  applyAgentSecretMigrationUpdates,
+  createFileCredentialBroker,
+  migrateAgentSecrets,
+  normalizeAgentRuntimeToolPolicy
+} from "./chunk-TDIQFT2F.js";
+import {
+  patch,
+  remove,
+  write
+} from "./chunk-G5H7RNFL.js";
+import {
+  asRecordOrEmpty
+} from "./chunk-KX6YBIHG.js";
+import {
+  createAgentKey,
+  require_index_umd,
+  toTrimmedString
+} from "./chunk-PN7AFLOK.js";
+import {
+  asyncThunkCreator,
+  buildCreateSlice,
+  getRuntimeServerContext
+} from "./chunk-EYEEHCU4.js";
+import {
+  asTrimmedString
+} from "./chunk-3EUW3WEO.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+import {
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// packages/ai/chat/agentCredentialSyncClient.ts
+function buildUrl(currentServer, credentialRef) {
+  return `${currentServer}/api/agent-credentials/${encodeURIComponent(credentialRef)}`;
+}
+async function fetchServerSyncedCredential(ctx, credentialRef) {
+  try {
+    const res = await fetch(buildUrl(ctx.currentServer, credentialRef), {
+      method: "GET",
+      headers: { Authorization: `Bearer ${ctx.authToken}` }
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.apiKey ?? null;
+  } catch {
+    return null;
+  }
+}
+async function deleteServerSyncedCredential(ctx, credentialRef) {
+  try {
+    const res = await fetch(buildUrl(ctx.currentServer, credentialRef), {
+      method: "DELETE",
+      headers: { Authorization: `Bearer ${ctx.authToken}` }
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function pushServerSyncedCredential(ctx, credentialRef, apiKey) {
+  try {
+    const res = await fetch(buildUrl(ctx.currentServer, credentialRef), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${ctx.authToken}`
+      },
+      body: JSON.stringify({ apiKey })
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+// packages/ai/agent/agentSlice.ts
+var import_ulid = __toESM(require_index_umd());
+var createAgentCredentialBroker = createFileCredentialBroker;
+function setAgentCredentialBrokerFactoryForTests(factory) {
+  createAgentCredentialBroker = factory ?? createFileCredentialBroker;
+}
+var readNonEmptyApiKey = (value) => asTrimmedString(value);
+var migrateRawApiKeyForAgent = async (args) => {
+  const broker = createAgentCredentialBroker();
+  const result = await migrateAgentSecrets({
+    agent: {
+      key: args.agentKey,
+      apiKey: args.apiKey,
+      apiKeyRef: args.apiKeyRef,
+      credentialRef: args.credentialRef
+    },
+    broker
+  });
+  const next = applyAgentSecretMigrationUpdates(args.record, result.updates);
+  if (readNonEmptyApiKey(next.apiKey)) {
+    throw new Error(
+      "Failed to migrate agent API key into the local credential broker. The raw key was not stripped."
+    );
+  }
+  return next;
+};
+var createSliceWithThunks = buildCreateSlice({
+  creators: { asyncThunk: asyncThunkCreator }
+});
+var initialState = {};
+var normalizeAgentReferences = (references) => {
+  if (!Array.isArray(references)) return [];
+  return references.map((ref) => ({
+    dbKey: ref.dbKey || "",
+    title: ref.title || "",
+    type: ref.type === "page" ? "knowledge" : ref.type || "knowledge"
+  }));
+};
+var normalizeRuntimeToolPolicy = (value) => {
+  const policy = normalizeAgentRuntimeToolPolicy(value);
+  if (!policy) return void 0;
+  const hasPolicyContent = Boolean(
+    policy.agentTools?.length || policy.runtimeTools?.length || policy.workspace || policy.shell || policy.isolation || policy.git || policy.budget || policy.audit
+  );
+  return hasPolicyContent ? policy : void 0;
+};
+var processAgentCreateForm = (formData, userId) => {
+  const isPublic = !!formData.isPublic;
+  const machineId = asTrimmedString(formData.machineId);
+  const result = {
+    ...formData,
+    // tags: "a, b" -> ["a", "b"]
+    tags: formData.tags ? formData.tags.split(",").map((s) => s.trim()).filter(Boolean) : [],
+    // 归一化 references
+    references: normalizeAgentReferences(formData.references || []),
+    // 非公开时，强制清空白名单，避免脏数据
+    whitelist: isPublic ? formData.whitelist || [] : [],
+    // allowFork 独立于公开：Space 内的私有 agent 也可被空间成员复制
+    allowFork: !!formData.allowFork
+  };
+  delete result.machineId;
+  result.runtimeToolPolicy = normalizeRuntimeToolPolicy(
+    formData.runtimeToolPolicy
+  );
+  if (!result.runtimeToolPolicy) {
+    delete result.runtimeToolPolicy;
+  }
+  if (formData.apiSource === "cli" && machineId) {
+    const binding = {
+      ...asRecordOrEmpty(result.runtimeBinding),
+      machineId,
+      ownerUserId: userId
+    };
+    result.runtimeBinding = binding;
+  }
+  return result;
+};
+var processAgentUpdateChanges = (data, userId, previousAgent) => {
+  const changes = {};
+  if ("name" in data) {
+    changes.name = String(data.name ?? "").trim();
+  }
+  if ("model" in data) {
+    changes.model = (data.model ?? "").trim();
+  }
+  if ("provider" in data) {
+    changes.provider = (data.provider ?? "").trim();
+  }
+  if ("prompt" in data) {
+    changes.prompt = (data.prompt ?? "").trim();
+  }
+  if ("introduction" in data) {
+    changes.introduction = (data.introduction ?? "").trim();
+  }
+  if ("customProviderUrl" in data) {
+    changes.customProviderUrl = (data.customProviderUrl ?? "").trim();
+  }
+  if ("apiKey" in data) {
+    changes.apiKey = (data.apiKey ?? "").trim();
+  }
+  if ("hasVision" in data && data.hasVision !== void 0) {
+    changes.hasVision = !!data.hasVision;
+  }
+  if ("apiSource" in data && data.apiSource) {
+    changes.apiSource = data.apiSource;
+  }
+  if ("cliProvider" in data) {
+    changes.cliProvider = data.cliProvider || "";
+  }
+  if ("machineId" in data) {
+    const machineId = String(data.machineId ?? "").trim();
+    const effectiveApiSource = data.apiSource ?? previousAgent?.apiSource;
+    if (machineId) {
+      if (effectiveApiSource === "cli" || effectiveApiSource === void 0) {
+        const binding = {
+          ...asRecordOrEmpty(changes.runtimeBinding),
+          machineId,
+          ownerUserId: userId
+        };
+        changes.runtimeBinding = binding;
+      }
+    } else {
+      if (effectiveApiSource === "cli" || effectiveApiSource === void 0) {
+        changes.runtimeBinding = null;
+      }
+    }
+  }
+  if ("useServerProxy" in data && data.useServerProxy !== void 0) {
+    changes.useServerProxy = !!data.useServerProxy;
+  }
+  if ("sharingLevel" in data) {
+    const sharingLevel = data.sharingLevel;
+    if (sharingLevel === "default" || sharingLevel === "split" || sharingLevel === "full") {
+      changes.sharingLevel = sharingLevel;
+    }
+  }
+  if ("greeting" in data) {
+    changes.greeting = data.greeting;
+  }
+  if ("tools" in data) {
+    changes.tools = Array.isArray(data.tools) ? data.tools.slice() : [];
+  }
+  if ("runtimeToolPolicy" in data) {
+    const rawRuntimeToolPolicy = data.runtimeToolPolicy;
+    changes.runtimeToolPolicy = rawRuntimeToolPolicy === null ? null : normalizeRuntimeToolPolicy(rawRuntimeToolPolicy) ?? null;
+  }
+  const numericKeys = [
+    "inputPrice",
+    "outputPrice",
+    "temperature",
+    "top_p",
+    "frequency_penalty",
+    "presence_penalty",
+    "max_tokens"
+  ];
+  numericKeys.forEach((key) => {
+    if (key in data) {
+      const raw = data[key];
+      if (raw === void 0 || raw === null) {
+        changes[key] = raw;
+      } else {
+        const num = Number(raw);
+        changes[key] = Number.isNaN(num) ? raw : num;
+      }
+    }
+  });
+  if ("reasoning_effort" in data) {
+    changes.reasoning_effort = data.reasoning_effort;
+  }
+  if ("tags" in data) {
+    const raw = data.tags;
+    let arr = [];
+    if (Array.isArray(raw)) {
+      arr = raw.map((s) => toTrimmedString(s)).filter(Boolean);
+    } else if (typeof raw === "string") {
+      arr = raw.split(",").map((s) => s.trim()).filter(Boolean);
+    }
+    changes.tags = arr;
+  }
+  if ("references" in data) {
+    changes.references = normalizeAgentReferences(
+      data.references || []
+    );
+  }
+  if ("whitelist" in data) {
+    changes.whitelist = data.whitelist || [];
+  }
+  if ("allowFork" in data) {
+    changes.allowFork = !!data.allowFork;
+  }
+  if ("avatarFileId" in data) {
+    const raw = data.avatarFileId;
+    changes.avatarFileId = raw ? String(raw).trim() : null;
+  }
+  if ("isPublic" in data) {
+    changes.isPublic = !!data.isPublic;
+    if (!changes.isPublic) {
+      changes.whitelist = [];
+    }
+  }
+  return changes;
+};
+var slice = createSliceWithThunks({
+  name: "agent",
+  initialState,
+  reducers: (create) => ({
+    /**
+     * 通用 LLM 调用（不带 Agent 上下文 / 历史）
+     */
+    runLlm: create.asyncThunk(async (args, thunkApi) => {
+      const overrides = {};
+      if (args.systemPromptOverride !== void 0) overrides.prompt = args.systemPromptOverride;
+      if (args.toolsOverride !== void 0) overrides.tools = args.toolsOverride;
+      const { _executeModel } = await import("./_executeModel-CPDNUUQV.js");
+      return _executeModel(
+        {
+          isStreaming: args.isStreaming ?? false,
+          withAgentContext: false,
+          withChatHistory: false,
+          agentConfigOverrides: Object.keys(overrides).length ? overrides : void 0
+        },
+        args,
+        thunkApi
+      );
+    }),
+    /**
+     * 通用 Agent 调用（带 Agent 上下文，多轮工具循环）
+     *
+     * 使用客户端 runAgentClientLoop：
+     * - 每轮调用 LLM（非流式）
+     * - 遇到 tool_calls 时通过 findToolExecutor 本地执行工具
+     * - 循环直到无工具调用或触发其他运行时停止条件
+     */
+    runAgent: create.asyncThunk(async (args, thunkApi) => {
+      const { runAgentClientLoop } = await import("./runAgentClientLoop-W4NKE64V.js");
+      const { content: loopContent, toolCallCount } = await runAgentClientLoop(
+        {
+          agentKey: args.agentKey,
+          content: args.content,
+          parentMessageId: args.parentMessageId,
+          billingDialogKey: args.billingDialogKey
+        },
+        thunkApi
+      );
+      return loopContent;
+    }),
+    /**
+     * 聊天轮次流式 Agent 调用
+     */
+    streamAgentChatTurn: create.asyncThunk(async (args, thunkApi) => {
+      const { streamAgentChatTurnHandler } = await import("./streamAgentChatTurn-YQW32AQH.js");
+      return streamAgentChatTurnHandler(args, thunkApi);
+    }),
+    /**
+     * 创建 Agent：
+     * - 写入用户私有路径
+     * - 如 isPublic=true，则同时写入公共路径
+     * - 返回完整 Agent 对象（包含 id / meta 字段）
+     */
+    createAgent: create.asyncThunk(
+      async ({ userId, formData, spaceId }, thunkApi) => {
+        const effectiveUserId = asOptionalTrimmedString(userId) ?? "local";
+        const processed = processAgentCreateForm(formData, effectiveUserId);
+        const now = Date.now();
+        const id = (0, import_ulid.ulid)();
+        const privateKey = createAgentKey.private(effectiveUserId, id);
+        const publicKey = createAgentKey.public(id);
+        let agent = {
+          ...processed,
+          id,
+          type: "agent" /* AGENT */,
+          userId: effectiveUserId,
+          createdAt: now,
+          updatedAt: now,
+          dialogCount: 0,
+          messageCount: 0,
+          tokenCount: 0,
+          spaceId
+          // 记录 spaceId
+        };
+        if (effectiveUserId === "local") {
+          agent.isPublic = false;
+        }
+        try {
+          const { localFirstLog } = await import("./localFirstLog-DHNOY2NA.js");
+          localFirstLog("agent.create.start", {
+            owner: effectiveUserId,
+            hasRawApiKey: Boolean(readNonEmptyApiKey(agent.apiKey)),
+            hasSpace: Boolean(spaceId)
+          });
+        } catch {
+        }
+        const createRawApiKey = readNonEmptyApiKey(agent.apiKey);
+        if (createRawApiKey) {
+          agent = await migrateRawApiKeyForAgent({
+            record: agent,
+            agentKey: privateKey,
+            apiKey: createRawApiKey,
+            apiKeyRef: agent.apiKeyRef,
+            credentialRef: agent.credentialRef
+          });
+        }
+        await thunkApi.dispatch(
+          write({
+            data: agent,
+            customKey: privateKey,
+            userId: effectiveUserId
+          })
+        ).unwrap();
+        if (agent.isPublic) {
+          await thunkApi.dispatch(
+            write({
+              data: agent,
+              customKey: publicKey,
+              userId: effectiveUserId
+            })
+          ).unwrap();
+        }
+        if (agent.credentialSynced && createRawApiKey) {
+          const ctx = getRuntimeServerContext(thunkApi.getState());
+          const credentialRef = agent.credentialRef;
+          if (ctx.currentToken && credentialRef) {
+            try {
+              await pushServerSyncedCredential(
+                { currentServer: ctx.currentServer ?? "", authToken: ctx.currentToken },
+                credentialRef,
+                createRawApiKey
+              );
+            } catch {
+            }
+          }
+        }
+        try {
+          const { localFirstLog } = await import("./localFirstLog-DHNOY2NA.js");
+          localFirstLog("agent.create.done", {
+            owner: effectiveUserId,
+            key: privateKey,
+            hasCredentialRef: Boolean(
+              typeof agent.credentialRef === "string" && agent.credentialRef.trim()
+            ),
+            hasRawApiKey: Boolean(readNonEmptyApiKey(agent.apiKey)),
+            isPublic: Boolean(agent.isPublic)
+          });
+        } catch {
+        }
+        return agent;
+      }
+    ),
+    /**
+     * 更新 Agent（支持局部字段 patch）：
+     * - patch 私有副本
+     * - 如提供 previousAgent，则同步更新 / 删除公共副本
+     *
+     * 注意：
+     * - Tool 场景下一般不提供 previousAgent，此时只保证私有副本被更新；
+     *   公共副本（应用市场）不做强一致保证。
+     */
+    updateAgent: create.asyncThunk(
+      async ({ userId, agentId, formData, previousAgent }, thunkApi) => {
+        const effectiveUserId = asOptionalTrimmedString(userId) ?? "local";
+        const normalizedAgentId = (() => {
+          const raw = agentId.trim();
+          if (raw.startsWith("agent-")) {
+            const parts = raw.split("-");
+            if (parts.length >= 3) return parts.slice(2).join("-");
+          }
+          return raw;
+        })();
+        const privateKey = createAgentKey.private(effectiveUserId, normalizedAgentId);
+        const publicKey = createAgentKey.public(normalizedAgentId);
+        let changes = processAgentUpdateChanges(formData || {}, effectiveUserId, previousAgent);
+        const updateRawApiKey = readNonEmptyApiKey(changes.apiKey);
+        if (updateRawApiKey) {
+          const formAny = formData || {};
+          const migrated = await migrateRawApiKeyForAgent({
+            record: { ...changes },
+            agentKey: privateKey,
+            apiKey: updateRawApiKey,
+            apiKeyRef: formAny.apiKeyRef ?? previousAgent?.apiKeyRef ?? changes.apiKeyRef,
+            credentialRef: formAny.credentialRef ?? previousAgent?.credentialRef ?? changes.credentialRef
+          });
+          changes = migrated;
+          if (!readNonEmptyApiKey(changes.apiKey)) {
+            changes.apiKey = null;
+          }
+        }
+        let localExists = false;
+        try {
+          const { db } = thunkApi.extra;
+          const localData = await db.get(privateKey);
+          localExists = !!localData;
+        } catch (e) {
+        }
+        if (localExists) {
+          await thunkApi.dispatch(
+            patch({
+              dbKey: privateKey,
+              changes
+            })
+          ).unwrap();
+        } else if (previousAgent) {
+          const merged = {
+            ...previousAgent,
+            ...changes,
+            id: normalizedAgentId,
+            type: previousAgent.type || "agent" /* AGENT */,
+            userId: effectiveUserId
+          };
+          await thunkApi.dispatch(
+            write({
+              data: merged,
+              customKey: privateKey,
+              userId: effectiveUserId
+            })
+          ).unwrap();
+        } else {
+          await thunkApi.dispatch(
+            patch({
+              dbKey: privateKey,
+              changes
+            })
+          ).unwrap();
+        }
+        if (previousAgent && effectiveUserId !== "local") {
+          const wasPublic = !!previousAgent.isPublic;
+          const hasIsPublicChange = Object.prototype.hasOwnProperty.call(
+            changes,
+            "isPublic"
+          );
+          const nowPublic = hasIsPublicChange ? !!changes.isPublic : wasPublic;
+          if (nowPublic) {
+            const mergedPublic = {
+              ...previousAgent,
+              ...changes,
+              id: normalizedAgentId,
+              type: previousAgent.type || "agent" /* AGENT */,
+              userId: effectiveUserId
+            };
+            await thunkApi.dispatch(
+              write({
+                data: mergedPublic,
+                customKey: publicKey,
+                userId: effectiveUserId
+              })
+            ).unwrap();
+          } else if (wasPublic && !nowPublic) {
+            await thunkApi.dispatch(remove(publicKey)).unwrap();
+          }
+        }
+        const base = previousAgent ?? {};
+        const mergedPrivate = {
+          ...base,
+          ...changes,
+          id: normalizedAgentId,
+          type: base.type || "agent" /* AGENT */,
+          userId: effectiveUserId
+        };
+        return mergedPrivate;
+      }
+    )
+  })
+});
+var {
+  runLlm,
+  runAgent,
+  streamAgentChatTurn,
+  createAgent,
+  updateAgent
+} = slice.actions;
+var agentReducer = slice.reducer;
+var agentSlice_default = agentReducer;
+
+export {
+  fetchServerSyncedCredential,
+  deleteServerSyncedCredential,
+  setAgentCredentialBrokerFactoryForTests,
+  slice,
+  runLlm,
+  runAgent,
+  streamAgentChatTurn,
+  createAgent,
+  updateAgent,
+  agentSlice_default
+};