@desplega.ai/agent-swarm 1.166.0 → 1.168.0

package/src/tests/claude-background-keepalive.fixture.ts

@@ -0,0 +1,162 @@
+// Fake Claude binary for the background-keepalive wiring tests. It speaks just
+// enough of both transports: the SDK initialize handshake on stdin, and the
+// stream-json stdout that the CLI and SDK sessions both parse. After one turn it
+// goes silent, the way Claude does while it waits on a background job, until the
+// test steps it through the control file (one command per line).
+const transport = process.env.BG_FIXTURE_TRANSPORT;
+const controlFile = process.env.BG_FIXTURE_CONTROL;
+const withBackgroundTask = process.env.BG_FIXTURE_BACKGROUND === "1";
+const sessionId = "22222222-2222-4222-8222-222222222222";
+
+if (process.argv.includes("--version")) {
+  console.log("2.1.263 (Claude Code)");
+  process.exit(0);
+}
+
+if ((transport !== "cli" && transport !== "sdk") || !controlFile) {
+  console.error("BG_FIXTURE_TRANSPORT (cli|sdk) and BG_FIXTURE_CONTROL are required");
+  process.exit(2);
+}
+
+function writeMessage(message: Record<string, unknown>): void {
+  console.log(JSON.stringify(message));
+}
+
+function backgroundTasksChanged(tasks: Array<Record<string, unknown>>): void {
+  writeMessage({
+    type: "system",
+    subtype: "background_tasks_changed",
+    tasks,
+    uuid: crypto.randomUUID(),
+    session_id: sessionId,
+  });
+}
+
+const usage = {
+  input_tokens: 10,
+  output_tokens: 1,
+  cache_read_input_tokens: 0,
+  cache_creation_input_tokens: 0,
+};
+
+let started = false;
+
+async function runTurn(): Promise<void> {
+  if (started) return;
+  started = true;
+  writeMessage({
+    type: "system",
+    subtype: "init",
+    session_id: sessionId,
+    model: "claude-haiku-4-5",
+    tools: [],
+    mcp_servers: [],
+    plugins: [],
+    permissionMode: "bypassPermissions",
+    slash_commands: [],
+    apiKeySource: "none",
+    cwd: process.cwd(),
+    claude_code_version: "2.1.263",
+    output_style: "default",
+    skills: [],
+    uuid: crypto.randomUUID(),
+  });
+  if (withBackgroundTask) {
+    backgroundTasksChanged([
+      { task_id: "bg-1", task_type: "local_bash", description: "Wait for TLC" },
+    ]);
+  }
+  writeMessage({
+    type: "assistant",
+    message: {
+      id: "message-1",
+      type: "message",
+      role: "assistant",
+      model: "claude-haiku-4-5",
+      content: [{ type: "text", text: "Waiting for the background job to finish." }],
+      stop_reason: "end_turn",
+      stop_sequence: null,
+      usage,
+    },
+    parent_tool_use_id: null,
+    uuid: crypto.randomUUID(),
+    session_id: sessionId,
+  });
+  writeMessage({
+    type: "result",
+    subtype: "success",
+    duration_ms: 1,
+    duration_api_ms: 1,
+    is_error: false,
+    num_turns: 1,
+    result: "Waiting for the background job to finish.",
+    stop_reason: "end_turn",
+    total_cost_usd: 0.001,
+    usage,
+    modelUsage: {},
+    permission_denials: [],
+    queued_turn_count: 0,
+    uuid: crypto.randomUUID(),
+    session_id: sessionId,
+  });
+
+  // Silent from here on, except for what the test asks for.
+  let handled = 0;
+  for (;;) {
+    const file = Bun.file(controlFile as string);
+    const commands = (await file.exists()) ? (await file.text()).split("\n").filter(Boolean) : [];
+    while (handled < commands.length) {
+      const command = commands[handled++];
+      if (command === "empty") backgroundTasksChanged([]);
+      if (command === "exit") process.exit(0);
+      if (command === "fail") {
+        console.error("Error: fixture process crashed");
+        process.exit(1);
+      }
+    }
+    await Bun.sleep(10);
+  }
+}
+
+async function readSdkInput(): Promise<void> {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  for await (const chunk of Bun.stdin.stream()) {
+    buffer += decoder.decode(chunk, { stream: true });
+    let newline = buffer.indexOf("\n");
+    while (newline >= 0) {
+      const line = buffer.slice(0, newline).trim();
+      buffer = buffer.slice(newline + 1);
+      newline = buffer.indexOf("\n");
+      if (!line) continue;
+      const message = JSON.parse(line) as {
+        type?: string;
+        request_id?: string;
+        request?: { subtype?: string };
+      };
+      if (message.type === "control_request" && message.request?.subtype === "initialize") {
+        writeMessage({
+          type: "control_response",
+          response: {
+            subtype: "success",
+            request_id: message.request_id ?? "fixture-initialize",
+            response: {
+              commands: [],
+              agents: [],
+              output_style: "default",
+              available_output_styles: [],
+              models: [],
+              account: {},
+            },
+          },
+        });
+      } else if (message.type === "user") {
+        void runTurn();
+      }
+    }
+  }
+}
+
+// The CLI transport passes the prompt with -p; the SDK sends it on stdin.
+if (transport === "sdk") void readSdkInput();
+else await runTurn();

