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

package/chunk-CHOZJMJS.js

@@ -0,0 +1,78 @@
+import {
+  clipCompactText
+} from "./chunk-5MMAK75Q.js";
+import {
+  asRecordOrEmpty
+} from "./chunk-KX6YBIHG.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+
+// packages/agent-runtime/fileWritePolicy.ts
+function evaluateFileWritePolicy(args) {
+  if (args.sessionApproved) return { permissionDecision: "allow" };
+  return {
+    permissionDecision: "ask",
+    permissionRequest: {
+      id: "permission-file-write-session",
+      tool: args.tool,
+      action: "file_write",
+      title: "\u786E\u8BA4\u5199\u5165\u6587\u4EF6",
+      body: `\u672C\u4F1A\u8BDD\u9996\u6B21\u5199\u5165\u6587\u4EF6\uFF1A${args.path}\u3002\u6279\u51C6\u540E\u672C\u4F1A\u8BDD\u540E\u7EED\u5199\u5165\u4E0D\u518D\u9010\u6B21\u786E\u8BA4\u3002`,
+      command: args.path,
+      suggestedRule: {
+        scope: "session",
+        pattern: { capability: "file_write", target: "session" }
+      }
+    }
+  };
+}
+
+// packages/agent-runtime/parseToolArguments.ts
+function parseToolArgumentsJson(raw) {
+  if (!raw?.trim()) return {};
+  try {
+    return asRecordOrEmpty(JSON.parse(raw));
+  } catch {
+    return {};
+  }
+}
+
+// packages/agent-runtime/summarizeToolArguments.ts
+function clip(value, max = 240) {
+  return clipCompactText(value, max);
+}
+function summarizeToolArguments(toolName, rawArgs) {
+  const args = parseToolArgumentsJson(rawArgs);
+  const pick = (...keys2) => {
+    for (const key of keys2) {
+      const value = asOptionalTrimmedString(args[key]);
+      if (value) return value;
+    }
+    return "";
+  };
+  const command = pick("command", "cmd", "runCommand", "executeCommand", "bash");
+  if (command) return clip(command);
+  const query = pick("query", "pattern", "search", "q");
+  if (query) return clip(query);
+  const filePath = pick("filePath", "file_path", "path", "filename", "file");
+  if (filePath) return clip(filePath);
+  const keys = Object.keys(args);
+  if (keys.length === 0) return "";
+  return clip(
+    keys.slice(0, 6).map((key) => {
+      const value = args[key];
+      if (typeof value === "string") return `${key}=${clip(value, 80)}`;
+      if (typeof value === "number" || typeof value === "boolean") {
+        return `${key}=${String(value)}`;
+      }
+      if (Array.isArray(value)) return `${key}[${value.length}]`;
+      return `${key}=${value === null ? "null" : typeof value}`;
+    }).join(" ")
+  );
+}
+
+export {
+  evaluateFileWritePolicy,
+  summarizeToolArguments
+};

package/chunk-CYJWI3NH.js

