nolo-cli 0.1.18 → 0.1.19

package/agent-runtime/hostAdapter.ts

@@ -33,6 +33,7 @@ export type AgentRuntimeSaveTurnInput = {
   agentKey: string;
   messages: AgentRuntimeChatMessage[];
   result: AgentRuntimeResult;
+  continueDialogId?: string;
 };
 
 export type AgentRuntimeHostAdapter = {

package/agent-runtime/localLoop.ts

@@ -44,6 +44,8 @@ export async function runLocalAgentTurn(
   const history = input.continueDialogId
     ? await input.adapter.loadDialogHistory(input.continueDialogId)
     : [];
+  const promptMessageCount = agentConfig.prompt?.trim() ? 1 : 0;
+  const turnStartIndex = promptMessageCount + history.length;
   const messages = buildMessages({
     prompt: agentConfig.prompt,
     history,
@@ -76,17 +78,23 @@ export async function runLocalAgentTurn(
         role: "tool",
         content: toolResult.content,
         tool_call_id: toolCall.id,
+        ...(toolResult.metadata ? { tool_result_metadata: toolResult.metadata } : {}),
       });
     }
   }
   result = result!;
+  messages.push({
+    role: "assistant",
+    content: result.content,
+  });
   const saved = await input.adapter.saveTurn({
     agentKey: agentConfig.key,
-    messages,
+    messages: messages.slice(turnStartIndex),
     result: {
       ...result,
       ...(toolCallCount > 0 ? { toolCallCount } : {}),
     },
+    ...(input.continueDialogId ? { continueDialogId: input.continueDialogId } : {}),
   });
 
   return {

package/agent-runtime/types.ts

@@ -33,6 +33,7 @@ export interface AgentRuntimeChatMessage {
   content: AgentRuntimeMessageContent;
   tool_call_id?: string;
   tool_calls?: AgentRuntimeToolCall[];
+  tool_result_metadata?: Record<string, unknown>;
   reasoning_content?: string;
   cybotKey?: string;
   agentKey?: string;

package/agentRunCommand.ts

@@ -181,10 +181,19 @@ export async function runAgentRunCommand(args: string[], deps: AgentRunCommandDe
   const runner = deps.runner ?? runAgentTurn;
   let localRuntimeCwd: string | undefined;
   if (parsed.allowShell) {
-    localRuntimeCwd = await (deps.prepareShellWorktree ?? prepareShellWorktree)({
-      agentKey: parsed.agentKey,
-      env,
-    });
+    try {
+      localRuntimeCwd = await (deps.prepareShellWorktree ?? prepareShellWorktree)({
+        agentKey: parsed.agentKey,
+        env,
+      });
+    } catch (error) {
+      output.write(
+        "[nolo] Could not prepare a local shell worktree.\n" +
+          "Run from inside a git repository, or set NOLO_LOCAL_WORKTREE to an existing isolated checkout.\n" +
+          `Reason: ${error instanceof Error ? error.message : String(error)}\n`
+      );
+      return 1;
+    }
   }
   const runEnv = parsed.allowShell
     ? {

package/client/localRuntimeAdapter.test.ts

@@ -81,7 +81,7 @@ describe("CLI local runtime adapter", () => {
     expect(result).toMatchObject({
       content: "local adapter ok",
       model: "gpt-4.1-mini",
-      dialogId: "01LOCAL",
+      dialogId: "dialog-existing",
     });
     expect(requests).toEqual([{
       url: "http://127.0.0.1:11434/v1/chat/completions",
@@ -97,29 +97,210 @@ describe("CLI local runtime adapter", () => {
       },
     }]);
     expect(batchOps.map((op) => op.key)).toEqual([
-      "dialog-user-1-01LOCAL",
-      "dialog-01LOCAL-msg-user",
-      "dialog-01LOCAL-msg-assistant",
+      "dialog-user-1-dialog-existing",
+      "dialog-dialog-existing-msg-1710000000000-001",
+      "dialog-dialog-existing-msg-1710000000000-002",
     ]);
-    expect(store.get("dialog-user-1-01LOCAL")).toMatchObject({
-      id: "01LOCAL",
-      dbKey: "dialog-user-1-01LOCAL",
+    expect(store.get("dialog-user-1-dialog-existing")).toMatchObject({
+      id: "dialog-existing",
+      dbKey: "dialog-user-1-dialog-existing",
       type: "dialog",
       primaryAgentKey: "agent-user-1-frontend",
       status: "done",
     });
-    expect(store.get("dialog-01LOCAL-msg-user")).toMatchObject({
-      dialogId: "01LOCAL",
+    expect(store.get("dialog-dialog-existing-msg-1710000000000-001")).toMatchObject({
+      dialogId: "dialog-existing",
       role: "user",
       content: "make it cleaner",
     });
-    expect(store.get("dialog-01LOCAL-msg-assistant")).toMatchObject({
-      dialogId: "01LOCAL",
+    expect(store.get("dialog-dialog-existing-msg-1710000000000-002")).toMatchObject({
+      dialogId: "dialog-existing",
       role: "assistant",
       content: "local adapter ok",
     });
   });
 
+  test("saves local tool call trace and shell metadata into the local dialog", async () => {
+    const store = new Map<string, any>([
+      ["agent-user-1-shell", {
+        dbKey: "agent-user-1-shell",
+        id: "shell",
+        prompt: "Use shell.",
+        model: "gpt-4.1-mini",
+      }],
+    ]);
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+        NOLO_LOCAL_SHELL_MODE: "worktree",
+      },
+      db: {
+        get: async (key) => {
+          if (!store.has(key)) throw new Error(`not found: ${key}`);
+          return store.get(key);
+        },
+        put: async (key, value) => {
+          store.set(key, value);
+        },
+        batch: async (ops) => {
+          for (const op of ops) {
+            if (op.type === "put") store.set(op.key, op.value);
+          }
+        },
+        iterator: () => (async function* () {})(),
+      },
+      cwd: import.meta.dir,
+      now: () => 1710000000000,
+      createId: () => "01TRACE",
+      fetchImpl: async (_url, init) => {
+        const body = JSON.parse(String(init?.body));
+        const hasToolResult = body.messages.some((message: any) => message.role === "tool");
+        if (!hasToolResult) {
+          return Response.json({
+            choices: [{
+              message: {
+                content: "",
+                tool_calls: [{
+                  id: "call-shell",
+                  type: "function",
+                  function: {
+                    name: "execShell",
+                    arguments: JSON.stringify({ cmd: "printf trace-ok" }),
+                  },
+                }],
+              },
+            }],
+          });
+        }
+        return Response.json({
+          choices: [{ message: { content: "done" } }],
+        });
+      },
+    });
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "shell",
+      input: "inspect",
+    });
+
+    expect(result.dialogId).toBe("01TRACE");
+    expect(store.get("dialog-user-1-01TRACE")).toMatchObject({
+      toolCallCount: 1,
+      localRuntime: expect.objectContaining({
+        host: "cli",
+        worktreePath: import.meta.dir,
+      }),
+    });
+    const messages = [...store.entries()]
+      .filter(([key]) => key.startsWith("dialog-01TRACE-msg-"))
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([, value]) => value);
+    expect(messages.map((message) => message.role)).toEqual([
+      "user",
+      "assistant",
+      "tool",
+      "assistant",
+    ]);
+    expect(messages[1]).toMatchObject({
+      tool_calls: [{
+        id: "call-shell",
+        function: { name: "execShell" },
+      }],
+    });
+    expect(messages[2]).toMatchObject({
+      role: "tool",
+      toolCallId: "call-shell",
+      metadata: { exitCode: 0 },
+    });
+    expect(messages[2].content).toContain("trace-ok");
+    expect(messages[3]).toMatchObject({
+      role: "assistant",
+      content: "done",
+    });
+  });
+
+  test("continues a local dialog instead of creating a new one", async () => {
+    const store = new Map<string, any>([
+      ["agent-user-1-frontend", {
+        dbKey: "agent-user-1-frontend",
+        id: "frontend",
+        prompt: "Fix UI",
+        model: "gpt-4.1-mini",
+      }],
+      ["dialog-user-1-dialog-existing", {
+        dbKey: "dialog-user-1-dialog-existing",
+        id: "dialog-existing",
+        type: "dialog",
+        userId: "user-1",
+        title: "Existing dialog",
+      }],
+      ["dialog-dialog-existing-msg-001", {
+        dbKey: "dialog-dialog-existing-msg-001",
+        id: "msg-001",
+        dialogId: "dialog-existing",
+        role: "assistant",
+        content: "previous answer",
+      }],
+    ]);
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+      },
+      db: {
+        get: async (key) => {
+          if (!store.has(key)) throw new Error(`not found: ${key}`);
+          return store.get(key);
+        },
+        put: async (key, value) => {
+          store.set(key, value);
+        },
+        batch: async (ops) => {
+          for (const op of ops) {
+            if (op.type === "put") store.set(op.key, op.value);
+          }
+        },
+        iterator: ({ gte, lte }) => (async function* () {
+          for (const entry of [...store.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+            if (entry[0] >= gte && entry[0] <= lte) yield entry;
+          }
+        })(),
+      },
+      now: () => 1710000000000,
+      createId: () => "SHOULDNOTUSE",
+      fetchImpl: async (_url, init) => {
+        const body = JSON.parse(String(init?.body));
+        expect(body.messages).toContainEqual({
+          role: "assistant",
+          content: "previous answer",
+        });
+        return Response.json({
+          choices: [{ message: { content: "continued" } }],
+        });
+      },
+    });
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "frontend",
+      input: "continue",
+      continueDialogId: "dialog-existing",
+    });
+
+    expect(result.dialogId).toBe("dialog-existing");
+    expect(store.has("dialog-user-1-SHOULDNOTUSE")).toBe(false);
+    expect(store.get("dialog-user-1-dialog-existing")).toMatchObject({
+      id: "dialog-existing",
+      title: "Existing dialog",
+      status: "done",
+    });
+    expect([...store.keys()].filter((key) => key.startsWith("dialog-dialog-existing-msg-"))).toContain(
+      "dialog-dialog-existing-msg-1710000000000-001"
+    );
+  });
+
   test("passes image_url message parts through to OpenAI-compatible providers", async () => {
     const requests: Array<{ body: any }> = [];
     const adapter = createCliLocalRuntimeAdapter({

package/client/localRuntimeAdapter.ts

@@ -161,6 +161,8 @@ 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 } : {}),
   }));
 }
 
