@desplega.ai/agent-swarm 1.113.0 → 1.115.0

package/src/tests/reasoning-effort.test.ts

@@ -17,7 +17,7 @@ import {
 
 describe("REASONING_EFFORT_LEVELS", () => {
   test("is the closed normalized enum", () => {
-    expect(REASONING_EFFORT_LEVELS).toEqual(["off", "low", "medium", "high", "xhigh"]);
+    expect(REASONING_EFFORT_LEVELS).toEqual(["off", "low", "medium", "high", "xhigh", "max"]);
   });
 });
 
@@ -25,10 +25,16 @@ describe("reasoningCapability — cache-sourced levels", () => {
   test("claude claude-opus-4-8: levels come from reasoning_options.effort, not the fallback", () => {
     const cap = reasoningCapability("claude", "claude-opus-4-8");
     expect(cap.supported).toBe(true);
-    // Cache lists [low, medium, high, xhigh, max]; "max" is dropped (out of scope).
+    // Cache lists [low, medium, high, xhigh, max]; "max" is not a Claude CLI effort.
     expect(cap.levels).toEqual(["low", "medium", "high", "xhigh"]);
   });
 
+  test("codex gpt-5.6-sol supports the new max effort", () => {
+    const cap = reasoningCapability("codex", "gpt-5.6-sol");
+    expect(cap.supported).toBe(true);
+    expect(cap.levels).toEqual(["off", "low", "medium", "high", "xhigh", "max"]);
+  });
+
   test("codex gpt-5.1-codex-max: cache already includes xhigh", () => {
     const cap = reasoningCapability("codex", "gpt-5.1-codex-max");
     expect(cap.supported).toBe(true);
@@ -156,6 +162,13 @@ describe("applyReasoningEffort — codex-config shape", () => {
       config: { model_reasoning_effort: "xhigh" },
     });
   });
+
+  test("max on gpt-5.6-sol is applied", () => {
+    expect(applyReasoningEffort("codex", "gpt-5.6-sol", "max")).toEqual({
+      kind: "codex-config",
+      config: { model_reasoning_effort: "max" },
+    });
+  });
 });
 
 describe("applyReasoningEffort — pi-session shape", () => {

package/src/tests/schedule-target-type.test.ts

@@ -288,6 +288,56 @@ describe("dispatchScheduleTarget — script target", () => {
     expect(result.task).toBeUndefined();
   }, 15_000);
 
+  test("scheduled script runs receive ctx.api and ctx.mcp connections", async () => {
+    const { upsertScriptConnection } = await import("../be/script-connections");
+    await upsertScriptConnection({
+      slug: "schedgql",
+      kind: "graphql",
+      scope: "global",
+      baseUrl: "https://gql.vendor.test/graphql",
+      allowedHosts: ["gql.vendor.test"],
+      agentId,
+    });
+    const mcpRow = {
+      id: crypto.randomUUID(),
+      serverId: crypto.randomUUID(),
+      runtime: { slug: "schedmcp", kind: "mcp", connectionId: "", tools: [{ name: "ping" }] },
+    };
+    mcpRow.runtime.connectionId = mcpRow.id;
+    getDb()
+      .prepare(
+        `INSERT INTO mcp_servers (id, name, transport, scope, url, createdAt, lastUpdatedAt)
+         VALUES (?, ?, 'http', 'global', 'http://mcp.invalid.test/mcp', datetime('now'), datetime('now'))`,
+      )
+      .run(mcpRow.serverId, `sched-mcp-${mcpRow.serverId.slice(0, 8)}`);
+    getDb()
+      .prepare(
+        `INSERT INTO script_connections
+           (id, slug, kind, scope, allowed_hosts_json, mcp_server_id, generated_runtime_json)
+         VALUES (?, 'schedmcp', 'mcp', 'global', '[]', ?, ?)`,
+      )
+      .run(mcpRow.id, mcpRow.serverId, JSON.stringify(mcpRow.runtime));
+
+    await saveGlobalScript(
+      "schedule-target-type-ctx-connections",
+      `export default async (args, ctx) => {
+        if (!ctx.api || !("schedgql" in ctx.api)) throw new Error("ctx.api missing schedgql");
+        if (!ctx.mcp || !("schedmcp" in ctx.mcp)) throw new Error("ctx.mcp missing schedmcp");
+        return { ok: true };
+      };`,
+    );
+    const schedule = createScheduledTask({
+      name: `dispatch-script-ctx-${crypto.randomUUID()}`,
+      intervalMs: 60_000,
+      targetType: "script",
+      scriptName: "schedule-target-type-ctx-connections",
+      createdByAgentId: agentId,
+    });
+
+    const result = await dispatchScheduleTarget(schedule);
+    expect(result.triggeredWorkflows).toBe(false);
+  }, 15_000);
+
   test("throws a clear error when the script does not exist", async () => {
     const schedule = createScheduledTask({
       name: `dispatch-script-missing-${crypto.randomUUID()}`,

package/src/tests/scheduled-tasks.test.ts

@@ -4,11 +4,13 @@ import {
   closeDb,
   createAgent,
   createScheduledTask,
+  createUser,
   deleteScheduledTask,
   getDb,
   getScheduledTaskById,
   getScheduledTaskByName,
   getScheduledTasks,
+  getTaskById,
   initDb,
   updateScheduledTask,
 } from "../be/db";
@@ -315,6 +317,44 @@ describe("Scheduled Tasks Integration", () => {
       expect(afterRun?.lastRunAt).toBeDefined();
     });
 
+    test("fired task inherits the schedule's createdBy as requestedByUserId", async () => {
+      const requester = createUser({ name: "Schedule Requester", email: "sched-req@example.com" });
+      const schedule = createScheduledTask({
+        name: "test-manual-run-createdby",
+        cronExpression: "0 9 * * *",
+        taskTemplate: "Task carrying schedule provenance",
+        createdByAgentId: testAgent.id,
+        createdBy: requester.id,
+        enabled: true,
+      });
+
+      await runScheduleNow(schedule.id);
+
+      const createdTask = getDb()
+        .query("SELECT id FROM agent_tasks WHERE task = ? ORDER BY createdAt DESC LIMIT 1")
+        .get(schedule.taskTemplate) as { id: string };
+      const task = getTaskById(createdTask.id);
+      expect(task?.requestedByUserId).toBe(requester.id);
+    });
+
+    test("fired task has no requestedByUserId when the schedule's createdBy is unset (first-ever schedules)", async () => {
+      const schedule = createScheduledTask({
+        name: "test-manual-run-no-createdby",
+        cronExpression: "0 9 * * *",
+        taskTemplate: "Task with no schedule provenance",
+        createdByAgentId: testAgent.id,
+        enabled: true,
+      });
+
+      await runScheduleNow(schedule.id);
+
+      const createdTask = getDb()
+        .query("SELECT id FROM agent_tasks WHERE task = ? ORDER BY createdAt DESC LIMIT 1")
+        .get(schedule.taskTemplate) as { id: string };
+      const task = getTaskById(createdTask.id);
+      expect(task?.requestedByUserId ?? null).toBeNull();
+    });
+
     test("should throw error for non-existent schedule", async () => {
       await expect(runScheduleNow("non-existent-schedule-id")).rejects.toThrow(
         "Schedule not found",

package/src/tests/script-apis-mcp.test.ts

@@ -114,6 +114,7 @@ async function dispatchScriptsApi(url: string, init: RequestInit = {}): Promise<
 }
 
 let workerId: string;
+let leadId: string;
 let scriptId: string;
 let savedEnv: NodeJS.ProcessEnv;
 let savedFetch: typeof globalThis.fetch;
@@ -136,6 +137,7 @@ beforeAll(async () => {
   refreshSecretScrubberCache();
   setScriptEmbeddingProviderForTests(noOpEmbeddingProvider);
   workerId = createAgent({ name: "script-apis-mcp-worker", isLead: false, status: "idle" }).id;
+  leadId = createAgent({ name: "script-apis-mcp-lead", isLead: true, status: "idle" }).id;
   process.env.MCP_BASE_URL = "http://script-apis-mcp.test";
   globalThis.fetch = (async (input, init) => {
     const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
@@ -185,18 +187,43 @@ describe("script-apis MCP tool", () => {
     const tools = buildToolServer();
     const result = (await tools.scriptApis.handler(
       { action: "create", scriptId, authMode: "bearer", label: "demo" },
-      meta(workerId),
+      meta(leadId),
     )) as StructuredResult<{ id: string; token: string; authMode: string }>;
     expect(result.structuredContent.success).toBe(true);
     expect(result.structuredContent.data?.token).toMatch(/^xsk_/);
     expect(result.structuredContent.data?.authMode).toBe("bearer");
   });
 
-  test("list masks bearer tokens by default and reveals with includeSecrets", async () => {
+  test("non-lead agents cannot mint or reveal bearer tokens", async () => {
     const tools = buildToolServer();
+    const createDenied = (await tools.scriptApis.handler(
+      { action: "create", scriptId, authMode: "bearer", label: "demo" },
+      meta(workerId),
+    )) as StructuredResult<unknown>;
+    expect(createDenied.structuredContent.success).toBe(false);
+    expect(createDenied.structuredContent.status).toBe(403);
+    expect(createDenied.structuredContent.error).toContain("Only lead agents can create");
+
     const created = (await tools.scriptApis.handler(
       { action: "create", scriptId, authMode: "bearer" },
+      meta(leadId),
+    )) as StructuredResult<{ id: string; token: string }>;
+    expect(created.structuredContent.success).toBe(true);
+
+    const revealDenied = (await tools.scriptApis.handler(
+      { action: "list", scriptId, includeSecrets: true },
       meta(workerId),
+    )) as StructuredResult<unknown>;
+    expect(revealDenied.structuredContent.success).toBe(false);
+    expect(revealDenied.structuredContent.status).toBe(403);
+    expect(revealDenied.structuredContent.error).toContain("Only lead agents can reveal");
+  });
+
+  test("list masks bearer tokens by default and reveals with includeSecrets", async () => {
+    const tools = buildToolServer();
+    const created = (await tools.scriptApis.handler(
+      { action: "create", scriptId, authMode: "bearer" },
+      meta(leadId),
     )) as StructuredResult<{ id: string; token: string }>;
     const realToken = created.structuredContent.data?.token;
     expect(realToken).toBeTruthy();
@@ -209,17 +236,14 @@ describe("script-apis MCP tool", () => {
 
     const revealed = (await tools.scriptApis.handler(
       { action: "list", scriptId, includeSecrets: true },
-      meta(workerId),
+      meta(leadId),
     )) as StructuredResult<{ apis: Array<{ id: string; token: string | null }> }>;
     expect(revealed.structuredContent.data?.apis[0]?.token).toBe(realToken);
   });
 
   test("list returns a null token for authMode 'none'", async () => {
     const tools = buildToolServer();
-    await tools.scriptApis.handler(
-      { action: "create", scriptId, authMode: "none" },
-      meta(workerId),
-    );
+    await tools.scriptApis.handler({ action: "create", scriptId, authMode: "none" }, meta(leadId));
     const listed = (await tools.scriptApis.handler(
       { action: "list", scriptId },
       meta(workerId),
@@ -231,14 +255,14 @@ describe("script-apis MCP tool", () => {
     const tools = buildToolServer();
     const created = (await tools.scriptApis.handler(
       { action: "create", scriptId, authMode: "bearer" },
-      meta(workerId),
+      meta(leadId),
     )) as StructuredResult<{ id: string; token: string }>;
     const endpointId = created.structuredContent.data?.id as string;
     const oldToken = created.structuredContent.data?.token;
 
     const rotated = (await tools.scriptApis.handler(
       { action: "rotate", scriptId, endpointId },
-      meta(workerId),
+      meta(leadId),
     )) as StructuredResult<{ token: string }>;
     expect(rotated.structuredContent.success).toBe(true);
     expect(rotated.structuredContent.data?.token).toBeTruthy();
@@ -249,13 +273,13 @@ describe("script-apis MCP tool", () => {
     const tools = buildToolServer();
     const created = (await tools.scriptApis.handler(
       { action: "create", scriptId, authMode: "none" },
-      meta(workerId),
+      meta(leadId),
     )) as StructuredResult<{ id: string }>;
     const endpointId = created.structuredContent.data?.id as string;
 
     const updated = (await tools.scriptApis.handler(
       { action: "update", scriptId, endpointId, enabled: false, label: "renamed" },
-      meta(workerId),
+      meta(leadId),
     )) as StructuredResult<{ enabled: boolean; label: string | null }>;
     expect(updated.structuredContent.success).toBe(true);
     expect(updated.structuredContent.data?.enabled).toBe(false);
@@ -266,13 +290,13 @@ describe("script-apis MCP tool", () => {
     const tools = buildToolServer();
     const created = (await tools.scriptApis.handler(
       { action: "create", scriptId, authMode: "none" },
-      meta(workerId),
+      meta(leadId),
     )) as StructuredResult<{ id: string }>;
     const endpointId = created.structuredContent.data?.id as string;
 
     const deleted = (await tools.scriptApis.handler(
       { action: "delete", scriptId, endpointId },
-      meta(workerId),
+      meta(leadId),
     )) as StructuredResult<{ deleted: boolean }>;
     expect(deleted.structuredContent.success).toBe(true);
     expect(deleted.structuredContent.data?.deleted).toBe(true);