nolo-cli 0.1.19 → 0.1.20

package/client/localRuntimeAdapter.ts

@@ -3,27 +3,65 @@ import type {
   AgentRuntimeHostAdapter,
   AgentRuntimeSaveTurnInput,
 } from "../agentRuntimeLocal";
-import type { AgentRuntimeChatMessage } from "../../agent-runtime";
+import {
+  buildLocalWorkspacePolicyToolNames,
+  buildLocalWorkspaceToolset,
+  buildLocalWorkspaceOpenAiTools,
+  buildOpenAiCompatibleChatCompletionRequest,
+  buildPlatformChatCompletionRequest,
+  createLocalWorkspaceToolExecutors,
+  parseOpenAiCompatibleChatCompletionResponse,
+  parsePlatformChatCompletionData,
+  parsePlatformChatCompletionResponse,
+  resolvePlatformChatProviderConfig,
+  shouldUsePlatformChatProvider,
+} from "../agentRuntimeLocal";
+import type { AgentRuntimeChatMessage } from "../agent-runtime";
 import { getDefaultCliLocalRuntimeDb } from "../localRuntimeDb";
+import { resolveAgentRuntimeConfigFromRecord } from "./agentConfigResolver";
+import { resolveCliOpenAiProviderConfig } from "./localProviderResolver";
+import {
+  buildLocalDialogWritePlan,
+  localDialogMessageRecordToRuntimeMessage,
+} from "./localDialogRecords";
+import {
+  buildLocalAgentLookupKeys,
+  shouldReadAgentKeyRemotely,
+} from "./localAgentRecords";
+import {
+  createCliHybridRecordStore,
+  type CliKvDb,
+  type HybridRecordStore,
+} from "./hybridRecordStore";
 import { executeLocalToolWithPolicy } from "./localToolPolicy";
+import { prepareTaskWorktree } from "./taskWorktree";
+import {
+  activateWorkspaceSession,
+  createWorkspaceSession,
+  formatWorkspaceSessionActivation,
+  type WorkspaceSession,
+} from "./workspaceSession";
 
 type EnvLike = Record<string, string | undefined>;
+type FetchInput = Parameters<typeof fetch>[0];
+type FetchInit = Parameters<typeof fetch>[1];
+const TRANSIENT_FETCH_MAX_ATTEMPTS = 8;
+const TRANSIENT_FETCH_RETRY_BASE_DELAY_MS = 250;
 
