nolo-cli 0.149.0-alpha.1 → 0.151.0-alpha.2

package/{chunk-ZOVKKMF6.js → chunk-FY4SDK2E.js}

@@ -14,7 +14,7 @@ function buildCliLocalRuntimeDbEnv(env = process.env) {
   };
 }
 async function getDefaultCliLocalRuntimeDb(options = {}) {
-  const { getDefaultCliLocalRuntimeDb: getAuthorityBackedDb } = await import("./localRuntimeAuthority-5W6IJRAD.js");
+  const { getDefaultCliLocalRuntimeDb: getAuthorityBackedDb } = await import("./localRuntimeAuthority-JDAD7CB6.js");
   return getAuthorityBackedDb(options);
 }
 

package/chunk-G6OOUQWJ.js

@@ -0,0 +1,417 @@
+import {
+  describeAttachmentForModel
+} from "./chunk-WJZOQR2J.js";
+
+// packages/ai/attachments/projectUserPart.ts
+var isRecord = (value) => typeof value === "object" && value !== null;
+var projectUserPartForModel = (part) => {
+  if (!isRecord(part) || typeof part.type !== "string") return [];
+  if (part.type === "text") {
+    return typeof part.text === "string" && part.text.trim() ? [part] : [];
+  }
+  if (part.type === "image_url") {
+    return isRecord(part.image_url) && typeof part.image_url.url === "string" && part.image_url.url.trim() ? [part] : [];
+  }
+  if (part.type === "attachment") return [{ type: "text", text: describeAttachmentForModel(part) }];
+  if (part.type === "media_job") {
+    const name = typeof part.name === "string" && part.name.trim() ? part.name.trim() : "\u672A\u547D\u540D\u6587\u4EF6";
+    const jobId = typeof part.jobId === "string" ? part.jobId : typeof part.id === "string" ? part.id : "";
+    return [{ type: "text", text: `[\u5A92\u4F53\u9644\u4EF6] \u6587\u4EF6=${name}${jobId ? ` jobId=${jobId}` : ""}` }];
+  }
+  if (typeof part.pageKey === "string" && ["page", "pdf", "docx"].includes(part.type)) return [];
+  return [{ type: "text", text: `[\u672A\u8BC6\u522B\u7684\u9644\u4EF6\u7C7B\u578B: ${part.type}]` }];
+};
+
+// packages/agent-runtime/outboundRequestDiagnostics.ts
+var OUTBOUND_DIAGNOSTIC_PREFIX = "[outbound-diagnostic]";
+var OUTBOUND_DIAGNOSTICS_ENV = "NOLO_OUTBOUND_DIAGNOSTICS";
+var MAX_PROVIDER_TOKEN_LENGTH = 96;
+var MAX_CALL_ID_LENGTH = 128;
+var MAX_UPSTREAM_REQUEST_ID_LENGTH = 128;
+var IDENTIFIER_PATTERN = /^[A-Za-z0-9._:@+/~-]+$/;
+var REQUEST_ID_PATTERN = /^[A-Za-z0-9._:-]+$/;
+var CONTROL_CHAR_PATTERN = /[\u0000-\u001f\u007f]/;
+var UPSTREAM_REQUEST_ID_HEADERS = ["x-request-id", "request-id"];
+var THINKING_VALUES = /* @__PURE__ */ new Set([
+  "enabled",
+  "disabled",
+  "unspecified",
+  "other"
+]);
+var REASONING_EFFORT_VALUES = /* @__PURE__ */ new Set([
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "unspecified",
+  "other"
+]);
+var ERROR_CATEGORY_VALUES = /* @__PURE__ */ new Set([
+  "none",
+  "reasoning-contract",
+  "invalid-request",
+  "authentication",
+  "rate-limit",
+  "upstream",
+  "other"
+]);
+var TERMINAL_OUTCOME_VALUES = /* @__PURE__ */ new Set([
+  "completed",
+  "http-error",
+  "network-error",
+  "aborted",
+  "stream-error"
+]);
+var SEAM_VALUES = /* @__PURE__ */ new Set([
+  "local-runtime",
+  "chat",
+  "server-loop"
+]);
+var WIRE_VALUES = /* @__PURE__ */ new Set(["chat.completions", "responses"]);
+var HOST_VALUES = /* @__PURE__ */ new Set(["client", "server"]);
+function isRawIdentifierAcceptable(value, maxLength) {
+  if (typeof value !== "string") return false;
+  if (value.length === 0) return false;
+  if (value.length > maxLength) return false;
+  if (CONTROL_CHAR_PATTERN.test(value)) return false;
+  return true;
+}
+function sanitizeProviderModelToken(value) {
+  if (!isRawIdentifierAcceptable(value, MAX_PROVIDER_TOKEN_LENGTH)) return "other";
+  const normalized = value.trim();
+  if (!normalized || !IDENTIFIER_PATTERN.test(normalized)) return "other";
+  return normalized;
+}
+function sanitizeCallId(value) {
+  if (!isRawIdentifierAcceptable(value, MAX_CALL_ID_LENGTH)) return void 0;
+  const normalized = value.trim();
+  if (!normalized || !REQUEST_ID_PATTERN.test(normalized)) return void 0;
+  return normalized;
+}
+function sanitizeUpstreamRequestId(value) {
+  if (!isRawIdentifierAcceptable(value, MAX_UPSTREAM_REQUEST_ID_LENGTH)) return void 0;
+  const normalized = value.trim();
+  if (!normalized || !REQUEST_ID_PATTERN.test(normalized)) return void 0;
+  return normalized;
+}
+function pickUpstreamRequestId(headers) {
+  if (!headers || typeof headers.get !== "function") return void 0;
+  try {
+    for (const name of UPSTREAM_REQUEST_ID_HEADERS) {
+      const raw = headers.get(name);
+      const safe = sanitizeUpstreamRequestId(raw);
+      if (safe) return safe;
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function classifyOutboundErrorCategory(status, errorText) {
+  const numeric = typeof status === "number" && Number.isFinite(status) ? status : 0;
+  if (numeric === 401 || numeric === 403) return "authentication";
+  if (numeric === 429) return "rate-limit";
+  if (numeric >= 500) return "upstream";
+  const text = typeof errorText === "string" ? errorText : "";
+  if (numeric >= 400) {
+    if (looksLikeReasoningContractError(text)) return "reasoning-contract";
+    return "invalid-request";
+  }
+  if (numeric === 0) return "other";
+  return numeric >= 200 && numeric < 300 ? "none" : "other";
+}
+function looksLikeReasoningContractError(text) {
+  if (!text) return false;
+  if (!/reasoning_content|reasoning/i.test(text)) return false;
+  return /expected a sequence|invalid type|serde|deserializ|type error|missing field/i.test(text);
+}
+function createRequestShapingCounts() {
+  return {
+    assistantToolTurns: 0,
+    missingReasoningTurns: 0,
+    placeholderInjectedTurns: 0,
+    reasoningStrippedTurns: 0
+  };
+}
+function createRequestFacts() {
+  return {
+    assistantToolTurns: 0,
+    missingReasoningTurns: 0,
+    // 未观测：只有塑形直连点（collector）能给出「本次注入」。
+    placeholderInjectedTurns: null,
+    reasoningStrippedTurns: null,
+    thinking: "unspecified",
+    reasoningEffort: "unspecified",
+    projection: { observed: false }
+  };
+}
+function applyShapingCounts(facts, counts) {
+  if (!counts) return facts;
+  facts.assistantToolTurns = toCount(counts.assistantToolTurns);
+  facts.missingReasoningTurns = toCount(counts.missingReasoningTurns);
+  facts.placeholderInjectedTurns = toCount(counts.placeholderInjectedTurns);
+  facts.reasoningStrippedTurns = toCount(counts.reasoningStrippedTurns);
+  return facts;
+}
+function attachProjectionFacts(facts, stats) {
+  if (!stats) {
+    facts.projection = { observed: false };
+    return facts;
+  }
+  facts.projection = {
+    observed: true,
+    badArguments: {
+      truncated: toCount(stats.badArguments?.truncated),
+      malformed: toCount(stats.badArguments?.malformed)
+    },
+    rewrittenToolCalls: toCount(stats.rewrittenToolCalls),
+    rewrittenAssistantMessages: toCount(stats.rewrittenAssistantMessages),
+    rewrittenToolMessages: toCount(stats.rewrittenToolMessages)
+  };
+  return facts;
+}
+function writeThinkingFacts(facts, body) {
+  const record = asRecord(body);
+  facts.thinking = resolveThinkingEnum(record);
+  facts.reasoningEffort = resolveReasoningEffortEnum(record);
+  return facts;
+}
+function resolveThinkingEnum(body) {
+  const thinking = asRecord(body.thinking);
+  if (typeof thinking.type === "string") {
+    const type = thinking.type.trim().toLowerCase();
+    if (type === "enabled") return "enabled";
+    if (type === "disabled") return "disabled";
+    return "other";
+  }
+  const chatTemplateKwargs = asRecord(body.chat_template_kwargs);
+  const enableThinking = body.enable_thinking ?? chatTemplateKwargs.enable_thinking;
+  if (typeof enableThinking === "boolean") return enableThinking ? "enabled" : "disabled";
+  return "unspecified";
+}
+function resolveReasoningEffortEnum(body) {
+  const raw = body.reasoning_effort;
+  if (typeof raw === "string") {
+    const value = raw.trim().toLowerCase();
+    if (REASONING_EFFORT_VALUES.has(value)) return value;
+    return "other";
+  }
+  const reasoning = asRecord(body.reasoning);
+  if (reasoning.enabled === false) return "none";
+  return "unspecified";
+}
+function deriveRequestFactsFromBody(body, shapingCounts) {
+  const facts = createRequestFacts();
+  writeThinkingFacts(facts, body);
+  const messages = extractMessages(body);
+  if (messages) {
+    for (const message of messages) {
+      const record = asRecord(message);
+      if (record.role !== "assistant") continue;
+      const toolCalls = record.tool_calls;
+      if (!Array.isArray(toolCalls) || toolCalls.length === 0) continue;
+      facts.assistantToolTurns += 1;
+      const reasoning = typeof record.reasoning_content === "string" ? record.reasoning_content : "";
+      if (reasoning.length === 0) {
+        facts.missingReasoningTurns += 1;
+      }
+    }
+  }
+  return applyShapingCounts(facts, shapingCounts);
+}
+function extractMessages(body) {
+  const record = asRecord(body);
+  if (Array.isArray(record.messages)) return record.messages;
+  if (Array.isArray(record.input)) return record.input;
+  return void 0;
+}
+function resolveOutboundWire(value, explicit) {
+  if (explicit) return explicit;
+  const text = typeof value === "string" ? value : "";
+  return /\/responses(?:[/?#]|$)/.test(text) ? "responses" : "chat.completions";
+}
+function isOutboundDiagnosticsEnabled(env = readProcessEnv()) {
+  return env?.[OUTBOUND_DIAGNOSTICS_ENV] === "1";
+}
+function readProcessEnv() {
+  if (typeof process === "undefined") return void 0;
+  return process.env;
+}
+function createConsoleOutboundDiagnosticSink(log = defaultLog) {
+  return (event) => {
+    try {
+      const serialized = serializeOutboundDiagnosticEvent(event);
+      log(`${OUTBOUND_DIAGNOSTIC_PREFIX} ${JSON.stringify(serialized)}`);
+    } catch {
+    }
+  };
+}
+function defaultLog(...args) {
+  console.log(...args);
+}
+function resolveOutboundDiagnosticSink(option) {
+  if (option?.sink) return option.sink;
+  if (option?.enabled === false) return void 0;
+  if (option?.enabled === true) return createConsoleOutboundDiagnosticSink();
+  if (isOutboundDiagnosticsEnabled()) return createConsoleOutboundDiagnosticSink();
+  return void 0;
+}
+function createOutboundDiagnosticCallId() {
+  return `obd_${Math.random().toString(36).slice(2, 10)}${Date.now().toString(36)}`;
+}
+function createOutboundDiagnosticCall(args) {
+  const callId = sanitizeCallId(args.callId) ?? createOutboundDiagnosticCallId();
+  const base = {
+    callId,
+    seam: args.seam,
+    host: args.host,
+    wire: args.wire,
+    provider: sanitizeProviderModelToken(args.provider),
+    model: sanitizeProviderModelToken(args.model)
+  };
+  return {
+    callId,
+    dispatch(attempt, facts) {
+      emitOutboundDiagnostic(args.sink, {
+        ...base,
+        version: 1,
+        phase: "dispatch",
+        attempt: toAttempt(attempt),
+        facts
+      });
+    },
+    httpResult(attempt, result) {
+      const upstreamRequestId = pickUpstreamRequestId(result.headers);
+      const providerCallId = sanitizeCallId(result.providerCallId);
+      emitOutboundDiagnostic(args.sink, {
+        ...base,
+        version: 1,
+        phase: "http-result",
+        attempt: toAttempt(attempt),
+        status: toStatus(result.status),
+        errorCategory: result.errorCategory ?? classifyOutboundErrorCategory(result.status),
+        ...providerCallId ? { providerCallId } : {},
+        ...upstreamRequestId ? { upstreamRequestId } : {}
+      });
+    },
+    terminal(attempt, outcome, providerCallId) {
+      const safeProviderCallId = sanitizeCallId(providerCallId);
+      emitOutboundDiagnostic(args.sink, {
+        ...base,
+        version: 1,
+        phase: "terminal",
+        attempt: toAttempt(attempt),
+        outcome,
+        ...safeProviderCallId ? { providerCallId: safeProviderCallId } : {}
+      });
+    }
+  };
+}
+function emitOutboundDiagnostic(sink, event) {
+  if (!sink) return;
+  try {
+    sink(event);
+  } catch {
+  }
+}
+function serializeOutboundDiagnosticEvent(event) {
+  const record = event;
+  const out = {
+    version: 1,
+    phase: toEnum(record.phase, /* @__PURE__ */ new Set(["dispatch", "http-result", "terminal"]), "dispatch"),
+    callId: sanitizeCallId(record.callId) ?? "unknown",
+    attempt: toAttempt(record.attempt),
+    seam: toEnum(record.seam, SEAM_VALUES, void 0) ?? void 0,
+    host: toEnum(record.host, HOST_VALUES, void 0) ?? void 0,
+    wire: toEnum(record.wire, WIRE_VALUES, void 0) ?? void 0,
+    provider: sanitizeProviderModelToken(record.provider),
+    model: sanitizeProviderModelToken(record.model)
+  };
+  const providerCallId = sanitizeCallId(record.providerCallId);
+  if (providerCallId) out.providerCallId = providerCallId;
+  if (out.phase === "dispatch") {
+    out.facts = serializeRequestFacts(record.facts);
+  } else if (out.phase === "http-result") {
+    out.status = toStatus(record.status);
+    out.errorCategory = toEnum(
+      record.errorCategory,
+      ERROR_CATEGORY_VALUES,
+      "other"
+    );
+    const upstreamRequestId = sanitizeUpstreamRequestId(record.upstreamRequestId);
+    if (upstreamRequestId) out.upstreamRequestId = upstreamRequestId;
+  } else {
+    out.outcome = toEnum(record.outcome, TERMINAL_OUTCOME_VALUES, "other");
+  }
+  for (const key of Object.keys(out)) {
+    if (out[key] === void 0) delete out[key];
+  }
+  return out;
+}
+function serializeRequestFacts(value) {
+  const record = asRecord(value);
+  const projection = asRecord(record.projection);
+  const output = {
+    assistantToolTurns: toCount(record.assistantToolTurns),
+    missingReasoningTurns: toCount(record.missingReasoningTurns),
+    placeholderInjectedTurns: typeof record.placeholderInjectedTurns === "number" ? toCount(record.placeholderInjectedTurns) : null,
+    reasoningStrippedTurns: typeof record.reasoningStrippedTurns === "number" ? toCount(record.reasoningStrippedTurns) : null,
+    thinking: toEnum(record.thinking, THINKING_VALUES, "unspecified"),
+    reasoningEffort: toEnum(
+      record.reasoningEffort,
+      REASONING_EFFORT_VALUES,
+      "unspecified"
+    )
+  };
+  if (projection.observed === true) {
+    const bad = asRecord(projection.badArguments);
+    output.projection = {
+      observed: true,
+      badArguments: {
+        truncated: toCount(bad.truncated),
+        malformed: toCount(bad.malformed)
+      },
+      rewrittenToolCalls: toCount(projection.rewrittenToolCalls),
+      rewrittenAssistantMessages: toCount(projection.rewrittenAssistantMessages),
+      rewrittenToolMessages: toCount(projection.rewrittenToolMessages)
+    };
+  } else {
+    output.projection = { observed: false };
+  }
+  return output;
+}
+function toCount(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return 0;
+  return Math.floor(value);
+}
+function toAttempt(value) {
+  const count = toCount(value);
+  return count > 0 ? count : 1;
+}
+function toStatus(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+  return Math.floor(value);
+}
+function toEnum(value, allowed, fallback) {
+  if (typeof value === "string" && allowed.has(value)) return value;
+  return fallback;
+}
+function asRecord(value) {
+  return value && typeof value === "object" ? value : {};
+}
+
+export {
+  projectUserPartForModel,
+  classifyOutboundErrorCategory,
+  createRequestShapingCounts,
+  createRequestFacts,
+  applyShapingCounts,
+  attachProjectionFacts,
+  writeThinkingFacts,
+  deriveRequestFactsFromBody,
+  resolveOutboundWire,
+  resolveOutboundDiagnosticSink,
+  createOutboundDiagnosticCall
+};

package/{chunk-PQWU42UQ.js → chunk-GCKHQECX.js}

@@ -1,13 +1,13 @@
 import {
   findModelConfig,
   getProviderByModelName
-} from "./chunk-3BXNTXYI.js";
-import {
-  asTrimmedLowercaseString
-} from "./chunk-QSJ3HFEF.js";
+} from "./chunk-I4SN4NUQ.js";
 import {
   asOptionalTrimmedString
 } from "./chunk-G3SUCT4W.js";
+import {
+  asTrimmedLowercaseString
+} from "./chunk-QSJ3HFEF.js";
 
 // packages/ai/agent/toolOutputPolicy.ts
 var MAX_IN_TURN_TOOL_CONTENT_CHARS = 4e3;
@@ -23,8 +23,8 @@ var TOOL_OUTPUT_PROFILES = {
   execShell: { maxChars: 4e3, headRatio: 0.35 },
   runCommand: { maxChars: 4e3, headRatio: 0.35 },
   launchProcess: { maxChars: 2800, headRatio: 0.35 },
-  editFile: { maxChars: 2800, headRatio: 0.62 },
-  writeFile: { maxChars: 2400, headRatio: 0.62 },
+  editFile: { maxChars: 1200, headRatio: 0.62 },
+  writeFile: { maxChars: 1e3, headRatio: 0.62 },
   readPastedText: { maxChars: 4800, headRatio: 0.5, historicalMaxChars: 4800 }
 };
 function resolveToolOutputProfile(toolName) {

package/chunk-GKXCHNTE.js

@@ -0,0 +1,15 @@
+import {
+  BUILTIN_NOLO_AGENT_KEY
+} from "./chunk-EZVK3N5L.js";
+
+// packages/core/init.ts
+var nolotusId = "0e95801d90";
+var ADMIN_IDS = /* @__PURE__ */ new Set([nolotusId]);
+var isSystemAdmin = (userId) => userId != null && ADMIN_IDS.has(userId);
+var noloAgentId = BUILTIN_NOLO_AGENT_KEY;
+
+export {
+  nolotusId,
+  isSystemAdmin,
+  noloAgentId
+};

package/{chunk-TXH4IWJL.js → chunk-GQN2WLAI.js}

@@ -1,16 +1,16 @@
 import {
-  require_date_fns
-} from "./chunk-M76ECQRD.js";
+  formatISO
+} from "./chunk-ZRAU6T47.js";
 import {
   require_react
 } from "./chunk-YDH3FDFQ.js";
-import {
-  toErrorMessage
-} from "./chunk-HNMXYYJR.js";
 import {
   patch,
   readAndWait
-} from "./chunk-HYZIYH2H.js";
+} from "./chunk-74RAWNQN.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
 import {
   asOptionalTrimmedString
 } from "./chunk-G3SUCT4W.js";
@@ -20,7 +20,6 @@ import {
 
 // packages/render/page/docStore.ts
 var import_react = __toESM(require_react(), 1);
-var import_date_fns = __toESM(require_date_fns(), 1);
 var createInitialState = () => ({
   content: null,
   slateData: null,
@@ -52,6 +51,7 @@ var createInitialState = () => ({
 var listeners = /* @__PURE__ */ new Set();
 var version = 0;
 var state = createInitialState();
+var latestInitRequestKey = null;
 var notify = () => {
   for (const listener of listeners) {
     try {
@@ -102,6 +102,9 @@ function getDocField(selector) {
 function getDocPageKey() {
   return state.pageKey;
 }
+function isDocStateForPage(state2, pageKey) {
+  return Boolean(pageKey) && state2.pageKey === pageKey;
+}
 function getDocIsInitialized() {
   return state.isInitialized;
 }
@@ -143,6 +146,7 @@ function updateDocTags(tags) {
   setState((prev) => ({ ...prev, tags }));
 }
 function resetDocState() {
+  latestInitRequestKey = null;
   setState(createInitialState());
 }
 function previewDocState(payload) {
@@ -190,6 +194,7 @@ function applyExternalDocUpdate(payload) {
 }
 async function initDocState(args, { dispatch }) {
   const { pageKey, isReadOnly } = args;
+  latestInitRequestKey = pageKey;
   setState((prev) => ({
     ...createInitialState(),
     isLoading: true,
@@ -198,6 +203,7 @@ async function initDocState(args, { dispatch }) {
   }));
   try {
     const readAction = await dispatch(readAndWait(pageKey));
+    if (latestInitRequestKey !== pageKey) return;
     if (readAndWait.fulfilled.match(readAction) && readAction.payload) {
       const data = readAction.payload;
       if (data.type !== "page" /* DOC */) {
@@ -247,6 +253,7 @@ async function initDocState(args, { dispatch }) {
       }));
     }
   } catch (e) {
+    if (latestInitRequestKey !== pageKey) return;
     setState((prev) => ({
       ...prev,
       isLoading: false,
@@ -300,7 +307,7 @@ async function saveDocState(arg, { dispatch, getState }) {
       { slateToRenderMarkdown },
       { buildSkillSummaryMarker }
     ] = await Promise.all([
-      import("./slateUtils-RIZES3PV.js"),
+      import("./slateUtils-NGV2NMKM.js"),
       import("./slateToRenderMarkdown-Y5IYN73U.js"),
       import("./skillSummaryMarker-42HKSXYY.js")
     ]);
@@ -309,7 +316,7 @@ async function saveDocState(arg, { dispatch, getState }) {
     const skillSummary = buildSkillSummaryMarker(meta);
     const content = slateToRenderMarkdown(slateData);
     const now = /* @__PURE__ */ new Date();
-    const updatedAt = (0, import_date_fns.formatISO)(now);
+    const updatedAt = formatISO(now);
     await dispatch(
       patch({
         dbKey: pageKey,
@@ -326,7 +333,7 @@ async function saveDocState(arg, { dispatch, getState }) {
     ).unwrap();
     if (dbSpaceId) {
       try {
-        const { updateContentTitle } = await import("./contentThunks-BDIQRZR6.js");
+        const { updateContentTitle } = await import("./contentThunks-5L7YQI3S.js");
         await dispatch(
           updateContentTitle({
             spaceId: dbSpaceId,
@@ -365,7 +372,7 @@ async function saveDocState(arg, { dispatch, getState }) {
   }
 }
 async function createDocState(args, thunkApi) {
-  const { createPageAction } = await import("./createPageAction-CDLDKPRM.js");
+  const { createPageAction } = await import("./createPageAction-VQDJIXMY.js");
   return createPageAction(args, thunkApi);
 }
 function subscribe(listener) {
@@ -387,6 +394,7 @@ function useDocField(selector) {
 }
 function resetDocStoreForTests() {
   state = createInitialState();
+  latestInitRequestKey = null;
   bump();
 }
 
@@ -394,6 +402,7 @@ export {
   getDocState,
   getDocField,
   getDocPageKey,
+  isDocStateForPage,
   getDocIsInitialized,
   getDocIsReadOnly,
   getDocHasPendingChanges,