nolo-cli 0.1.32 → 0.1.34

package/README.md

@@ -90,7 +90,7 @@ nolo chat
 nolo connect
 nolo connect --watch
 nolo connect --daemon
-nolo daemon --server-url https://api.nolo.chat --api-key sk_machine_xxx
+nolo daemon --server-url https://api.nolo.chat --machine-key sk_machine_xxx
 nolo machine status
 nolo run "summarize my latest agent dialogs"
 nolo doc create --title "Trip Notes" --body "hello" --sync local,us --dry-run
@@ -100,7 +100,6 @@ 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
-nolo agent smoke-bound agent-user-1-agent-1 --msg "ping"
 nolo agent smoke-current agent-user-1-agent-1 --msg "ping"
 nolo chat --agent agent-pub-01APPBUILDER00000001YAII3I --msg "你好"
 ```
@@ -117,7 +116,7 @@ nolo connect          # send one machine heartbeat
 nolo connect --watch  # keep this terminal process online with periodic heartbeats
 nolo connect --ws     # keep a live connector websocket for bound agent runs
 nolo connect --daemon # start connect --ws silently in the background
-nolo daemon --server-url https://api.nolo.chat --api-key sk_machine_xxx
+nolo daemon --server-url https://api.nolo.chat --machine-key sk_machine_xxx
 nolo machine status   # list machines registered to the current profile
 ```
 
@@ -127,13 +126,13 @@ They do not expose shell, file-write, or raw local LLM endpoints.
 Run a Slock-style connector command:
 
 ```bash
-nolo daemon --server-url https://api.nolo.chat --api-key sk_machine_xxx
+nolo daemon --server-url https://api.nolo.chat --machine-key sk_machine_xxx
 ```
 
 Future published package shape:
 
 ```bash
-npx @nolo/daemon@latest --server-url https://api.nolo.chat --api-key sk_machine_xxx
+npx @nolo/daemon@latest --server-url https://api.nolo.chat --machine-key sk_machine_xxx
 ```
 
 The daemon registers this computer, reports local CLI capabilities, keeps a live
@@ -153,7 +152,6 @@ Run a one-command connector smoke test:
 
 ```bash
 nolo agent runtime-doctor <agentKey>
-nolo agent smoke-bound <agentKey> --msg "ping"
 nolo agent smoke-current <agentKey> --msg "ping"
 ```
 
@@ -161,10 +159,6 @@ nolo agent smoke-current <agentKey> --msg "ping"
 machine has the required CLI capability. `smoke-current` heartbeats the current
 machine, binds the agent to it, opens a temporary connector websocket, calls
 `/api/agent/run`, and prints the returned dialog id/content.
-`smoke-bound` does not start a local connector or rebind anything. It validates
-the agent through its existing runtime binding by calling the real
-`/api/agent/run` path, so it is the safer probe for shared-Space member runs
-that should execute through another owner's online connector.
 
 ## Product Shape
 

package/agent-runtime/agentRecordConfig.ts

