nolo-cli 0.1.23 → 0.1.29

package/server/handlers/agentRun/requestContext.ts

@@ -0,0 +1,86 @@
+import type { AgentRunRequest, ChatMessage } from "./types";
+
+const MAX_AGENT_RUN_TIMEOUT_MS = 30 * 60 * 1000;
+
+export interface ParsedAgentRunRequest {
+  body: AgentRunRequest;
+  requestedAgentKey: string;
+  userInput: AgentRunRequest["userInput"];
+  history: ChatMessage[];
+  stream: boolean;
+  runtimeContext: AgentRunRequest["runtimeContext"];
+  effectiveMaxRounds: number;
+  background: boolean;
+  spaceId: AgentRunRequest["spaceId"];
+  category: AgentRunRequest["category"];
+  inheritedFromDialogKey: AgentRunRequest["inheritedFromDialogKey"];
+  parentDialogId: AgentRunRequest["parentDialogId"];
+  runtimeProfile: AgentRunRequest["runtimeProfile"];
+  runtimeOptions: AgentRunRequest["runtimeOptions"];
+  debugContextLayers: boolean;
+  continueDialogId: AgentRunRequest["continueDialogId"];
+  effectiveAgentRunTimeoutMs: number | undefined;
+}
+
+export type AgentRunRequestParseResult =
+  | { ok: true; value: ParsedAgentRunRequest }
+  | { ok: false; error: { message: string; status: number } };
+
+export function normalizeAgentRunTimeoutMs(value: unknown): number | undefined {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return undefined;
+  }
+  return Math.min(Math.floor(value), MAX_AGENT_RUN_TIMEOUT_MS);
+}
+
+export function parseAgentRunRequestBody(body: unknown): AgentRunRequestParseResult {
+  const request = body as AgentRunRequest;
+  const {
+    agentKey: requestedAgentKey,
+    userInput,
+    messages: history = [],
+    stream = false,
+    runtimeContext,
+    maxRounds,
+    background = false,
+    spaceId,
+    category,
+    inheritedFromDialogKey,
+    parentDialogId,
+    runtimeProfile,
+    runtimeOptions,
+    debugContextLayers = false,
+    continueDialogId,
+    timeoutMs,
+  } = request;
+
+  if (!requestedAgentKey) {
+    return { ok: false, error: { message: "agentKey is required", status: 400 } };
+  }
+  if (!userInput) {
+    return { ok: false, error: { message: "userInput is required", status: 400 } };
+  }
+
+  return {
+    ok: true,
+    value: {
+      body: request,
+      requestedAgentKey,
+      userInput,
+      history,
+      stream,
+      runtimeContext,
+      effectiveMaxRounds: maxRounds ?? 12,
+      background,
+      spaceId,
+      category,
+      inheritedFromDialogKey,
+      parentDialogId,
+      runtimeProfile,
+      runtimeOptions,
+      debugContextLayers,
+      continueDialogId,
+      effectiveAgentRunTimeoutMs: normalizeAgentRunTimeoutMs(timeoutMs),
+    },
+  };
+}

package/server/handlers/agentRun/response.ts

@@ -0,0 +1,27 @@
+export const AGENT_RUN_CORS_HEADERS: Record<string, string> = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "POST, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type, Authorization",
+};
+
+export function agentRunJson(payload: unknown, status = 200): Response {
+  return new Response(JSON.stringify(payload), {
+    status,
+    headers: { ...AGENT_RUN_CORS_HEADERS, "Content-Type": "application/json" },
+  });
+}
+
+export function agentRunError(message: string, status: number): Response {
+  return agentRunJson({ error: message }, status);
+}
+
+export function agentRunSse(stream: BodyInit): Response {
+  return new Response(stream, {
+    headers: {
+      ...AGENT_RUN_CORS_HEADERS,
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+    },
+  });
+}

package/server/handlers/agentRun/runBilling.ts

