nolo-cli 0.7.0 → 0.8.0-alpha.10

package/chunk-XKIMRZO2.js

@@ -0,0 +1,221 @@
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+
+// packages/create/editor/transforms/slateToSimplifiedMarkdown.ts
+function renderTextNode(node) {
+  if (!node || typeof node.text !== "string") return "";
+  let text = node.text;
+  if (!text) return "";
+  if (node.bold) text = `**${text}**`;
+  if (node.italic) text = `*${text}*`;
+  if (node.strikethrough) text = `~~${text}~~`;
+  return text;
+}
+function renderPlainText(node, options = {}) {
+  if (!node) return "";
+  if (typeof node.text === "string") return renderTextNode(node);
+  if (!Array.isArray(node.children)) return "";
+  return node.children.map((child) => renderPlainText(child, options)).join("");
+}
+function renderTable(node, listDepth, options) {
+  const rows = Array.isArray(node.children) ? node.children : [];
+  if (rows.length === 0) return "";
+  const alignments = Array.isArray(node.columns) ? node.columns.map((column) => column?.align || "left") : [];
+  const renderedRows = rows.map(
+    (row) => (Array.isArray(row?.children) ? row.children : []).map((cell) => {
+      const content = renderPlainText(cell, options).replace(/\n+/g, " ").trim();
+      return content || " ";
+    })
+  );
+  const header = renderedRows[0] || [];
+  const divider = header.map((_, index) => {
+    const align = alignments[index];
+    if (align === "center") return ":---:";
+    if (align === "right") return "---:";
+    return "---";
+  });
+  const body = renderedRows.slice(1);
+  const allRows = [header, divider, ...body].map((cells) => `| ${cells.join(" | ")} |`).join("\n");
+  return `${allRows}
+
+`;
+}
+function renderListItem(node, listDepth, ordered, start, index, options = {}) {
+  const indentation = "  ".repeat(listDepth);
+  const marker = node.checked === true ? "- [x]" : node.checked === false ? "- [ ]" : ordered ? `${start + index}.` : "-";
+  const segments = Array.isArray(node.children) ? node.children : [];
+  const renderedSegments = segments.flatMap((child) => {
+    const rendered = renderNode(child, listDepth + 1, options).trimEnd();
+    return rendered ? [rendered] : [];
+  });
+  if (renderedSegments.length === 0) {
+    return `${indentation}${marker}
+`;
+  }
+  const [first, ...rest] = renderedSegments;
+  const lines = first.split("\n");
+  const firstLine = lines.shift() || "";
+  const restFirst = lines.map((line) => `${indentation}  ${line}`).join("\n");
+  const restBlocks = rest.map((block) => `${indentation}  ${block}`).join("\n");
+  return [
+    `${indentation}${marker} ${firstLine}`,
+    restFirst,
+    restBlocks
+  ].filter(Boolean).join("\n") + "\n";
+}
+function renderNode(node, listDepth = 0, options = {}) {
+  if (!node) return "";
+  const indentation = "  ".repeat(listDepth);
+  switch (node.type) {
+    case "heading-one":
+      return `# ${node.children.map((n) => renderNode(n, listDepth, options)).join("")}
+
+`;
+    case "heading-two":
+      return `## ${node.children.map((n) => renderNode(n, listDepth, options)).join("")}
+
+`;
+    case "heading-three":
+      return `### ${node.children.map((n) => renderNode(n, listDepth, options)).join("")}
+
+`;
+    case "heading-four":
+      return `#### ${node.children.map((n) => renderNode(n, listDepth, options)).join("")}
+
+`;
+    case "heading-five":
+      return `##### ${node.children.map((n) => renderNode(n, listDepth, options)).join("")}
+
+`;
+    case "heading-six":
+      return `###### ${node.children.map((n) => renderNode(n, listDepth, options)).join("")}
+
+`;
+    case "paragraph":
+      return `${node.children.map((n) => renderNode(n, listDepth, options)).join("")}
+
+`;
+    case "list":
+      return node.children.map(
+        (item, index) => renderListItem(item, listDepth, !!node.ordered, node.start || 1, index, options)
+      ).join("");
+    case "list-item":
+      return renderListItem(node, listDepth, false, 1, 0, options);
+    case "quote":
+      const content = node.children.map((n) => renderNode(n, listDepth, options)).join("").trim();
+      return `> ${content.replace(/\n/g, "\n> ")}
+
+`;
+    case "code-block":
+      const code = node.children.map(
+        (line) => (line.children || []).map((text) => text.text).join("")
+      ).join("\n");
+      return "```" + (node.language || "") + "\n" + code + "\n```\n\n";
+    case "link":
+      const linkText = node.children.map((n) => renderNode(n, listDepth, options)).join("");
+      return `[${linkText}](${node.url})`;
+    case "table":
+      return renderTable(node, listDepth, options);
+    case "code-inline":
+      return `\`${node.children.map((n) => renderNode(n, listDepth, options)).join("")}\``;
+    case "mention": {
+      if (options.mentionResolver) {
+        return options.mentionResolver(node);
+      }
+      const label = node.label || node.resourceId || "mention";
+      const resourceType = node.resourceType || "unknown";
+      const resourceId = node.resourceId || "unknown";
+      return `@[${resourceType}:${resourceId}|${label}]`;
+    }
+    case "image": {
+      const alt = node.alt || "";
+      const title = node.title ? ` "${node.title}"` : "";
+      return `![${alt}](${node.url || ""}${title})`;
+    }
+    case "html-inline":
+      return typeof node.html === "string" ? node.html : "";
+    case "html-block":
+      return typeof node.html === "string" ? `${node.html}
+
+` : "";
+    case "thematic-break":
+      return "---\n\n";
+    default:
+      return renderTextNode(node) || (node.children ? node.children.map((child) => renderNode(child, listDepth, options)).join("") : "");
+  }
+}
+function slateToSimplifiedMarkdown(nodes, options = {}) {
+  if (!nodes || nodes.length === 0) {
+    return "";
+  }
+  return nodes.map((node) => renderNode(node, 0, options)).join("").trim() + "\n";
+}
+
+// packages/ai/tools/readDocTool.ts
+var readDocFunctionSchema = {
+  name: "readDoc",
+  description: [
+    "\u8BFB\u53D6\u6307\u5B9A\u9875\u9762\u7684\u5185\u5BB9\uFF0C\u5E76\u5C06\u7ED3\u6784\u5316\u7684\u6570\u636E\u8F6C\u6362\u4E3A Markdown \u683C\u5F0F\u8FD4\u56DE\u3002",
+    "\u5982\u679C\u4F60\u62FF\u5230\u4E86\u9875\u9762\u7684 dbKey\uFF08\u5982 page-xxx\uFF09\uFF0C\u8BF7\u4F7F\u7528\u6B64\u5DE5\u5177\u67E5\u770B\u9875\u9762\u5185\u5BB9\u3002"
+  ].join("\n"),
+  parameters: {
+    type: "object",
+    properties: {
+      id: {
+        type: "string",
+        description: "\u9875\u9762/\u6587\u6863\u7684\u6570\u636E\u5E93\u952E\uFF08dbKey\uFF09\uFF0C\u4F8B\u5982 page-xxx\u3002"
+      }
+    },
+    required: ["id"]
+  }
+};
+var readPageFunctionSchema = {
+  ...readDocFunctionSchema,
+  name: "readPage"
+};
+var buildReadDocResult = (pageData) => {
+  const markdownContent = slateToSimplifiedMarkdown(pageData.slateData || []);
+  const rawData = {
+    success: true,
+    id: pageData.dbKey,
+    title: pageData.title,
+    content: markdownContent,
+    metadata: {
+      spaceId: pageData.spaceId,
+      created: pageData.created
+    }
+  };
+  const displayData = `\u5DF2\u6210\u529F\u8BFB\u53D6\u9875\u9762\u300A${pageData.title}\u300B\u3002
+
+\u5185\u5BB9\u5982\u4E0B\uFF1A
+
+${markdownContent}`;
+  return { rawData, displayData };
+};
+async function readDocFunc(args, thunkApi) {
+  const id = args.id ?? args.doc ?? args.docKey ?? args.pageKey ?? args.key;
+  if (!id || !id.toLowerCase().startsWith("page-")) {
+    throw new Error(`\u65E0\u6548\u7684\u9875\u9762 ID: ${id}\u3002\u9875\u9762 ID \u901A\u5E38\u4EE5 "page-" \u5F00\u5934\u3002`);
+  }
+  try {
+    const { readAction } = await import("./read-RIJCIVKX.js");
+    const pageData = await readAction({ dbKey: id }, thunkApi);
+    if (!pageData) {
+      throw new Error(`\u672A\u627E\u5230 ID \u4E3A ${id} \u7684\u9875\u9762\u3002`);
+    }
+    return buildReadDocResult(pageData);
+  } catch (error) {
+    throw new Error(`\u8BFB\u53D6\u9875\u9762\u65F6\u51FA\u9519: ${toErrorMessage(error)}`);
+  }
+}
+var readPageFunc = readDocFunc;
+
+export {
+  slateToSimplifiedMarkdown,
+  readDocFunctionSchema,
+  readPageFunctionSchema,
+  buildReadDocResult,
+  readDocFunc,
+  readPageFunc
+};

