nolo-cli 0.32.0 → 0.33.0-alpha.10

package/{chunk-W367V5CH.js → chunk-54BAYVCY.js}

@@ -1,7 +1,38 @@
+import {
+  getLocalProviderSecret
+} from "./chunk-HS7MLR74.js";
 import {
   ANTIGRAVITY_CLOUD_CODE_BASE_URL,
   isAntigravityOAuthAgent
-} from "./chunk-YHGHADBQ.js";
+} from "./chunk-SCUETSRP.js";
+import {
+  clipMultilineText,
+  fetchAndSerializeTable,
+  resolveBuiltinSkillPage,
+  waitForAbortableDelay
+} from "./chunk-MDIAECHA.js";
+import {
+  createDrainExhaustedResponse,
+  isCoreDrainingBody,
+  isGatewayHttpStatus,
+  normalizeNonNegativeMs,
+  parseRetryAfterHeaderMs
+} from "./chunk-RQSOAMPJ.js";
+import {
+  slateToSimplifiedMarkdown
+} from "./chunk-75U775RZ.js";
+import {
+  extractCategorizedMentions
+} from "./chunk-GM6PU7B6.js";
+import {
+  fetchAndCacheMessages
+} from "./chunk-DDVIBKIB.js";
+import {
+  shouldUseServerProxy
+} from "./chunk-YYLHWIW6.js";
+import {
+  fetchServerSyncedCredential
+} from "./chunk-66CWPJK2.js";
 import {
   buildCurrentTimeBlock,
   buildIdentityBlock,
@@ -9,81 +40,79 @@ import {
   requiresBareImageUrl,
   resolveToolGuidedSections,
   toBareImageUrlMessages
-} from "./chunk-3UGKATZQ.js";
+} from "./chunk-ZWS6DUHX.js";
 import {
   convertMessagesToResponsesInput,
+  getUsageRequestOptions,
   preserveAgentStateFields
-} from "./chunk-D34RI6NI.js";
+} from "./chunk-NNWHHCVP.js";
+import {
+  buildProviderAuthHeaders
+} from "./chunk-7YYHKBJP.js";
+import {
+  estimateTokenCount
+} from "./chunk-DKMOY3QI.js";
 import {
-  buildProviderAuthHeaders,
   isOpenAiResponsesModel,
   resolvePlatformChatCompletionsEndpoint,
   resolvePlatformResponsesEndpoint
-} from "./chunk-UDA3ZYLW.js";
+} from "./chunk-CPYYM4RJ.js";
 import {
-  MEMORY_USE_GUIDANCE,
-  wrapHistoricalSummaryWithReplayGuard
-} from "./chunk-XFG3BAKN.js";
-import {
-  waitForAbortableDelay
-} from "./chunk-MITD7CON.js";
-import {
-  createDrainExhaustedResponse,
-  isCoreDrainingBody,
-  isGatewayHttpStatus,
-  normalizeNonNegativeMs,
-  parseRetryAfterHeaderMs
-} from "./chunk-Z5MXSEOJ.js";
+  clampReasoningEffort,
+  getModelConfig,
+  isModelSupportReasoningEffort
+} from "./chunk-DFUPZE6V.js";
 import {
-  resolveBuiltinSkillPage
-} from "./chunk-D2BPX6DQ.js";
+  createFileCredentialBroker
+} from "./chunk-RQFO3CAF.js";
 import {
-  shouldUseServerProxy
-} from "./chunk-3GZT3L6F.js";
+  MEMORY_USE_GUIDANCE,
+  buildUserResponseLanguageContext,
+  wrapHistoricalSummaryWithReplayGuard
+} from "./chunk-FMEVI5TG.js";
 import {
-  estimateTokenCount
-} from "./chunk-BGTUGS3T.js";
+  buildSkillGuidancePromptBlock,
+  extractRuntimePageCapabilities,
+  resolveSkillGraphFromRoots
+} from "./chunk-HUCT7HID.js";
 import {
-  createFileCredentialBroker,
-  fetchServerSyncedCredential
-} from "./chunk-ODS2MVMU.js";
+  canonicalizeToolNames
+} from "./chunk-ZZ2MH7LE.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";
-import {
-  clampReasoningEffort,
-  getModelConfig,
-  isModelSupportReasoningEffort
-} from "./chunk-2K4NDPT5.js";
 import {
   isDeepInfraKimiModel,
   isFireworksKimiModel,
   resolveFireworksKimiModel
-} from "./chunk-CAENRKNJ.js";
+} from "./chunk-OR2HNLVO.js";
+import {
+  createSpaceKey
+} from "./chunk-4F5M2MW5.js";
 import {
   read
-} from "./chunk-LAXMH7JY.js";
+} from "./chunk-UM4H3URE.js";
 import {
   asTrimmedLowercaseString
 } from "./chunk-QSJ3HFEF.js";