package/src/tests/claude-background-keepalive.test.ts

@@ -0,0 +1,139 @@
+import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+import { ClaudeBackgroundKeepalive } from "../providers/claude-background-keepalive";
+
+// The keepalive's contract is the HTTP heartbeat it sends while Claude idles on
+// background work. A local server records those requests; short intervals keep
+// the timing real without fake clocks.
+const INTERVAL_MS = 20;
+// Real timers under CI's parallel load can slip a tick; retry instead of
+// widening every window.
+const TIMING = { retry: 2 };
+const received: Array<{ method: string; path: string; auth: string | null; agent: string | null }> =
+  [];
+const server = Bun.serve({
+  port: 0,
+  fetch(req) {
+    const url = new URL(req.url);
+    received.push({
+      method: req.method,
+      path: url.pathname,
+      auth: req.headers.get("authorization"),
+      agent: req.headers.get("x-agent-id"),
+    });
+    return Response.json({ updated: true });
+  },
+});
+
+afterAll(() => server.stop(true));
+beforeEach(() => {
+  received.length = 0;
+});
+
+function keepalive(maxIdleMs?: number, apiUrl = `http://127.0.0.1:${server.port}`) {
+  return new ClaudeBackgroundKeepalive({
+    apiUrl,
+    apiKey: "key-123",
+    agentId: "agent-1",
+    taskId: "task-1",
+    intervalMs: INTERVAL_MS,
+    maxIdleMs,
+  });
+}
+
+const bgChanged = (tasks: Array<Record<string, unknown>>) => ({
+  type: "system",
+  subtype: "background_tasks_changed",
+  tasks,
+});
+
+describe("ClaudeBackgroundKeepalive", () => {
+  test(
+    "keeps heartbeating after the turn ends while a background Bash job is live",
+    async () => {
+      const k = keepalive();
+      // Message order from the stalled run: the backgrounded Bash joins the set,
+      // the assistant ends its turn, then the process goes silent.
+      k.observe(
+        bgChanged([{ task_id: "bscveebhn", task_type: "local_bash", description: "Wait for TLC" }]),
+      );
+      k.observe({ type: "assistant" });
+      k.observe({ type: "result", subtype: "success" });
+      await Bun.sleep(INTERVAL_MS * 6);
+      k.stop();
+
+      expect(received.length).toBeGreaterThanOrEqual(3);
+      expect(received[0]).toEqual({
+        method: "PUT",
+        path: "/api/active-sessions/heartbeat/task-1",
+        auth: "Bearer key-123",
+        agent: "agent-1",
+      });
+    },
+    TIMING,
+  );
+
+  test(
+    "a silent session with no background work sends nothing, so it still goes stale",
+    async () => {
+      const k = keepalive();
+      k.observe({ type: "assistant" });
+      k.observe({ type: "result", subtype: "success" });
+      // Ambient watchers are not activity either.
+      k.observe(bgChanged([{ task_id: "watcher", ambient: true }]));
+      await Bun.sleep(INTERVAL_MS * 5);
+      k.stop();
+      expect(received).toHaveLength(0);
+    },
+    TIMING,
+  );
+
+  test(
+    "stops when the background set empties",
+    async () => {
+      const k = keepalive();
+      k.observe(bgChanged([{ task_id: "a" }, { task_id: "b" }]));
+      await Bun.sleep(INTERVAL_MS * 3);
+      k.observe(bgChanged([]));
+      await Bun.sleep(INTERVAL_MS);
+      const settled = received.length;
+      expect(settled).toBeGreaterThan(0);
+      await Bun.sleep(INTERVAL_MS * 4);
+      k.stop();
+      expect(received).toHaveLength(settled);
+    },
+    TIMING,
+  );
+
+  test(
+    "a background job that never settles is covered only up to the idle cap",
+    async () => {
+      const k = keepalive(INTERVAL_MS * 3);
+      k.observe(bgChanged([{ task_id: "hung" }]));
+      await Bun.sleep(INTERVAL_MS * 6);
+      const capped = received.length;
+      expect(capped).toBeGreaterThan(0);
+      await Bun.sleep(INTERVAL_MS * 4);
+      expect(received).toHaveLength(capped);
+
+      // New output from the session restarts coverage while the job is live.
+      k.observe({ type: "assistant" });
+      await Bun.sleep(INTERVAL_MS * 2);
+      k.stop();
+      expect(received.length).toBeGreaterThan(capped);
+    },
+    TIMING,
+  );
+
+  test(
+    "stop() ends the keepalive and ignores later messages",
+    async () => {
+      const k = keepalive();
+      k.observe(bgChanged([{ task_id: "a" }]));
+      k.stop();
+      k.observe(bgChanged([{ task_id: "b" }]));
+      await Bun.sleep(INTERVAL_MS * 4);
+      expect(received).toHaveLength(0);
+    },
+    TIMING,
+  );
+});

