nolo-cli 0.1.23 → 0.1.29

package/server/handlers/agentRun/syncRunDialog.ts

@@ -0,0 +1,90 @@
+import type {
+  appendToExistingDialog,
+  saveRunAsDialog,
+} from "./saveDialog";
+import type { AgentRunRuntimeContext, LoopResult } from "./types";
+
+type SyncDialogResult = Pick<
+  Awaited<ReturnType<typeof saveRunAsDialog>>,
+  "dialogId" | "dialogKey"
+>;
+
+type CompleteSyncAgentRunDialogOptions = {
+  continueDialogId?: string | null;
+  existingDialogKey?: string | null;
+  dialogAgentKey: string;
+  traceAgentKey?: string;
+  userId: string | null;
+  continueDialogUserId: string | null;
+  callerType: "jwt";
+  userInput: string;
+  result: LoopResult;
+  durationMs: number;
+  spaceId?: string;
+  category?: string;
+  inheritedFromDialogKey?: string;
+  parentDialogId?: string;
+  runtimeProfile?: any;
+  runtimeContext?: AgentRunRuntimeContext | null;
+  runtimeToolPolicySnapshot?: Record<string, unknown>;
+  workspaceLease?: Record<string, unknown>;
+  appendToExistingDialog: typeof appendToExistingDialog;
+  saveRunAsDialog: typeof saveRunAsDialog;
+  summarizeMessagesForDebug(messages: unknown[]): unknown;
+  log?: typeof console.log;
+  error?: typeof console.error;
+};
+
+export async function completeSyncAgentRunDialog(
+  options: CompleteSyncAgentRunDialogOptions,
+): Promise<SyncDialogResult> {
+  const log = options.log ?? console.log;
+  const error = options.error ?? console.error;
+  const saveFn = options.continueDialogId
+    ? () => {
+        log("[agentRun] continue-save", {
+          dialogId: options.continueDialogId,
+          trace: options.summarizeMessagesForDebug(
+            (options.result.trace ?? []) as unknown[],
+          ),
+        });
+        return options.appendToExistingDialog({
+          dialogId: options.continueDialogId!,
+          dialogKey: options.existingDialogKey ?? undefined,
+          agentKey: options.dialogAgentKey,
+          traceAgentKey: options.traceAgentKey,
+          userId: options.continueDialogUserId,
+          userInput: options.userInput,
+          result: options.result,
+          durationMs: options.durationMs,
+          spaceId: options.spaceId,
+          runtimeProfile: options.runtimeProfile,
+          runtimeContext: options.runtimeContext,
+          runtimeToolPolicySnapshot: options.runtimeToolPolicySnapshot,
+          workspaceLease: options.workspaceLease,
+        });
+      }
+    : () =>
+        options.saveRunAsDialog({
+          agentKey: options.dialogAgentKey,
+          traceAgentKey: options.traceAgentKey,
+          userId: options.userId,
+          callerType: options.callerType,
+          userInput: options.userInput,
+          result: options.result,
+          durationMs: options.durationMs,
+          spaceId: options.spaceId,
+          category: options.category,
+          inheritedFromDialogKey: options.inheritedFromDialogKey,
+          parentDialogId: options.parentDialogId,
+          runtimeProfile: options.runtimeProfile,
+          runtimeContext: options.runtimeContext,
+          runtimeToolPolicySnapshot: options.runtimeToolPolicySnapshot,
+          workspaceLease: options.workspaceLease,
+        });
+
+  return saveFn().catch((caught) => {
+    error("saveRunAsDialog failed:", caught);
+    return { dialogId: "unknown", dialogKey: "" };
+  });
+}

package/server/handlers/agentRun/tableActivityProjection.ts