+import {
+  getRuntimeServerContext
+} from "./chunk-X664KVEV.js";
 import {
   isAbortError
-} from "./chunk-5RDLGLAP.js";
+} from "./chunk-WJSW43QZ.js";
+import {
+  asTrimmedString
+} from "./chunk-3EUW3WEO.js";
+import {
+  extractCustomId
+} from "./chunk-BJIRLHJR.js";
 import {
   API_ENDPOINTS
 } from "./chunk-LCBAMY2M.js";
 import {
   isLoopbackUrl
 } from "./chunk-4SN6J65J.js";
-import {
-  asTrimmedString
-} from "./chunk-3EUW3WEO.js";
-import {
-  buildSkillGuidancePromptBlock,
-  canonicalizeToolNames,
-  extractRuntimePageCapabilities,
-  resolveSkillGraphFromRoots
-} from "./chunk-3AUWC6EM.js";
 import {
   asOptionalTrimmedString
 } from "./chunk-G3SUCT4W.js";
@@ -452,55 +481,6 @@ function resolveAgentCallPlan(agentConfig, _env) {
   };
 }
 
-// packages/ai/llm/usageRequestOptions.ts
-var STREAM_USAGE_PROVIDERS = /* @__PURE__ */ new Set([
-  "google",
-  "openrouter",
-  "xai",
-  "openai",
-  "fireworks",
-  "mistral",
-  "cloudflare",
-  "gmi"
-]);
-var EXTRA_USAGE_FIELD_PROVIDERS = /* @__PURE__ */ new Set(["openrouter"]);
-var normalizeProviderName = (providerName) => asTrimmedLowercaseString(providerName);
-var getUsageRequestOptions = (providerName, options) => {
-  const normalizedProvider = normalizeProviderName(providerName);
-  const api = options?.api ?? "chat-completions";
-  if (api === "responses") {
-    return EXTRA_USAGE_FIELD_PROVIDERS.has(normalizedProvider) ? {
-      usage: {
-        include: true
-      }
-    } : {};
-  }
-  return {
-    ...STREAM_USAGE_PROVIDERS.has(normalizedProvider) ? {
-      stream_options: {
-        include_usage: true
-      }
-    } : {},
-    ...EXTRA_USAGE_FIELD_PROVIDERS.has(normalizedProvider) ? {
-      usage: {
-        include: true
-      }
-    } : {}
-  };
-};
-
-// packages/app/i18n/mapLanguage.ts
-var languageMap = {
-  "en-US": "English",
-  "zh-CN": "Simplified Chinese",
-  "zh-TW": "Traditional Chinese",
-  "ja-JP": "Japanese"
-  // Add more mappings as needed
-};
-var mapLanguage = (responseLanguage) => {
-  return languageMap[responseLanguage] || responseLanguage;
-};
-
 // packages/ai/agent/contextCompiler.ts
 function createHash(_algo) {
   let buf = "";
@@ -680,12 +660,10 @@ var buildSystemPromptContext = (options) => {
   } = options;
   const safeLanguage = options.language ?? (typeof navigator !== "undefined" ? navigator.language : "en");
   const { name, prompt: mainPrompt, dbKey, model } = agentConfig;
-  const mappedLanguage = mapLanguage(safeLanguage);
   const identitySection = buildIdentityBlock({
     agentName: name,
     agentId: dbKey,
-    model,
-    responseLanguage: mappedLanguage
+    model
   });
   const corePersonaSection = mainPrompt ? `-- - \u6838\u5FC3\u89D2\u8272\u4E0E\u4EFB\u52A1-- -
 ${mainPrompt}` : "";
@@ -718,6 +696,7 @@ ${contexts.userGlobalPrompt.trim()} ` : "";
 ${wrapHistoricalSummaryWithReplayGuard(contexts.dialogSummary)}` : "";
   return compileContextLayers([
     { id: "identity", owner: "platform", cacheScope: "session", content: identitySection },
+    { id: "user-response-language", owner: "platform", cacheScope: "session", content: buildUserResponseLanguageContext({ language: safeLanguage }) },
     { id: "startup-protocol", owner: "platform", cacheScope: "static", content: startupProtocol },
     { id: "core-persona", owner: "agent", cacheScope: "session", content: corePersonaSection },
     { id: "agent-orchestration", owner: "platform", cacheScope: "session", content: toolSections.agentOrchestration },
@@ -1280,27 +1259,6 @@ async function safeBrokerGet(broker, ref) {
   }
 }
 
-// packages/shared/providerSecrets.ts
-function providerSecretKey(presetId) {
-  const normalized = presetId.trim().replace(/[^a-zA-Z0-9]+/g, "_").toUpperCase();
-  return `${normalized}_KEY`;
-}
-
-// packages/ai/agent/providerSecrets.ts
-var STORAGE_KEY = "nolo-local-secrets";
-function readLocalSecrets() {
-  if (typeof localStorage === "undefined") return {};
-  try {
-    const value = JSON.parse(localStorage.getItem(STORAGE_KEY) ?? "{}");
-    return value && typeof value === "object" ? value : {};
-  } catch {
-    return {};
-  }
-}
-function getLocalProviderSecret(presetId) {
-  return readLocalSecrets()[providerSecretKey(presetId)] ?? null;
-}
-
 // packages/ai/chat/fetchUtils.ts
 var buildProxyPayload = (bodyData, api, agentConfig, dialogId) => {
   const apiSource = agentConfig.apiSource === "custom" || agentConfig.apiSource === "cli" ? agentConfig.apiSource : void 0;
@@ -1418,7 +1376,336 @@ var performFetchRequest = async (params) => {
   }
 };
 
+// packages/create/editor/transforms/slateToText.ts
+function getNodeText(node) {
+  if (node.text) {
+    return node.text;
+  }
+  if (node.children && Array.isArray(node.children)) {
+    return node.children.map(getNodeText).join("\n");
+  }
+  return "";
+}
+function slateToText(nodes) {
+  if (!nodes || nodes.length === 0) {
+    return "";
+  }
+  return nodes.map(getNodeText).join("\n\n");
+}
+
+// packages/ai/context/buildReferenceContext.ts
+var MAX_META_TEXT_LENGTH = 80;
+var DIALOG_REFERENCE_MESSAGE_LIMIT = 20;
+var DIALOG_REFERENCE_SNIPPET_CHARS = 1200;
+var DIALOG_HANDOFF_SNIPPET_CHARS = 360;
+var truncateMetaText = (value, max = MAX_META_TEXT_LENGTH) => {
+  if (!value) return "";
+  if (value.length <= max) return value;
+  return `${value.slice(0, max - 3)}...`;
+};
+var readSafe = async (dispatch, dbKey) => {
+  try {
+    return await dispatch(read({
+      dbKey
+    })).unwrap();
+  } catch {
+    return null;
+  }
+};
+var buildMentionMetaMap = async (slateData, dispatch) => {
+  const metaMap = /* @__PURE__ */ new Map();
+  const mentions = extractCategorizedMentions(slateData);
+  if (!mentions) return metaMap;
+  const pageEntries = await Promise.all(
+    (mentions.pages || []).map(async (pageId) => {
+      const pageData = await readSafe(dispatch, pageId);
+      if (!pageData) {
+        return [`page:${pageId}`, { displayType: "page", metaParts: [] }];
+      }
+      if (pageData.type === "dialog" /* DIALOG */) {
+        const agentCount = Array.isArray(pageData.cybots) ? pageData.cybots.length : 0;
+        return [
+          `page:${pageId}`,
+          {
+            displayType: "dialog",
+            title: pageData.title,
+            metaParts: [
+              `agents=${agentCount}`,
+              `updated=${pageData.updatedAt || pageData.updated_at || pageData.updated || "Unknown"}`
+            ]
+          }
+        ];
+      }
+      const tags = pageData.tags && pageData.tags.length > 0 ? pageData.tags.slice(0, 5).join(", ") : "";
+      return [
+        `page:${pageId}`,
+        {
+          displayType: "page",
+          title: pageData.title,
+          metaParts: [
+            pageData.spaceId ? `space=${pageData.spaceId}` : "",
+            tags ? `tags=${tags}` : "",
+            `updated=${pageData.updatedAt || pageData.updated_at || pageData.updated || "Unknown"}`
+          ].filter(Boolean)
+        }
+      ];
+    })
+  );
+  pageEntries.forEach((entry) => metaMap.set(entry[0], entry[1]));
+  const agentEntries = await Promise.all(
+    (mentions.agents || []).map(async (agentId) => {
+      const agentData = await readSafe(dispatch, agentId);
+      if (!agentData) {
+        return [`agent:${agentId}`, { displayType: "agent", metaParts: [] }];
+      }
+      const desc = truncateMetaText(
+        agentData.description || agentData.introduction || ""
+      );
+      return [
+        `agent:${agentId}`,
+        {
+          displayType: "agent",
+          title: agentData.name,
+          metaParts: [
+            `public=${agentData.isPublic ? "yes" : "no"}`,
+            desc ? `desc=${desc}` : ""
+          ].filter(Boolean)
+        }
+      ];
+    })
+  );
+  agentEntries.forEach((entry) => metaMap.set(entry[0], entry[1]));
+  const spaceEntries = await Promise.all(
+    (mentions.spaces || []).map(async (spaceId) => {
+      const spaceKey = createSpaceKey.space(spaceId);
+      const spaceData = await readSafe(dispatch, spaceKey);
+      if (!spaceData) {
+        return [`space:${spaceId}`, { displayType: "space", metaParts: [] }];
+      }
+      const desc = truncateMetaText(spaceData.description || "");
+      const categoriesCount = Object.keys(spaceData.categories || {}).length;
+      const contentsCount = Object.keys(spaceData.contents || {}).length;
+      return [
+        `space:${spaceId}`,
+        {
+          displayType: "space",
+          title: spaceData.name,
+          metaParts: [
+            desc ? `desc=${desc}` : "",
+            `categories=${categoriesCount}`,
+            `contents=${contentsCount}`
+          ].filter(Boolean)
+        }
+      ];
+    })
+  );
+  spaceEntries.forEach((entry) => metaMap.set(entry[0], entry[1]));
+  return metaMap;
+};
+var buildInlineMention = (node, metaMap) => {
+  const resourceType = node.resourceType || "unknown";
+  const resourceId = node.resourceId || "unknown";
+  const key = `${resourceType}:${resourceId}`;
+  const meta = metaMap.get(key);
+  const label = meta?.title || node.label || resourceId || "mention";
+  const displayType = meta?.displayType || resourceType;
+  const metaParts = meta?.metaParts ?? [];
+  const idPart = resourceType === "tool" ? `tool=${resourceId}` : `dbkey=${resourceId}`;
+  const metaSuffix = metaParts.length ? ` | ${metaParts.join(" | ")}` : "";
+  return `@${label}(${displayType} | ${idPart}${metaSuffix})`;
+};
+var clipReferenceText = (value, max) => {
+  const raw = typeof value === "string" ? value : value == null ? "" : JSON.stringify(value);
+  return clipMultilineText(raw, max);
+};
+var fetchDialogReference = async (dbKey, refContent, dispatch) => {
+  const dialogConfig = refContent;
+  const dialogTitle = dialogConfig.title || `Untitled Dialog (${dbKey})`;
+  const dialogId = extractCustomId(dbKey) || dbKey.replace(/^dialog-/, "");
+  const checkpoint = dialogConfig.runtimeCheckpoint || null;
+  const summary = asTrimmedString(dialogConfig.summary);
+  const messages = await dispatch(
+    async (_dispatch, getState, { db }) => {
+      const state = getState();
+      const { currentToken: token, remoteServers } = getRuntimeServerContext(state);
+      return await fetchAndCacheMessages({
+        db,
+        dialogId,
+        limit: DIALOG_REFERENCE_MESSAGE_LIMIT,
+        token,
+        remoteServers: remoteServers.length > 0 ? remoteServers : void 0
+      });
+    }
+  );
+  const sortedMessages = [...messages].reverse();
+  const formatContent = (content) => clipReferenceText(content, DIALOG_REFERENCE_SNIPPET_CHARS);
+  const transcript = sortedMessages.map((msg, index) => {
+    const toolLine = msg.toolName ? ` tool=${msg.toolName}` : "";
+    const agentLine = msg.cybotKey ? ` agent=${msg.cybotKey}` : "";
+    const createdLine = msg.createdAt ? ` at=${msg.createdAt}` : "";
+    return [
+      `### Message ${index + 1}: ${msg.role || "unknown"} id=${msg.id || "unknown"}${toolLine}${agentLine}${createdLine}`,
+      formatContent(msg.content) || "[empty]"
+    ].join("\n");
+  }).join("\n\n");
+  const checkpointLines = [];
+  if (checkpoint && typeof checkpoint === "object") {
+    if (checkpoint.status) checkpointLines.push(`- status: ${checkpoint.status}`);
+    if (checkpoint.lastUserInput) checkpointLines.push(`- lastUserInput: ${formatContent(checkpoint.lastUserInput)}`);
+    if (checkpoint.lastAssistantText) checkpointLines.push(`- lastAssistantText: ${formatContent(checkpoint.lastAssistantText)}`);
+    if (Array.isArray(checkpoint.lastToolNames) && checkpoint.lastToolNames.length) {
+      checkpointLines.push(`- lastToolNames: ${checkpoint.lastToolNames.join(", ")}`);
+    }
+    if (Array.isArray(checkpoint.availableToolNames) && checkpoint.availableToolNames.length) {
+      checkpointLines.push(`- availableToolNames: ${checkpoint.availableToolNames.join(", ")}`);
+    }
+  }
+  const recentToolEvidence = sortedMessages.filter((msg) => msg.role === "tool" || msg.toolName).slice(-3).map((msg) => {
+    const label = msg.toolName ? `${msg.toolName}` : "tool";
+    return `- ${label} id=${msg.id || "unknown"}: ${clipReferenceText(msg.content, DIALOG_HANDOFF_SNIPPET_CHARS) || "[empty]"}`;
+  });
+  const handoffLines = [
+    `- Use this when continuing work, transferring to another Agent, comparing with the current task, or preparing a document/plan from the prior discussion.`,
+    `- Current state source: ${checkpointLines.length ? "Runtime Checkpoint" : "summaries and recent transcript"}.`,
+    summary ? `- Compressed background: passive summary is available below; treat it as lossy, not original wording.` : "",
+    recentToolEvidence.length ? `- Recent tool evidence:
+${recentToolEvidence.join("\n")}` : `- Recent tool evidence: none loaded in the latest ${DIALOG_REFERENCE_MESSAGE_LIMIT} messages.`,
+    `- For exact claims, old decisions, original wording, files/tools mentioned earlier, or anything not visible in the recent transcript, call searchDialogMessages with DB Key ${dbKey}.`
+  ].filter(Boolean);
+  const referenceBody = [
+    `Conversation Reference:`,
+    `DB Key: ${dbKey}`,
+    `Title: ${dialogTitle}`,
+    `Status: ${dialogConfig.status || "unknown"}`,
+    `Loaded Recent Messages: ${sortedMessages.length}`,
+    `Conversation Handoff:
+${handoffLines.join("\n")}`,
+    checkpointLines.length ? `Runtime Checkpoint:
+${checkpointLines.join("\n")}` : "",
+    summary ? `Passive Summary (compressed history, not original wording):
+${wrapHistoricalSummaryWithReplayGuard(summary)}` : "",
+    `Recent Transcript (original message excerpts, oldest to newest):
+${transcript || "[no recent messages loaded]"}`,
+    [
+      `Coverage Note: This reference intentionally loads only the latest ${DIALOG_REFERENCE_MESSAGE_LIMIT} messages plus summaries/checkpoint to control token load.`,
+      `Original Message Lookup Policy: If the user asks for an exact old message, original wording, who said what, why a decision was made, early-history detail, file/tool evidence, failed attempts, or a comparison with prior work, use searchDialogMessages({ dialogKey: "${dbKey}", query: "..." }) before making a factual claim from this referenced conversation.`
+    ].join("\n")
+  ].filter(Boolean).join("\n\n");
+  const tokenEstimate = estimateTokenCount(referenceBody);
+  return `${referenceBody}
+
+Token Load Estimate: ${tokenEstimate} tokens for this conversation reference.
+---
+
+`;
+};
+var fetchTableReference = async (dbKey, refContent, dispatch) => {
+  const tableMeta = refContent;
+  const title = tableMeta.displayName || tableMeta.description || `Untitled Table (${dbKey})`;
+  const { markdown: tableMd } = await dispatch(
+    async (_dispatch, getState, { db }) => {
+      const state = getState();
+      const { currentToken: token, remoteServers } = getRuntimeServerContext(state);
+      return await fetchAndSerializeTable(tableMeta, db, {
+        token,
+        remoteServers
+      });
+    }
+  );
+  const tags = tableMeta.tags?.length ? tableMeta.tags.join(", ") : "None";
+  const description = tableMeta.description || "No description provided.";
+  return `Reference Item (Table):
+DB Key: ${dbKey}
+Title: ${title}
+Description: ${description}
+Tags: ${tags}
+Content (Markdown Table):
+
+${tableMd}
+---
+
+`;
+};
+var fetchSlateReference = async (dbKey, refContent, dispatch, options) => {
+  if (!refContent?.slateData) return null;
+  const title = refContent.title || `Untitled (${dbKey})`;
+  let contentString;
+  let contentType;
+  const inlineMentionMeta = options.inlineMentionMeta ?? options.format === "simplified_markdown";
+  switch (options.format) {
+    case "text":
+      contentType = "Plain Text";
+      contentString = slateToText(refContent.slateData);
+      break;
+    case "simplified_markdown":
+      contentType = "Simplified Markdown";
+      if (inlineMentionMeta) {
+        const metaMap = await buildMentionMetaMap(refContent.slateData, dispatch);
+        contentString = slateToSimplifiedMarkdown(refContent.slateData, {
+          mentionResolver: (node) => buildInlineMention(node, metaMap)
+        });
+      } else {
+        contentString = slateToSimplifiedMarkdown(refContent.slateData);
+      }
+      break;
+    case "json":
+    default:
+      contentType = "Slate JSON";
+      contentString = JSON.stringify(refContent.slateData, null, 2);
+      break;
+  }
+  if (!contentString || typeof contentString === "string" && !contentString.trim() || contentString === "[]") {
+    return null;
+  }
+  const tags = (refContent.tags || []).length > 0 ? refContent.tags.join(", ") : "None";
+  const createdAt = refContent.created || "Unknown Creation Date";
+  const updatedAt = refContent.updated || "Unknown Update Date";
+  return `Reference Item:
+DB Key: ${dbKey}
+Title: ${title}
+Content (${contentType}):
+${contentString}
+Tags: ${tags}
+Created At: ${createdAt}
+Updated At: ${updatedAt}
+---
+
+`;
+};
+var fetchReferenceContents = async (references, dispatch, options = { format: "simplified_markdown" }) => {
+  const result = /* @__PURE__ */ new Map();
+  if (!references || references.length === 0) return result;
+  const referencePromises = references.map(async (dbKey) => {
+    try {
+      const hasPreloaded = options.preloaded?.has(dbKey);
+      const refContent = hasPreloaded ? options.preloaded?.get(dbKey) : await dispatch(read({
+        dbKey
+      })).unwrap();
+      if (!refContent) return null;
+      let formatted = null;
+      if (refContent.type === "dialog" /* DIALOG */) {
+        formatted = await fetchDialogReference(dbKey, refContent, dispatch);
+      } else if (refContent.type === "table" /* TABLE */) {
+        formatted = await fetchTableReference(dbKey, refContent, dispatch);
+      } else {
+        formatted = await fetchSlateReference(dbKey, refContent, dispatch, options);
+      }
+      if (formatted) return [dbKey, formatted];
+      return null;
+    } catch (error) {
+      console.error(`Error fetching reference ${dbKey}:`, error);
+      return null;
+    }
+  });
+  const resolved = await Promise.all(referencePromises);
+  resolved.forEach((item) => {
+    if (item) result.set(item[0], item[1]);
+  });
+  return result;
+};
+
 export {
+  fetchReferenceContents,
   mergeReferences,
   resolveReferenceAssets,
   resolveToolsFromKeys,