nolo-cli 0.1.13 → 0.1.14

package/README.md

@@ -93,8 +93,10 @@ nolo connect --daemon
 nolo daemon --server-url https://api.nolo.chat --api-key sk_machine_xxx
 nolo machine status
 nolo run "summarize my latest agent dialogs"
-nolo doc create --title "Trip Notes" --body "hello"
-nolo skill-doc create --title "Agent Query Skill" --description "Inspect recent agent dialogs"
+nolo doc create --title "Trip Notes" --body "hello" --sync local,us --dry-run
+nolo doc create --title "Proxy Notes" --description "Windows setup" --body-file ./proxy.md --sync local,main,us --allow-secrets
+nolo skill-doc create --title "Agent Query Skill" --description "Inspect recent agent dialogs" --body-file ./skill.md --sync local,main,us
+nolo space read 01KKY77TT0DA9NY7TNW3R7255N --content-key page-user-id --brief
 nolo agent list --json
 nolo agent bind-current agent-user-1-agent-1
 nolo agent runtime-doctor agent-user-1-agent-1
@@ -102,6 +104,11 @@ nolo agent smoke-current agent-user-1-agent-1 --msg "ping"
 nolo chat --agent agent-pub-01APPBUILDER00000001YAII3I --msg "你好"
 ```
 
+For document creation, prefer the CLI over direct scripts. Use `nolo doc create`
+for ordinary pages and `nolo skill-doc create` for skill-backed pages. Both
+support `--sync`, `--dry-run`, `--json`, and `--allow-secrets`; scripts remain
+the lower-level fallback for debugging.
+
 Experimental machine connector commands:
 
 ```bash

package/agent-runtime/hostAdapter.ts

@@ -0,0 +1,53 @@
+import type {
+  AgentRuntimeChatMessage,
+  AgentRuntimeHost,
+  AgentRuntimeResult,
+} from "./types";
+
+export type AgentRuntimeAgentConfig = {
+  key: string;
+  name?: string;
+  prompt?: string;
+  model?: string;
+  provider?: string;
+  toolNames?: string[];
+};
+
+export type AgentRuntimeProvider = {
+  model: string;
+  complete(messages: AgentRuntimeChatMessage[]): Promise<AgentRuntimeResult>;
+};
+
+export type AgentRuntimeToolCallInput = {
+  id: string;
+  name: string;
+  arguments: string;
+};
+
+export type AgentRuntimeToolResult = {
+  content: string;
+  metadata?: Record<string, unknown>;
+};
+
+export type AgentRuntimeSaveTurnInput = {
+  agentKey: string;
+  messages: AgentRuntimeChatMessage[];
+  result: AgentRuntimeResult;
+};
+
+export type AgentRuntimeHostAdapter = {
+  host: AgentRuntimeHost;
+  capabilities: string[];
+  loadAgentConfig(agentRef: string): Promise<AgentRuntimeAgentConfig | null>;
+  loadDialogHistory(dialogId: string): Promise<AgentRuntimeChatMessage[]>;
+  saveTurn(input: AgentRuntimeSaveTurnInput): Promise<{ dialogId: string }>;
+  resolveProvider(agentConfig: AgentRuntimeAgentConfig): Promise<AgentRuntimeProvider>;
+  executeTool(call: AgentRuntimeToolCallInput): Promise<AgentRuntimeToolResult>;
+};
+
+export function createRuntimeHostDescriptor(adapter: AgentRuntimeHostAdapter) {
+  return {
+    host: adapter.host,
+    capabilities: [...adapter.capabilities],
+  };
+}

package/agent-runtime/index.ts