@@ -0,0 +1,119 @@
+import {
+  fetchReferenceContents,
+  resolveReferenceAssets
+} from "./chunk-RN2GPWN6.js";
+import {
+  updateTokensAction
+} from "./chunk-U5ICMAFV.js";
+import {
+  applyUpdateTokensFulfilled
+} from "./chunk-OWYYDMGJ.js";
+import {
+  extractReasoningFromResponseOutput,
+  extractTextFromResponseOutput,
+  extractToolCallsFromResponseOutput
+} from "./chunk-3SZA4U64.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
+
+// packages/ai/agent/fetchAgentContexts.ts
+async function fetchAgentContexts(references, dispatch) {
+  if (!Array.isArray(references)) {
+    return { botInstructionsContext: "", botKnowledgeContext: "" };
+  }
+  const { references: normalizedRefs, contentByKey } = await resolveReferenceAssets(references, dispatch);
+  const instructionKeys = /* @__PURE__ */ new Set();
+  const knowledgeKeys = /* @__PURE__ */ new Set();
+  normalizedRefs.forEach((ref) => {
+    if (!ref.dbKey) return;
+    ref.type === "instruction" ? instructionKeys.add(ref.dbKey) : knowledgeKeys.add(ref.dbKey);
+  });
+  const [instructionsMap, knowledgeMap] = await Promise.all([
+    fetchReferenceContents(Array.from(instructionKeys), dispatch, {
+      preloaded: contentByKey
+    }),
+    fetchReferenceContents(Array.from(knowledgeKeys), dispatch, {
+      preloaded: contentByKey
+    })
+  ]);
+  return {
+    botInstructionsContext: Array.from(instructionsMap.values()).join(""),
+    botKnowledgeContext: Array.from(knowledgeMap.values()).join("")
+  };
+}
+
+// packages/ai/agent/updateAgentTokens.ts
+async function updateAgentTokens(args, thunkApi) {
+  const observedAt = Date.now();
+  const payload = await updateTokensAction(args, thunkApi);
+  if (args?.dialogKey && payload) {
+    applyUpdateTokensFulfilled({
+      observedAt,
+      authoritative: args?.contextUsageAuthoritative !== false && (args?.usageRecord?.usage ?? args?.usage)?.billing_estimated !== true,
+      dialogKey: args.dialogKey,
+      input_tokens: payload.input_tokens,
+      output_tokens: payload.output_tokens,
+      cost: payload.cost
+    });
+  }
+  return payload;
+}
+
+// packages/integrations/openai/responsesJsonToChatCompletions.ts
+var isChatCompletionsShapedJson = (value) => isRecord(value) && Array.isArray(value.choices);
+var isExplicitNonCompletedStatus = (status) => typeof status === "string" && status.trim().toLowerCase() !== "completed";
+var asTokenCount = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+var projectChatUsage = (raw) => {
+  if (!isRecord(raw)) return null;
+  const usage = { ...raw };
+  if (asTokenCount(usage.prompt_tokens) === void 0) {
+    const inputTokens = asTokenCount(raw.input_tokens);
+    if (inputTokens !== void 0) usage.prompt_tokens = inputTokens;
+  }
+  if (asTokenCount(usage.completion_tokens) === void 0) {
+    const outputTokens = asTokenCount(raw.output_tokens);
+    if (outputTokens !== void 0) usage.completion_tokens = outputTokens;
+  }
+  if (asTokenCount(usage.total_tokens) === void 0) {
+    const prompt = asTokenCount(usage.prompt_tokens);
+    const completion = asTokenCount(usage.completion_tokens);
+    if (prompt !== void 0 && completion !== void 0) {
+      usage.total_tokens = prompt + completion;
+    }
+  }
+  return usage;
+};
+var responsesJsonToChatCompletions = (parsed) => {
+  if (!isRecord(parsed)) return null;
+  if (isChatCompletionsShapedJson(parsed)) return null;
+  if (parsed.error !== void 0 && parsed.error !== null) return null;
+  if (isExplicitNonCompletedStatus(parsed.status)) return null;
+  if (!Array.isArray(parsed.output)) return null;
+  const content = extractTextFromResponseOutput(parsed);
+  const reasoningContent = extractReasoningFromResponseOutput(parsed);
+  const toolCalls = extractToolCallsFromResponseOutput(parsed);
+  const usage = projectChatUsage(parsed.usage);
+  return {
+    object: "chat.completion",
+    choices: [
+      {
+        index: 0,
+        finish_reason: toolCalls.length > 0 ? "tool_calls" : "stop",
+        message: {
+          role: "assistant",
+          content,
+          ...reasoningContent ? { reasoning_content: reasoningContent } : {},
+          ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+        }
+      }
+    ],
+    ...usage ? { usage } : {}
+  };
+};
+
+export {
+  fetchAgentContexts,
+  updateAgentTokens,
+  responsesJsonToChatCompletions
+};

package/{chunk-GBRG75BQ.js → chunk-D2MDMY2M.js}