@@ -0,0 +1,108 @@
+import { estimateMissingUsage } from "../../../ai/token/missingUsageEstimate";
+import {
+  countAssistantImageGenerationOutputs,
+  isOpenAIBuiltInImageGenerationAgent,
+  withImageGenerationCount,
+} from "../../../ai/token/openaiImageGenerationUsage";
+import type { LoopResult } from "./types";
+
+type BillingRunResult = Pick<
+  LoopResult,
+  "content" | "provider" | "model" | "inputPrice" | "outputPrice" | "usage" | "trace"
+>;
+
+export function buildBillingAgentConfig(
+  agentConfig: any,
+  result: Pick<
+    BillingRunResult,
+    "provider" | "model" | "inputPrice" | "outputPrice"
+  >,
+) {
+  const hasConfiguredInputPrice =
+    typeof agentConfig.inputPrice === "number" &&
+    Number.isFinite(agentConfig.inputPrice);
+  const hasConfiguredOutputPrice =
+    typeof agentConfig.outputPrice === "number" &&
+    Number.isFinite(agentConfig.outputPrice);
+
+  return {
+    ...agentConfig,
+    ...(result.provider ? { provider: result.provider } : {}),
+    ...(result.model ? { model: result.model } : {}),
+    ...(!hasConfiguredInputPrice && typeof result.inputPrice === "number"
+      ? { inputPrice: result.inputPrice }
+      : {}),
+    ...(!hasConfiguredOutputPrice && typeof result.outputPrice === "number"
+      ? { outputPrice: result.outputPrice }
+      : {}),
+  };
+}
+
+export const resolveAgentRunBillingUsage = ({
+  agentConfig,
+  content,
+  dialogId,
+  mode,
+  userId,
+  warn = console.warn,
+}: {
+  agentConfig: any;
+  content?: unknown;
+  dialogId: string;
+  mode: "background" | "sync";
+  userId?: string | null;
+  warn?: typeof console.warn;
+}) => {
+  if (!userId || !agentConfig?.provider || agentConfig.provider === "custom") {
+    return null;
+  }
+
+  warn("[billing] Missing usage in agentRun result; using estimated token write", {
+    dialogId,
+    mode,
+    userId,
+    provider: agentConfig.provider,
+    model: agentConfig.model,
+    endpointKey: agentConfig.endpointKey,
+  });
+  return estimateMissingUsage({ content });
+};
+
+export function resolveAgentRunBilledUsage({
+  agentConfig,
+  result,
+  dialogId,
+  mode,
+  userId,
+  warn,
+}: {
+  agentConfig: any;
+  result: BillingRunResult;
+  dialogId: string;
+  mode: "background" | "sync";
+  userId?: string | null;
+  warn?: typeof console.warn;
+}) {
+  const billingAgentConfig = buildBillingAgentConfig(agentConfig, result);
+  const billingUsage =
+    result.usage ??
+    resolveAgentRunBillingUsage({
+      agentConfig: billingAgentConfig,
+      content: result.content,
+      dialogId,
+      mode,
+      userId,
+      warn,
+    });
+  const billedUsage = isOpenAIBuiltInImageGenerationAgent(billingAgentConfig)
+    ? withImageGenerationCount(
+        billingUsage as any,
+        countAssistantImageGenerationOutputs(result.trace as any[]),
+      )
+    : billingUsage;
+
+  return {
+    billingAgentConfig,
+    billedUsage,
+  };
+}

package/server/handlers/agentRun/runDialogPreparation.ts