@@ -0,0 +1,28 @@
+export const AGENT_RUNTIME_PACKAGE_ID = "agent-runtime";
+
+export { createRuntimeHostDescriptor } from "./hostAdapter";
+export { runLocalAgentTurn } from "./localLoop";
+export { resolveAgentRuntimeDecision } from "./runtimeDecision";
+export type {
+  AgentRuntimeAgentConfig,
+  AgentRuntimeHostAdapter,
+  AgentRuntimeProvider,
+  AgentRuntimeSaveTurnInput,
+  AgentRuntimeToolCallInput,
+  AgentRuntimeToolResult,
+} from "./hostAdapter";
+export type {
+  LocalAgentTurnInput,
+  LocalAgentTurnResult,
+} from "./localLoop";
+export type {
+  AgentRuntimeChatMessage,
+  AgentRuntimeDecision,
+  AgentRuntimeDecisionInput,
+  AgentRuntimeHost,
+  AgentRuntimeMessageContent,
+  AgentRuntimeMode,
+  AgentRuntimeRequestedMode,
+  AgentRuntimeResult,
+  AgentRuntimeToolCall,
+} from "./types";

package/agent-runtime/localLoop.ts

@@ -0,0 +1,62 @@
+import type {
+  AgentRuntimeHostAdapter,
+} from "./hostAdapter";
+import type {
+  AgentRuntimeChatMessage,
+  AgentRuntimeResult,
+} from "./types";
+
+export type LocalAgentTurnInput = {
+  adapter: AgentRuntimeHostAdapter;
+  agentRef: string;
+  input: string;
+  continueDialogId?: string;
+};
+
+export type LocalAgentTurnResult = AgentRuntimeResult & {
+  dialogId: string;
+};
+
+function buildMessages(args: {
+  prompt?: string;
+  history: AgentRuntimeChatMessage[];
+  input: string;
+}): AgentRuntimeChatMessage[] {
+  return [
+    ...(args.prompt?.trim()
+      ? [{ role: "system" as const, content: args.prompt.trim() }]
+      : []),
+    ...args.history,
+    { role: "user" as const, content: args.input },
+  ];
+}
+
+export async function runLocalAgentTurn(
+  input: LocalAgentTurnInput
+): Promise<LocalAgentTurnResult> {
+  const agentConfig = await input.adapter.loadAgentConfig(input.agentRef);
+  if (!agentConfig) {
+    throw new Error(`Local agent config not found: ${input.agentRef}`);
+  }
+
+  const history = input.continueDialogId
+    ? await input.adapter.loadDialogHistory(input.continueDialogId)
+    : [];
+  const messages = buildMessages({
+    prompt: agentConfig.prompt,
+    history,
+    input: input.input,
+  });
+  const provider = await input.adapter.resolveProvider(agentConfig);
+  const result = await provider.complete(messages);
+  const saved = await input.adapter.saveTurn({
+    agentKey: agentConfig.key,
+    messages,
+    result,
+  });
+
+  return {
+    ...result,
+    dialogId: saved.dialogId,
+  };
+}

package/agent-runtime/runtimeDecision.ts

@@ -0,0 +1,70 @@
+import type {
+  AgentRuntimeDecision,
+  AgentRuntimeDecisionInput,
+} from "./types";
+
+function uniqueCapabilities(capabilities: string[]) {
+  return [...new Set(capabilities.filter(Boolean))];
+}
+
+function localMissingCapabilities(input: AgentRuntimeDecisionInput) {
+  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);
+}
+
+export function resolveAgentRuntimeDecision(
+  input: AgentRuntimeDecisionInput
+): AgentRuntimeDecision {
+  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,
+  };
+}

package/agent-runtime/types.ts