package/chunk-Y5GCAMGP.js

@@ -0,0 +1,9 @@
+// packages/core/positiveFiniteNumberOrFallback.ts
+function parsePositiveFiniteNumberOrFallback(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+export {
+  parsePositiveFiniteNumberOrFallback
+};

package/chunk-YWPXYBY7.js

@@ -0,0 +1,360 @@
+import {
+  readDbRecord,
+  writeAgentRecord
+} from "./chunk-FQZWM5YX.js";
+import {
+  buildSkillSummaryMarker
+} from "./chunk-VF4K2QE6.js";
+import {
+  buildSkillDocMarkdown
+} from "./chunk-NXZGF7F7.js";
+import {
+  createSpaceKey
+} from "./chunk-UAD2WT54.js";
+import {
+  parseUserIdFromAuthToken,
+  readOption,
+  resolveAuthToken,
+  resolveServerUrl
+} from "./chunk-ISNCLGUZ.js";
+import {
+  require_index_umd
+} from "./chunk-PN7AFLOK.js";
+import {
+  asTrimmedLowercaseString
+} from "./chunk-QSJ3HFEF.js";
+import {
+  DEFAULT_LOCAL_API_ORIGIN
+} from "./chunk-4SN6J65J.js";
+import {
+  NOLO_CLUSTER_SERVERS
+} from "./chunk-LCBAMY2M.js";
+import {
+  normalizeServerOrigin
+} from "./chunk-CF7PE763.js";
+import {
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// packages/cli/docPageHelpers.ts
+var import_ulid = __toESM(require_index_umd(), 1);
+import { readFileSync } from "node:fs";
+function getCliArg(args, flag) {
+  const idx = args.indexOf(flag);
+  return idx !== -1 ? args[idx + 1] : void 0;
+}
+function readBodyArg(args, fallback = "") {
+  const bodyFile = getCliArg(args, "--body-file");
+  if (bodyFile !== void 0) {
+    return readFileSync(bodyFile, "utf8");
+  }
+  return getCliArg(args, "--body") ?? fallback;
+}
+function textToSlate(text) {
+  return text.split("\n").map((line) => ({
+    type: "paragraph",
+    children: [{ text: line }]
+  }));
+}
+function createPageId() {
+  return (0, import_ulid.ulid)();
+}
+function buildPageKey(userId, pageId) {
+  return `page-${userId}-${pageId}`;
+}
+function buildPageRecord(args) {
+  const { dbKey, pageId, title, spaceId, content, existing, meta, slateData } = args;
+  const now = Date.now();
+  const createdAt = typeof existing?.createdAt === "number" ? existing.createdAt : now;
+  const created = typeof existing?.created === "string" ? existing.created : new Date(createdAt).toISOString();
+  const nextRecord = {
+    ...existing ?? {},
+    id: existing?.id ?? pageId,
+    dbKey,
+    type: "page",
+    title,
+    spaceId,
+    content,
+    updatedAt: now,
+    createdAt,
+    created
+  };
+  if (meta !== void 0) {
+    if (meta === null) {
+      delete nextRecord.meta;
+    } else {
+      nextRecord.meta = meta;
+    }
+  }
+  if (slateData !== void 0) {
+    if (slateData === null) {
+      delete nextRecord.slateData;
+    } else {
+      nextRecord.slateData = slateData;
+    }
+  } else if (!existing?.slateData) {
+    nextRecord.slateData = textToSlate(content);
+  }
+  return nextRecord;
+}
+
+// packages/cli/docSkillHelpers.ts
+function normalizeSkillSeed(input) {
+  return input.trim().toLowerCase().replace(/[^a-z0-9\u4e00-\u9fa5]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function deterministicId(prefix, seed) {
+  let h = 2166136261;
+  for (let i = 0; i < seed.length; i++) {
+    h ^= seed.charCodeAt(i);
+    h = h * 16777619 >>> 0;
+  }
+  const suffix = h.toString(36).toUpperCase().padStart(14, "0");
+  return (prefix + suffix).slice(0, 26);
+}
+function buildSkillDocId(input) {
+  return deterministicId("01SK", normalizeSkillSeed(input) || input);
+}
+function buildSkillPageKey(userId, skillId) {
+  return buildPageKey(userId, skillId);
+}
+function buildSkillPageRecord(args) {
+  const {
+    dbKey,
+    skillId,
+    title,
+    spaceId,
+    body,
+    skillConfig,
+    evalConfig,
+    workflowConfig,
+    existing
+  } = args;
+  return {
+    ...buildPageRecord({
+      dbKey,
+      pageId: skillId,
+      title,
+      spaceId,
+      content: buildSkillDocMarkdown({
+        body,
+        skillConfig,
+        evalConfig,
+        workflowConfig
+      }),
+      existing,
+      meta: {
+        ...existing?.meta ?? {},
+        kind: "skill",
+        skillConfig,
+        ...evalConfig ? { evalConfig } : {},
+        ...workflowConfig ? { workflowConfig } : {}
+      },
+      slateData: null
+    })
+  };
+}
+function parseJsonArg(raw, fallback) {
+  if (raw === void 0) return fallback;
+  return JSON.parse(raw);
+}
+
+// packages/cli/docSpaceHelpers.ts
+async function ensurePageAttachedToSpace(params) {
+  const { baseUrl, userId, authToken, spaceId, contentKey, title, skillSummary } = params;
+  const spaceKey = createSpaceKey.space(spaceId);
+  const spaceRecord = await readDbRecord({
+    dbKey: spaceKey,
+    authToken,
+    fetchImpl: fetch,
+    serverUrl: baseUrl
+  });
+  const now = Date.now();
+  await writeAgentRecord({
+    agentKey: spaceKey,
+    authToken,
+    fetchImpl: fetch,
+    serverUrl: baseUrl,
+    userId,
+    record: {
+      ...spaceRecord,
+      contents: {
+        ...spaceRecord.contents ?? {},
+        [contentKey]: {
+          ...spaceRecord.contents?.[contentKey] ?? {},
+          title,
+          type: "page",
+          contentKey,
+          ...skillSummary !== void 0 ? { skillSummary } : {},
+          updatedAt: now,
+          createdAt: spaceRecord.contents?.[contentKey]?.createdAt ?? now
+        }
+      },
+      updatedAt: now
+    }
+  });
+}
+async function removePageFromSpace(params) {
+  const { baseUrl, userId, authToken, spaceId, contentKey } = params;
+  const spaceKey = createSpaceKey.space(spaceId);
+  const spaceRecord = await readDbRecord({
+    dbKey: spaceKey,
+    authToken,
+    fetchImpl: fetch,
+    serverUrl: baseUrl
+  });
+  const nextContents = { ...spaceRecord.contents ?? {} };
+  delete nextContents[contentKey];
+  await writeAgentRecord({
+    agentKey: spaceKey,
+    authToken,
+    fetchImpl: fetch,
+    serverUrl: baseUrl,
+    userId,
+    record: {
+      ...spaceRecord,
+      contents: nextContents,
+      updatedAt: Date.now()
+    }
+  });
+}
+
+// packages/cli/docCommandShared.ts
+function hasHelpArg(args) {
+  return args.includes("--help") || args.includes("-h");
+}
+function hasFlag(args, flag) {
+  return args.includes(flag);
+}
+function normalizeBaseUrl(base) {
+  return normalizeServerOrigin(base);
+}
+function localBaseFromEnv(env) {
+  return normalizeBaseUrl(env.SCRIPT_LOCAL_BASE_URL || DEFAULT_LOCAL_API_ORIGIN);
+}
+function targetToBase(target, env) {
+  const normalized = asTrimmedLowercaseString(target);
+  if (normalized === "local") return localBaseFromEnv(env);
+  if (normalized === "main") return normalizeBaseUrl(NOLO_CLUSTER_SERVERS[0]);
+  if (normalized === "us") return normalizeBaseUrl(NOLO_CLUSTER_SERVERS[1]);
+  return normalizeBaseUrl(target);
+}
+function parseSyncTargets(raw, env) {
+  if (!raw) return void 0;
+  return raw.split(",").map((value) => value.trim()).filter(Boolean).filter((value) => value !== "none").map((value) => targetToBase(value, env));
+}
+function isLocalBaseUrl(baseUrl) {
+  try {
+    const hostname = new URL(baseUrl).hostname;
+    return hostname === "localhost" || hostname === "127.0.0.1";
+  } catch {
+    return false;
+  }
+}
+function resolveWriteTargets(args, env) {
+  const explicitSync = parseSyncTargets(readOption(args, "--sync"), env);
+  const targets = hasFlag(args, "--local-only") ? [localBaseFromEnv(env)] : explicitSync ?? [resolveServerUrl(args, env)];
+  const filtered = hasFlag(args, "--no-local") ? targets.filter((target) => !isLocalBaseUrl(target)) : targets;
+  return Array.from(new Set(filtered.map(normalizeBaseUrl)));
+}
+function readTitle(args) {
+  const valueFlags = /* @__PURE__ */ new Set([
+    "--title",
+    "--name",
+    "--description",
+    "--body",
+    "--body-file",
+    "--space",
+    "--id",
+    "--key",
+    "--kind",
+    "--sync",
+    "--tools",
+    "--required-skills",
+    "--recommended-skills",
+    "--preferred-agents",
+    "--trigger-mode",
+    "--budget-tier",
+    "--prompt-patch",
+    "--token",
+    "--server"
+  ]);
+  return readOption(args, "--title") ?? args.find((value, index) => {
+    if (index === 0) return false;
+    if (valueFlags.has(args[index - 1])) return false;
+    return !value.startsWith("-");
+  });
+}
+function resolveDocKind(args, fallback) {
+  if (hasFlag(args, "--page") || readOption(args, "--kind") === "page") return "page";
+  return fallback;
+}
+function requireTokenUser(args, env, dryRun) {
+  const authToken = resolveAuthToken(args, env);
+  const userId = parseUserIdFromAuthToken(authToken) || env.USER_ID || "";
+  if (!authToken && !dryRun) {
+    throw new Error("doc command requires an auth token. Pass --token or set AUTH_TOKEN.");
+  }
+  if (!userId && !dryRun) {
+    throw new Error("auth token does not contain userId. Pass a user-scoped token.");
+  }
+  return {
+    authToken,
+    userId: userId || "dry-run"
+  };
+}
+async function writePageRecord(args) {
+  await writeAgentRecord({
+    agentKey: args.dbKey,
+    authToken: args.authToken,
+    fetchImpl: fetch,
+    serverUrl: args.serverUrl,
+    userId: args.userId,
+    record: args.record
+  });
+  if (args.spaceId) {
+    await ensurePageAttachedToSpace({
+      baseUrl: args.serverUrl,
+      userId: args.userId,
+      authToken: args.authToken,
+      spaceId: args.spaceId,
+      contentKey: args.dbKey,
+      title: args.title,
+      skillSummary: args.skillSummary
+    });
+  }
+}
+async function readPageRecord(args) {
+  return readDbRecord({
+    dbKey: args.dbKey,
+    authToken: args.authToken,
+    fetchImpl: fetch,
+    serverUrl: args.serverUrl
+  });
+}
+function buildSkillSummaryForRecord(record) {
+  const meta = record?.meta;
+  const skillConfig = meta?.skillConfig;
+  if (!skillConfig) return void 0;
+  return buildSkillSummaryMarker(meta);
+}
+
+export {
+  readBodyArg,
+  createPageId,
+  buildPageKey,
+  buildPageRecord,
+  buildSkillDocId,
+  buildSkillPageKey,
+  buildSkillPageRecord,
+  parseJsonArg,
+  removePageFromSpace,
+  hasHelpArg,
+  hasFlag,
+  resolveWriteTargets,
+  readTitle,
+  resolveDocKind,
+  requireTokenUser,
+  writePageRecord,
+  readPageRecord,
+  buildSkillSummaryForRecord
+};

package/chunk-Z4NR32XR.js

@@ -0,0 +1,50 @@
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+
+// packages/chat/dialog/dialogAgents.ts
+var normalizeAgentId = (value) => asOptionalTrimmedString(value) ?? null;
+var dedupeAgentIds = (agentIds) => {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const agentId of agentIds) {
+    const normalized = normalizeAgentId(agentId);
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    result.push(normalized);
+  }
+  return result;
+};
+var getDialogAgentIds = (dialogConfig) => {
+  if (!dialogConfig) return [];
+  const primaryAgentKey = normalizeAgentId(dialogConfig.primaryAgentKey);
+  if (Array.isArray(dialogConfig.cybots)) {
+    return dedupeAgentIds([primaryAgentKey, ...dialogConfig.cybots]);
+  }
+  if (primaryAgentKey) {
+    return [primaryAgentKey];
+  }
+  const legacyAgentId = normalizeAgentId(dialogConfig.llmId);
+  if (legacyAgentId) {
+    return [legacyAgentId];
+  }
+  return [];
+};
+var getPrimaryDialogAgentId = (dialogConfig) => getDialogAgentIds(dialogConfig)[0] ?? null;
+var addDialogAgentIds = (existingAgentIds, nextAgentIds) => {
+  const merged = [...existingAgentIds, ...nextAgentIds];
+  return merged.filter((id, index) => merged.indexOf(id) === index);
+};
+var replacePrimaryDialogAgentId = (existingAgentIds, nextPrimaryAgentId) => [
+  nextPrimaryAgentId,
+  ...existingAgentIds.filter((id) => id !== nextPrimaryAgentId)
+];
+var removeDialogAgentId = (existingAgentIds, agentIdToRemove) => existingAgentIds.filter((id) => id !== agentIdToRemove);
+
+export {
+  getDialogAgentIds,
+  getPrimaryDialogAgentId,
+  addDialogAgentIds,
+  replacePrimaryDialogAgentId,
+  removeDialogAgentId
+};

package/chunk-ZNFJWEN4.js

@@ -0,0 +1,56 @@
+// packages/agent-runtime/runtimeDecision.ts
+function uniqueCapabilities(capabilities) {
+  return [...new Set(capabilities.filter(Boolean))];
+}
+function localMissingCapabilities(input) {
+  const missing = [...input.missingLocalCapabilities ?? []];
+  if (!input.hasLocalAgentConfig) missing.push("agent-config");
+  if (!input.hasLocalProvider) missing.push("provider");
+  if (!input.hasLocalPersistence) missing.push("persistence");
+  if (input.requiresServer) missing.push("server-required");
+  if (input.host === "web") missing.push("local-host-adapter");
+  return uniqueCapabilities(missing);
+}
+function resolveAgentRuntimeDecision(input) {
+  const requestedMode = input.requestedMode ?? "auto";
+  const missingLocalCapabilities = localMissingCapabilities(input);
+  const localRunnable = missingLocalCapabilities.length === 0;
+  if (requestedMode === "server") {
+    return {
+      mode: "server",
+      runnable: input.serverFallbackAvailable,
+      reason: input.serverFallbackAvailable ? "server runtime was requested" : "server runtime was requested but no server fallback is available",
+      missingLocalCapabilities,
+      syncAfterRun: false
+    };
+  }
+  if (requestedMode === "local") {
+    return {
+      mode: "local",
+      runnable: localRunnable,
+      reason: localRunnable ? "local runtime was requested and all local capabilities are available" : "local runtime was requested but local capabilities are missing",
+      missingLocalCapabilities,
+      syncAfterRun: localRunnable && Boolean(input.syncRequested)
+    };
+  }
+  if (localRunnable) {
+    return {
+      mode: "local",
+      runnable: true,
+      reason: "local runtime capabilities are available",
+      missingLocalCapabilities,
+      syncAfterRun: Boolean(input.syncRequested)
+    };
+  }
+  return {
+    mode: "server",
+    runnable: input.serverFallbackAvailable,
+    reason: input.serverFallbackAvailable ? "local runtime capabilities are missing; using server fallback" : "local runtime capabilities are missing and no server fallback is available",
+    missingLocalCapabilities,
+    syncAfterRun: false
+  };
+}
+
+export {
+  resolveAgentRuntimeDecision
+};