@@ -0,0 +1,55 @@
+import type { createPendingDialog as persistPendingDialog } from "./saveDialog";
+
+export type PendingRunDialogInput = Parameters<typeof persistPendingDialog>[0];
+type PendingRunDialogRecord = Pick<
+  Awaited<ReturnType<typeof persistPendingDialog>>,
+  "dialogId" | "dialogKey"
+>;
+
+export type PreparedRunDialog = {
+  dialogId: string;
+  dialogKey: string;
+  effectiveUserId: string | null;
+  effectiveSpaceId?: string;
+};
+
+export type PrepareRunDialogOptions = {
+  continueDialogId?: string | null;
+  existingDialogKey: string | null;
+  existingDialogRecord: any | null;
+  continueDialogUserId: string | null;
+  fallbackSpaceId?: string;
+  pendingDialogInput: PendingRunDialogInput;
+  createPendingDialog(
+    input: PendingRunDialogInput,
+  ): Promise<PendingRunDialogRecord>;
+};
+
+export async function prepareRunDialog(
+  options: PrepareRunDialogOptions,
+): Promise<PreparedRunDialog> {
+  if (options.continueDialogId) {
+    if (!options.existingDialogKey) {
+      throw Object.assign(
+        new Error(`Dialog not found: ${options.continueDialogId}`),
+        { status: 404 },
+      );
+    }
+
+    return {
+      dialogId: options.continueDialogId,
+      dialogKey: options.existingDialogKey,
+      effectiveUserId: options.continueDialogUserId,
+      effectiveSpaceId:
+        options.existingDialogRecord?.spaceId ?? options.fallbackSpaceId,
+    };
+  }
+
+  const pending = await options.createPendingDialog(options.pendingDialogInput);
+  return {
+    dialogId: pending.dialogId,
+    dialogKey: pending.dialogKey,
+    effectiveUserId: options.pendingDialogInput.userId,
+    effectiveSpaceId: options.pendingDialogInput.spaceId,
+  };
+}

package/server/handlers/agentRun/runtimeBinding.ts

@@ -0,0 +1,61 @@
+import type {
+  DialogConfig,
+  DialogRuntimeBinding,
+  DialogRuntimeController,
+  DialogRuntimeProfile,
+} from "../../../app/types";
+
+function normalizeString(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  return trimmed || undefined;
+}
+
+export function buildDialogRuntimeBinding(args: {
+  existing?: Partial<DialogRuntimeBinding> | null;
+  dialogId: string;
+  agentKey: string;
+  tenantUserId?: string | null;
+  controller?: DialogRuntimeController;
+  triggerType?: DialogConfig["triggerType"];
+  executionMode?: DialogConfig["executionMode"];
+  runtimeProfile?: DialogRuntimeProfile;
+  spaceId?: string | null;
+  category?: string | null;
+  runtimeToolPolicySnapshot?: Record<string, unknown> | null;
+  workspaceLease?: Record<string, unknown> | null;
+}): DialogRuntimeBinding {
+  const existing = args.existing && typeof args.existing === "object" ? args.existing : {};
+  const tenantUserId = normalizeString(args.tenantUserId);
+  const runtimeAnchorDialogId =
+    normalizeString(existing.runtimeAnchorDialogId) ?? normalizeString(args.dialogId) ?? args.dialogId;
+
+  return {
+    version: 1,
+    agentKey: normalizeString(args.agentKey) ?? args.agentKey,
+    runtimeAnchorDialogId,
+    controller: args.controller ?? existing.controller ?? "request",
+    ...(tenantUserId ? { tenantUserId } : {}),
+    ...(args.triggerType ?? existing.triggerType
+      ? { triggerType: args.triggerType ?? existing.triggerType }
+      : {}),
+    ...(args.executionMode ?? existing.executionMode
+      ? { executionMode: args.executionMode ?? existing.executionMode }
+      : {}),
+    ...(args.runtimeProfile ?? existing.runtimeProfile
+      ? { runtimeProfile: args.runtimeProfile ?? existing.runtimeProfile }
+      : {}),
+    ...(normalizeString(args.spaceId) ?? normalizeString(existing.spaceId)
+      ? { spaceId: normalizeString(args.spaceId) ?? normalizeString(existing.spaceId) }
+      : {}),
+    ...(normalizeString(args.category) ?? normalizeString(existing.category)
+      ? { category: normalizeString(args.category) ?? normalizeString(existing.category) }
+      : {}),
+    ...(args.runtimeToolPolicySnapshot ?? existing.runtimeToolPolicySnapshot
+      ? { runtimeToolPolicySnapshot: args.runtimeToolPolicySnapshot ?? existing.runtimeToolPolicySnapshot }
+      : {}),
+    ...(args.workspaceLease ?? existing.workspaceLease
+      ? { workspaceLease: args.workspaceLease ?? existing.workspaceLease }
+      : {}),
+  };
+}

