nolo-cli 0.108.0-alpha.1 → 0.108.0

package/chunk-DGDGNYI5.js

@@ -0,0 +1,593 @@
+import {
+  DEFAULT_AUTO_APPROVED_SELF_UPDATE_FIELDS,
+  DEFAULT_USER_PREFERENCE_PROFILE,
+  normalizeAgentUpdateFieldList,
+  normalizePolicyLevelSetting,
+  normalizeSystemBuiltinSkills,
+  normalizeTonePresetSetting
+} from "./chunk-5XN3OSCT.js";
+import {
+  fetchAndCacheTableRows
+} from "./chunk-P6KLYCL3.js";
+import {
+  require_react
+} from "./chunk-YDH3FDFQ.js";
+import {
+  createAsyncThunk,
+  createSelector
+} from "./chunk-IJERIUXS.js";
+import {
+  selectIdentityUserId
+} from "./chunk-SEJ5OS6F.js";
+import {
+  resolveBuiltinCapability,
+  resolveBuiltinSkillEntry
+} from "./chunk-RRQQAG7W.js";
+import {
+  DEFAULT_SYSTEM_AGENT_CAPABILITIES
+} from "./chunk-IXH3HKY2.js";
+import {
+  asTrimmedNonEmptyStringArray
+} from "./chunk-I42VC5KR.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+import {
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// packages/ai/chat/parseMultilineSSE.ts
+function createSSEParser() {
+  let buffer = "";
+  return function parseSSE(chunk) {
+    const results = [];
+    if (!chunk) return results;
+    buffer += chunk;
+    const events = buffer.split(/\r?\n\r?\n/);
+    buffer = events.pop() ?? "";
+    for (const ev of events) {
+      if (!ev.trim()) continue;
+      const lines = ev.split(/\r?\n/);
+      let accumulator = "";
+      for (const line of lines) {
+        const t = line.trim();
+        if (t === "data: [DONE]") {
+          if (accumulator.trim()) {
+            try {
+              results.push(JSON.parse(accumulator));
+            } catch (e) {
+            }
+            accumulator = "";
+          }
+          results.push("[DONE]");
+          continue;
+        }
+        let content = "";
+        let isDataLine = false;
+        if (t.startsWith("data:")) {
+          content = line.substring(line.indexOf("data:") + 5).trim();
+          isDataLine = true;
+        } else if (accumulator && t && !t.startsWith("event:") && !t.startsWith("id:") && !t.startsWith("retry:")) {
+          content = line;
+        } else {
+          continue;
+        }
+        if (isDataLine && !accumulator) {
+          try {
+            const obj = JSON.parse(content);
+            results.push(obj);
+            continue;
+          } catch (e) {
+          }
+        }
+        accumulator += content;
+      }
+      if (accumulator.trim()) {
+        try {
+          const obj = JSON.parse(accumulator);
+          results.push(obj);
+        } catch (e) {
+        }
+      }
+    }
+    return results;
+  };
+}
+var parseMultilineSSE = createSSEParser();
+
+// packages/core/abortableDelay.ts
+function waitForAbortableDelay(ms, signal) {
+  const delayMs = Number.isFinite(ms) && ms >= 0 ? Math.round(ms) : 0;
+  if (signal?.aborted) {
+    return Promise.reject(new DOMException("Aborted", "AbortError"));
+  }
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timeoutId);
+      signal?.removeEventListener("abort", onAbort);
+      reject(new DOMException("Aborted", "AbortError"));
+    };
+    const timeoutId = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, delayMs);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// packages/app/settings/fieldSelectors.ts
+var selectMaxExecutionTime = (state) => state.settings.maxExecutionTime;
+var selectGlobalPrompt = (state) => state.settings.globalPrompt;
+var selectUserTonePreset = (state) => normalizeTonePresetSetting(state.settings.userTonePreset);
+var selectKnowledgeCaptureLevel = (state) => normalizePolicyLevelSetting(
+  state.settings.knowledgeCaptureLevel,
+  DEFAULT_USER_PREFERENCE_PROFILE.knowledgeCaptureLevel
+);
+var selectSpaceContextLevel = (state) => state.settings.enableReadCurrentSpace === false ? 1 : normalizePolicyLevelSetting(
+  state.settings.spaceContextLevel,
+  DEFAULT_USER_PREFERENCE_PROFILE.spaceContextLevel
+);
+var selectAutoApproveSelfUpdateFields = createSelector(
+  [(state) => state.settings.autoApproveSelfUpdateFields],
+  (fields) => normalizeAgentUpdateFieldList(
+    fields,
+    DEFAULT_AUTO_APPROVED_SELF_UPDATE_FIELDS
+  )
+);
+var selectAiRecentContentLimit = (state) => state.settings.aiRecentContentLimit ?? 50;
+var selectSystemBuiltinSkills = createSelector(
+  [(state) => state.settings.systemBuiltinSkills],
+  (systemBuiltinSkills) => normalizeSystemBuiltinSkills(
+    systemBuiltinSkills,
+    DEFAULT_SYSTEM_AGENT_CAPABILITIES
+  )
+);
+
+// packages/ai/tools/uiCardSchema.ts
+var UI_CARD_VERSION = 1;
+var MAX_BLOCKS = 32;
+var MAX_TEXT_BYTES = 2e4;
+var UI_CARD_MAX_BYTES = 1e5;
+var UI_CARD_ENVELOPE_MAX_BYTES = UI_CARD_MAX_BYTES + 4096;
+var MAX_COLLECTION_ITEMS = 500;
+var MAX_JSON_DEPTH = 12;
+var MAX_JSON_NODES = 2e3;
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function hasOnlyKeys(value, allowed) {
+  return Object.keys(value).every((key) => allowed.includes(key));
+}
+function isText(value) {
+  return typeof value === "string" && new TextEncoder().encode(value).byteLength <= MAX_TEXT_BYTES;
+}
+function isStringArray(value, max = MAX_COLLECTION_ITEMS) {
+  return Array.isArray(value) && value.length <= max && value.every(isText);
+}
+function isJsonValue(value, depth, budget) {
+  budget.nodes += 1;
+  if (budget.nodes > MAX_JSON_NODES || depth > MAX_JSON_DEPTH) return false;
+  if (value === null || typeof value === "boolean") return true;
+  if (typeof value === "string") return isText(value);
+  if (typeof value === "number") return Number.isFinite(value);
+  if (Array.isArray(value)) return value.every((item) => isJsonValue(item, depth + 1, budget));
+  if (!isRecord(value)) return false;
+  for (const [key, item] of Object.entries(value)) {
+    if (["$ref", "$expr", "expression", "script"].includes(key)) return false;
+    if (!isText(key) || !isJsonValue(item, depth + 1, budget)) return false;
+  }
+  return true;
+}
+function isChoiceQuestion(value) {
+  if (!isRecord(value) || !hasOnlyKeys(value, ["id", "header", "question", "choices", "multiSelect", "allowOther", "required"])) return false;
+  if (!isText(value.id) || !value.id.trim() || !isText(value.question) || !value.question.trim()) return false;
+  if (value.header !== void 0 && !isText(value.header)) return false;
+  for (const flag of ["multiSelect", "allowOther", "required"]) {
+    if (value[flag] !== void 0 && typeof value[flag] !== "boolean") return false;
+  }
+  if (!Array.isArray(value.choices) || value.choices.length === 0 || value.choices.length > MAX_COLLECTION_ITEMS) return false;
+  const ids = /* @__PURE__ */ new Set();
+  for (const option of value.choices) {
+    if (!isRecord(option) || !hasOnlyKeys(option, ["id", "label", "detail", "recommended", "userMessage"])) return false;
+    if (!isText(option.label) || !option.label.trim()) return false;
+    if (option.id !== void 0) {
+      if (!isText(option.id) || !option.id.trim() || ids.has(option.id)) return false;
+      ids.add(option.id);
+    }
+    if (option.detail !== void 0 && !isText(option.detail)) return false;
+    if (option.userMessage !== void 0 && !isText(option.userMessage)) return false;
+    if (option.recommended !== void 0 && typeof option.recommended !== "boolean") return false;
+  }
+  return true;
+}
+function isAppUrl(value) {
+  try {
+    const parsed = new URL(value);
+    const hasWebProtocol = parsed.protocol === "http:" || parsed.protocol === "https:";
+    const authority = value.slice(value.indexOf("//") + 2).split(/[/?#]/, 1)[0];
+    return hasWebProtocol && authority.length > 0 && parsed.hostname.length > 0;
+  } catch {
+    return false;
+  }
+}
+function isBlock(value) {
+  if (!isRecord(value) || typeof value.type !== "string") return false;
+  switch (value.type) {
+    case "text":
+      return hasOnlyKeys(value, ["type", "text"]) && isText(value.text);
+    case "metric":
+      return hasOnlyKeys(value, ["type", "label", "value", "detail"]) && isText(value.label) && isText(value.value) && (value.detail === void 0 || isText(value.detail));
+    case "list":
+      return hasOnlyKeys(value, ["type", "title", "items"]) && (value.title === void 0 || isText(value.title)) && isStringArray(value.items);
+    case "table": {
+      const columns = value.columns;
+      const rows = value.rows;
+      return hasOnlyKeys(value, ["type", "columns", "rows"]) && isStringArray(columns, 50) && columns.length > 0 && Array.isArray(rows) && rows.length <= MAX_COLLECTION_ITEMS && rows.every((row) => isStringArray(row, 50) && row.length === columns.length);
+    }
+    case "choice":
+      return hasOnlyKeys(value, ["type", "question"]) && isChoiceQuestion(value.question);
+    case "action": {
+      if (!isRecord(value.action) || typeof value.action.type !== "string") return false;
+      if (value.action.type === "submit") {
+        if (!hasOnlyKeys(value, ["type", "action"]) || !hasOnlyKeys(value.action, ["type", "payload"])) return false;
+        if (value.action.payload === void 0) return true;
+        return isRecord(value.action.payload) && isJsonValue(value.action.payload, 0, { nodes: 0 });
+      }
+      if (value.action.type === "openApp") {
+        return hasOnlyKeys(value, ["type", "action"]) && hasOnlyKeys(value.action, ["type", "appId", "url"]) && isText(value.action.appId) && !!value.action.appId.trim() && (value.action.url === void 0 || isText(value.action.url) && isAppUrl(value.action.url));
+      }
+      return false;
+    }
+    default:
+      return false;
+  }
+}
+function parseUiCard(input) {
+  if (!isRecord(input) || !hasOnlyKeys(input, ["id", "version", "source", "blocks"])) return { ok: false, error: "invalid card shape" };
+  if (typeof input.id !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(input.id)) return { ok: false, error: "invalid card id" };
+  if (input.version !== UI_CARD_VERSION || input.source !== "tool") return { ok: false, error: "unsupported card version or source" };
+  if (!Array.isArray(input.blocks) || input.blocks.length > MAX_BLOCKS || !input.blocks.every(isBlock)) return { ok: false, error: "invalid blocks" };
+  try {
+    if (new TextEncoder().encode(JSON.stringify(input)).byteLength > UI_CARD_MAX_BYTES) return { ok: false, error: "card too large" };
+  } catch {
+    return { ok: false, error: "unserializable card" };
+  }
+  return { ok: true, value: input };
+}
+function uiCardFallback(card) {
+  return card.blocks.map((block) => {
+    switch (block.type) {
+      case "text":
+        return block.text;
+      case "metric":
+        return `${block.label}: ${block.value}${block.detail ? ` (${block.detail})` : ""}`;
+      case "list":
+        return `${block.title ? `${block.title}
+` : ""}${block.items.map((item) => `- ${item}`).join("\n")}`;
+      case "table":
+        return [block.columns.join(" | "), ...block.rows.map((row) => row.join(" | "))].join("\n");
+      case "choice":
+        return `${block.question.question}
+${block.question.choices.map((item) => `- ${item.label}${item.detail ? ` \u2014 ${item.detail}` : ""}`).join("\n")}`;
+      case "action":
+        return block.action.type === "submit" ? `Submit action (not executed): ${block.action.payload === void 0 ? "{}" : JSON.stringify(block.action.payload)}` : `Open app (not authorized): ${block.action.appId}${block.action.url ? ` (${block.action.url})` : ""}`;
+    }
+  }).join("\n\n");
+}
+
+// packages/ai/tools/agentSkillConfig.ts
+var MODES = [
+  "required",
+  "recommended",
+  "disabled"
+];
+var DEFAULT_RECOMMENDED_SKILL_SLUGS = [
+  "worktree-isolation",
+  "systematic-investigation",
+  "show-me"
+];
+var asMode = (value) => typeof value === "string" && MODES.includes(value) ? value : null;
+var resolveAgentSkillConfig = (source) => {
+  const out = {};
+  const skills = source?.skills;
+  if (skills && typeof skills === "object" && !Array.isArray(skills)) {
+    for (const [rawSlug, rawMode] of Object.entries(skills)) {
+      const slug = typeof rawSlug === "string" ? rawSlug.trim() : "";
+      const mode = asMode(rawMode);
+      if (slug && mode) out[slug] = mode;
+    }
+    return out;
+  }
+  for (const slug of asTrimmedNonEmptyStringArray(source?.enabledPacks) ?? []) {
+    out[slug] = "required";
+  }
+  return out;
+};
+var resolveAgentRequiredPackIds = (source) => {
+  const config = resolveAgentSkillConfig(source);
+  return Object.keys(config).filter((slug) => config[slug] === "required");
+};
+var resolveAgentRecommendedSkillNames = (source, lookup) => {
+  const config = resolveAgentSkillConfig(source);
+  const resolve = lookup ?? defaultSkillTitleLookup;
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const push = (slug) => {
+    const title = resolve(slug)?.title || slug;
+    if (seen.has(title)) return;
+    seen.add(title);
+    out.push(title);
+  };
+  for (const slug of Object.keys(config)) {
+    if (config[slug] !== "recommended") continue;
+    push(slug);
+  }
+  for (const slug of DEFAULT_RECOMMENDED_SKILL_SLUGS) {
+    if (Object.hasOwn(config, slug)) continue;
+    push(slug);
+  }
+  return out;
+};
+var defaultSkillTitleLookup = (slug) => {
+  const cap = resolveBuiltinCapability(slug);
+  if (cap) return { title: cap.title };
+  const skill = resolveBuiltinSkillEntry(slug);
+  return skill ? { title: skill.title } : null;
+};
+var isAgentSkillDisabled = (source, slug) => resolveAgentSkillConfig(source)[slug] === "disabled";
+
+// packages/core/clipMultilineText.ts
+function clipMultilineText(value, max) {
+  const trimmed = value.trim();
+  if (trimmed.length <= max) return trimmed;
+  return `${trimmed.slice(0, max)}
+...[truncated ${trimmed.length - max} chars]`;
+}
+
+// packages/render/table/utils/tableSerialization.ts
+var fetchAndSerializeTable = async (tableMeta, db, options = {}) => {
+  const tenantId = tableMeta.tenantId;
+  const tableId = tableMeta.tableId;
+  const results = await fetchAndCacheTableRows({
+    db,
+    tenantId,
+    tableId,
+    token: options.token,
+    remoteServers: options.remoteServers ?? []
+  });
+  const columns = tableMeta.columns || [];
+  const headerRow = columns.map((c) => c.label || c.name);
+  const separatorRow = columns.map(() => "---");
+  let tableMd = "";
+  if (columns.length > 0) {
+    tableMd = `| ${headerRow.join(" | ")} |
+| ${separatorRow.join(" | ")} |
+`;
+    results.forEach((row) => {
+      const rowData = columns.map((col) => {
+        const val = row[col.name];
+        return val === void 0 || val === null ? "" : String(val).replace(/\|/g, "\\|");
+      });
+      tableMd += `| ${rowData.join(" | ")} |
+`;
+    });
+  } else {
+    tableMd = "(No columns defined for this table)";
+  }
+  return { rows: results, markdown: tableMd };
+};
+
+// packages/ai/tools/toolResultError.ts
+var ToolResultError = class extends Error {
+  code;
+  rawData;
+  displayData;
+  retryable;
+  constructor(message, options) {
+    super(message);
+    this.name = "ToolResultError";
+    this.code = options?.code;
+    this.rawData = options?.rawData;
+    this.displayData = options?.displayData;
+    this.retryable = options?.retryable;
+  }
+};
+var getToolResultErrorData = (error) => {
+  if (!error || typeof error !== "object") return null;
+  const candidate = error;
+  return {
+    rawData: candidate.rawData,
+    displayData: candidate.displayData,
+    code: candidate.code,
+    retryable: candidate.retryable,
+    message: candidate.message
+  };
+};
+
+// packages/ai/tools/toolRunStore.ts
+var import_react = __toESM(require_react());
+var createToolRunId = () => `toolrun_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+var runsById = /* @__PURE__ */ new Map();
+var listeners = /* @__PURE__ */ new Set();
+var version = 0;
+var notify = () => {
+  version += 1;
+  for (const listener of listeners) {
+    try {
+      listener();
+    } catch {
+    }
+  }
+};
+function toolRunStarted(payload) {
+  const {
+    id,
+    messageId,
+    toolName,
+    behavior,
+    inputSummary,
+    startedAt,
+    interaction,
+    input
+  } = payload;
+  runsById.set(id, {
+    id,
+    messageId,
+    toolName,
+    behavior,
+    inputSummary,
+    status: "running",
+    startedAt: startedAt ?? Date.now(),
+    interaction,
+    input,
+    error: void 0,
+    finishedAt: void 0,
+    outputSummary: void 0,
+    steps: void 0
+  });
+  notify();
+}
+function toolRunSetPending(payload) {
+  const { id } = payload;
+  const run = runsById.get(id);
+  if (run) {
+    run.status = "pending";
+    notify();
+  }
+}
+function toolRunSucceeded(payload) {
+  const { id, outputSummary, steps, finishedAt } = payload;
+  const run = runsById.get(id);
+  if (run) {
+    run.status = "succeeded";
+    run.outputSummary = outputSummary;
+    if (steps !== void 0) {
+      run.steps = steps;
+    }
+    run.finishedAt = finishedAt ?? Date.now();
+    notify();
+  }
+}
+function toolRunUpdated(payload) {
+  const { id, outputSummary, steps } = payload;
+  const run = runsById.get(id);
+  if (run) {
+    if (outputSummary !== void 0) {
+      run.outputSummary = outputSummary;
+    }
+    if (steps !== void 0) {
+      run.steps = steps;
+    }
+    notify();
+  }
+}
+function toolRunFailed(payload) {
+  const { id, error, outputSummary, steps, finishedAt } = payload;
+  const run = runsById.get(id);
+  if (run) {
+    run.status = "failed";
+    run.error = error;
+    if (outputSummary !== void 0) {
+      run.outputSummary = outputSummary;
+    }
+    if (steps !== void 0) {
+      run.steps = steps;
+    }
+    run.finishedAt = finishedAt ?? Date.now();
+    notify();
+  }
+}
+function getAllToolRuns() {
+  return Array.from(runsById.values()).sort((a, b) => a.startedAt - b.startedAt);
+}
+function getToolRunById(id) {
+  return runsById.get(id);
+}
+var executeToolRun = createAsyncThunk(
+  "toolRun/executeToolRun",
+  async ({ id, inputOverride }, thunkApi) => {
+    const run = getToolRunById(id);
+    if (!run) {
+      throw new Error(`ToolRun not found: ${id}`);
+    }
+    const executionInput = inputOverride ?? run.input;
+    if (!executionInput) {
+      throw new Error(`ToolRun ${id} has no input to execute with.`);
+    }
+    const { findToolExecutor } = await import("./tools-UMU2DYQX.js");
+    const { executor } = findToolExecutor(run.toolName);
+    toolRunStarted({
+      id: run.id,
+      messageId: run.messageId,
+      toolName: run.toolName,
+      behavior: run.behavior,
+      inputSummary: run.inputSummary,
+      startedAt: Date.now(),
+      interaction: run.interaction,
+      input: executionInput
+    });
+    try {
+      const result = await executor(executionInput, thunkApi, {
+        parentMessageId: run.messageId
+      });
+      toolRunSucceeded({
+        id: run.id,
+        outputSummary: result?.displayData || ""
+      });
+      if (run.toolName === "deleteSpaces") {
+        const latestState = thunkApi.getState();
+        const userId = selectIdentityUserId(latestState);
+        if (userId) {
+          const { fetchUserSpaceMemberships } = await import("./memberThunks-Y3Q7GZTG.js");
+          await thunkApi.dispatch(fetchUserSpaceMemberships(userId));
+        }
+      }
+      return {
+        id: run.id,
+        rawData: result?.rawData,
+        displayData: result?.displayData
+      };
+    } catch (e) {
+      const msg = toErrorMessage(e);
+      const structured = getToolResultErrorData(e);
+      toolRunFailed({
+        id: run.id,
+        error: msg,
+        outputSummary: asOptionalTrimmedString(structured?.displayData)
+      });
+      throw e;
+    }
+  }
+);
+
+export {
+  UI_CARD_ENVELOPE_MAX_BYTES,
+  parseUiCard,
+  uiCardFallback,
+  createSSEParser,
+  waitForAbortableDelay,
+  resolveAgentRequiredPackIds,
+  resolveAgentRecommendedSkillNames,
+  isAgentSkillDisabled,
+  clipMultilineText,
+  fetchAndSerializeTable,
+  selectMaxExecutionTime,
+  selectGlobalPrompt,
+  selectUserTonePreset,
+  selectKnowledgeCaptureLevel,
+  selectSpaceContextLevel,
+  selectAutoApproveSelfUpdateFields,
+  selectAiRecentContentLimit,
+  ToolResultError,
+  getToolResultErrorData,
+  createToolRunId,
+  toolRunStarted,
+  toolRunSetPending,
+  toolRunSucceeded,
+  toolRunUpdated,
+  toolRunFailed,
+  getAllToolRuns
+};

package/{chunk-TRV2MIDW.js → chunk-EXAJ6DCR.js}

@@ -91,6 +91,7 @@ function createCliAuthorityBrokerSocketInvoker(options) {
       const timeout = setTimeout(() => {
         finish(() => {
           socket.destroy();
+          socket.unref?.();
           reject(new CliAuthorityBrokerTimeoutError(options.endpoint, timeoutMs));
         });
       }, timeoutMs);

package/{chunk-PVZT43MU.js → chunk-EXR4XCFE.js}

@@ -1,26 +1,28 @@
+import {
+  patch,
+  remove,
+  write
+} from "./chunk-RNNWTMKT.js";
+import {
+  getRuntimeServerContext
+} from "./chunk-4YRTZIVN.js";
+import {
+  asyncThunkCreator,
+  buildCreateSlice
+} from "./chunk-IJERIUXS.js";
 import {
   applyAgentSecretMigrationUpdates,
   createFileCredentialBroker,
   migrateAgentSecrets,
   normalizeAgentRuntimeToolPolicy
-} from "./chunk-HVURBGF3.js";
+} from "./chunk-PWRS2SU2.js";
 import {
   asRecordOrEmpty
 } from "./chunk-KX6YBIHG.js";
-import {
-  patch,
-  remove,
-  write
-} from "./chunk-VRTTFDBM.js";
 import {
   createAgentKey,
   toTrimmedString
-} from "./chunk-VMFTFOWF.js";
-import {
-  asyncThunkCreator,
-  buildCreateSlice,
-  getRuntimeServerContext
-} from "./chunk-UKWGR5SS.js";
+} from "./chunk-RLRYVSCD.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";
@@ -304,7 +306,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-GTYLDSJW.js");
+      const { _executeModel } = await import("./_executeModel-RVAKYU4J.js");
       return _executeModel(
         {
           isStreaming: args.isStreaming ?? false,
@@ -325,7 +327,7 @@ var slice = createSliceWithThunks({
      * - 循环直到无工具调用或触发其他运行时停止条件
      */
     runAgent: create.asyncThunk(async (args, thunkApi) => {
-      const { runAgentClientLoop } = await import("./runAgentClientLoop-JLRJIF3F.js");
+      const { runAgentClientLoop } = await import("./runAgentClientLoop-AYNL3KMJ.js");
       const { content: loopContent, toolCallCount } = await runAgentClientLoop(
         {
           agentKey: args.agentKey,
@@ -341,7 +343,7 @@ var slice = createSliceWithThunks({
      * 聊天轮次流式 Agent 调用
      */
     streamAgentChatTurn: create.asyncThunk(async (args, thunkApi) => {
-      const { streamAgentChatTurnHandler } = await import("./streamAgentChatTurn-DZ3PP7ZH.js");
+      const { streamAgentChatTurnHandler } = await import("./streamAgentChatTurn-O5T3B4B3.js");
       return streamAgentChatTurnHandler(args, thunkApi);
     }),
     /**