package/src/tests/claude-default-route.test.ts

@@ -12,6 +12,7 @@ import {
 import {
   buildClaudeSessionEnvironment,
   checkClaudeCredentials,
+  claudeOpenRouterAttributionEnv,
   resolveClaudeBinaryArgv,
   withClaudeRouteEnv,
 } from "../providers/claude-adapter";
@@ -258,3 +259,77 @@ describe("internal-ai credential", () => {
     expect(cred?.kind).toBe("anthropic");
   });
 });
+
+describe("claude OpenRouter attribution", () => {
+  const OPENROUTER = {
+    ANTHROPIC_BASE_URL: "https://openrouter.ai/api",
+    ANTHROPIC_AUTH_TOKEN: "sk-or",
+  };
+  const ATTRIBUTION = [
+    "HTTP-Referer: https://agent-swarm.dev",
+    "X-OpenRouter-Title: Agent Swarm",
+    "X-OpenRouter-Categories: personal-agent,cloud-agent",
+  ];
+  const spawnEnv = (env: Record<string, string>) =>
+    buildClaudeSessionEnvironment(
+      {
+        taskId: crypto.randomUUID(),
+        agentId: crypto.randomUUID(),
+        env,
+        apiUrl: "http://fixture.invalid",
+        apiKey: "example-fixture-swarm-key",
+      } as ProviderSessionConfig,
+      "sonnet",
+      "/tmp/fixture-task",
+    ).env;
+
+  test("an openrouter.ai base URL appends the attribution headers", () => {
+    expect(spawnEnv(OPENROUTER).ANTHROPIC_CUSTOM_HEADERS).toBe(ATTRIBUTION.join("\n"));
+  });
+
+  test("the operator's header lines are kept in order; ours replace same-name lines", () => {
+    const env = spawnEnv({
+      ...OPENROUTER,
+      ANTHROPIC_CUSTOM_HEADERS:
+        "X-Gateway-Key: secret\nhttp-referer: https://mine.example\nX-Team: a",
+    });
+    expect(env.ANTHROPIC_CUSTOM_HEADERS).toBe(
+      ["X-Gateway-Key: secret", "X-Team: a", ...ATTRIBUTION].join("\n"),
+    );
+  });
+
+  test("unset, Anthropic, gateway and lookalike base URLs leave ANTHROPIC_CUSTOM_HEADERS byte-identical", () => {
+    const operator = "X-Gateway-Key: secret\n\nX-Team: a  ";
+    for (const base of [
+      {},
+      { ANTHROPIC_BASE_URL: "https://api.anthropic.com" },
+      { ANTHROPIC_BASE_URL: GATEWAY_URL },
+      { ANTHROPIC_BASE_URL: "https://openrouter.ai.evil.example/api" },
+      { ANTHROPIC_BASE_URL: "not a url" },
+    ]) {
+      expect(claudeOpenRouterAttributionEnv(base)).toEqual({});
+      expect(
+        spawnEnv({ ...base, ANTHROPIC_API_KEY: "sk-ant" }).ANTHROPIC_CUSTOM_HEADERS,
+      ).toBeUndefined();
+      expect(
+        spawnEnv({ ...base, ANTHROPIC_API_KEY: "sk-ant", ANTHROPIC_CUSTOM_HEADERS: operator })
+          .ANTHROPIC_CUSTOM_HEADERS,
+      ).toBe(operator);
+    }
+  });
+
+  test("OPENROUTER_APP_ATTRIBUTION=false leaves the operator's value untouched", () => {
+    for (const off of ["false", "0", "FALSE"]) {
+      expect(
+        spawnEnv({
+          ...OPENROUTER,
+          OPENROUTER_APP_ATTRIBUTION: off,
+          ANTHROPIC_CUSTOM_HEADERS: "X-A: b",
+        }).ANTHROPIC_CUSTOM_HEADERS,
+      ).toBe("X-A: b");
+      expect(
+        spawnEnv({ ...OPENROUTER, OPENROUTER_APP_ATTRIBUTION: off }).ANTHROPIC_CUSTOM_HEADERS,
+      ).toBe(undefined);
+    }
+  });
+});

