stagent 0.9.5 → 0.10.0

package/src/lib/chat/tools/__tests__/schedule-tools.test.ts

@@ -0,0 +1,261 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { z } from "zod";
+
+interface ScheduleRow {
+  id: string;
+  maxTurns: number | null;
+  [key: string]: unknown;
+}
+
+const { mockState } = vi.hoisted(() => ({
+  mockState: {
+    rows: [] as ScheduleRow[],
+    lastInsertValues: null as Record<string, unknown> | null,
+    lastUpdateValues: null as Record<string, unknown> | null,
+  },
+}));
+
+vi.mock("@/lib/db", () => {
+  const selectBuilder = {
+    from() { return this; },
+    where() { return this; },
+    orderBy() { return this; },
+    limit() { return this; },
+    get() { return Promise.resolve(mockState.rows[0]); },
+    then<TResolve>(resolve: (rows: ScheduleRow[]) => TResolve) {
+      return Promise.resolve(mockState.rows).then(resolve);
+    },
+  };
+  return {
+    db: {
+      select: () => selectBuilder,
+      insert: () => ({
+        values: (v: Record<string, unknown>) => {
+          mockState.lastInsertValues = v;
+          mockState.rows = [{ id: "sched-1", maxTurns: null, ...v } as ScheduleRow];
+          return Promise.resolve();
+        },
+      }),
+      update: () => ({
+        set: (v: Record<string, unknown>) => {
+          mockState.lastUpdateValues = v;
+          mockState.rows[0] = { ...mockState.rows[0], ...v } as ScheduleRow;
+          return { where: () => Promise.resolve() };
+        },
+      }),
+      delete: () => ({ where: () => Promise.resolve() }),
+    },
+  };
+});
+
+vi.mock("@/lib/db/schema", () => ({
+  schedules: {
+    id: "id",
+    status: "status",
+    projectId: "projectId",
+    updatedAt: "updatedAt",
+    cronExpression: "cronExpression",
+  },
+}));
+
+vi.mock("drizzle-orm", () => ({
+  eq: () => ({}),
+  and: () => ({}),
+  desc: () => ({}),
+  like: () => ({}),
+}));
+
+vi.mock("@/lib/schedules/interval-parser", () => ({
+  parseInterval: () => "*/30 * * * *",
+  computeNextFireTime: () => new Date("2026-04-11T10:00:00Z"),
+  computeStaggeredCron: (cron: string) => ({
+    cronExpression: cron,
+    offsetApplied: 0,
+    collided: false,
+  }),
+}));
+
+vi.mock("@/lib/schedules/nlp-parser", () => ({
+  parseNaturalLanguage: () => null,
+}));
+
+vi.mock("@/lib/schedules/prompt-analyzer", () => ({
+  analyzePromptEfficiency: () => [],
+}));
+
+import { scheduleTools } from "../schedule-tools";
+
+function getTool(name: string) {
+  const tools = scheduleTools({ projectId: "proj-1" } as never);
+  const tool = tools.find((t) => t.name === name);
+  if (!tool) throw new Error(`Tool not found: ${name}`);
+  return tool;
+}
+
+function parseArgs(toolName: string, args: unknown) {
+  const tool = getTool(toolName);
+  return z.object(tool.zodShape).safeParse(args);
+}
+
+beforeEach(() => {
+  mockState.rows = [];
+  mockState.lastInsertValues = null;
+  mockState.lastUpdateValues = null;
+});
+
+describe("create_schedule maxTurns Zod validation", () => {
+  const base = {
+    name: "test",
+    prompt: "hello",
+    interval: "every 30 minutes",
+  };
+
+  it("accepts a valid maxTurns value", () => {
+    const result = parseArgs("create_schedule", { ...base, maxTurns: 50 });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts omitted maxTurns (inherit default)", () => {
+    const result = parseArgs("create_schedule", base);
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects maxTurns below 10", () => {
+    const result = parseArgs("create_schedule", { ...base, maxTurns: 9 });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects maxTurns above 500", () => {
+    const result = parseArgs("create_schedule", { ...base, maxTurns: 501 });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects non-integer maxTurns", () => {
+    const result = parseArgs("create_schedule", { ...base, maxTurns: 50.5 });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects explicit null on create (only update supports clear-to-null)", () => {
+    const result = parseArgs("create_schedule", { ...base, maxTurns: null });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe("update_schedule maxTurns Zod validation", () => {
+  const base = { scheduleId: "sched-1" };
+
+  it("accepts a valid maxTurns value", () => {
+    const result = parseArgs("update_schedule", { ...base, maxTurns: 100 });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts explicit null to clear an override", () => {
+    const result = parseArgs("update_schedule", { ...base, maxTurns: null });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts omitted maxTurns (unchanged)", () => {
+    const result = parseArgs("update_schedule", base);
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects out-of-range maxTurns on update", () => {
+    const result = parseArgs("update_schedule", { ...base, maxTurns: 9 });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe("create_schedule maxTurns persistence", () => {
+  it("writes maxTurns to the insert payload when provided", async () => {
+    const tool = getTool("create_schedule");
+    await tool.handler({
+      name: "test",
+      prompt: "hello",
+      interval: "every 30 minutes",
+      maxTurns: 75,
+    });
+    expect(mockState.lastInsertValues).not.toBeNull();
+    expect(mockState.lastInsertValues?.maxTurns).toBe(75);
+  });
+
+  it("writes null to maxTurns when omitted (inherit default)", async () => {
+    const tool = getTool("create_schedule");
+    await tool.handler({
+      name: "test",
+      prompt: "hello",
+      interval: "every 30 minutes",
+    });
+    expect(mockState.lastInsertValues?.maxTurns).toBe(null);
+  });
+
+  it("sets maxTurnsSetAt to a Date when maxTurns is provided", async () => {
+    const tool = getTool("create_schedule");
+    await tool.handler({
+      name: "test",
+      prompt: "hello",
+      interval: "every 30 minutes",
+      maxTurns: 75,
+    });
+    expect(mockState.lastInsertValues?.maxTurnsSetAt).toBeInstanceOf(Date);
+  });
+
+  it("sets maxTurnsSetAt to null when maxTurns is omitted", async () => {
+    const tool = getTool("create_schedule");
+    await tool.handler({
+      name: "test",
+      prompt: "hello",
+      interval: "every 30 minutes",
+    });
+    expect(mockState.lastInsertValues?.maxTurnsSetAt).toBe(null);
+  });
+});
+
+describe("update_schedule maxTurns persistence", () => {
+  beforeEach(() => {
+    mockState.rows = [{
+      id: "sched-1",
+      name: "existing",
+      status: "active",
+      maxTurns: 50,
+    } as ScheduleRow];
+  });
+
+  it("writes the new maxTurns value when provided", async () => {
+    const tool = getTool("update_schedule");
+    await tool.handler({ scheduleId: "sched-1", maxTurns: 120 });
+    expect(mockState.lastUpdateValues?.maxTurns).toBe(120);
+  });
+
+  it("writes null when explicitly clearing the override", async () => {
+    const tool = getTool("update_schedule");
+    await tool.handler({ scheduleId: "sched-1", maxTurns: null });
+    expect(mockState.lastUpdateValues).not.toBeNull();
+    expect("maxTurns" in (mockState.lastUpdateValues ?? {})).toBe(true);
+    expect(mockState.lastUpdateValues?.maxTurns).toBe(null);
+  });
+
+  it("does not touch maxTurns when the field is omitted", async () => {
+    const tool = getTool("update_schedule");
+    await tool.handler({ scheduleId: "sched-1", name: "renamed" });
+    expect("maxTurns" in (mockState.lastUpdateValues ?? {})).toBe(false);
+  });
+
+  it("sets maxTurnsSetAt to a Date when maxTurns is set to a number", async () => {
+    const tool = getTool("update_schedule");
+    await tool.handler({ scheduleId: "sched-1", maxTurns: 120 });
+    expect(mockState.lastUpdateValues?.maxTurnsSetAt).toBeInstanceOf(Date);
+  });
+
+  it("sets maxTurnsSetAt to null when maxTurns is cleared", async () => {
+    const tool = getTool("update_schedule");
+    await tool.handler({ scheduleId: "sched-1", maxTurns: null });
+    expect("maxTurnsSetAt" in (mockState.lastUpdateValues ?? {})).toBe(true);
+    expect(mockState.lastUpdateValues?.maxTurnsSetAt).toBe(null);
+  });
+
+  it("does not touch maxTurnsSetAt when maxTurns is omitted", async () => {
+    const tool = getTool("update_schedule");
+    await tool.handler({ scheduleId: "sched-1", name: "renamed" });
+    expect("maxTurnsSetAt" in (mockState.lastUpdateValues ?? {})).toBe(false);
+  });
+});

package/src/lib/chat/tools/__tests__/task-tools.test.ts

@@ -0,0 +1,352 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { z } from "zod";
+
+interface TaskRow {
+  id: string;
+  title: string;
+  status: string;
+  projectId: string | null;
+  agentProfile: string | null;
+  assignedAgent: string | null;
+  [key: string]: unknown;
+}
+
+const { mockState } = vi.hoisted(() => ({
+  mockState: {
+    rows: [] as TaskRow[],
+    lastInsertValues: null as Record<string, unknown> | null,
+    lastUpdateValues: null as Record<string, unknown> | null,
+  },
+}));
+
+vi.mock("@/lib/db", () => {
+  const selectBuilder = {
+    from() { return this; },
+    where() { return this; },
+    orderBy() { return this; },
+    limit() {
+      return Promise.resolve(mockState.rows);
+    },
+    get() { return Promise.resolve(mockState.rows[0]); },
+    then<TResolve>(resolve: (rows: TaskRow[]) => TResolve) {
+      return Promise.resolve(mockState.rows).then(resolve);
+    },
+  };
+  return {
+    db: {
+      select: () => selectBuilder,
+      insert: () => ({
+        values: (v: Record<string, unknown>) => {
+          mockState.lastInsertValues = v;
+          mockState.rows = [{
+            id: "task-1",
+            title: "",
+            status: "planned",
+            projectId: null,
+            agentProfile: null,
+            assignedAgent: null,
+            ...v,
+          } as TaskRow];
+          return Promise.resolve();
+        },
+      }),
+      update: () => ({
+        set: (v: Record<string, unknown>) => {
+          mockState.lastUpdateValues = v;
+          if (mockState.rows[0]) {
+            mockState.rows[0] = { ...mockState.rows[0], ...v } as TaskRow;
+          }
+          return { where: () => Promise.resolve() };
+        },
+      }),
+    },
+  };
+});
+
+vi.mock("@/lib/db/schema", () => ({
+  tasks: {
+    id: "id",
+    projectId: "projectId",
+    status: "status",
+    priority: "priority",
+    createdAt: "createdAt",
+  },
+}));
+
+vi.mock("drizzle-orm", () => ({
+  eq: () => ({}),
+  and: () => ({}),
+  desc: () => ({}),
+  like: () => ({}),
+}));
+
+// Mock the profile registry: accept "general" and "code-reviewer"
+// and "researcher", reject everything else.
+vi.mock("@/lib/agents/profiles/registry", () => {
+  const validIds = new Set(["general", "code-reviewer", "researcher"]);
+  return {
+    getProfile: (id: string) =>
+      validIds.has(id)
+        ? { id, name: id, description: "test", tags: [], skillMd: "", allowedTools: [], mcpServers: {}, systemPrompt: "" }
+        : undefined,
+    listProfiles: () => Array.from(validIds).map((id) => ({ id, name: id })),
+  };
+});
+
+// Mock the runtime catalog so isAgentRuntimeId is deterministic.
+vi.mock("@/lib/agents/runtime/catalog", () => ({
+  DEFAULT_AGENT_RUNTIME: "claude",
+  SUPPORTED_AGENT_RUNTIMES: ["claude", "anthropic-direct", "openai-direct"],
+  isAgentRuntimeId: (id: string) => ["claude", "anthropic-direct", "openai-direct"].includes(id),
+}));
+
+// Mock the router so execute_task's dynamic import doesn't explode.
+vi.mock("@/lib/agents/router", () => ({
+  executeTaskWithAgent: () => Promise.resolve(),
+}));
+
+import { taskTools } from "../task-tools";
+
+function getTool(name: string, ctx: { projectId?: string | null } = { projectId: undefined }) {
+  const tools = taskTools(ctx as never);
+  const tool = tools.find((t) => t.name === name);
+  if (!tool) throw new Error(`Tool not found: ${name}`);
+  return tool;
+}
+
+function parseArgs(toolName: string, args: unknown) {
+  const tool = getTool(toolName);
+  return z.object(tool.zodShape).safeParse(args);
+}
+
+function callHandler(toolName: string, args: unknown, ctx: { projectId?: string | null } = { projectId: undefined }) {
+  const tool = getTool(toolName, ctx);
+  return tool.handler(args);
+}
+
+function getToolResultText(result: { content: Array<{ type: string; text: string }>; isError?: boolean }) {
+  return result.content[0]?.text ?? "";
+}
+
+beforeEach(() => {
+  mockState.rows = [];
+  mockState.lastInsertValues = null;
+  mockState.lastUpdateValues = null;
+});
+
+describe("create_task agentProfile Zod validation", () => {
+  const base = { title: "test task" };
+
+  it("accepts a valid profile id", () => {
+    const result = parseArgs("create_task", { ...base, agentProfile: "general" });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts another valid profile id", () => {
+    const result = parseArgs("create_task", { ...base, agentProfile: "code-reviewer" });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts omitted agentProfile", () => {
+    const result = parseArgs("create_task", base);
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects a runtime id passed as agentProfile", () => {
+    const result = parseArgs("create_task", { ...base, agentProfile: "anthropic-direct" });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects an arbitrary invalid string", () => {
+    const result = parseArgs("create_task", { ...base, agentProfile: "not-a-profile" });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe("create_task handler-level error messages", () => {
+  it("returns a descriptive error naming the invalid value and listing valid profile ids", async () => {
+    const result = await callHandler("create_task", {
+      title: "test task",
+      agentProfile: "anthropic-direct",
+    });
+    expect(result.isError).toBe(true);
+    const text = getToolResultText(result);
+    expect(text).toContain("anthropic-direct");
+    expect(text).toMatch(/code-reviewer|general|researcher/);
+  });
+
+  it("inserts a task when agentProfile is valid", async () => {
+    const result = await callHandler("create_task", {
+      title: "test task",
+      agentProfile: "general",
+    });
+    expect(result.isError).toBeFalsy();
+    expect(mockState.lastInsertValues?.agentProfile).toBe("general");
+  });
+
+  it("inserts with null agentProfile when omitted", async () => {
+    await callHandler("create_task", { title: "test task" });
+    expect(mockState.lastInsertValues?.agentProfile).toBe(null);
+  });
+});
+
+describe("update_task agentProfile Zod validation", () => {
+  const base = { taskId: "task-1" };
+
+  it("accepts a valid profile id", () => {
+    const result = parseArgs("update_task", { ...base, agentProfile: "researcher" });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects a runtime id", () => {
+    const result = parseArgs("update_task", { ...base, agentProfile: "anthropic-direct" });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe("update_task handler-level agentProfile validation", () => {
+  beforeEach(() => {
+    mockState.rows = [{
+      id: "task-1",
+      title: "existing",
+      status: "planned",
+      projectId: null,
+      agentProfile: null,
+      assignedAgent: null,
+    } as TaskRow];
+  });
+
+  it("returns a descriptive error when the new agentProfile is invalid", async () => {
+    const result = await callHandler("update_task", {
+      taskId: "task-1",
+      agentProfile: "anthropic-direct",
+    });
+    expect(result.isError).toBe(true);
+    expect(getToolResultText(result)).toContain("anthropic-direct");
+  });
+
+  it("updates when the new agentProfile is valid", async () => {
+    const result = await callHandler("update_task", {
+      taskId: "task-1",
+      agentProfile: "code-reviewer",
+    });
+    expect(result.isError).toBeFalsy();
+    expect(mockState.lastUpdateValues?.agentProfile).toBe("code-reviewer");
+  });
+});
+
+describe("execute_task stale agentProfile surfacing", () => {
+  it("returns synchronous error when the stored task.agentProfile is invalid", async () => {
+    mockState.rows = [{
+      id: "task-1",
+      title: "stale task",
+      status: "planned",
+      projectId: null,
+      agentProfile: "anthropic-direct",
+      assignedAgent: null,
+    } as TaskRow];
+
+    const result = await callHandler("execute_task", { taskId: "task-1" });
+    expect(result.isError).toBe(true);
+    const text = getToolResultText(result);
+    expect(text).toContain("anthropic-direct");
+    expect(text).toContain("update_task");
+  });
+
+  it("queues execution when task.agentProfile is valid", async () => {
+    mockState.rows = [{
+      id: "task-1",
+      title: "ok task",
+      status: "planned",
+      projectId: null,
+      agentProfile: "general",
+      assignedAgent: null,
+    } as TaskRow];
+
+    const result = await callHandler("execute_task", { taskId: "task-1" });
+    expect(result.isError).toBeFalsy();
+  });
+
+  it("queues execution when task.agentProfile is null (runtime falls back to general)", async () => {
+    mockState.rows = [{
+      id: "task-1",
+      title: "ok task",
+      status: "planned",
+      projectId: null,
+      agentProfile: null,
+      assignedAgent: null,
+    } as TaskRow];
+
+    const result = await callHandler("execute_task", { taskId: "task-1" });
+    expect(result.isError).toBeFalsy();
+  });
+});
+
+describe("list_tasks empty-result note", () => {
+  it("returns an envelope with note when a project filter is active and zero rows result", async () => {
+    mockState.rows = [];
+    const result = await callHandler("list_tasks", {}, { projectId: "proj-active" });
+    expect(result.isError).toBeFalsy();
+    const parsed = JSON.parse(getToolResultText(result));
+    expect(parsed).toMatchObject({ tasks: [], note: expect.stringContaining("proj-active") });
+    expect(parsed.note).toContain("projectId: null");
+    expect(parsed.note).toContain("get_task");
+  });
+
+  it("returns the plain array (no note) when a project filter is active and rows are returned", async () => {
+    mockState.rows = [{
+      id: "task-1",
+      title: "existing",
+      status: "planned",
+      projectId: "proj-active",
+      agentProfile: null,
+      assignedAgent: null,
+    } as TaskRow];
+
+    const result = await callHandler("list_tasks", {}, { projectId: "proj-active" });
+    const parsed = JSON.parse(getToolResultText(result));
+    expect(Array.isArray(parsed)).toBe(true);
+    expect(parsed).toHaveLength(1);
+  });
+
+  it("returns the plain array (no note) when no filter is active and zero rows result", async () => {
+    mockState.rows = [];
+    const result = await callHandler("list_tasks", {}, { projectId: undefined });
+    const parsed = JSON.parse(getToolResultText(result));
+    expect(Array.isArray(parsed)).toBe(true);
+    expect(parsed).toHaveLength(0);
+  });
+});
+
+describe("get_task AC #4: failed tasks remain findable", () => {
+  it("finds a task regardless of status (including failed)", async () => {
+    mockState.rows = [{
+      id: "task-1",
+      title: "a failed task",
+      status: "failed",
+      projectId: "proj-other",
+      agentProfile: null,
+      assignedAgent: null,
+    } as TaskRow];
+
+    const result = await callHandler("get_task", { taskId: "task-1" });
+    expect(result.isError).toBeFalsy();
+    const text = getToolResultText(result);
+    expect(text).toContain("task-1");
+    expect(text).toContain("failed");
+  });
+
+  it("does not apply a project filter (returns the task even when stored under a different project)", async () => {
+    mockState.rows = [{
+      id: "task-1",
+      title: "cross-project task",
+      status: "completed",
+      projectId: "proj-A",
+      agentProfile: null,
+      assignedAgent: null,
+    } as TaskRow];
+
+    const result = await callHandler("get_task", { taskId: "task-1" }, { projectId: "proj-B" });
+    expect(result.isError).toBeFalsy();
+  });
+});