@@ -0,0 +1,132 @@
+import { DataType } from "../../../create/types";
+
+export type SubjectRef = {
+  kind: string;
+  id: string;
+  role?: string;
+};
+
+export type TableDialogActivityRef = {
+  type: "dialog";
+  dialogId: string;
+  dialogKey?: string;
+  role?: string;
+  agentKey?: string;
+  parentDialogId?: string;
+  status?: string;
+  updatedAt: string;
+};
+
+export type ActivityProjectionDb = {
+  get(key: string): Promise<any>;
+  put(key: string, value: any): Promise<void>;
+};
+
+const MAX_ACTIVITY_REFS = 20;
+const TABLE_ROW_SUBJECT_KINDS = new Set(["table-row", "tableRow"]);
+
+function normalizeString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function normalizeExistingActivityRefs(value: unknown): TableDialogActivityRef[] {
+  if (!Array.isArray(value)) return [];
+  return value
+    .map((item) => {
+      if (!item || typeof item !== "object" || Array.isArray(item)) return null;
+      const raw = item as Record<string, unknown>;
+      const dialogId = normalizeString(raw.dialogId);
+      if (raw.type !== "dialog" || !dialogId) return null;
+      return {
+        type: "dialog" as const,
+        dialogId,
+        ...(normalizeString(raw.dialogKey) ? { dialogKey: normalizeString(raw.dialogKey) } : {}),
+        ...(normalizeString(raw.role) ? { role: normalizeString(raw.role) } : {}),
+        ...(normalizeString(raw.agentKey) ? { agentKey: normalizeString(raw.agentKey) } : {}),
+        ...(normalizeString(raw.parentDialogId) ? { parentDialogId: normalizeString(raw.parentDialogId) } : {}),
+        ...(normalizeString(raw.status) ? { status: normalizeString(raw.status) } : {}),
+        updatedAt: normalizeString(raw.updatedAt) ?? new Date(0).toISOString(),
+      };
+    })
+    .filter((item): item is TableDialogActivityRef => Boolean(item));
+}
+
+function activityStatusRank(status: unknown) {
+  const normalized = normalizeString(status)?.toLowerCase();
+  if (normalized === "done" || normalized === "completed" || normalized === "failed" || normalized === "error") {
+    return 3;
+  }
+  if (normalized === "running" || normalized === "active") return 2;
+  if (normalized === "pending" || normalized === "queued") return 1;
+  return 0;
+}
+
+function mergeSameDialogActivityRef(
+  existing: TableDialogActivityRef | undefined,
+  nextRef: TableDialogActivityRef,
+) {
+  if (!existing) return nextRef;
+  const existingRank = activityStatusRank(existing.status);
+  const nextRank = activityStatusRank(nextRef.status);
+  if (nextRank < existingRank) {
+    return {
+      ...nextRef,
+      ...existing,
+      dialogKey: existing.dialogKey ?? nextRef.dialogKey,
+      role: existing.role ?? nextRef.role,
+      agentKey: existing.agentKey ?? nextRef.agentKey,
+      parentDialogId: existing.parentDialogId ?? nextRef.parentDialogId,
+    };
+  }
+  return nextRef;
+}
+
+export function mergeTableDialogActivityRef(row: any, nextRef: TableDialogActivityRef) {
+  const meta = row && typeof row.meta === "object" && !Array.isArray(row.meta) ? row.meta : {};
+  const existing = normalizeExistingActivityRefs(meta.activityRefs);
+  const sameDialog = existing.find(
+    (item) => item.type === nextRef.type && item.dialogId === nextRef.dialogId
+  );
+  const mergedRef = mergeSameDialogActivityRef(sameDialog, nextRef);
+  const withoutSameDialog = existing.filter(
+    (item) => !(item.type === nextRef.type && item.dialogId === nextRef.dialogId)
+  );
+  const activityRefs = [...withoutSameDialog, mergedRef].slice(-MAX_ACTIVITY_REFS);
+  return {
+    ...row,
+    meta: {
+      ...meta,
+      activityRefs,
+      latestActivityRef: mergedRef,
+    },
+    updatedAt: mergedRef.updatedAt,
+  };
+}
+
+export async function projectDialogActivityToSubjectRows(args: {
+  db: ActivityProjectionDb;
+  subjectRefs: SubjectRef[];
+  activityRef: TableDialogActivityRef;
+}): Promise<{ updatedRowDbKeys: string[]; skippedRowDbKeys: string[] }> {
+  const rowDbKeys = Array.from(
+    new Set(
+      args.subjectRefs
+        .filter((ref) => TABLE_ROW_SUBJECT_KINDS.has(ref.kind) && normalizeString(ref.id))
+        .map((ref) => ref.id.trim())
+    )
+  );
+  const updatedRowDbKeys: string[] = [];
+  const skippedRowDbKeys: string[] = [];
+
+  for (const dbKey of rowDbKeys) {
+    const row = await args.db.get(dbKey).catch(() => null);
+    if (!row || row.deletedAt || row.type !== DataType.TABLE_ROW) {
+      skippedRowDbKeys.push(dbKey);
+      continue;
+    }
+    await args.db.put(dbKey, mergeTableDialogActivityRef(row, args.activityRef));
+    updatedRowDbKeys.push(dbKey);
+  }
+
+  return { updatedRowDbKeys, skippedRowDbKeys };
+}

package/server/handlers/agentRun/taskRunControlPrompt.ts