package/server/handlers/agentRun/runtimeContext.ts

@@ -0,0 +1,143 @@
+import type { AgentRunRuntimeContext } from "./types";
+
+const KNOWN_SURFACES = new Set([
+  "web",
+  "electron",
+  "electron-bun",
+  "cli",
+  "server-script",
+  "backend-script",
+  "react-native",
+]);
+
+const SURFACE_LABELS: Record<string, string> = {
+  web: "Web app",
+  electron: "Electron desktop app",
+  "electron-bun": "Electron/Bun desktop runtime",
+  cli: "CLI/TUI",
+  "server-script": "server-side script",
+  "backend-script": "backend script",
+  "react-native": "React Native app",
+};
+
+const normalizeSurface = (value?: string | null) => {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  return normalized || "unknown";
+};
+
+const normalizeOptionalString = (value: unknown) =>
+  typeof value === "string" && value.trim() ? value.trim() : undefined;
+
+const normalizeOptionalStringArray = (value: unknown) =>
+  Array.isArray(value)
+    ? value
+        .filter((item): item is string => typeof item === "string" && !!item.trim())
+        .map((item) => item.trim())
+        : undefined;
+
+function normalizeSubjectRefs(value: unknown) {
+  if (!Array.isArray(value)) return undefined;
+  const refs = value
+    .map((item) => {
+      if (!item || typeof item !== "object") return null;
+      const raw = item as Record<string, unknown>;
+      const kind = normalizeOptionalString(raw.kind);
+      const id = normalizeOptionalString(raw.id);
+      if (!kind || !id) return null;
+      return {
+        kind,
+        id,
+        ...(normalizeOptionalString(raw.role) ? { role: normalizeOptionalString(raw.role) } : {}),
+      };
+    })
+    .filter((item): item is { kind: string; id: string; role?: string } => Boolean(item));
+  return refs.length ? refs : undefined;
+}
+
+export function normalizeAgentRunRuntimeContext(args: {
+  runtimeContext?: AgentRunRuntimeContext | null;
+}): AgentRunRuntimeContext {
+  const rawContext =
+    args.runtimeContext && typeof args.runtimeContext === "object"
+      ? args.runtimeContext
+      : {};
+  const surface = normalizeSurface(rawContext.surface);
+  return {
+    surface,
+    host:
+      normalizeOptionalString(rawContext.host) ??
+      (surface === "cli" ? "terminal" : undefined),
+    runtime:
+      normalizeOptionalString(rawContext.runtime) ??
+      (surface === "cli" ? "bun" : undefined),
+    entrypoint:
+      normalizeOptionalString(rawContext.entrypoint) ??
+      (surface === "cli" ? "nolo-cli" : undefined),
+    capabilities:
+      Array.isArray(rawContext.capabilities)
+        ? rawContext.capabilities
+            .filter((item): item is string => typeof item === "string" && !!item.trim())
+            .map((item) => item.trim())
+        : undefined,
+    taskRun:
+      rawContext.taskRun && typeof rawContext.taskRun === "object"
+        ? {
+            rowDbKey: normalizeOptionalString(rawContext.taskRun.rowDbKey),
+            taskRunId: normalizeOptionalString(rawContext.taskRun.taskRunId),
+            workItemId: normalizeOptionalString(rawContext.taskRun.workItemId),
+            artifactIds: normalizeOptionalStringArray(rawContext.taskRun.artifactIds),
+          }
+        : undefined,
+    subjectRefs: normalizeSubjectRefs(rawContext.subjectRefs),
+  };
+}
+
+export function buildRuntimeContextPrompt(context: AgentRunRuntimeContext) {
+  const surface = normalizeSurface(context.surface);
+  const surfaceLabel = SURFACE_LABELS[surface] ?? surface;
+  const knownSurface = KNOWN_SURFACES.has(surface);
+  const lines = [
+    "--- 当前运行入口 ---",
+    `surface: ${surfaceLabel}`,
+    context.host ? `host: ${context.host}` : "",
+    context.runtime ? `runtime: ${context.runtime}` : "",
+    context.entrypoint ? `entrypoint: ${context.entrypoint}` : "",
+    context.capabilities?.length
+      ? `capabilities: ${context.capabilities.join(", ")}`
+      : "",
+    "",
+    "你需要先察觉用户当前通过哪个运行入口与你对话，再决定回答方式、工具使用和委派边界。",
+  ].filter(Boolean);
+
+  if (surface === "cli") {
+    lines.push(
+      "当前是终端里的统一 nolo 助手：回答要适合命令行阅读，不要假设用户正在看网页画布、右侧预览或浏览器 UI。",
+      "轻量输入要轻量回应：用户只说 hi、你好、随便问问、瞎聊、困了、在吗 等寒暄或状态时，默认 1-3 句，像终端里的工作伙伴一样自然接住。",
+      "不要自我介绍，不要主动罗列能力清单，不要把轻问候扩展成菜单；只有用户明确问“你能做什么”、要方案、列表、步骤或比较时才列条目。",
+      "只有当用户明确要制作网页、小工具、应用、图表展示页或产品原型时，才委派给 App Builder；否则优先直接回答、管理 Agent/Dialog/Doc，或说明可执行的 CLI 下一步。",
+      "如果确实委派给 App Builder，要求其用终端友好的方式交付：简短说明结果、关键链接、后续命令或需要用户确认的点。",
+    );
+  } else if (surface === "web") {
+    lines.push(
+      "当前是网页应用入口：可以自然引用网页里的 dialog、doc、table、app preview、可点击 UI 和浏览器内可见状态。",
+    );
+  } else if (surface === "electron" || surface === "electron-bun") {
+    lines.push(
+      "当前是桌面应用入口：可以考虑本地文件、窗口、剪贴板、系统 shell 和桌面状态，但仍需遵守权限与确认边界。",
+    );
+  } else if (surface === "server-script" || surface === "backend-script") {
+    lines.push(
+      "当前是后端脚本入口：默认输出机器可读、可复现的结果，避免依赖交互式 UI；需要人工确认时明确返回下一步。",
+    );
+  } else if (surface === "react-native") {
+    lines.push(
+      "当前是移动端 React Native 入口：回答应适合窄屏和触控交互，不要假设桌面多窗、终端或网页预览存在。",
+    );
+  } else if (!knownSurface) {
+    lines.push(
+      "当前入口未完全识别：先保持入口无关的回答，避免假设网页、终端、桌面或移动端能力存在。",
+    );
+  }
+
+  return lines.join("\n");
+}