@@ -80,6 +80,7 @@ var buildTombstoneRecord = (record, nowIso) => {
 
 export {
   getRecordTimestamp,
+  getTombstoneTimestamp,
   isTombstoneRecord,
   shouldReplaceWithNextRecord,
   buildTombstoneRecord

package/{chunk-3SV7RM24.js → chunk-D2QN6CTI.js}

@@ -7,63 +7,68 @@ import {
   listUserRecordsFromServers,
   readDbRecordFromServers,
   readLiveDbRecordAfterTombstoneMerge
-} from "./chunk-XISEYOGH.js";
-import {
-  isLevelLockError
-} from "./chunk-URMS4XY2.js";
-import {
-  resolveLocalDialogDbCandidates,
-  resolveServerDbPath
-} from "./chunk-GLKOYSRU.js";
+} from "./chunk-USHQX6VT.js";
 import {
   fetchWithTransientRetry
-} from "./chunk-5UTFL4QJ.js";
+} from "./chunk-I2ZMGXXF.js";
 import {
   DRAIN_EXHAUSTED_USER_MESSAGE,
-  isDrainExhaustedResponse
-} from "./chunk-3L2WKC3W.js";
+  isDrainExhaustedResponse,
+  parsePositiveFiniteNumberOrFallback
+} from "./chunk-XPWGOTBQ.js";
 import {
   buildDialogAttachmentPlan,
   extractFileContentIds
-} from "./chunk-6O4IK4V2.js";
+} from "./chunk-OFFL4DCR.js";
+import {
+  createClientLogger
+} from "./chunk-QQ56R7KS.js";
+import {
+  isLevelNotFoundError
+} from "./chunk-OW765XBU.js";
 import {
   boundSummaryText,
   buildDialogReadEnvelope,
   projectDialogReadForAgent
-} from "./chunk-RGNEEJ3Y.js";
-import {
-  toErrorMessage
-} from "./chunk-HNMXYYJR.js";
-import {
-  parseUserIdFromAuthToken,
-  readOption,
-  resolveAuthToken,
-  resolveDeleteServerCandidates,
-  resolveServerCandidates,
-  resolveServerUrl
-} from "./chunk-A7GB5UGH.js";
-import {
-  parsePositiveFiniteNumberOrFallback
-} from "./chunk-Y5GCAMGP.js";
+} from "./chunk-QLQ573SU.js";
 import {
   asRecordOrEmpty
 } from "./chunk-KX6YBIHG.js";
 import {
   asNonEmptyStringArray,
   asTrimmedNonEmptyStringArray
-} from "./chunk-3AH7LNUB.js";
-import {
-  createClientLogger
-} from "./chunk-QOKAKDPE.js";
+} from "./chunk-I42VC5KR.js";
 import {
-  isLevelNotFoundError
-} from "./chunk-OW765XBU.js";
+  resolveRunsDir
+} from "./chunk-YVLQXTUB.js";
 import {
   isRecord
 } from "./chunk-KUG52IAP.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";
+import {
+  getDefaultCliLocalRuntimeDb
+} from "./chunk-2IXDJNZI.js";
+import {
+  isLevelLockError
+} from "./chunk-AWVFQMOV.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import {
+  resolveLocalDialogDbCandidates,
+  resolveNoloHome,
+  resolveServerDbPath
+} from "./chunk-GLKOYSRU.js";
+import {
+  parseUserIdFromAuthToken,
+  readOption,
+  resolveAuthToken,
+  resolveDeleteServerCandidates,
+  resolveServerCandidates,
+  resolveServerUrl
+} from "./chunk-A7GB5UGH.js";
 import {
   DEFAULT_LOCAL_API_ORIGIN
 } from "./chunk-4SN6J65J.js";
@@ -180,7 +185,8 @@ async function deleteDialogAttachmentCandidates(args) {
 }
 
 // packages/cli/dialogCommands.ts
