@cueloop/daemon 0.1.0-alpha.96 → 0.1.0-alpha.98

package/src/thread-agent-validation.ts

@@ -0,0 +1,108 @@
+import * as v from "valibot";
+import type { ThreadAgentState } from "@cueloop/schema";
+
+const AgentAnchorSchema = v.object({
+  quote: v.pipe(v.string(), v.minLength(1), v.maxLength(32_768)),
+  prefix: v.string(),
+  suffix: v.string(),
+  blockIndex: v.number(),
+  start: v.number(),
+  end: v.number(),
+  endBlockIndex: v.optional(v.number()),
+});
+
+/** Validate agent comments at the socket and persisted transcript boundaries. */
+export const AgentCommentSchema = v.object({
+  id: v.string(),
+  messageId: v.string(),
+  anchor: AgentAnchorSchema,
+  body: v.pipe(v.string(), v.minLength(1), v.maxLength(32_768)),
+  sent: v.boolean(),
+  replyTo: v.optional(v.string()),
+  author: v.optional(v.string()),
+});
+
+/** Validate persisted agent transcripts independently of submitted artifacts. */
+const StoredAgentSchema = v.object({
+  threadId: v.string(),
+  fxSessionId: v.optional(v.string()),
+  harness: v.optional(
+    v.object({ id: v.string(), label: v.string(), sessionId: v.optional(v.string()) }),
+  ),
+  phase: v.variant("kind", [
+    v.object({ kind: v.literal("idle") }),
+    v.object({ kind: v.literal("running") }),
+    v.object({ kind: v.literal("failed"), error: v.string() }),
+    v.object({
+      kind: v.literal("permission"),
+      permission: v.object({
+        id: v.string(),
+        title: v.string(),
+        options: v.array(
+          v.object({
+            optionId: v.string(),
+            name: v.string(),
+            kind: v.string(),
+          }),
+        ),
+      }),
+    }),
+  ]),
+  messages: v.array(
+    v.object({
+      id: v.string(),
+      role: v.picklist(["user", "agent"]),
+      text: v.string(),
+      complete: v.boolean(),
+      revision: v.number(),
+      submissionId: v.optional(v.string()),
+    }),
+  ),
+  tools: v.array(
+    v.object({
+      id: v.string(),
+      turnId: v.string(),
+      title: v.string(),
+      kind: v.string(),
+      status: v.picklist(["pending", "in_progress", "completed", "failed", "cancelled"]),
+      output: v.string(),
+      locations: v.array(v.object({ path: v.string(), line: v.optional(v.number()) })),
+    }),
+  ),
+  comments: v.array(AgentCommentSchema),
+  submissions: v.optional(
+    v.array(
+      v.object({
+        id: v.string(),
+        commentId: v.optional(v.string()),
+        messageId: v.optional(v.string()),
+        prompt: v.string(),
+        quote: v.optional(v.string()),
+        context: v.optional(v.string()),
+        status: v.picklist(["queued", "running", "completed", "failed"]),
+      }),
+    ),
+  ),
+  configOptions: v.optional(
+    v.array(
+      v.object({
+        id: v.string(),
+        name: v.string(),
+        category: v.optional(v.string()),
+        currentValue: v.string(),
+        options: v.array(v.object({ value: v.string(), name: v.string() })),
+      }),
+    ),
+  ),
+});
+
+/** Read the first fx prototype's records without discarding their session identity. */
+export const ThreadAgentSchema: v.GenericSchema<ThreadAgentState> = v.pipe(
+  StoredAgentSchema,
+  v.transform(({ fxSessionId, ...state }) => ({
+    ...state,
+    harness:
+      state.harness ??
+      (fxSessionId ? { id: "fx", label: "fx", sessionId: fxSessionId } : undefined),
+  })),
+);

package/src/thread-agent.test.ts