package/server/handlers/agentRun/runtimeExecutionContext.ts

@@ -0,0 +1,153 @@
+import type { AgentRunRequest, ChatMessage } from "./types";
+
+type RuntimeExecutionContextOptions = {
+  agentConfig: any;
+  agentKey: string;
+  userId: string | null;
+  userInput: AgentRunRequest["userInput"];
+  userInputText: string;
+  contextHistory: ChatMessage[];
+  spaceId?: string | null;
+  runtimeProfile?: any;
+  existingDialogRecord: any | null;
+  taskRunPreflightPrompt?: string | null;
+  loadUserSettings(userId: string): Promise<any>;
+  resolveRuntimePolicy(args: {
+    agentConfig: any;
+    settingsRecord: any;
+    userInput: string;
+    dialogPolicyState: any;
+  }): any;
+  buildUserPolicyContext(runtimePolicy: any): string;
+  resolveMemoryRuntime(args: {
+    userId: string | null;
+    spaceId: string | null;
+    agentKey: string;
+    userInput: string;
+  }): Promise<any>;
+  resolveAutonomousRuntimeContext(args: {
+    runtimeProfile: any;
+    userId: string | null;
+    spaceId?: string | null;
+    agentKey: string;
+    checkpoint: any;
+    userInput: string;
+  }): Promise<any>;
+  buildRuntimeSystemMessageContext(args: {
+    agentName: string;
+    agentId: string;
+    agentPrompt: string;
+    tools: string[];
+    autonomousRuntimeBlock: any;
+    userPolicyContext: string;
+    memoryPromptBlock: any;
+  }): any;
+  buildAgentRunUserMessageContent(
+    userInput: AgentRunRequest["userInput"],
+    turnInstruction?: string | null,
+    prelude?: string | null,
+  ): ChatMessage["content"];
+  canonicalizeToolNames(toolNames: string[]): string[];
+  prioritizeToolNames(toolNames: string[], preferredToolNames: string[]): string[];
+};
+
+export async function prepareAgentRunExecutionContext(
+  options: RuntimeExecutionContextOptions,
+) {
+  let agentConfig = options.agentConfig;
+  let userSettingsRecord: any = null;
+  if (options.userId) {
+    try {
+      userSettingsRecord = await options.loadUserSettings(options.userId);
+    } catch (_) { }
+  }
+
+  const runtimePolicy = options.resolveRuntimePolicy({
+    agentConfig,
+    settingsRecord: userSettingsRecord,
+    userInput: options.userInputText,
+    dialogPolicyState: options.existingDialogRecord?.policyState,
+  });
+  const userPolicyContext = options.buildUserPolicyContext(runtimePolicy);
+  const effectiveRuntimeProfile =
+    options.runtimeProfile ??
+    options.existingDialogRecord?.runtimeBinding?.runtimeProfile;
+  const memoryRuntime = await options.resolveMemoryRuntime({
+    userId: options.userId,
+    spaceId: options.spaceId ?? null,
+    agentKey: options.agentKey,
+    userInput: options.userInputText,
+  });
+  const autonomousRuntime = await options.resolveAutonomousRuntimeContext({
+    runtimeProfile: effectiveRuntimeProfile,
+    userId: options.userId,
+    spaceId: options.existingDialogRecord?.spaceId ?? options.spaceId,
+    agentKey: options.agentKey,
+    checkpoint: options.existingDialogRecord?.runtimeCheckpoint ?? null,
+    userInput: options.userInputText,
+  });
+
+  if (autonomousRuntime.requiredTools.length > 0) {
+    agentConfig = {
+      ...agentConfig,
+      tools: options.prioritizeToolNames(
+        options.canonicalizeToolNames([
+          ...(agentConfig.tools ?? []),
+          ...autonomousRuntime.requiredTools,
+        ]),
+        autonomousRuntime.requiredTools,
+      ),
+    };
+  }
+  if (autonomousRuntime.disabledTools.length > 0) {
+    const disabledTools = new Set(
+      options.canonicalizeToolNames(autonomousRuntime.disabledTools),
+    );
+    agentConfig = {
+      ...agentConfig,
+      tools: options.canonicalizeToolNames(agentConfig.tools ?? []).filter(
+        (toolName) => !disabledTools.has(toolName),
+      ),
+    };
+  }
+  if (autonomousRuntime.exclusiveTools.length > 0) {
+    agentConfig = {
+      ...agentConfig,
+      tools: options.canonicalizeToolNames(autonomousRuntime.exclusiveTools),
+    };
+  }
+
+  const runtimeSystemMessageContext = options.buildRuntimeSystemMessageContext({
+    agentName: agentConfig.name,
+    agentId: agentConfig.dbKey ?? options.agentKey,
+    agentPrompt: agentConfig.prompt,
+    tools: agentConfig.tools ?? [],
+    autonomousRuntimeBlock: autonomousRuntime.block,
+    userPolicyContext,
+    memoryPromptBlock: memoryRuntime.promptBlock,
+  });
+  const runtimeSystemMessages = runtimeSystemMessageContext.messages;
+  const modelUserInput = options.buildAgentRunUserMessageContent(
+    options.userInput,
+    autonomousRuntime.turnInstruction,
+    options.taskRunPreflightPrompt,
+  );
+  const messages: ChatMessage[] = [
+    ...runtimeSystemMessages,
+    ...options.contextHistory,
+    { role: "user", content: modelUserInput },
+  ];
+
+  return {
+    agentConfig,
+    runtimePolicy,
+    userPolicyContext,
+    effectiveRuntimeProfile,
+    memoryRuntime,
+    autonomousRuntime,
+    runtimeSystemMessageContext,
+    runtimeSystemMessages,
+    modelUserInput,
+    messages,
+  };
+}