nolo-cli 0.8.0-alpha.2 → 0.8.0-alpha.21

package/chunk-XBUBEFNX.js

@@ -0,0 +1,34 @@
+import {
+  fetchReferenceContents,
+  resolveReferenceAssets
+} from "./chunk-7GNGZRLZ.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("")
+  };
+}
+
+export {
+  fetchAgentContexts
+};

package/chunk-XENYHRUE.js

@@ -0,0 +1,104 @@
+import {
+  createMemoryKey,
+  memoryOwnerRange,
+  memorySubjectKindRange
+} from "./chunk-O4BU24WZ.js";
+
+// packages/ai/memory/queryShared.ts
+var chooseMemoryOwners = (input) => {
+  const owners = [];
+  if (input.userId) {
+    owners.push({ ownerType: "user", ownerId: input.userId });
+  }
+  if (input.spaceId) {
+    owners.push({ ownerType: "space", ownerId: input.spaceId });
+  }
+  return owners;
+};
+var loadOwnerItemsFromDb = async (db, owner, limit) => {
+  const range = memoryOwnerRange(owner.ownerType, owner.ownerId);
+  const refs = [];
+  for await (const [, value] of db.iterator({
+    gte: range.start,
+    lte: range.end,
+    reverse: true
+  })) {
+    refs.push(value ?? {});
+    if (refs.length >= limit) break;
+  }
+  const items = await Promise.all(
+    refs.map(
+      (ref) => typeof ref?.memoryId === "string" ? db.get(createMemoryKey(owner.ownerType, owner.ownerId, ref.memoryId)).catch(() => null) : Promise.resolve(null)
+    )
+  );
+  return items.filter((item) => !!item);
+};
+var loadSubjectKindItemsFromDb = async (db, subject, kind, limit) => {
+  const range = memorySubjectKindRange(subject.subjectType, subject.subjectId, kind);
+  const refs = [];
+  for await (const [, value] of db.iterator({
+    gte: range.start,
+    lte: range.end,
+    reverse: true
+  })) {
+    refs.push(value ?? {});
+    if (refs.length >= limit) break;
+  }
+  const items = await Promise.all(
+    refs.map(
+      (ref) => typeof ref?.memoryKey === "string" ? db.get(ref.memoryKey).catch(() => null) : Promise.resolve(null)
+    )
+  );
+  return items.filter((item) => !!item);
+};
+var loadMemoryCandidatesFromDb = async (db, input) => {
+  const kinds = input.kinds ?? ["episodic", "semantic", "procedural"];
+  const ownerLimit = input.ownerLimit ?? 12;
+  const ownerFallback = input.ownerFallback ?? "onSubjectMiss";
+  const ownerKeySet = new Set(
+    input.owners.filter((owner) => owner.ownerId).map((owner) => `${owner.ownerType}:${owner.ownerId}`)
+  );
+  const subjects = input.subjects.filter(
+    (subject) => !!subject.subjectId
+  );
+  const subjectResults = subjects.length > 0 ? await Promise.all(
+    subjects.flatMap(
+      (subject) => kinds.map(
+        (kind) => loadSubjectKindItemsFromDb(db, subject, kind, ownerLimit)
+      )
+    )
+  ) : [];
+  const subjectHitCount = subjectResults.reduce((sum, items) => sum + items.length, 0);
+  const shouldLoadOwnerFallback = ownerFallback !== "never" && (subjects.length === 0 || subjectHitCount === 0 || ownerFallback === "always");
+  const results = shouldLoadOwnerFallback ? await Promise.all(
+    [
+      ...subjectResults,
+      ...input.owners.map((owner) => loadOwnerItemsFromDb(db, owner, ownerLimit))
+    ]
+  ) : subjectResults;
+  const kindSet = new Set(kinds);
+  const seen = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const items of results) {
+    for (const item of items) {
+      if (seen.has(item.id)) continue;
+      if (!kindSet.has(item.kind)) continue;
+      if (ownerKeySet.size > 0 && !ownerKeySet.has(`${item.ownerType}:${item.ownerId}`)) {
+        continue;
+      }
+      if (!shouldLoadOwnerFallback && subjects.length > 0 && !subjects.some(
+        (subject) => subject.subjectType === item.subjectType && subject.subjectId === item.subjectId
+      )) {
+        continue;
+      }
+      seen.add(item.id);
+      merged.push(item);
+    }
+  }
+  return merged;
+};
+
+export {
+  chooseMemoryOwners,
+  loadMemoryCandidatesFromDb
+};

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-YPRZSPF3.js