@@ -0,0 +1,307 @@
+import { expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { SCHEMA_VERSION, type Thread, type AgentHarnessAdapter } from "@cueloop/schema";
+import { ThreadAgentManager } from "./thread-agent";
+
+function createTestThread(home: string): Thread {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id: "adapter-test",
+    workspace: { repoRoot: home, branch: "main" },
+    artifact: { type: "plan", content: "Review the retry", meta: {} },
+    revisions: [],
+    annotations: [],
+    message: null,
+    status: "pending",
+    createdAt: "2026-10-04",
+  };
+}
+
+test("a non-ACP harness streams and resumes through the same Thread manager", async () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-harness-"));
+  const thread = createTestThread(home);
+  const sessions: (string | undefined)[] = [];
+  const adapter: AgentHarnessAdapter = {
+    id: "test-native",
+    label: "Native agent",
+    connect(options) {
+      sessions.push(options.sessionId);
+
+      return {
+        start: async () => options.sessionId ?? "native-session",
+        prompt: async () => {
+          options.onEvent({
+            kind: "tool",
+            id: "read",
+            title: "Read retry",
+            toolKind: "read",
+            status: "completed",
+          });
+          options.onEvent({ kind: "message", id: crypto.randomUUID(), text: "Native answer" });
+
+          return { outcome: "completed" as const };
+        },
+        cancel() {},
+        permission() {},
+        close() {},
+      };
+    },
+  };
+  let manager = new ThreadAgentManager({
+    home,
+    enabled: true,
+    adapter,
+    getThread: () => thread,
+    onChange() {},
+  });
+  const finish = async () => {
+    for (let attempt = 0; manager.get(thread.id).phase.kind !== "idle" && attempt < 100; attempt++)
+      await Bun.sleep(1);
+    expect(manager.get(thread.id).phase).toEqual({ kind: "idle" });
+  };
+
+  try {
+    manager.prompt({ id: thread.id, text: "Explain" });
+    await finish();
+    expect(manager.get(thread.id).harness).toEqual({
+      id: "test-native",
+      label: "Native agent",
+      sessionId: "native-session",
+    });
+    expect(manager.get(thread.id).messages[1]?.text).toBe("Native answer");
+    const promptDiscussion = { id: manager.get(thread.id).submissions![0]!.id };
+    expect(manager.isReadOnly(thread.id, promptDiscussion.id)).toBe(true);
+    const promptReply = manager.reply(thread.id, promptDiscussion.id, "The prompt is clear");
+    expect(promptReply.comments.at(-1)?.replyTo).toBe(promptDiscussion.id);
+    const answer = manager.get(thread.id).messages[1]!;
+    manager.comment({
+      id: thread.id,
+      comment: {
+        id: "answer-question",
+        messageId: answer.id,
+        anchor: { quote: "Native", prefix: "", suffix: " answer", blockIndex: 0, start: 0, end: 6 },
+        body: "Explain this",
+        sent: false,
+      },
+    });
+    const replied = manager.reply(thread.id, "answer-question", "This is the explanation");
+    expect(replied.comments.at(-1)).toMatchObject({
+      replyTo: "answer-question",
+      messageId: answer.id,
+      sent: true,
+      author: "embedded-agent",
+    });
+    manager.comment({
+      id: thread.id,
+      comment: {
+        ...replied.comments.find((entry) => entry.id === "answer-question")!,
+        id: "answer-followup",
+        replyTo: "answer-question",
+        body: "Why?",
+        sent: false,
+      },
+    });
+    manager.prompt({ id: thread.id, text: "" });
+    expect(
+      manager.get(thread.id).submissions?.find((entry) => entry.commentId === "answer-followup")
+        ?.context,
+    ).toContain("This is the explanation");
+    await finish();
+    manager.dispose();
+    manager = new ThreadAgentManager({
+      home,
+      enabled: true,
+      adapter,
+      getThread: () => thread,
+      onChange() {},
+    });
+    manager.prompt({ id: thread.id, text: "Continue" });
+    await finish();
+    expect(sessions).toEqual([undefined, "native-session"]);
+    const other = new ThreadAgentManager({
+      home,
+      enabled: true,
+      adapter: { ...adapter, id: "another-agent" },
+      getThread: () => thread,
+      onChange() {},
+    });
+
+    expect(() => other.prompt({ id: thread.id, text: "Mix sessions" })).toThrow(
+      "different harness",
+    );
+    other.dispose();
+  } finally {
+    manager.dispose();
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("the first prototype's fx records migrate without losing session identity", () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-harness-migrate-"));
+  const thread = createTestThread(home);
+  const path = join(home, "thread-agents");
+
+  mkdirSync(path);
+  writeFileSync(
+    join(path, `${thread.id}.json`),
+    JSON.stringify({
+      threadId: thread.id,
+      fxSessionId: "saved-fx-session",
+      phase: { kind: "idle" },
+      messages: [],
+      tools: [],
+      comments: [],
+    }),
+  );
+  const manager = new ThreadAgentManager({
+    home,
+    enabled: false,
+    getThread: () => thread,
+    onChange() {},
+  });
+
+  try {
+    expect(manager.get(thread.id).harness).toEqual({
+      id: "fx",
+      label: "fx",
+      sessionId: "saved-fx-session",
+    });
+  } finally {
+    manager.dispose();
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("empty input is a no-op; queued comments freeze once and retries reuse their mirrors", async () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-agent-queue-"));
+  const thread = createTestThread(home);
+  const prompts: string[] = [];
+  const finishes: ((outcome: "completed" | "cancelled") => void)[] = [];
+  const adapter: AgentHarnessAdapter = {
+    id: "test",
+    label: "Test",
+    connect(options) {
+      return {
+        start: async () => "session",
+        prompt: (text) => {
+          prompts.push(text);
+          options.onEvent({
+            kind: "message",
+            id: `answer-${prompts.length}`,
+            text: `Reply ${prompts.length}`,
+          });
+
+          return new Promise((resolve) => finishes.push((outcome) => resolve({ outcome })));
+        },
+        cancel() {
+          finishes.at(-1)?.("cancelled");
+        },
+        permission() {},
+        close() {},
+      };
+    },
+  };
+  const manager = new ThreadAgentManager({
+    home,
+    enabled: true,
+    adapter,
+    getThread: () => thread,
+    onChange() {},
+  });
+  const tick = () => new Promise<void>((resolve) => setImmediate(resolve));
+
+  try {
+    manager.prompt({ id: thread.id, text: "" });
+    expect(prompts).toEqual([]);
+    expect(manager.get(thread.id).messages).toEqual([]);
+    thread.annotations.push({
+      id: "first",
+      kind: "comment",
+      body: "Explain first",
+      anchor: {
+        quote: "Review",
+        prefix: "",
+        suffix: " the retry",
+        blockIndex: 0,
+        start: 0,
+        end: 6,
+      },
+      createdAt: thread.createdAt,
+    });
+    manager.prompt({ id: thread.id, text: "" });
+    await tick();
+    expect(manager.isReadOnly(thread.id, "first")).toBe(true);
+    thread.annotations.push({ ...thread.annotations[0]!, id: "second", body: "Explain second" });
+    manager.prompt({ id: thread.id, text: "" });
+    expect(prompts).toHaveLength(1);
+    expect(manager.get(thread.id).submissions?.map((entry) => entry.status)).toEqual([
+      "running",
+      "queued",
+    ]);
+    finishes[0]!("completed");
+    await tick();
+    expect(prompts).toHaveLength(2);
+    expect(prompts[1]).toContain("Input: Explain second");
+    expect(prompts[1]).toContain("Reply 1");
+    finishes[1]!("cancelled");
+    await tick();
+    const failed = manager.get(thread.id).submissions![1]!;
+    const mirrors = manager.get(thread.id).messages.filter((entry) => entry.role === "user");
+
+    manager.prompt({ id: thread.id, text: "", retry: failed.id });
+    await tick();
+    expect(manager.get(thread.id).messages.filter((entry) => entry.role === "user")).toEqual(
+      mirrors,
+    );
+    expect(manager.isReadOnly(thread.id, "second")).toBe(true);
+    finishes[2]!("completed");
+    await tick();
+    expect(manager.get(thread.id).submissions?.map((entry) => entry.status)).toEqual([
+      "completed",
+      "completed",
+    ]);
+    manager.prompt({ id: thread.id, text: "" });
+    expect(prompts).toHaveLength(3);
+  } finally {
+    manager.dispose();
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("rejected first batches leave originals editable and create no queued turn", () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-agent-rejected-"));
+  const thread = createTestThread(home);
+  const manager = new ThreadAgentManager({
+    home,
+    enabled: true,
+    adapter: {
+      id: "test",
+      label: "Test",
+      connect() {
+        throw new Error("A rejected batch must not start");
+      },
+    },
+    getThread: () => thread,
+    onChange() {},
+  });
+  const original = {
+    id: "valid",
+    kind: "comment",
+    body: "Explain",
+    anchor: { quote: "Review", prefix: "", suffix: " the retry", blockIndex: 0, start: 0, end: 6 },
+    createdAt: thread.createdAt,
+  };
+
+  try {
+    thread.annotations.push(original, { ...original, id: "oversized", body: "x".repeat(320001) });
+    expect(() => manager.prompt({ id: thread.id, text: "" })).toThrow("320 KiB");
+    expect(manager.get(thread.id).messages).toEqual([]);
+    expect(manager.get(thread.id).submissions).toBeUndefined();
+    expect(manager.isReadOnly(thread.id, "valid")).toBe(false);
+  } finally {
+    manager.dispose();
+    rmSync(home, { recursive: true, force: true });
+  }
+});