@@ -0,0 +1,122 @@
+import type {
+  TaskRunBudgetRule,
+  TaskRunControlPolicy,
+  TaskRunCodexUsageSnapshot,
+} from "../../../ai/taskRun/taskRunProtocol";
+
+export const parseTaskRunControlPolicy = (resultText: string): TaskRunControlPolicy | undefined => {
+  try {
+    const parsed = JSON.parse(resultText);
+    const control = parsed?.row?.meta?.taskRun?.control;
+    return control && typeof control === "object" ? control : undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+const formatBudgetRule = (name: string, rule: TaskRunBudgetRule): string => {
+  const parts = [
+    rule.agentKey ? `agentKey=${rule.agentKey}` : "",
+    rule.provider ? `provider=${rule.provider}` : "",
+    rule.model ? `model=${rule.model}` : "",
+    rule.customProviderUrl ? `customProviderUrl=${rule.customProviderUrl}` : "",
+    rule.apiKeyHeader ? `apiKeyHeader=${rule.apiKeyHeader}` : "",
+    rule.freeUntil ? `freeUntil=${rule.freeUntil}` : "",
+    Number.isFinite(rule.dailyUsdLimit) ? `dailyUsdLimit=$${rule.dailyUsdLimit}` : "",
+    rule.hardStopAfter ? `hardStopAfter=${rule.hardStopAfter}` : "",
+    rule.note ? `note=${rule.note}` : "",
+  ].filter(Boolean);
+  return `- ${name}: ${parts.join(", ") || "configured"}`;
+};
+
+const formatCodexUsageWindow = (
+  label: string,
+  window: TaskRunCodexUsageSnapshot["primary"],
+): string => {
+  if (!window) return "";
+  const parts = [
+    Number.isFinite(window.usedPercent) ? `used=${window.usedPercent}%` : "",
+    Number.isFinite(window.windowMinutes) ? `window=${window.windowMinutes}m` : "",
+    Number.isFinite(window.resetsAt) ? `resetsAt=${window.resetsAt}` : "",
+  ].filter(Boolean);
+  return parts.length ? `${label}: ${parts.join(", ")}` : "";
+};
+
+function appendCodexUsageLines(lines: string[], snapshot?: TaskRunCodexUsageSnapshot): void {
+  if (!snapshot) return;
+  lines.push(
+    "local Codex usage snapshot:",
+    [
+      snapshot.planType ? `plan=${snapshot.planType}` : "",
+      snapshot.observedAt ? `observedAt=${snapshot.observedAt}` : "",
+      Number.isFinite(snapshot.lastTotalTokens) ? `lastTotalTokens=${snapshot.lastTotalTokens}` : "",
+      Number.isFinite(snapshot.totalTokens) ? `totalTokens=${snapshot.totalTokens}` : "",
+    ].filter(Boolean).join(", "),
+    formatCodexUsageWindow("primary", snapshot.primary),
+    formatCodexUsageWindow("secondary", snapshot.secondary),
+  );
+}
+
+export function buildTaskRunControlPolicyPrompt(
+  control: TaskRunControlPolicy | undefined,
+  now: Date = new Date(),
+) {
+  if (!control) return "";
+  const lines = [
+    "--- TaskRun control policy ---",
+    control.autonomy ? `autonomy: ${control.autonomy}` : "",
+  ].filter(Boolean);
+
+  const modelBudget = control.budget?.modelBudget ?? {};
+  const modelBudgetLines = Object.entries(modelBudget).map(([name, rule]) =>
+    formatBudgetRule(name, rule)
+  );
+  if (modelBudgetLines.length > 0) {
+    lines.push("model budget:", ...modelBudgetLines);
+  }
+
+  const runnerBudget = control.budget?.runnerBudget ?? {};
+  const runnerBudgetLines = Object.entries(runnerBudget).map(([name, rule]) =>
+    formatBudgetRule(name, rule)
+  );
+  if (runnerBudgetLines.length > 0) {
+    lines.push("runner budget:", ...runnerBudgetLines);
+  }
+
+  if (control.codexPolicy) {
+    lines.push(
+      `codexPolicy: ${control.codexPolicy.mode}`,
+      control.codexPolicy.requireFor?.length
+        ? `codex required for: ${control.codexPolicy.requireFor.join(", ")}`
+        : "",
+      control.codexPolicy.avoidFor?.length
+        ? `avoid Codex for: ${control.codexPolicy.avoidFor.join(", ")}`
+        : "",
+    );
+  }
+  appendCodexUsageLines(lines, control.codexUsageSnapshot);
+
+  if (control.nextWakeAt) lines.push(`nextWakeAt: ${control.nextWakeAt}`);
+  if (control.pausedReason) {
+    lines.push(
+      `HARD STOP: task is paused. Report pausedReason instead of spending more model budget: ${control.pausedReason}`,
+    );
+  }
+
+  for (const [name, rule] of [
+    ...Object.entries(modelBudget),
+    ...Object.entries(runnerBudget),
+  ]) {
+    if (rule.hardStopAfter && Date.parse(rule.hardStopAfter) <= now.getTime()) {
+      lines.push(
+        `HARD STOP: ${name} budget expired at ${rule.hardStopAfter}; choose another allowed route or report a blocker.`,
+      );
+    }
+  }
+
+  lines.push(
+    "Before delegation or tool-heavy exploration, follow this policy: prefer free-window/low-cost routes for routine work, and reserve Codex for supervision, quality gates, complex unblocking, and main/release decisions.",
+  );
+
+  return lines.filter(Boolean).join("\n");
+}