@@ -192,8 +194,9 @@ async function writeDialog(args: {
   userId: string;
   now: () => number;
   createId: () => string;
+  cwd?: string;
 }) {
-  const dialogId = args.createId();
+  const dialogId = args.input.continueDialogId || args.createId();
   const now = args.now();
   const nowIso = new Date(now).toISOString();
   const dialogKey = `dialog-${args.userId}-${dialogId}`;
@@ -206,56 +209,74 @@ async function writeDialog(args: {
           .map((part) => part.text)
           .join(" ")
       : "";
+  let existingDialog: any = null;
+  if (args.input.continueDialogId) {
+    try {
+      existingDialog = await args.db.get(dialogKey);
+    } catch {
+      existingDialog = null;
+    }
+  }
+  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: lastUserText.trim()
-          ? lastUserText.trim().slice(0, 80)
-          : "Local agent run",
+        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: nowIso,
+        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 } : {}),
+        },
       },
     },
-    {
-      type: "put",
-      key: `dialog-${dialogId}-msg-user`,
-      value: {
-        id: "msg-user",
-        dbKey: `dialog-${dialogId}-msg-user`,
-        dialogId,
-        role: "user",
-        content: lastUser?.content ?? "",
-        userId: args.userId,
-        createdAt: nowIso,
-      },
-    },
-    {
-      type: "put",
-      key: `dialog-${dialogId}-msg-assistant`,
-      value: {
-        id: "msg-assistant",
-        dbKey: `dialog-${dialogId}-msg-assistant`,
-        dialogId,
-        role: "assistant",
-        content: args.input.result.content,
-        agentKey: args.input.agentKey,
-        cybotKey: args.input.agentKey,
-        createdAt: nowIso,
-      },
-    },
+    ...messageOps,
   ];
   await args.db.batch(ops);
   return { dialogId };
@@ -293,6 +314,7 @@ export function createCliLocalRuntimeAdapter(
       userId,
       now,
       createId,
+      cwd: deps.cwd,
     }),
     resolveProvider: async (agentConfig) => ({
       model: agentConfig.model || "gpt-4.1-mini",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nolo-cli",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "type": "module",
   "description": "Agent-first terminal workspace for Nolo",
   "bin": {