@@ -0,0 +1,87 @@
+export type AgentRuntimeMode = "local" | "server";
+export type AgentRuntimeHost = "cli" | "desktop" | "web" | "server";
+export type AgentRuntimeRequestedMode = "auto" | AgentRuntimeMode;
+
+export const AGENT_RUNTIME_MESSAGE_ROLES = ["system", "user", "assistant", "tool"] as const;
+
+export type AgentRuntimeMessageContent =
+  | string
+  | Array<
+      | { type: "text"; text: string }
+      | {
+          type: "image_url";
+          image_url: { url: string };
+          google_native?: {
+            inlineData: {
+              mimeType: string;
+              data: string;
+            };
+            thoughtSignature?: string;
+          };
+        }
+    >
+  | null;
+
+export interface AgentRuntimeToolCall {
+  id: string;
+  type: "function";
+  function: { name: string; arguments: string };
+}
+
+export interface AgentRuntimeChatMessage {
+  role: (typeof AGENT_RUNTIME_MESSAGE_ROLES)[number];
+  content: AgentRuntimeMessageContent;
+  tool_call_id?: string;
+  tool_calls?: AgentRuntimeToolCall[];
+  reasoning_content?: string;
+  cybotKey?: string;
+  agentKey?: string;
+  agentName?: string;
+  parallelSessionId?: string;
+  parallelBranchId?: string;
+  parallelLabel?: string;
+  parallelIndex?: number;
+}
+
+export interface AgentRuntimeResult {
+  content: string;
+  model: string;
+  provider?: string;
+  inputPrice?: number;
+  outputPrice?: number;
+  usage?: Record<string, any>;
+  trace?: AgentRuntimeChatMessage[];
+  runtimeToolNames?: string[];
+  toolCallCount?: number;
+  policyState?: unknown;
+  latencyProfile?: {
+    totalMs: number;
+    llmRequestCount: number;
+    llmWaitMs: number;
+    llmJsonParseMs: number;
+    toolExecutionMs: number;
+    timeToFirstAssistantMs?: number;
+    timeToFirstToolResultMs?: number;
+    endedAt: number;
+  };
+}
+
+export type AgentRuntimeDecisionInput = {
+  requestedMode?: AgentRuntimeRequestedMode;
+  syncRequested?: boolean;
+  host?: AgentRuntimeHost;
+  hasLocalAgentConfig: boolean;
+  hasLocalProvider: boolean;
+  hasLocalPersistence: boolean;
+  missingLocalCapabilities?: string[];
+  requiresServer?: boolean;
+  serverFallbackAvailable: boolean;
+};
+
+export type AgentRuntimeDecision = {
+  mode: AgentRuntimeMode;
+  runnable: boolean;
+  reason: string;
+  missingLocalCapabilities: string[];
+  syncAfterRun: boolean;
+};

package/agentRuntimeCommands.ts