package/src/tests/claude-hook-output.test.ts

@@ -0,0 +1,233 @@
+/**
+ * Claude Code hook stdout contract.
+ *
+ * Claude Code parses hook stdout as JSON only when the whole stdout is one
+ * JSON object. A plain status line before a block made the block land as
+ * text, and the tool call ran anyway. Plain stdout on PreToolUse/PostToolUse
+ * never reaches the model, so nudges on those events must be JSON
+ * `additionalContext`.
+ *
+ * Each test runs the real hook as a subprocess against a fake API.
+ */
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import pkg from "../../package.json";
+import { CHILD_PROCESS_TEST_BUDGET_MS, runChild } from "./test-proc";
+
+const SERVER_NAME = pkg.config?.name ?? "agent-swarm";
+const HOOK_PATH = join(import.meta.dir, "..", "hooks", "hook.ts");
+
+type FakeState = {
+  isLead: boolean;
+  cancelledTaskId: string | null;
+  shouldBlockPolling: boolean;
+};
+
+const state: FakeState = { isLead: false, cancelledTaskId: null, shouldBlockPolling: false };
+let server: ReturnType<typeof Bun.serve>;
+let projectDir: string;
+
+beforeAll(async () => {
+  server = Bun.serve({
+    port: 0,
+    fetch(req) {
+      const url = new URL(req.url);
+      if (url.pathname === "/me") {
+        return Response.json({
+          id: "00000000-0000-4000-8000-000000000001",
+          name: "probe",
+          isLead: state.isLead,
+          status: "busy",
+          shouldBlockPolling: state.shouldBlockPolling,
+          inbox: {
+            unreadCount: 2,
+            mentionsCount: 0,
+            offeredTasksCount: 1,
+            poolTasksCount: 0,
+            inProgressCount: 1,
+            recentMentions: [],
+          },
+        });
+      }
+      if (url.pathname === "/cancelled-tasks") {
+        const cancelled = state.cancelledTaskId
+          ? [{ id: state.cancelledTaskId, task: "t", failureReason: "stop now" }]
+          : [];
+        return Response.json({ cancelled });
+      }
+      return Response.json({ ok: true });
+    },
+  });
+  projectDir = await mkdtemp(join(tmpdir(), "claude-hook-output-"));
+  await Bun.write(
+    join(projectDir, ".mcp.json"),
+    JSON.stringify({
+      mcpServers: {
+        [SERVER_NAME]: {
+          url: `http://127.0.0.1:${server.port}/mcp`,
+          headers: {
+            Authorization: "Bearer test",
+            "X-Agent-ID": "00000000-0000-4000-8000-000000000001",
+          },
+        },
+      },
+    }),
+  );
+});
+
+afterAll(async () => {
+  server.stop(true);
+  await rm(projectDir, { recursive: true, force: true });
+});
+
+async function runHook(event: Record<string, unknown>, taskId: string) {
+  const taskFile = join(projectDir, `task-${taskId}.json`);
+  await Bun.write(
+    taskFile,
+    JSON.stringify({ taskId, agentId: "a", startedAt: new Date().toISOString() }),
+  );
+  const env: Record<string, string | undefined> = {
+    ...process.env,
+    CLAUDE_PROJECT_DIR: projectDir,
+    TASK_FILE: taskFile,
+  };
+  return runChild(["bun", HOOK_PATH], {
+    cwd: projectDir,
+    env,
+    stdin: JSON.stringify({ cwd: projectDir, ...event }),
+  });
+}
+
+/** Assert stdout is exactly one JSON object and return it. */
+function parseSoleJson(stdout: string): Record<string, unknown> {
+  const trimmed = stdout.trim();
+  expect(trimmed.split("\n")).toHaveLength(1);
+  return JSON.parse(trimmed) as Record<string, unknown>;
+}
+
+const bashTouch = {
+  tool_name: "Bash",
+  tool_input: { command: "touch /tmp/probe" },
+};
+
+describe("claude hook stdout", () => {
+  test(
+    "blocked PreToolUse prints exactly one deny JSON object",
+    async () => {
+      const taskId = crypto.randomUUID();
+      Object.assign(state, { isLead: false, cancelledTaskId: taskId, shouldBlockPolling: false });
+      const result = await runHook({ hook_event_name: "PreToolUse", ...bashTouch }, taskId);
+      expect(result.exitCode).toBe(0);
+      const out = parseSoleJson(result.stdout) as {
+        hookSpecificOutput: Record<string, string>;
+      };
+      expect(out.hookSpecificOutput.hookEventName).toBe("PreToolUse");
+      expect(out.hookSpecificOutput.permissionDecision).toBe("deny");
+      expect(out.hookSpecificOutput.permissionDecisionReason).toContain("TASK CANCELLED");
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test(
+    "blocked UserPromptSubmit prints only the block JSON, no status line",
+    async () => {
+      const taskId = crypto.randomUUID();
+      Object.assign(state, { isLead: false, cancelledTaskId: taskId, shouldBlockPolling: false });
+      const result = await runHook({ hook_event_name: "UserPromptSubmit", prompt: "go" }, taskId);
+      expect(result.exitCode).toBe(0);
+      const out = parseSoleJson(result.stdout);
+      expect(out.decision).toBe("block");
+      expect(String(out.reason)).toContain("TASK CANCELLED");
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test(
+    "UserPromptSubmit without a block still prints the status line and tray",
+    async () => {
+      Object.assign(state, { isLead: false, cancelledTaskId: null, shouldBlockPolling: false });
+      const result = await runHook(
+        { hook_event_name: "UserPromptSubmit", prompt: "go" },
+        crypto.randomUUID(),
+      );
+      expect(result.stdout).toContain('You are registered as worker agent "probe"');
+      expect(result.stdout).toContain("📬 2 unread");
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test(
+    "unblocked PreToolUse prints nothing on stdout",
+    async () => {
+      Object.assign(state, { isLead: false, cancelledTaskId: null, shouldBlockPolling: false });
+      const result = await runHook(
+        { hook_event_name: "PreToolUse", ...bashTouch },
+        crypto.randomUUID(),
+      );
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout.trim()).toBe("");
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test(
+    "polling limit blocks poll-task with one deny JSON object",
+    async () => {
+      Object.assign(state, { isLead: true, cancelledTaskId: null, shouldBlockPolling: true });
+      const result = await runHook(
+        { hook_event_name: "PreToolUse", tool_name: "mcp__agent-swarm__poll-task", tool_input: {} },
+        crypto.randomUUID(),
+      );
+      const out = parseSoleJson(result.stdout) as {
+        hookSpecificOutput: Record<string, string>;
+      };
+      expect(out.hookSpecificOutput.permissionDecision).toBe("deny");
+      expect(out.hookSpecificOutput.permissionDecisionReason).toContain("POLLING LIMIT");
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test(
+    "loop warning reaches the model as PreToolUse additionalContext",
+    async () => {
+      Object.assign(state, { isLead: false, cancelledTaskId: null, shouldBlockPolling: false });
+      const taskId = crypto.randomUUID();
+      let stdout = "";
+      try {
+        for (let i = 0; i < 14 && stdout.trim() === ""; i++) {
+          stdout = (await runHook({ hook_event_name: "PreToolUse", ...bashTouch }, taskId)).stdout;
+        }
+      } finally {
+        await rm(`/tmp/agent-swarm-tool-history/${taskId}.json`, { force: true });
+      }
+      const out = parseSoleJson(stdout) as { hookSpecificOutput: Record<string, string> };
+      expect(out.hookSpecificOutput.hookEventName).toBe("PreToolUse");
+      expect(out.hookSpecificOutput.additionalContext).toStartWith("Warning: ");
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS * 3,
+  );
+
+  test(
+    "lead send-task reminder reaches the model as PostToolUse additionalContext",
+    async () => {
+      Object.assign(state, { isLead: true, cancelledTaskId: null, shouldBlockPolling: false });
+      const result = await runHook(
+        {
+          hook_event_name: "PostToolUse",
+          tool_name: "mcp__agent-swarm__send-task",
+          tool_input: {},
+          tool_response: { task: { id: "task-123" } },
+        },
+        crypto.randomUUID(),
+      );
+      const out = parseSoleJson(result.stdout) as {
+        hookSpecificOutput: Record<string, string>;
+      };
+      expect(out.hookSpecificOutput.hookEventName).toBe("PostToolUse");
+      expect(out.hookSpecificOutput.additionalContext).toContain("Task ID: task-123.");
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+});

package/src/tests/codex-adapter-pool-auth-revalidate.test.ts

@@ -34,6 +34,7 @@
 import { afterAll, afterEach, beforeAll, describe, expect, it } from "bun:test";
 import { unlink } from "node:fs/promises";
 import { createServer, type Server } from "node:http";
+import { join } from "node:path";
 import { closeDb, initDb } from "../be/db";
 import { handleOAuthLocks } from "../http/oauth-locks";
 import { resolveCodexAuthMode } from "../providers/codex-adapter.js";
@@ -45,6 +46,7 @@ const TEST_DB_PATH = "./test-codex-adapter-pool-auth-revalidate.sqlite";
 const MOCK_API_URL = "http://localhost:3013";
 const MOCK_API_KEY = "example-test-api-key";
 const FAKE_HOME = "/home/fake-pool-worker";
+const FAKE_AUTH_PATH = join(FAKE_HOME, ".codex", "auth.json");
 
 process.env.SECRETS_ENCRYPTION_KEY = Buffer.alloc(32, 4).toString("base64");
 
@@ -106,14 +108,14 @@ function fakeAuthJsonFs(initialContent: string) {
   let file: string | null = initialContent;
   const fs = {
     readFile: async (path: string): Promise<string> => {
-      if (path !== `${FAKE_HOME}/.codex/auth.json` || file === null) {
+      if (path !== FAKE_AUTH_PATH || file === null) {
         throw new Error("ENOENT");
       }
       return file;
     },
     mkdir: async (): Promise<undefined> => undefined,
     writeFile: async (path: string, data: string): Promise<void> => {
-      expect(path).toBe(`${FAKE_HOME}/.codex/auth.json`);
+      expect(path).toBe(FAKE_AUTH_PATH);
       file = data;
     },
   };