@@ -0,0 +1,148 @@
+import {
+  getPublicImageAgentDefaultProfile
+} from "./chunk-VIDPVFP3.js";
+import {
+  getApproxPricePerImage
+} from "./chunk-CWMSB67P.js";
+import {
+  getModelConfig
+} from "./chunk-BBYVOSU2.js";
+import {
+  asOptionalFiniteNumber
+} from "./chunk-WWC7I6TA.js";
+import {
+  asOptionalPositiveFiniteNumber
+} from "./chunk-U6VC4MU4.js";
+
+// packages/ai/llm/getPricing.ts
+var MAX_OUTPUT_TOKENS = 8192;
+var getModelPricing = (provider, modelName, _requestedServiceTier) => {
+  let model;
+  try {
+    model = getModelConfig(provider, modelName);
+  } catch {
+    return null;
+  }
+  if (!model?.price) return null;
+  return getModelPricingForModel(provider, modelName, model);
+};
+var getModelPricingForModel = (provider, modelName, model) => {
+  if (!model.price) return null;
+  return {
+    inputPrice: model.price.input,
+    inputCacheHitPrice: typeof model.price.inputCacheHit === "number" ? model.price.inputCacheHit : 0,
+    outputPrice: model.price.output
+  };
+};
+var hasExplicitAgentPricing = (config) => [config?.inputPrice, config?.outputPrice].some(
+  (value) => asOptionalPositiveFiniteNumber(value) !== void 0
+);
+var getPrices = (config, serverPrices) => ({
+  agentInput: Number(config?.inputPrice ?? 0),
+  agentOutput: Number(config?.outputPrice ?? 0),
+  serverInput: Number(serverPrices?.inputPrice ?? 0),
+  serverOutput: Number(serverPrices?.outputPrice ?? 0)
+});
+var getFinalPrice = (prices) => {
+  const rawValues = Object.values(prices);
+  const validValues = rawValues.flatMap((value) => {
+    const finite = asOptionalFiniteNumber(value);
+    return finite === void 0 ? [] : [finite];
+  });
+  if (validValues.length === 0) {
+    return 0;
+  }
+  const maxPricePerMillion = Math.max(...validValues);
+  const maxPricePerToken = maxPricePerMillion / 1e6;
+  return maxPricePerToken * MAX_OUTPUT_TOKENS;
+};
+var TYPICAL_INPUT_TOKENS = 500;
+var TYPICAL_OUTPUT_TOKENS = 300;
+var trimTrailingZeros = (value) => {
+  if (!value.includes(".")) return value;
+  return value.replace(/\.?0+$/, "");
+};
+var getAgentPriceHint = (agent) => {
+  const imagePriceModel = agent.imageModel ?? agent.model;
+  if (agent.imageConfig?.enabled && agent.provider && imagePriceModel) {
+    try {
+      const model = getModelConfig(agent.provider, imagePriceModel);
+      const mode = agent.imageWorkflow;
+      if (mode === "generate") {
+        const defaultProfile = getPublicImageAgentDefaultProfile("generate");
+        const pricePerImage = getApproxPricePerImage(model, "1K");
+        if (typeof pricePerImage === "number") {
+          return {
+            type: "per_image",
+            amount: pricePerImage,
+            labelKey: "defaultImageProfileEstimate",
+            profileLabel: `${defaultProfile.quality} \xB7 ${defaultProfile.size}`
+          };
+        }
+      } else {
+        const pricePerImage = getApproxPricePerImage(
+          model,
+          agent.imageConfig?.imageSize
+        );
+        if (typeof pricePerImage === "number") {
+          return { type: "per_image", amount: pricePerImage };
+        }
+      }
+    } catch {
+    }
+  }
+  const inputPrice = agent.inputPrice ?? 0;
+  const outputPrice = agent.outputPrice ?? 0;
+  if (inputPrice === 0 && outputPrice === 0) return null;
+  const amount = (inputPrice * TYPICAL_INPUT_TOKENS + outputPrice * TYPICAL_OUTPUT_TOKENS) / 1e6;
+  return { type: "per_turn", amount };
+};
+var formatPriceAmount = (amount) => {
+  if (amount >= 0.1) return amount.toFixed(2);
+  if (amount >= 0.01) return amount.toFixed(3);
+  if (amount >= 1e-3) return amount.toFixed(4);
+  if (amount >= 1e-4) return amount.toFixed(5);
+  return amount.toFixed(6);
+};
+var formatModelCostPerMillion = (value, creditsUnit = "\u79EF\u5206") => {
+  const finite = asOptionalFiniteNumber(value);
+  if (finite === void 0) return "\u672A\u77E5";
+  if (finite === 0) return "\u514D\u8D39";
+  const decimals = Math.abs(finite) < 1 ? 3 : 2;
+  const amount = finite.toFixed(decimals).replace(/\.0+$/, "").replace(/(\.\d*?[1-9])0+$/, "$1");
+  return `${amount} ${creditsUnit}`;
+};
+var formatCompactTurnPrice = (amount) => {
+  if (amount <= 0) {
+    return { amountText: "0", unitCount: 1 };
+  }
+  if (amount >= 0.01) {
+    return {
+      amountText: trimTrailingZeros(formatPriceAmount(amount)),
+      unitCount: 1
+    };
+  }
+  const perHundred = amount * 100;
+  if (perHundred >= 0.01) {
+    return {
+      amountText: trimTrailingZeros(formatPriceAmount(perHundred)),
+      unitCount: 100
+    };
+  }
+  return {
+    amountText: trimTrailingZeros(formatPriceAmount(amount * 1e3)),
+    unitCount: 1e3
+  };
+};
+
+export {
+  getModelPricing,
+  getModelPricingForModel,
+  hasExplicitAgentPricing,
+  getPrices,
+  getFinalPrice,
+  getAgentPriceHint,
+  formatPriceAmount,
+  formatModelCostPerMillion,
+  formatCompactTurnPrice
+};

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
+};

package/cliExecutor-K3F7DMRO.js

@@ -0,0 +1,36 @@
+import {
+  CLI_PROBE_BINARIES,
+  CliProviderQuotaError,
+  buildCliProcessEnv,
+  closeCliSession,
+  detectCliProviderQuotaLimit,
+  executeCli,
+  executeCliSessionTurn,
+  executeCliSessionTurnStreaming,
+  executeCliStreaming,
+  getCliSession,
+  isBufferedCliStreamingProvider,
+  materializeCliImageInputs,
+  startCliSession
+} from "./chunk-CMKUBIGW.js";
+import "./chunk-JBTJAPUF.js";
+import {
+  buildCliPrompt
+} from "./chunk-ATNTHIZI.js";
+import "./chunk-4VNS5WPM.js";
+export {
+  CLI_PROBE_BINARIES,
+  CliProviderQuotaError,
+  buildCliProcessEnv,
+  buildCliPrompt,
+  closeCliSession,
+  detectCliProviderQuotaLimit,
+  executeCli,
+  executeCliSessionTurn,
+  executeCliSessionTurnStreaming,
+  executeCliStreaming,
+  getCliSession,
+  isBufferedCliStreamingProvider,
+  materializeCliImageInputs,
+  startCliSession
+};