@@ -64,6 +64,10 @@ export function resolveAgentRuntimeConfigFromRecord(
   const apiSource = stringField(record, "apiSource");
   const cliProvider = stringField(record, "cliProvider");
   const customProviderUrl = stringField(record, "customProviderUrl");
+  const apiKey = stringField(record, "apiKey");
+  const apiKeyHeader = stringField(record, "apiKeyHeader");
+  const apiKeyFromAgentKey = stringField(record, "apiKeyFromAgentKey");
+  const useServerProxy = record.useServerProxy === true;
   const provider = stringField(record, "provider") ?? stringField(record, "apiSource");
   const toolNames = resolveAgentRuntimeToolNames(record);
   const temperature = numberField(record, "temperature");
@@ -77,6 +81,7 @@ export function resolveAgentRuntimeConfigFromRecord(
     objectField(record, "runtimeToolPolicy") ??
     objectField(runtimeBinding ?? {}, "runtimeToolPolicy");
   const localWorkspaceMode = localWorkspaceModeField(record);
+  const delegation = objectField(record, "delegation");
   return {
     key,
     ...(name ? { name } : {}),
@@ -86,6 +91,10 @@ export function resolveAgentRuntimeConfigFromRecord(
     ...(apiSource ? { apiSource } : {}),
     ...(cliProvider ? { cliProvider } : {}),
     ...(customProviderUrl ? { customProviderUrl } : {}),
+    ...(apiKey ? { apiKey } : {}),
+    ...(apiKeyHeader ? { apiKeyHeader } : {}),
+    ...(apiKeyFromAgentKey ? { apiKeyFromAgentKey } : {}),
+    ...(useServerProxy ? { useServerProxy } : {}),
     ...(toolNames ? { toolNames } : {}),
     ...(temperature !== undefined ? { temperature } : {}),
     ...(topP !== undefined ? { top_p: topP } : {}),
@@ -96,6 +105,7 @@ export function resolveAgentRuntimeConfigFromRecord(
     ...(runtimeBinding ? { runtimeBinding } : {}),
     ...(runtimeToolPolicy ? { runtimeToolPolicy } : {}),
     ...(localWorkspaceMode ? { localWorkspaceMode } : {}),
+    ...(delegation ? { delegation } : {}),
     rawRecord: record,
   };
 }

package/agent-runtime/hostAdapter.ts

@@ -14,6 +14,10 @@ export type AgentRuntimeAgentConfig = {
   apiSource?: string;
   cliProvider?: string;
   customProviderUrl?: string;
+  apiKey?: string;
+  apiKeyHeader?: string;
+  apiKeyFromAgentKey?: string;
+  useServerProxy?: boolean;
   toolNames?: string[];
   temperature?: number;
   top_p?: number;
@@ -24,18 +28,23 @@ export type AgentRuntimeAgentConfig = {
   runtimeBinding?: Record<string, unknown>;
   runtimeToolPolicy?: AgentRuntimeToolPolicy;
   localWorkspaceMode?: "current" | "task-worktree";
+  delegation?: Record<string, unknown>;
   rawRecord?: Record<string, unknown>;
 };
 
 export type AgentRuntimeProvider = {
   model: string;
-  complete(messages: AgentRuntimeChatMessage[]): Promise<AgentRuntimeResult>;
+  complete(
+    messages: AgentRuntimeChatMessage[],
+    options?: { timeoutMs?: number }
+  ): Promise<AgentRuntimeResult>;
 };
 
 export type AgentRuntimeToolCallInput = {
   id: string;
   name: string;
   arguments: string;
+  userInput?: string;
 };
 
 export type AgentRuntimeToolResult = {

package/agent-runtime/index.ts

@@ -10,6 +10,11 @@ export {
   parseOpenAiCompatibleChatCompletionResponse,
 } from "./openAiCompatibleProvider";
 export { resolveOpenAiCompatibleProviderConfig } from "./openAiCompatibleProviderConfig";
+export {
+  buildProviderAuthHeaders,
+  buildProviderExecutionPlan,
+  resolveAgentProviderMode,
+} from "./providerResolution";
 export {
   buildPlatformChatCompletionRequest,
   canUsePlatformChatProvider,
@@ -27,11 +32,6 @@ export {
 } from "./agentRecordKeys";
 export { resolveAgentRuntimeConfigFromRecord } from "./agentRecordConfig";
 export { dialogMessageRecordToAgentRuntimeMessage } from "./dialogMessageRecord";
-export {
-  renderDialogStatus,
-  resolveDialogActiveHealth,
-  resolveDialogTerminalState,
-} from "./dialogStatus";
 export { buildAgentRuntimeDialogWritePlan } from "./dialogWritePlan";
 export {
   createHybridRecordStore,
@@ -46,16 +46,14 @@ export {
   formatPreparedGitTaskWorkspace,
   prepareGitTaskWorkspace,
 } from "./taskWorkspace";
-export {
-  createHostRuntimeConfig,
-  createHostRuntimeCapabilities,
-  resolveHostRuntimeConfigFromEnv,
-  resolveHostRuntimeCapabilitiesFromEnv,
-} from "./hostRuntimeConfig";
 export {
   executeLocalToolWithPolicy,
   resolveLocalToolPolicy,
 } from "./localToolPolicy";
+export {
+  evaluateShellCommandPolicy,
+  isDestructiveShellCommand,
+} from "./shellCommandPolicy";
 export {
   mergeAgentRuntimeToolPolicies,
   normalizeAgentRuntimeToolPolicy,
@@ -93,12 +91,6 @@ export type {
 export type {
   PreparedGitTaskWorkspace,
 } from "./taskWorkspace";
-export type {
-  HostRuntimeConfig,
-  HostRuntimeCapabilities,
-  HostRuntimeSurface,
-  HostRuntimeWorkspaceBinding,
-} from "./hostRuntimeConfig";
 export type {
   LocalToolPolicyDecision,
 } from "./localToolPolicy";
@@ -108,9 +100,6 @@ export type {
 export type {
   PlatformChatProviderConfig,
 } from "./platformChatProvider";
-export type {
-  DialogStatusSnapshot,
-} from "./dialogStatus";
 export type {
   AgentRuntimeChatMessage,
   AgentRuntimeDecision,

package/agent-runtime/localLoop.ts

@@ -13,6 +13,7 @@ export type LocalAgentTurnInput = {
   input: AgentRuntimeMessageContent;
   continueDialogId?: string;
   maxToolRounds?: number;
+  timeoutMs?: number;
   onToolEvent?: (event: LocalAgentToolEvent) => void;
 };
 
@@ -40,6 +41,29 @@ function formatToolExecutionError(args: {
   return `${args.toolName} failed: ${message}`;
 }
 
+function formatStructuredToolExecutionError(args: {
+  toolName: string;
+  error: unknown;
+}) {
+  if (!args.error || typeof args.error !== "object") return null;
+  const error = args.error as {
+    code?: unknown;
+    message?: unknown;
+    policy?: unknown;
+  };
+  if (typeof error.code !== "string") return null;
+  return JSON.stringify({
+    error: error.code,
+    message:
+      typeof error.message === "string"
+        ? error.message
+        : formatToolExecutionError(args),
+    ...(error.policy && typeof error.policy === "object"
+      ? { policy: error.policy }
+      : {}),
+  });
+}
+
 function shouldReturnToolExecutionErrors(adapter: AgentRuntimeHostAdapter) {
   return adapter.capabilities.includes("local-tools");
 }
@@ -66,6 +90,16 @@ function buildMessages(args: {
   ];
 }
 
+function extractUserInputText(content: AgentRuntimeMessageContent): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((part) => (part?.type === "text" ? part.text : ""))
+    .filter(Boolean)
+    .join("\n")
+    .trim();
+}
+
 export async function runLocalAgentTurn(
   input: LocalAgentTurnInput
 ): Promise<LocalAgentTurnResult> {
@@ -92,10 +126,13 @@ export async function runLocalAgentTurn(
   });
   const provider = await input.adapter.resolveProvider(agentConfig);
   const maxToolRounds = input.maxToolRounds ?? DEFAULT_LOCAL_AGENT_MAX_TOOL_ROUNDS;
+  const userInputText = extractUserInputText(input.input);
   let toolCallCount = 0;
   let result: AgentRuntimeResult;
   for (let round = 0; round <= maxToolRounds; round += 1) {
-    result = await provider.complete(messages);
+    result = await provider.complete(messages, {
+      ...(typeof input.timeoutMs === "number" ? { timeoutMs: input.timeoutMs } : {}),
+    });
     const toolCalls = result.tool_calls ?? [];
     if (toolCalls.length === 0) break;
     if (round === maxToolRounds) {
@@ -122,6 +159,7 @@ export async function runLocalAgentTurn(
           id: toolCall.id,
           name: toolName,
           arguments: toolCall.function.arguments,
+          ...(userInputText ? { userInput: userInputText } : {}),
         });
         emitToolEvent(input, {
           type: "tool-result",
@@ -140,11 +178,20 @@ export async function runLocalAgentTurn(
           message: error instanceof Error ? error.message : String(error),
         });
         toolResult = {
-          content: formatToolExecutionError({ toolName, error }),
+          content:
+            formatStructuredToolExecutionError({ toolName, error }) ??
+            formatToolExecutionError({ toolName, error }),
           metadata: {
             error: true,
             toolName,
             message: error instanceof Error ? error.message : String(error),
+            ...(
+              error &&
+              typeof error === "object" &&
+              typeof (error as { code?: unknown }).code === "string"
+                ? { code: (error as { code: string }).code }
+                : {}
+            ),
           },
         };
       }

package/agent-runtime/localToolPolicy.ts

@@ -2,7 +2,8 @@ import type {
   AgentRuntimeToolCallInput,
   AgentRuntimeToolResult,
 } from "./types";
-import type { HostRuntimeConfig } from "./hostRuntimeConfig";
+import { canonicalizeToolName } from "../ai/tools/toolNameAliases";
+import { evaluateShellCommandPolicy } from "./shellCommandPolicy";
 
 type EnvLike = Record<string, string | undefined>;
 
@@ -49,6 +50,26 @@ function parseToolAllowlist(value: string | undefined) {
     .filter(Boolean);
 }
 
+function normalizeLocalToolName(toolName: string) {
+  return canonicalizeToolName(
+    String(toolName ?? "").replace(/^functions\./, "").trim(),
+  );
+}
+
+function parseShellCommandPayload(rawArguments: string) {
+  try {
+    const parsed = JSON.parse(rawArguments || "{}");
+    if (!parsed || typeof parsed !== "object") return {};
+    return parsed as { command?: unknown; cmd?: unknown; input?: unknown };
+  } catch {
+    return {};
+  }
+}
+
+function isLocalShellModeEnabled(env: EnvLike) {
+  return ["worktree", "dangerous", "1", "true"].includes(env.NOLO_LOCAL_SHELL_MODE || "");
+}
+
 function isRestrictedLocalToolMode(env: EnvLike) {
   return env.NOLO_LOCAL_TOOL_MODE === "restricted";
 }
@@ -66,84 +87,105 @@ function isToolDeclaredOrExplicitlyFree(args: {
 
 export function resolveLocalToolPolicy(args: {
   env: EnvLike;
-  hostRuntimeConfig?: HostRuntimeConfig;
   agentToolNames?: string[];
   toolName: string;
 }): LocalToolPolicyDecision {
+  const toolName = normalizeLocalToolName(args.toolName);
   const restrictedMode = isRestrictedLocalToolMode(args.env);
-  if (args.toolName === "execShell") {
-    if (!(args.agentToolNames ?? []).includes("execShell")) {
-      return {
-        allowed: false,
-        toolName: args.toolName,
-        reason: "execShell is not requested by this agent runtime.",
-      };
-    }
-    if (args.hostRuntimeConfig?.capabilities.allowShell === true) {
-      return { allowed: true, toolName: args.toolName };
+  if (!toolName) {
+    return {
+      allowed: false,
+      toolName,
+      reason: "Tool name is required.",
+    };
+  }
+
+  if (toolName === "execShell") {
+    if (isLocalShellModeEnabled(args.env)) {
+      return { allowed: true, toolName };
     }
     return {
       allowed: false,
-      toolName: args.toolName,
-      reason: "execShell requires host shell capability.",
+      toolName,
+      reason: "execShell requires NOLO_LOCAL_SHELL_MODE=worktree.",
     };
   }
 
-  if (NEVER_LOCAL_TOOLS.has(args.toolName)) {
+  if (NEVER_LOCAL_TOOLS.has(toolName)) {
     return {
       allowed: false,
-      toolName: args.toolName,
-      reason: `${args.toolName} is blocked by the local runtime safety policy.`,
+      toolName,
+      reason: `${toolName} is blocked by the local runtime safety policy.`,
     };
   }
 
-  if (REMOVED_LOCAL_TOOLS.has(args.toolName)) {
+  if (REMOVED_LOCAL_TOOLS.has(toolName)) {
     return {
       allowed: false,
-      toolName: args.toolName,
-      reason: `${args.toolName} has been removed from the local runtime tool surface. Use execShell in shell-enabled workspace runs when shell is needed.`,
+      toolName,
+      reason: `${toolName} has been removed from the local runtime tool surface. Use execShell in shell-enabled workspace runs when shell is needed.`,
     };
   }
 
   const allowedByEnv = new Set(parseToolAllowlist(args.env.NOLO_LOCAL_ALLOWED_TOOLS));
-  const agentTools = new Set(args.agentToolNames ?? []);
-  if (!restrictedMode && agentTools.has(args.toolName)) {
-    return { allowed: true, toolName: args.toolName };
+  const agentTools = new Set(
+    (args.agentToolNames ?? []).map(normalizeLocalToolName).filter(Boolean),
+  );
+  if (!restrictedMode && agentTools.has(toolName)) {
+    return { allowed: true, toolName };
   }
-  if (DEFAULT_LOCAL_TOOLS.has(args.toolName) && agentTools.has(args.toolName)) {
-    return { allowed: true, toolName: args.toolName };
+  if (DEFAULT_LOCAL_TOOLS.has(toolName) && agentTools.has(toolName)) {
+    return { allowed: true, toolName };
   }
-  if (allowedByEnv.has(args.toolName) && agentTools.has(args.toolName)) {
-    return { allowed: true, toolName: args.toolName };
+  if (allowedByEnv.has(toolName) && agentTools.has(toolName)) {
+    return { allowed: true, toolName };
   }
 
   return {
     allowed: false,
-    toolName: args.toolName,
+    toolName,
     reason:
-      `${args.toolName} is not enabled for local runtime runs. ` +
+      `${toolName} is not enabled for local runtime runs. ` +
       "Set NOLO_LOCAL_ALLOWED_TOOLS and make sure the agent declares the tool before using it locally.",
   };
 }
 
 export async function executeLocalToolWithPolicy(args: {
   env: EnvLike;
-  hostRuntimeConfig?: HostRuntimeConfig;
   agentToolNames?: string[];
   call: AgentRuntimeToolCallInput;
   executors?: Record<string, (call: AgentRuntimeToolCallInput) => Promise<AgentRuntimeToolResult>>;
 }): Promise<AgentRuntimeToolResult> {
   const decision = resolveLocalToolPolicy({
     env: args.env,
-    hostRuntimeConfig: args.hostRuntimeConfig,
     agentToolNames: args.agentToolNames,
     toolName: args.call.name,
   });
   if (!decision.allowed) throw new Error(decision.reason);
 
-  const executor = args.executors?.[args.call.name];
+  const executor = args.executors?.[decision.toolName];
   if (!executor) {
-    throw new Error(`${args.call.name} is allowed by policy but no local executor is registered.`);
+    throw new Error(`${decision.toolName} is allowed by policy but no local executor is registered.`);
   }
-  return executor(args.call);
+  if (decision.toolName === "execShell") {
+    const parsed = parseShellCommandPayload(args.call.arguments);
+    const shellPolicy = evaluateShellCommandPolicy({
+      command: parsed.command ?? parsed.cmd,
+      input: parsed.input,
+      userInput: args.call.userInput,
+    });
+    if (shellPolicy.verdict === "forbidden") {
+      const error = new Error(shellPolicy.reason) as Error & {
+        code?: string;
+        policy?: Record<string, unknown>;
+      };
+      error.code = shellPolicy.code;
+      error.policy = shellPolicy.policy;
+      throw error;
+    }
+  }
+  return executor({
+    ...args.call,
+    name: decision.toolName,
+  });
 }