-import { existsSync } from "node:fs";
+import { existsSync, realpathSync } from "node:fs";
+import path from "node:path";
 
 // packages/core/positiveIntegerOrFallback.ts
 function parsePositiveIntegerOrFallback(value, fallback) {
@@ -188,6 +194,32 @@ function parsePositiveIntegerOrFallback(value, fallback) {
   return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
 }
 
+// packages/cli/tui/localRunChildDialogIds.ts
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+function loadLocalRunChildDialogIds(args = {}) {
+  const ids = /* @__PURE__ */ new Set();
+  const runsDir = resolveRunsDir(args.env, args.homedir);
+  let entries;
+  try {
+    entries = readdirSync(runsDir);
+  } catch {
+    return ids;
+  }
+  for (const name of entries) {
+    if (!name.endsWith(".json")) continue;
+    try {
+      const record = JSON.parse(readFileSync(join(runsDir, name), "utf8"));
+      const dialogId = record?.dialogId;
+      if (typeof dialogId === "string" && dialogId.trim()) {
+        ids.add(dialogId.trim());
+      }
+    } catch {
+    }
+  }
+  return ids;
+}
+
 // packages/cli/dialogCommands.ts
 var logger = createClientLogger("cli:dialog");
 var DIALOG_ID_RE = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
@@ -361,6 +393,7 @@ function normalizeDialogRecord(record, fallbackDbKey) {
     createdAt: typeof record?.createdAt === "string" || typeof record?.createdAt === "number" ? record.createdAt : typeof record?.created === "string" || typeof record?.created === "number" ? record.created : null,
     spaceId: typeof record?.spaceId === "string" && record.spaceId.trim() ? record.spaceId : null,
     triggerType: typeof record?.triggerType === "string" ? record.triggerType : null,
+    parentDialogId: asOptionalTrimmedString(record?.parentDialogId) ?? null,
     primaryAgentKey: typeof record?.primaryAgentKey === "string" && record.primaryAgentKey.trim() ? record.primaryAgentKey : null,
     cybots: Array.isArray(record?.cybots) ? record.cybots.filter((agent) => typeof agent === "string") : []
   };
@@ -377,16 +410,33 @@ function sortDialogs(dialogs) {
 function isScheduledDialog(record) {
   return record.triggerType === "automation_run" || record.triggerType === "scheduled_run" || Boolean(record.parentAutomationKey) || Boolean(record.parentTaskKey);
 }
+function isRunSpawnedDialog(record) {
+  return record.triggerType === "api" || record.triggerType === "localhost";
+}
+function isChildDialogByField(record) {
+  return Boolean(record.parentDialogId) && record.parentDialogId !== record.id;
+}
+function isChildDialog(record, localChildIds) {
+  return isRunSpawnedDialog(record) || localChildIds.has(record.id) || isChildDialogByField(record);
+}
+function isHiddenFromDialogList(record, localChildIds, options = {}) {
+  if (!options.includeScheduled && isScheduledDialog(record)) return true;
+  if (!options.includeChild && isChildDialog(record, localChildIds)) return true;
+  return false;
+}
 function printListUsage(output) {
   output.write(`Usage:
-  nolo dialog list [--space <spaceId|spaceUrl>] [--limit ${DEFAULT_DIALOG_LIST_LIMIT}] [--offset <n>] [--all] [--json] [--jsonl] [--ids-only]
+  nolo dialog list [--space <spaceId|spaceUrl>] [--limit ${DEFAULT_DIALOG_LIST_LIMIT}] [--offset <n>] [--all] [--json] [--jsonl] [--ids-only] [--include-scheduled] [--include-child]
 
 Options:
   --space <space>       List current user's dialogs attached to one space.
   --limit <n>           Maximum dialogs to return. Default: ${DEFAULT_DIALOG_LIST_LIMIT}. Use 0 or --all for full dump.
   --offset <n>          Skip first n dialogs after sort/filter (paging).
   --all                 Full dump (same as --limit 0). Prefer --jsonl for large results.
-  --include-scheduled   Include scheduled automation run dialogs.
+  --include-scheduled   Include scheduled automation run dialogs (hidden by default). Independent of --include-child.
+  --include-child       Include child run dialogs (hidden by default): triggerType api/localhost, dialogs in the
+                        local run record set, or with a parentDialogId pointing to another dialog.
+                        Independent of --include-scheduled.
   --json                Print machine-readable JSON object.
   --jsonl               Stream one dialog JSON object per line (lowest memory).
   --ids-only            Print only dialog ids.
@@ -725,7 +775,7 @@ function isExplicitDialogIdMismatch(meta, dialogId) {
   return meta && typeof meta === "object" && "id" in meta && meta.id != null && String(meta.id) !== dialogId;
 }
 async function readDialogFromLocalDb(dialogKey, dialogId, limit, readLocalDialog) {
-  const reader = readLocalDialog ?? (await import("./localDialogRead-EBRS242U.js")).readDialogFromLocalDb;
+  const reader = readLocalDialog ?? (await import("./localDialogRead-FSOMOPDZ.js")).readDialogFromLocalDb;
   const result = await reader({ dialogKey, dialogId, limit });
   return {
     ...result,
@@ -733,48 +783,31 @@ async function readDialogFromLocalDb(dialogKey, dialogId, limit, readLocalDialog
   };
 }
 async function readLocalDialogAtDbPathDefault(args) {
-  if (!existsSync(args.dbPath)) {
+  if (!existsSync(path.join(args.dbPath, "CURRENT"))) {
     throw Object.assign(
-      new Error(`local database directory does not exist: ${args.dbPath}`),
-      { code: "LEVEL_DATABASE_DIR_MISSING" }
+      new Error(`local database does not exist: ${args.dbPath}`),
+      { code: "LEVEL_NOT_FOUND" }
     );
   }
-  const [{ Level }, { safeJsonEncoding }, { fetchMessages }] = await Promise.all([
-    import("./levelLazyShim-GZBKODGI.js"),
-    import("./serverStoreFactory-YMXDF4NI.js"),
-    import("./fetchMessages-67MEFPZR.js")
-  ]);
-  const db = new Level(args.dbPath, {
-    valueEncoding: safeJsonEncoding,
-    createIfMissing: false
-  });
-  try {
-    await db.open();
-    let meta;
-    try {
-      meta = await db.get(args.dialogKey);
-    } catch (error) {
-      if (isLevelNotFoundError(error)) return { meta: void 0, msgs: [] };
-      throw error;
-    }
-    const msgs = await fetchMessages(db, args.dialogId, {
-      limit: args.limit,
-      throwOnError: true
-    });
-    return { meta, msgs };
-  } finally {
-    await db.close().catch(() => void 0);
-  }
+  const db = await getDefaultCliLocalRuntimeDb();
+  const { readDialogFromLocalDb: reader } = await import("./localDialogRead-FSOMOPDZ.js");
+  return reader({ ...args, db });
 }
 async function readDialogFromLocalDbWithFallback(args) {
   const candidates = localDialogDbCandidates();
   const attempts = [];
   let missMessage = "local dialog not found";
   let lockedError;
-  let genericError;
   const primaryPath = candidates[0];
+  const homePath = path.join(resolveNoloHome(), "data", "leveldb");
+  const isHomePath = existsSync(primaryPath) && existsSync(homePath) && realpathSync(primaryPath) === realpathSync(homePath);
   try {
-    const local = await readDialogFromLocalDb(
+    if (!args.readLocalDialog && !existsSync(primaryPath)) {
+      throw Object.assign(new Error(`local database directory does not exist: ${primaryPath}`), {
+        code: "LEVEL_NOT_FOUND"
+      });
+    }
+    const local = !args.readLocalDialog && isHomePath ? await readLocalDialogAtDbPathDefault({ ...args, dbPath: primaryPath }) : await readDialogFromLocalDb(
       args.dialogKey,
       args.dialogId,
       args.limit,
@@ -828,11 +861,15 @@ async function readDialogFromLocalDbWithFallback(args) {
       const locked = isLevelDbOpenUnavailableError(error);
       attempts.push({
         path: dbPath,
-        status: locked ? "locked" : "error",
+        status: locked ? "locked" : isLevelNotFoundError(error) ? "miss" : "error",
         reason: toErrorMessage(error)
       });
+      if (!locked && !isLevelNotFoundError(error)) {
+        const failure = error instanceof Error ? error : new Error(toErrorMessage(error));
+        Object.assign(failure, { localAttempts: attempts });
+        throw failure;
+      }
       if (locked && !lockedError) lockedError = error;
-      else if (!locked && !genericError) genericError = error;
     }
   }
   const aggregate = (error, code) => {
@@ -842,7 +879,6 @@ async function readDialogFromLocalDbWithFallback(args) {
     return err;
   };
   if (lockedError) throw aggregate(lockedError);
-  if (genericError) throw aggregate(genericError);
   throw aggregate(new Error(missMessage), "LEVEL_NOT_FOUND");
 }
 async function readDialogSnapshot(args) {
@@ -1560,6 +1596,8 @@ async function runDialogListCommand(args, deps = {}) {
   const offset = readOffset(args);
   const spaceInput = readOption(args, "--space") ?? readOption(args, "--space-id");
   const includeScheduled = hasFlag(args, "--include-scheduled");
+  const includeChild = hasFlag(args, "--include-child");
+  const localChildIds = deps.localChildDialogIds ?? loadLocalRunChildDialogIds({ env });
   try {
     let source = "user-data";
     let resolvedSpaceId = null;
@@ -1592,7 +1630,9 @@ async function runDialogListCommand(args, deps = {}) {
       queryFailures = result.failures;
     }
     const sorted = sortDialogs(
-      records.map((record) => normalizeDialogRecord(record)).filter((dialog) => dialog != null).filter((dialog) => includeScheduled || !isScheduledDialog(dialog))
+      records.map((record) => normalizeDialogRecord(record)).filter((dialog) => dialog != null).filter(
+        (dialog) => !isHiddenFromDialogList(dialog, localChildIds, { includeScheduled, includeChild })
+      )
     );
     const window = resultLimit.unlimited ? sorted.slice(offset, offset + UNBOUNDED_DIALOG_CAP) : sorted.slice(offset, offset + limit);
     const hitLimit = !resultLimit.unlimited && sorted.length > offset + window.length;
@@ -1946,9 +1986,14 @@ ${d.title}
 }
 
 export {
+  loadLocalRunChildDialogIds,
   normalizeDialogRecord,
   sortDialogs,
   isScheduledDialog,
+  isRunSpawnedDialog,
+  isChildDialogByField,
+  isChildDialog,
+  isHiddenFromDialogList,
   isLevelDbOpenUnavailableError,
   readDialogSnapshot,
   isCleanDialogNotFoundFailure,

package/{chunk-TZZ2WRBL.js → chunk-DFDXM2Y4.js}

@@ -1,26 +1,30 @@
+import {
+  patch,
+  remove,
+  write
+} from "./chunk-74RAWNQN.js";
+import {
+  getRuntimeServerContext
+} from "./chunk-4YRTZIVN.js";
+import {
+  asyncThunkCreator,
+  buildCreateSlice
+} from "./chunk-IJERIUXS.js";
 import {
   applyAgentSecretMigrationUpdates,
-  createFileCredentialBroker,
   migrateAgentSecrets,
   normalizeAgentRuntimeToolPolicy
-} from "./chunk-L36OWPP3.js";
+} from "./chunk-LIQJTQRN.js";
+import {
+  createFileCredentialBroker
+} from "./chunk-UHTDNB5Y.js";
 import {
   asRecordOrEmpty
 } from "./chunk-KX6YBIHG.js";
-import {
-  patch,
-  remove,
-  write
-} from "./chunk-HYZIYH2H.js";
 import {
   createAgentKey,
   toTrimmedString
-} from "./chunk-3AH7LNUB.js";
-import {
-  asyncThunkCreator,
-  buildCreateSlice,
-  getRuntimeServerContext
-} from "./chunk-WIWM4FE3.js";
+} from "./chunk-5EMSBTQ6.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";
@@ -304,7 +308,7 @@ var slice = createSliceWithThunks({
       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-OW3H7ICR.js");
+      const { _executeModel } = await import("./_executeModel-T7ANHTUW.js");
       return _executeModel(
         {
           isStreaming: args.isStreaming ?? false,
@@ -325,7 +329,7 @@ var slice = createSliceWithThunks({
      * - 循环直到无工具调用或触发其他运行时停止条件
      */
     runAgent: create.asyncThunk(async (args, thunkApi) => {
-      const { runAgentClientLoop } = await import("./runAgentClientLoop-6E6UC3CE.js");
+      const { runAgentClientLoop } = await import("./runAgentClientLoop-GS3SGG37.js");
       const { content: loopContent, toolCallCount } = await runAgentClientLoop(
         {
           agentKey: args.agentKey,
@@ -341,7 +345,7 @@ var slice = createSliceWithThunks({
      * 聊天轮次流式 Agent 调用
      */
     streamAgentChatTurn: create.asyncThunk(async (args, thunkApi) => {
-      const { streamAgentChatTurnHandler } = await import("./streamAgentChatTurn-3UXPYFNX.js");
+      const { streamAgentChatTurnHandler } = await import("./streamAgentChatTurn-4XYC33KE.js");
       return streamAgentChatTurnHandler(args, thunkApi);
     }),
     /**

package/{chunk-5TEEECZM.js → chunk-E2AKSW7L.js}

@@ -1,6 +1,9 @@
 import {
   requireTokenUser
-} from "./chunk-SLLGJZDT.js";
+} from "./chunk-ISQL4V7C.js";
+import {
+  t
+} from "./chunk-SW4S4XYB.js";
 import {
   resolveServerUrl
 } from "./chunk-A7GB5UGH.js";
@@ -34,21 +37,21 @@ async function cliApiRequest(args) {
   try {
     response = await fetch(url, init);
   } catch (error) {
-    throw new CliApiError(`\u8BF7\u6C42\u5931\u8D25: ${error.message}`, "NETWORK_ERROR", 0);
+    throw new CliApiError(t("api.requestFailed", error.message), "NETWORK_ERROR", 0);
   }
   let data;
   try {
     data = await response.json();
   } catch {
     throw new CliApiError(
-      `\u670D\u52A1\u7AEF\u8FD4\u56DE\u975E JSON \u54CD\u5E94 (HTTP ${response.status})`,
+      t("api.nonJsonResponse", String(response.status)),
       "INVALID_RESPONSE",
       response.status
     );
   }
   if (!response.ok || data.success !== true) {
     const errorObj = data.error ?? {};
-    const message = errorObj.message || data.message || `\u8BF7\u6C42\u5931\u8D25 (HTTP ${response.status})`;
+    const message = errorObj.message || data.message || t("api.requestFailedHttp", String(response.status));
     const code = errorObj.code || `HTTP_${response.status}`;
     throw new CliApiError(message, code, response.status);
   }
@@ -56,13 +59,13 @@ async function cliApiRequest(args) {
 }
 function printCliError(error) {
   if (error instanceof CliApiError) {
-    process.stderr.write(`\u9519\u8BEF [${error.code}]: ${error.message}
+    process.stderr.write(`${t("api.errorWithCode", error.code, error.message)}
 `);
   } else if (error instanceof Error) {
-    process.stderr.write(`\u9519\u8BEF: ${error.message}
+    process.stderr.write(`${t("api.error", error.message)}
 `);
   } else {
-    process.stderr.write(`\u9519\u8BEF: ${String(error)}
+    process.stderr.write(`${t("api.error", String(error))}
 `);
   }
 }

package/{chunk-RSEEDUMS.js → chunk-EDX5XSJM.js}

@@ -4,11 +4,11 @@ import {
 import {
   patch,
   read
-} from "./chunk-HYZIYH2H.js";
+} from "./chunk-74RAWNQN.js";
 import {
   DEVICE_LOCAL_OWNER_ID,
   isDeviceLocalSpaceBody
-} from "./chunk-WIWM4FE3.js";
+} from "./chunk-4YRTZIVN.js";
 import {
   selectIdentityUserId
 } from "./chunk-SEJ5OS6F.js";