-export type CliLocalRuntimeDb = {
-  get(key: string): Promise<any>;
-  put(key: string, value: any): Promise<unknown>;
-  batch(ops: Array<{ type: "put"; key: string; value: any }>): Promise<unknown>;
-  iterator(options: { gte: string; lte?: string; lt?: string; reverse?: boolean; limit?: number }): AsyncIterable<[string, any]>;
-};
+export type CliLocalRuntimeDb = CliKvDb;
 
 export type CliLocalRuntimeAdapterDeps = {
   env: EnvLike;
   db?: CliLocalRuntimeDb;
+  store?: HybridRecordStore;
   now?: () => number;
   createId?: () => string;
   fetchImpl?: typeof fetch;
   cwd?: string;
+  output?: { write(chunk: string): unknown };
+  prepareTaskWorktree?: typeof prepareTaskWorktree;
   localToolExecutors?: Record<string, (call: any) => Promise<{ content: string; metadata?: Record<string, unknown> }>>;
+  sleep?: (ms: number) => Promise<void>;
 };
 
 async function defaultLocalRuntimeDb(): Promise<CliLocalRuntimeDb> {
@@ -34,252 +72,176 @@ function createFallbackId() {
   return `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`.toUpperCase();
 }
 
-function resolveOpenAiCompatibleBaseUrl(env: EnvLike) {
-  return (env.NOLO_LOCAL_OPENAI_BASE_URL || env.OPENAI_BASE_URL || "https://api.openai.com/v1")
-    .replace(/\/+$/, "");
+function resolveLocalUserId(env: EnvLike) {
+  return env.NOLO_LOCAL_USER_ID || env.NOLO_USER_ID || "local";
 }
 
-function resolveApiKey(env: EnvLike) {
-  return env.OPENAI_API_KEY || env.NOLO_LOCAL_OPENAI_API_KEY || "";
+function shellModeEnabled(env: EnvLike) {
+  return ["worktree", "dangerous", "1", "true"].includes(env.NOLO_LOCAL_SHELL_MODE || "");
 }
 
-function resolveLocalUserId(env: EnvLike) {
-  return env.NOLO_LOCAL_USER_ID || env.NOLO_USER_ID || "local";
+function parseLocalToolBudgets(env: EnvLike) {
+  const raw = env.NOLO_LOCAL_TOOL_BUDGETS?.trim();
+  if (!raw) return {};
+  const budgets: Record<string, number> = {};
+  for (const part of raw.split(",")) {
+    const [name, value] = part.split("=").map((item) => item.trim());
+    const limit = Number(value);
+    if (name && Number.isFinite(limit) && limit >= 0) budgets[name] = Math.floor(limit);
+  }
+  return budgets;
 }
 
-function buildExecShellTool() {
-  return {
-    type: "function",
-    function: {
-      name: "execShell",
-      description: "Run a shell command in the current isolated local workspace.",
-      parameters: {
-        type: "object",
-        properties: {
-          cmd: {
-            type: "string",
-            description: "Shell command to run.",
-          },
-        },
-        required: ["cmd"],
-      },
-    },
-  };
+function assertWithinLocalToolBudget(args: {
+  toolName: string;
+  budgets: Record<string, number>;
+  usage: Map<string, number>;
+}) {
+  const limit = args.budgets[args.toolName];
+  if (typeof limit !== "number") return;
+  const nextCount = (args.usage.get(args.toolName) ?? 0) + 1;
+  args.usage.set(args.toolName, nextCount);
+  if (nextCount <= limit) return;
+  throw new Error(
+    `${args.toolName} exceeded local tool budget ${limit}. Stop broad discovery; edit the narrowest likely file or report a blocker.`
+  );
 }
 
-function shellModeEnabled(env: EnvLike) {
-  return ["worktree", "dangerous", "1", "true"].includes(env.NOLO_LOCAL_SHELL_MODE || "");
+function isTransientFetchError(error: unknown) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /certificate|handshake|network|socket|timed out|timeout|ECONNRESET/i.test(message);
 }
 
-function buildOpenAiTools(args: { toolNames?: string[]; env: EnvLike }) {
-  return args.toolNames?.includes("execShell") || shellModeEnabled(args.env)
-    ? [buildExecShellTool()]
-    : [];
+async function defaultSleep(ms: number) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function transientFetchRetryDelayMs(attempt: number) {
+  return Math.min(attempt * TRANSIENT_FETCH_RETRY_BASE_DELAY_MS, 2_000);
 }
 
-function parseToolArguments(raw: string) {
-  try {
-    const parsed = JSON.parse(raw || "{}");
-    return parsed && typeof parsed === "object" ? parsed : {};
-  } catch {
-    return {};
+async function fetchWithTransientRetry(
+  fetchImpl: typeof fetch,
+  input: FetchInput,
+  init?: FetchInit,
+  options: { sleep?: (ms: number) => Promise<void> } = {}
+) {
+  let lastError: unknown;
+  for (let attempt = 1; attempt <= TRANSIENT_FETCH_MAX_ATTEMPTS; attempt += 1) {
+    try {
+      return await fetchImpl(input, init);
+    } catch (error) {
+      if (!isTransientFetchError(error)) throw error;
+      lastError = error;
+      if (attempt < TRANSIENT_FETCH_MAX_ATTEMPTS) {
+        await (options.sleep ?? defaultSleep)(transientFetchRetryDelayMs(attempt));
+      }
+    }
   }
+  throw lastError;
 }
 
-async function executeShellCommand(args: {
-  call: any;
-  cwd: string;
-}) {
-  const parsed = parseToolArguments(String(args.call.arguments ?? ""));
-  const cmd = String(parsed.cmd ?? parsed.command ?? "").trim();
-  if (!cmd) throw new Error("execShell requires a non-empty cmd argument.");
-  const proc = Bun.spawn(["/bin/sh", "-lc", cmd], {
-    cwd: args.cwd,
-    stdout: "pipe",
-    stderr: "pipe",
-    stdin: "ignore",
+function buildOpenAiTools(args: { toolNames?: string[]; env: EnvLike }) {
+  const toolset = buildLocalWorkspaceToolsetForEnv(args);
+  return buildLocalWorkspaceOpenAiTools({
+    toolNames: toolset.toolNames,
+    exposeShellTools: toolset.exposeShellTools,
   });
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited,
-  ]);
-  return {
-    content: [
-      stdout.trim() ? `stdout:\n${stdout.trim()}` : "",
-      stderr.trim() ? `stderr:\n${stderr.trim()}` : "",
-      `exitCode: ${exitCode}`,
-    ].filter(Boolean).join("\n\n"),
-    metadata: { exitCode },
-  };
 }
 
-function buildLocalToolExecutors(deps: CliLocalRuntimeAdapterDeps) {
+function buildLocalWorkspaceToolsetForEnv(args: { toolNames?: string[]; env: EnvLike }) {
+  const toolset = buildLocalWorkspaceToolset({
+    declaredToolNames: args.toolNames,
+    exposeShellTools: shellModeEnabled(args.env),
+  });
+  return toolset;
+}
+
+function buildLocalPolicyToolNames(args: { toolNames?: string[]; env: EnvLike }) {
+  return buildLocalWorkspacePolicyToolNames({
+    declaredToolNames: args.toolNames,
+    exposeShellTools: shellModeEnabled(args.env),
+  });
+}
+
+function buildLocalToolExecutors(args: {
+  workspaceRoot: string;
+  localToolExecutors?: CliLocalRuntimeAdapterDeps["localToolExecutors"];
+}) {
   return {
-    execShell: (call: any) => executeShellCommand({
-      call,
-      cwd: deps.cwd ?? process.cwd(),
-    }),
-    ...(deps.localToolExecutors ?? {}),
+    ...createLocalWorkspaceToolExecutors({ workspaceRoot: args.workspaceRoot }),
+    ...(args.localToolExecutors ?? {}),
   };
 }
 
-async function resolveDb(deps: CliLocalRuntimeAdapterDeps) {
-  return deps.db ?? defaultLocalRuntimeDb();
+function readLocalWorkspaceMode(agentConfig: AgentRuntimeAgentConfig | null) {
+  if (agentConfig?.localWorkspaceMode === "task-worktree") return "task-worktree";
+  const runtimeBinding = agentConfig?.runtimeBinding;
+  const value = runtimeBinding?.localWorkspaceMode ?? runtimeBinding?.workspaceMode;
+  return value === "task-worktree" ? "task-worktree" : "current";
 }
 
-async function readAgentFromDb(args: {
-  db: CliLocalRuntimeDb;
+async function resolveStore(deps: CliLocalRuntimeAdapterDeps) {
+  if (deps.store) return deps.store;
+  return createCliHybridRecordStore({
+    db: deps.db ?? await defaultLocalRuntimeDb(),
+    env: deps.env,
+    fetchImpl: deps.fetchImpl,
+  });
+}
+
+async function readAgentFromStore(args: {
+  store: HybridRecordStore;
   agentRef: string;
   userId: string;
 }): Promise<AgentRuntimeAgentConfig | null> {
-  const candidates = [
-    args.agentRef,
-    `agent-${args.userId}-${args.agentRef}`,
-    `cybot-${args.userId}-${args.agentRef}`,
-  ];
-  for (const key of candidates) {
-    try {
-      const record = await args.db.get(key);
-      if (!record || typeof record !== "object") continue;
-      return {
-        key,
-        ...(typeof record.name === "string" ? { name: record.name } : {}),
-        ...(typeof record.prompt === "string" ? { prompt: record.prompt } : {}),
-        ...(typeof record.model === "string" ? { model: record.model } : {}),
-        ...(typeof record.provider === "string" ? { provider: record.provider } : {}),
-        ...(Array.isArray(record.toolNames) ? { toolNames: record.toolNames } : {}),
-      };
-    } catch {
-      // Try the next local LevelDB key convention.
-    }
+  for (const key of buildLocalAgentLookupKeys(args)) {
+    const record = await args.store.read(key, {
+      remote: shouldReadAgentKeyRemotely(key),
+    });
+    if (!record || typeof record !== "object") continue;
+    return resolveAgentRuntimeConfigFromRecord(key, record);
   }
   return null;
 }
 
-function toOpenAiMessages(messages: AgentRuntimeChatMessage[]) {
-  return messages.map((message) => ({
-    role: message.role,
-    content: message.content ?? "",
-    ...(message.tool_call_id ? { tool_call_id: message.tool_call_id } : {}),
-    ...(Array.isArray(message.tool_calls) ? { tool_calls: message.tool_calls } : {}),
-  }));
-}
-
 async function readDialogMessages(args: {
-  db: CliLocalRuntimeDb;
+  store: HybridRecordStore;
   dialogId: string;
 }) {
   const messages: AgentRuntimeChatMessage[] = [];
   const prefix = `dialog-${args.dialogId}-msg-`;
-  const iterator = args.db.iterator({ gte: prefix, lte: `${prefix}\uffff` });
+  const iterator = args.store.iterator({ gte: prefix, lte: `${prefix}\uffff` });
   for await (const [, value] of iterator) {
-    if (!value || typeof value !== "object") continue;
-    if (value.role === "system") continue;
-    if (value.role === "user" || value.role === "assistant" || value.role === "tool") {
-      messages.push({
-        role: value.role,
-        content: value.content ?? null,
-        ...(typeof value.toolCallId === "string" ? { tool_call_id: value.toolCallId } : {}),
-        ...(Array.isArray(value.tool_calls) ? { tool_calls: value.tool_calls } : {}),
-      });
-    }
+    const message = localDialogMessageRecordToRuntimeMessage(value);
+    if (message) messages.push(message);
   }
   return messages;
 }
 
 async function writeDialog(args: {
-  db: CliLocalRuntimeDb;
+  store: HybridRecordStore;
   input: AgentRuntimeSaveTurnInput;
   userId: string;
   now: () => number;
   createId: () => string;
   cwd?: string;
 }) {
-  const dialogId = args.input.continueDialogId || args.createId();
-  const now = args.now();
-  const nowIso = new Date(now).toISOString();
-  const dialogKey = `dialog-${args.userId}-${dialogId}`;
-  const lastUser = [...args.input.messages].reverse().find((message) => message.role === "user");
-  const lastUserText = typeof lastUser?.content === "string"
-    ? lastUser.content
-    : Array.isArray(lastUser?.content)
-      ? lastUser.content
-          .filter((part) => part.type === "text")
-          .map((part) => part.text)
-          .join(" ")
-      : "";
   let existingDialog: any = null;
   if (args.input.continueDialogId) {
-    try {
-      existingDialog = await args.db.get(dialogKey);
-    } catch {
-      existingDialog = null;
-    }
+    const dialogKey = `dialog-${args.userId}-${args.input.continueDialogId}`;
+    existingDialog = await args.store.read(dialogKey);
   }
-  const messageOps = args.input.messages
-    .filter((message) => message.role !== "system")
-    .map((message, index) => {
-      const id = `${now}-${String(index + 1).padStart(3, "0")}`;
-      const key = `dialog-${dialogId}-msg-${id}`;
-      return {
-        type: "put" as const,
-        key,
-        value: {
-          id,
-          dbKey: key,
-          dialogId,
-          role: message.role,
-          content: message.content ?? "",
-          ...(message.role === "user" ? { userId: args.userId } : {}),
-          ...(message.role === "assistant" ? {
-            agentKey: args.input.agentKey,
-            cybotKey: args.input.agentKey,
-          } : {}),
-          ...(message.tool_call_id ? { toolCallId: message.tool_call_id } : {}),
-          ...(Array.isArray(message.tool_calls) ? { tool_calls: message.tool_calls } : {}),
-          ...(message.tool_result_metadata ? { metadata: message.tool_result_metadata } : {}),
-          createdAt: nowIso,
-        },
-      };
-    });
-  const ops: Array<{ type: "put"; key: string; value: any }> = [
-    {
-      type: "put",
-      key: dialogKey,
-      value: {
-        ...(existingDialog && typeof existingDialog === "object" ? existingDialog : {}),
-        id: dialogId,
-        dbKey: dialogKey,
-        type: "dialog",
-        userId: args.userId,
-        cybots: [args.input.agentKey],
-        primaryAgentKey: args.input.agentKey,
-        title: typeof existingDialog?.title === "string" && existingDialog.title.trim()
-          ? existingDialog.title
-          : lastUserText.trim()
-            ? lastUserText.trim().slice(0, 80)
-            : "Local agent run",
-        status: "done",
-        triggerType: "cli-local",
-        executionMode: "foreground",
-        createdAt: existingDialog?.createdAt ?? nowIso,
-        updatedAt: nowIso,
-        finishedAt: now,
-        usage: args.input.result.usage,
-        ...(typeof args.input.result.toolCallCount === "number"
-          ? { toolCallCount: args.input.result.toolCallCount }
-          : {}),
-        localRuntime: {
-          host: "cli",
-          ...(args.cwd ? { worktreePath: args.cwd } : {}),
-        },
-      },
-    },
-    ...messageOps,
-  ];
-  await args.db.batch(ops);
-  return { dialogId };
+  const plan = buildLocalDialogWritePlan({
+    input: args.input,
+    userId: args.userId,
+    now: args.now(),
+    createId: args.createId,
+    existingDialog,
+    cwd: args.cwd,
+  });
+  await args.store.batch(plan.ops);
+  return { dialogId: plan.dialogId };
 }
 
 export function createCliLocalRuntimeAdapter(
@@ -289,76 +251,139 @@ export function createCliLocalRuntimeAdapter(
   const createId = deps.createId ?? createFallbackId;
   const fetchImpl = deps.fetchImpl ?? fetch;
   const userId = resolveLocalUserId(deps.env);
+  const localToolBudgets = parseLocalToolBudgets(deps.env);
+  const localToolUsage = new Map<string, number>();
   let activeAgentToolNames: string[] = [];
-  const localToolExecutors = buildLocalToolExecutors(deps);
+  let workspaceSession: WorkspaceSession = createWorkspaceSession({ cwd: deps.cwd });
+  let localToolExecutors = buildLocalToolExecutors({
+    workspaceRoot: workspaceSession.workspaceRoot,
+    localToolExecutors: deps.localToolExecutors,
+  });
+
+  async function activateAgentWorkspaceSession(args: {
+    agentRef: string;
+    agentConfig: AgentRuntimeAgentConfig | null;
+  }) {
+    const previousWorkspaceRoot = workspaceSession.workspaceRoot;
+    workspaceSession = await activateWorkspaceSession(workspaceSession, {
+      agentKey: args.agentConfig?.key ?? args.agentRef,
+      mode: readLocalWorkspaceMode(args.agentConfig),
+      env: deps.env,
+      prepareTaskWorkspace: deps.prepareTaskWorktree,
+    });
+    if (workspaceSession.workspaceRoot === previousWorkspaceRoot) return;
+    localToolExecutors = buildLocalToolExecutors({
+      workspaceRoot: workspaceSession.workspaceRoot,
+      localToolExecutors: deps.localToolExecutors,
+    });
+    deps.output?.write(formatWorkspaceSessionActivation(workspaceSession));
+  }
 
   return {
     host: "cli",
-    capabilities: ["leveldb-agent-config", "local-provider", "leveldb-persistence"],
+    capabilities: ["leveldb-agent-config", "local-provider", "leveldb-persistence", "local-tools"],
     loadAgentConfig: async (agentRef) => {
-      const agentConfig = await readAgentFromDb({
+      const agentConfig = await readAgentFromStore({
         agentRef,
-        db: await resolveDb(deps),
+        store: await resolveStore(deps),
         userId,
       });
-      activeAgentToolNames = agentConfig?.toolNames ?? [];
+      activeAgentToolNames = buildLocalPolicyToolNames({
+        toolNames: agentConfig?.toolNames,
+        env: deps.env,
+      });
+      await activateAgentWorkspaceSession({ agentRef, agentConfig });
       return agentConfig;
     },
     loadDialogHistory: async (dialogId) => readDialogMessages({
       dialogId,
-      db: await resolveDb(deps),
+      store: await resolveStore(deps),
     }),
     saveTurn: async (input) => writeDialog({
-      db: await resolveDb(deps),
+      store: await resolveStore(deps),
       input,
       userId,
       now,
       createId,
-      cwd: deps.cwd,
+      cwd: workspaceSession.workspaceRoot,
     }),
-    resolveProvider: async (agentConfig) => ({
-      model: agentConfig.model || "gpt-4.1-mini",
-      complete: async (messages) => {
-        const tools = buildOpenAiTools({
-          toolNames: agentConfig.toolNames,
+    resolveProvider: async (agentConfig) => {
+      if (shouldUsePlatformChatProvider(deps.env, agentConfig)) {
+        const providerConfig = resolvePlatformChatProviderConfig({
+          agentConfig,
           env: deps.env,
         });
-        const res = await fetchImpl(`${resolveOpenAiCompatibleBaseUrl(deps.env)}/chat/completions`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            ...(resolveApiKey(deps.env)
-              ? { Authorization: `Bearer ${resolveApiKey(deps.env)}` }
-              : {}),
-          },
-          body: JSON.stringify({
-            model: agentConfig.model || "gpt-4.1-mini",
-            messages: toOpenAiMessages(messages),
-            stream: false,
-            ...(tools.length > 0 ? { tools } : {}),
-          }),
-        });
-        const data = await res.json().catch(() => ({}));
-        if (!res.ok) {
-          throw new Error(`local provider failed: HTTP ${res.status} ${JSON.stringify(data)}`);
-        }
-        const choiceMessage = data?.choices?.[0]?.message ?? {};
-        const content = String(choiceMessage?.content ?? "");
         return {
-          content,
-          model: agentConfig.model || "gpt-4.1-mini",
-          provider: agentConfig.provider || "openai-compatible",
-          ...(Array.isArray(choiceMessage?.tool_calls) ? { tool_calls: choiceMessage.tool_calls } : {}),
-          usage: data?.usage,
-          trace: messages,
+          model: providerConfig.model,
+          complete: async (messages) => {
+            const tools = buildOpenAiTools({
+              toolNames: agentConfig.toolNames,
+              env: deps.env,
+            });
+            const request = buildPlatformChatCompletionRequest({
+              providerConfig,
+              messages,
+              tools,
+            });
+            const res = await fetchWithTransientRetry(fetchImpl, request.url, request.init, {
+              sleep: deps.sleep,
+            });
+            const data = parsePlatformChatCompletionData(await res.text().catch(() => ""));
+            if (!res.ok) {
+              throw new Error(`platform provider failed: HTTP ${res.status} ${JSON.stringify(data)}`);
+            }
+            return parsePlatformChatCompletionResponse({
+              providerConfig,
+              data,
+              trace: messages,
+            });
+          },
         };
-      },
-    }),
-    executeTool: async (call) => executeLocalToolWithPolicy({
-      env: deps.env,
-      agentToolNames: activeAgentToolNames,
-      call,
-      executors: localToolExecutors,
-    }),
+      }
+
+      const providerConfig = resolveCliOpenAiProviderConfig({
+        agentConfig,
+        env: deps.env,
+      });
+      return {
+        model: providerConfig.model,
+        complete: async (messages) => {
+          const tools = buildOpenAiTools({
+            toolNames: agentConfig.toolNames,
+            env: deps.env,
+          });
+          const request = buildOpenAiCompatibleChatCompletionRequest({
+            providerConfig,
+            messages,
+            tools,
+          });
+          const res = await fetchWithTransientRetry(fetchImpl, request.url, request.init, {
+            sleep: deps.sleep,
+          });
+          const data = await res.json().catch(() => ({}));
+          if (!res.ok) {
+            throw new Error(`local provider failed: HTTP ${res.status} ${JSON.stringify(data)}`);
+          }
+          return parseOpenAiCompatibleChatCompletionResponse({
+            providerConfig,
+            data,
+            trace: messages,
+          });
+        },
+      };
+    },
+    executeTool: async (call) => {
+      assertWithinLocalToolBudget({
+        toolName: call.name,
+        budgets: localToolBudgets,
+        usage: localToolUsage,
+      });
+      return executeLocalToolWithPolicy({
+        env: deps.env,
+        agentToolNames: activeAgentToolNames,
+        call,
+        executors: localToolExecutors,
+      });
+    },
   };
 }