@@ -1,8 +1,10 @@
-import type { MachineHeartbeat } from "./connector-experimental/protocol";
-import { detectMachineInfo } from "./connector-experimental/machineInfo";
-import {
-  assertMachineRunAllowed,
-  buildMachinePermissionPromptBlock,
+import type { MachineHeartbeat } from "./connector-experimental/protocol";
+import { detectMachineInfo } from "./connector-experimental/machineInfo";
+import { resolveAgentRuntimeDecision } from "./agent-runtime/runtimeDecision";
+import { resolveCliLocalRuntimeDbPath } from "./localRuntimeDb";
+import {
+  assertMachineRunAllowed,
+  buildMachinePermissionPromptBlock,
   resolveMachineRunPermissionPolicy,
 } from "./ai/agent/machineRunPermissions";
 import { resolveConnectorWebSocketTarget } from "./connectorWebSocketTarget";
@@ -16,28 +18,89 @@ type SmokeWebSocketOptions = {
   onOpen: () => void | Promise<void>;
   sentMessages: string[];
 };
-type LocalCliExecutor = (
-  provider: string,
-  prompt: string,
-  options: { model?: string; yolo?: boolean }
-) => Promise<{ text: string; raw?: string; elapsed?: number }>;
-
-type AgentRuntimeCommandDeps = {
+type LocalCliExecutor = (
+  provider: string,
+  prompt: string,
+  options: { model?: string; yolo?: boolean }
+) => Promise<{ text: string; raw?: string; elapsed?: number }>;
+type LocalRuntimeProbeResult = {
+  ok: boolean;
+  dbPath: string;
+  agentFound: boolean;
+  agentKey?: string;
+  error?: string;
+};
+
+type AgentRuntimeCommandDeps = {
   env?: EnvLike;
   output?: OutputLike;
   fetchImpl?: typeof fetch;
-  machineInfo?: () => MachineHeartbeat;
-  connectWebSocket?: (url: string, options: SmokeWebSocketOptions) => Promise<void>;
-  executeCli?: LocalCliExecutor;
-};
+  machineInfo?: () => MachineHeartbeat;
+  connectWebSocket?: (url: string, options: SmokeWebSocketOptions) => Promise<void>;
+  executeCli?: LocalCliExecutor;
+  localRuntimeProbe?: (env: EnvLike) => Promise<LocalRuntimeProbeResult>;
+};
 
 function resolveServerUrl(env: EnvLike) {
   return (env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
 }
 
-function resolveAuthToken(env: EnvLike) {
-  return env.AUTH_TOKEN || env.AUTH || "";
-}
+function resolveAuthToken(env: EnvLike) {
+  return env.AUTH_TOKEN || env.AUTH || "";
+}
+
+function detectLocalAgentConfig(env: EnvLike) {
+  return Boolean(readLocalAgentKey(env) || env.NOLO_AGENT_CACHE_READY);
+}
+
+function readLocalAgentKey(env: EnvLike) {
+  return env.NOLO_LOCAL_AGENT_KEY || env.NOLO_AGENT || "";
+}
+
+function detectLocalProvider(env: EnvLike) {
+  return Boolean(
+    env.OPENAI_API_KEY ||
+    env.ANTHROPIC_API_KEY ||
+    env.GOOGLE_API_KEY ||
+    env.NOLO_LOCAL_OPENAI_BASE_URL ||
+    env.OLLAMA_BASE_URL
+  );
+}
+
+function detectProviderLabel(env: EnvLike) {
+  if (env.NOLO_LOCAL_OPENAI_BASE_URL) return `openai-compatible endpoint ${env.NOLO_LOCAL_OPENAI_BASE_URL}`;
+  if (env.OLLAMA_BASE_URL) return `ollama-compatible endpoint ${env.OLLAMA_BASE_URL}`;
+  if (env.OPENAI_API_KEY) return "openai via env OPENAI_API_KEY";
+  if (env.ANTHROPIC_API_KEY) return "anthropic via env ANTHROPIC_API_KEY";
+  if (env.GOOGLE_API_KEY) return "google via env GOOGLE_API_KEY";
+  return "missing";
+}
+
+async function defaultLocalRuntimeProbe(env: EnvLike): Promise<LocalRuntimeProbeResult> {
+  const dbPath = resolveCliLocalRuntimeDbPath({ env });
+  const agentKey = readLocalAgentKey(env);
+  try {
+    const { getDefaultCliLocalRuntimeDb } = await import("./localRuntimeDb");
+    const db = await getDefaultCliLocalRuntimeDb();
+    if (!agentKey) {
+      return { ok: true, dbPath, agentFound: false };
+    }
+    try {
+      await db.get(agentKey);
+      return { ok: true, dbPath, agentFound: true, agentKey };
+    } catch {
+      return { ok: true, dbPath, agentFound: false, agentKey };
+    }
+  } catch (error) {
+    return {
+      ok: false,
+      dbPath,
+      agentFound: false,
+      ...(agentKey ? { agentKey } : {}),
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
 
 function parseUserIdFromAuthToken(token: string) {
   const payload = token.trim().split(".")[0];
@@ -413,7 +476,7 @@ export async function runAgentSmokeCurrentCommand(
   }
 }
 
-export async function runAgentRuntimeDoctorCommand(
+export async function runAgentRuntimeDoctorCommand(
   args: string[],
   deps: AgentRuntimeCommandDeps = {}
 ) {
@@ -462,5 +525,59 @@ export async function runAgentRuntimeDoctorCommand(
       }\n`
     );
     return 1;
-  }
-}
+  }
+}
+
+export async function runDoctorRuntimeCommand(
+  _args: string[],
+  deps: AgentRuntimeCommandDeps = {}
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const authToken = resolveAuthToken(env);
+  const serverUrl = resolveServerUrl(env);
+  const localProbe = await (deps.localRuntimeProbe ?? defaultLocalRuntimeProbe)(env);
+  const hasLocalAgentConfig = detectLocalAgentConfig(env) && localProbe.ok && localProbe.agentFound;
+  const hasLocalProvider = detectLocalProvider(env);
+  const missingLocalCapabilities = [
+    ...(localProbe.ok ? [] : ["leveldb"]),
+    ...(hasLocalAgentConfig ? [] : ["agent-config"]),
+    ...(hasLocalProvider ? [] : ["provider"]),
+  ];
+  const decision = resolveAgentRuntimeDecision({
+    requestedMode: "auto",
+    syncRequested: false,
+    host: "cli",
+    hasLocalAgentConfig,
+    hasLocalProvider,
+    hasLocalPersistence: true,
+    missingLocalCapabilities,
+    requiresServer: false,
+    serverFallbackAvailable: Boolean(authToken || env.NOLO_SERVER || env.BASE_URL),
+  });
+
+  output.write(`Runtime: ${decision.mode}\n`);
+  output.write(`Reason: ${decision.reason}\n`);
+  output.write(`LevelDB: ${localProbe.ok ? "ok" : "failed"}\n`);
+  output.write(`DB path: ${localProbe.dbPath}\n`);
+  if (!localProbe.ok && localProbe.error) {
+    output.write(`DB error: ${localProbe.error}\n`);
+  }
+  if (localProbe.agentKey) {
+    output.write(`Agent config: ${localProbe.agentFound ? "found" : "missing"} (${localProbe.agentKey})\n`);
+  } else {
+    output.write("Agent config: missing (no local agent key)\n");
+  }
+  output.write(`Provider: ${hasLocalProvider ? "available" : "missing"} (${detectProviderLabel(env)})\n`);
+  output.write("Persistence: LevelDB local store\n");
+  output.write(`Sync: ${authToken ? "available" : "unavailable"}${authToken ? "" : " (not authenticated)"}\n`);
+  output.write(`Server fallback: ${decision.runnable && decision.mode === "server" ? serverUrl : authToken || env.NOLO_SERVER || env.BASE_URL ? serverUrl : "unavailable"}\n`);
+  if (decision.missingLocalCapabilities.length > 0) {
+    output.write("Missing local capabilities:\n");
+    for (const capability of decision.missingLocalCapabilities) {
+      output.write(`- ${capability}\n`);
+    }
+  }
+
+  return decision.runnable ? 0 : 1;
+}

package/agentRuntimeLocal.ts

@@ -0,0 +1,7 @@
+export { runLocalAgentTurn } from "./agent-runtime/localLoop";
+export type {
+  AgentRuntimeAgentConfig,
+  AgentRuntimeHostAdapter,
+  AgentRuntimeRequestedMode,
+  AgentRuntimeSaveTurnInput,
+} from "./agent-runtime";

package/ai/agent/_executeModel.ts

@@ -0,0 +1,118 @@
+import { RootState } from "app/store";
+import { Agent, Message } from "app/types";
+import { selectCurrentDialogConfig } from "chat/dialog/dialogSlice";
+import { read } from "database/dbSlice";
+import { fetchAgentContexts } from "ai/agent/fetchAgentContexts";
+import { filterAndCleanMessages } from "integrations/openai/filterAndCleanMessages";
+import { selectAllMsgs } from "chat/messages/messageSlice";
+import { generateRequestBody } from "ai/llm/generateRequestBody";
+import { getApiEndpoint } from "ai/llm/providers";
+import { selectCurrentServer } from "app/settings/settingSlice";
+import { selectCurrentToken } from "auth/authSlice";
+
+import { sendOpenAICompletionsRequest } from "../chat/sendOpenAICompletionsRequest";
+import { performFetchRequest } from "../chat/fetchUtils";
+import { updateTokensAction } from "chat/dialog/actions/updateTokensAction";
+import { extractCustomId } from "core/prefix";
+
+export const _executeModel = async (
+  options: {
+    isStreaming: boolean;
+    withAgentContext: boolean;
+    withChatHistory: boolean;
+    agentConfigOverrides?: Record<string, any>;
+  },
+  args: {
+    llmConfig?: Partial<Agent> & Pick<Agent, "provider" | "model">;
+    agentKey?: string;
+    agentConfig?: Partial<Agent> & Pick<Agent, "provider" | "model">;
+    content: any;
+    parentMessageId?: string;
+    billingDialogKey?: string;
+  },
+  thunkApi: any
+) => {
+  const { isStreaming, withAgentContext, withChatHistory, agentConfigOverrides } = options;
+  const { getState, dispatch, rejectWithValue } = thunkApi;
+  const { content } = args;
+  const state = getState() as RootState;
+
+  let agentConfig: Partial<Agent> & Pick<Agent, "provider" | "model">;
+  if (args.llmConfig) {
+    agentConfig = args.llmConfig;
+  } else if (args.agentConfig) {
+    agentConfig = args.agentConfig;
+  } else {
+    const agentKey = args.agentKey || selectCurrentDialogConfig(state)?.cybots?.[0];
+    if (!agentKey) {
+      const msg = "Model execution failed: No llmConfig, agentConfig, or agentKey provided.";
+      console.error(msg);
+      return rejectWithValue(msg);
+    }
+    try {
+      agentConfig = await dispatch(read({ dbKey: agentKey })).unwrap();
+    } catch (error: any) {
+      console.error(`_executeModel failed to load agent [${agentKey}]`, error);
+      return rejectWithValue(error.message);
+    }
+  }
+
+  try {
+    const resolvedConfig = agentConfigOverrides
+      ? { ...agentConfig, ...agentConfigOverrides }
+      : agentConfig;
+    const agentContexts = withAgentContext
+      ? await fetchAgentContexts(resolvedConfig.references, dispatch)
+      : {};
+
+    let messages: Message[];
+    if (withChatHistory) {
+      messages = filterAndCleanMessages(selectAllMsgs(state));
+      messages.push({ role: "user", content: args.content });
+    } else {
+      messages = [{ role: "user", content: args.content }];
+    }
+
+    const bodyData = generateRequestBody({
+      agentConfig: resolvedConfig,
+      messages,
+      userInput: content,
+      contexts: agentContexts,
+    });
+    bodyData.stream = isStreaming;
+
+    if (isStreaming) {
+      await sendOpenAICompletionsRequest({
+        bodyData,
+        agentConfig: resolvedConfig,
+        thunkApi,
+        dialogKey: selectCurrentDialogConfig(state)?.dbKey,
+        parentMessageId: args.parentMessageId,
+      });
+    } else {
+      const response = await performFetchRequest({
+        agentConfig: resolvedConfig,
+        api: getApiEndpoint(resolvedConfig),
+        bodyData,
+        currentServer: selectCurrentServer(state),
+        token: selectCurrentToken(state),
+      });
+      const result = await response.json();
+      if (args.billingDialogKey && result?.usage) {
+        await updateTokensAction(
+          {
+            dialogId: extractCustomId(args.billingDialogKey),
+            dialogKey: args.billingDialogKey,
+            usage: result.usage,
+            agentConfig: resolvedConfig,
+          },
+          thunkApi
+        );
+      }
+      return result.choices[0].message.content;
+    }
+  } catch (error: any) {
+    console.error(`_executeModel failed`, error);
+    return rejectWithValue(error.message);
+  }
+};