@desplega.ai/agent-swarm 1.149.1 → 1.151.0

package/src/tests/extensions-tool-call.test.ts

@@ -0,0 +1,288 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import * as z from "zod";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  getDbClient,
+  getKv,
+  getTaskById,
+  initDb,
+  startTask,
+} from "../be/db";
+import { installExtension, listExtensionRuns } from "../be/extensions/db";
+import { getExtensionBridgeToken, resolveBridgeCallOrigin } from "../extensions/dispatcher";
+import { enableExtension, stopExtensionRuntime } from "../extensions/lifecycle";
+import { registerStoreProgressTool } from "../tools/store-progress";
+import {
+  createToolRegistrar,
+  markExtensionRequestOrigin,
+  markScriptSdkRequestOrigin,
+  swarmToolOutputSchema,
+  toolOk,
+} from "../tools/utils";
+import type { ExtensionInstallBody } from "../types";
+import { loadBundleFixture } from "./fixtures/extensions/load";
+
+const TEST_DB_PATH = "./test-extensions-tool-call.sqlite";
+
+type RegisteredTool = {
+  handler: (argsOrExtra: unknown, extra?: unknown) => Promise<CallToolResult>;
+};
+
+function registeredTool(server: McpServer, name: string): RegisteredTool {
+  const tools = (server as unknown as { _registeredTools: Record<string, RegisteredTool> })
+    ._registeredTools;
+  const tool = tools[name];
+  if (!tool) throw new Error(`Tool "${name}" was not registered`);
+  return tool;
+}
+
+function meta(agentId: string) {
+  return {
+    sessionId: crypto.randomUUID(),
+    requestInfo: { headers: { "x-agent-id": agentId } },
+  };
+}
+
+async function removeDbFiles(): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    await Bun.file(TEST_DB_PATH + suffix)
+      .delete()
+      .catch(() => {});
+  }
+}
+
+async function enableFixture(name: string, config?: Record<string, unknown>) {
+  const bundle: ExtensionInstallBody = { ...(await loadBundleFixture(name)), config };
+  const installed = await installExtension(bundle);
+  return await enableExtension(installed.extension.id);
+}
+
+async function createProgressTarget() {
+  const agent = await createAgent({
+    name: `tool-hook-worker-${crypto.randomUUID()}`,
+    isLead: false,
+    status: "busy",
+    capabilities: [],
+  });
+  const task = await createTaskExtended("tool hook progress target", {
+    agentId: agent.id,
+    source: "mcp",
+  });
+  await startTask(task.id);
+  return { agent, task };
+}
+
+async function waitFor(predicate: () => Promise<boolean>, timeoutMs = 10_000): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (!(await predicate())) {
+    if (Date.now() >= deadline) throw new Error("Timed out while waiting for a tool hook");
+    await Bun.sleep(20);
+  }
+}
+
+describe("extension tool-call hooks", () => {
+  beforeAll(async () => {
+    await removeDbFiles();
+    initDb(TEST_DB_PATH);
+  });
+
+  afterAll(async () => {
+    await stopExtensionRuntime();
+    closeDb();
+    await removeDbFiles();
+  });
+
+  beforeEach(async () => {
+    await stopExtensionRuntime();
+    const client = getDbClient();
+    await client.run("DELETE FROM agent_tasks");
+    await client.run("DELETE FROM extensions");
+    await client.run("DELETE FROM kv_entries");
+  });
+
+  test("valid modified arguments reach the real store-progress tool", async () => {
+    const extension = await enableFixture("rewrite-progress-prefix", { prefix: "reviewed: " });
+    const { agent, task } = await createProgressTarget();
+    const server = new McpServer({ name: "tool-hook-rewrite", version: "1.0.0" });
+    registerStoreProgressTool(server);
+
+    const result = await registeredTool(server, "store-progress").handler(
+      { taskId: task.id, progress: "ready" },
+      meta(agent.id),
+    );
+
+    expect(result.isError).toBe(false);
+    expect((await getTaskById(task.id))?.progress).toBe("reviewed: ready");
+    expect(await listExtensionRuns(extension.id)).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ event: "pre.tool.call", action: "modify" }),
+      ]),
+    );
+  });
+
+  test("invalid modified arguments fail open and create an error run", async () => {
+    const extension = await enableFixture("rewrite-progress-prefix", {
+      prefix: "unused: ",
+      invalid: true,
+    });
+    const { agent, task } = await createProgressTarget();
+    const server = new McpServer({ name: "tool-hook-invalid", version: "1.0.0" });
+    registerStoreProgressTool(server);
+    const warning = spyOn(console, "warn").mockImplementation(() => {});
+
+    try {
+      const result = await registeredTool(server, "store-progress").handler(
+        { taskId: task.id, progress: "original" },
+        meta(agent.id),
+      );
+
+      expect(result.isError).toBe(false);
+      expect((await getTaskById(task.id))?.progress).toBe("original");
+      expect(warning).toHaveBeenCalledWith(
+        expect.stringContaining("Ignored invalid arguments from pre.tool.call"),
+      );
+      expect(await listExtensionRuns(extension.id)).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ event: "pre.tool.call", action: "error" }),
+        ]),
+      );
+    } finally {
+      warning.mockRestore();
+    }
+  });
+
+  test("a compliant call dispatches post.tool.call after finalization", async () => {
+    const extension = await enableFixture("no-exclamation-marks");
+    const server = new McpServer({ name: "tool-hook-post", version: "1.0.0" });
+    let callbackFinished = false;
+    createToolRegistrar(server)(
+      "store-progress",
+      {
+        inputSchema: z.object({ progress: z.string() }),
+        outputSchema: swarmToolOutputSchema(),
+      },
+      async () => {
+        await Bun.sleep(5);
+        callbackFinished = true;
+        return toolOk("Progress accepted.");
+      },
+    );
+
+    const result = await registeredTool(server, "store-progress").handler(
+      { progress: "done." },
+      meta(crypto.randomUUID()),
+    );
+    expect(result.isError).toBe(false);
+    expect(callbackFinished).toBe(true);
+
+    await waitFor(async () =>
+      (await listExtensionRuns(extension.id)).some((run) => run.event === "post.tool.call"),
+    );
+    const postRun = (await listExtensionRuns(extension.id)).find(
+      (run) => run.event === "post.tool.call",
+    );
+    expect(postRun).toMatchObject({ action: "continue" });
+    expect(postRun?.durationMs).toBeNumber();
+    const state = await getKv(
+      `task:agent:${extension.agentId}`,
+      "ext:no-exclamation-marks:last-post",
+    );
+    expect(state).not.toBeNull();
+    const postPayload = state?.value as {
+      tool: string;
+      args: unknown;
+      result: unknown;
+      durationMs: number;
+    };
+    expect(typeof postPayload.durationMs).toBe("number");
+    expect(postPayload.durationMs).toBeGreaterThanOrEqual(5);
+    expect(postPayload).toMatchObject({
+      tool: "store-progress",
+      args: { progress: "done." },
+      result: { ok: true, message: "Progress accepted." },
+    });
+  });
+
+  test("script SDK and extension origins bypass both hooks", async () => {
+    const extension = await enableFixture("no-exclamation-marks");
+    const server = new McpServer({ name: "tool-hook-origin", version: "1.0.0" });
+    createToolRegistrar(server)(
+      "store-progress",
+      {
+        inputSchema: z.object({ progress: z.string() }),
+        outputSchema: swarmToolOutputSchema(),
+      },
+      async () => toolOk("Progress accepted."),
+    );
+    const tool = registeredTool(server, "store-progress");
+
+    const scriptResult = await tool.handler(
+      { progress: "script!" },
+      markScriptSdkRequestOrigin(meta(crypto.randomUUID())),
+    );
+    const extensionResult = await tool.handler(
+      { progress: "extension!" },
+      markExtensionRequestOrigin(meta(extension.agentId!)),
+    );
+
+    expect(scriptResult.isError).toBe(false);
+    expect(extensionResult.isError).toBe(false);
+    await Bun.sleep(20);
+    expect(await listExtensionRuns(extension.id)).toEqual([]);
+  });
+
+  test("the bridge grants the extension origin only with the per-process token", async () => {
+    const extension = await enableFixture("no-exclamation-marks");
+    const agentId = extension.agentId!;
+    // A caller-controlled agent header alone must not claim the extension origin.
+    expect(resolveBridgeCallOrigin(agentId, undefined)).toBe("script-sdk");
+    expect(resolveBridgeCallOrigin(agentId, "forged")).toBe("script-sdk");
+    expect(resolveBridgeCallOrigin(crypto.randomUUID(), getExtensionBridgeToken())).toBe(
+      "script-sdk",
+    );
+    expect(resolveBridgeCallOrigin(agentId, getExtensionBridgeToken())).toBe("extension");
+  });
+
+  test("the no-input branch ignores modified arguments and still runs post hooks", async () => {
+    const rewritingExtension = await enableFixture("rewrite-progress-prefix", {
+      prefix: "ignored",
+      tool: "no-input",
+    });
+    const observingExtension = await enableFixture("no-exclamation-marks");
+    const server = new McpServer({ name: "tool-hook-no-input", version: "1.0.0" });
+    let callbackCalls = 0;
+    createToolRegistrar(server)("no-input", { outputSchema: swarmToolOutputSchema() }, async () => {
+      callbackCalls += 1;
+      return toolOk("No input accepted.");
+    });
+    const warning = spyOn(console, "warn").mockImplementation(() => {});
+
+    try {
+      const result = await registeredTool(server, "no-input").handler(meta(crypto.randomUUID()));
+
+      expect(result.isError).toBe(false);
+      expect(callbackCalls).toBe(1);
+      expect(warning).toHaveBeenCalledWith(
+        expect.stringContaining(
+          'tool "no-input" from extension "rewrite-progress-prefix" because the tool has no input schema',
+        ),
+      );
+      expect(await listExtensionRuns(rewritingExtension.id)).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ event: "pre.tool.call", action: "error" }),
+        ]),
+      );
+      await waitFor(async () =>
+        (await listExtensionRuns(observingExtension.id)).some(
+          (run) => run.event === "post.tool.call" && run.action === "continue",
+        ),
+      );
+    } finally {
+      warning.mockRestore();
+    }
+  });
+});

package/src/tests/extensions-validate.test.ts

@@ -0,0 +1,196 @@
+import { describe, expect, test } from "bun:test";
+import { validateBundle } from "../be/extensions/validate";
+import { loadBundleFixture } from "./fixtures/extensions/load";
+
+describe("extension bundle validation", () => {
+  test.each(["../escape.ts", "/abs.ts"])("rejects unsafe hooks path %s", async (path) => {
+    const bundle = await loadBundleFixture("minimal");
+    bundle.manifest.assets.hooks = path;
+    const result = await validateBundle(bundle);
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.diagnostics.join("\n")).toContain("relative POSIX file path");
+  });
+
+  test("reports each unsafe file key", async () => {
+    const bundle = await loadBundleFixture("minimal");
+    bundle.files["../escape.ts"] = "";
+    bundle.files["nested/../escape.ts"] = "";
+    const result = await validateBundle(bundle);
+    expect(result).toEqual({
+      ok: false,
+      diagnostics: [
+        'Unsafe bundle file path: "../escape.ts"',
+        'Unsafe bundle file path: "nested/../escape.ts"',
+      ],
+    });
+  });
+  test("accepts the minimal API extension", async () => {
+    const bundle = await loadBundleFixture("minimal");
+    expect(await validateBundle(bundle)).toEqual({ ok: true, manifest: bundle.manifest });
+  });
+
+  test("accepts zod and stdlib imports", async () => {
+    const bundle = await loadBundleFixture("minimal");
+    bundle.files["hooks.ts"] = `import { table } from "stdlib";
+import type { SwarmExtension } from "swarm-extension";
+import { z } from "zod";
+export const config = z.object({ label: z.string() });
+const extension: SwarmExtension = () => { void table([{ ok: true }]); };
+export default extension;
+`;
+    expect(await validateBundle(bundle)).toEqual({ ok: true, manifest: bundle.manifest });
+  });
+
+  test("infers typed config from the extension manifest", async () => {
+    const bundle = await loadBundleFixture("minimal");
+    bundle.files["hooks.ts"] = `import type { SwarmExtension } from "swarm-extension";
+import { z } from "zod";
+export const config = z.object({ channelId: z.string(), agentId: z.string() });
+const manifest = {
+  name: "minimal",
+  description: "Minimal extension",
+  version: "1.0.0",
+  runtime: "api",
+  assets: { hooks: "hooks.ts" },
+  config,
+} as const;
+const extension: SwarmExtension<typeof manifest> = (api) => {
+  api.on("pre.slack.route", (_event, ctx) => {
+    const channelId: string = ctx.config.channelId;
+    // @ts-expect-error channelId is inferred as a string.
+    const invalid: number = ctx.config.channelId;
+    void channelId;
+    void invalid;
+  });
+};
+export default extension;
+`;
+    expect(await validateBundle(bundle)).toEqual({ ok: true, manifest: bundle.manifest });
+  });
+
+  test("bare SwarmExtension uses API context", async () => {
+    const valid = await loadBundleFixture("minimal");
+    valid.files["hooks.ts"] = `import type { SwarmExtension } from "swarm-extension";
+const extension: SwarmExtension = (api) => {
+  api.on("post.task.created", (_event, ctx) => { void ctx.swarm; });
+};
+export default extension;
+`;
+    expect(await validateBundle(valid)).toEqual({ ok: true, manifest: valid.manifest });
+
+    const invalid = await loadBundleFixture("minimal");
+    invalid.files["hooks.ts"] = `import type { SwarmExtension } from "swarm-extension";
+const extension: SwarmExtension = (api) => {
+  api.on("post.task.created", (_event, ctx) => { void ctx.worker; });
+};
+export default extension;
+`;
+    const result = await validateBundle(invalid);
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.diagnostics.join("\n")).toContain("worker");
+  });
+
+  test("explicit worker extensions keep worker context typing", async () => {
+    const bundle = await loadBundleFixture("minimal");
+    bundle.files["hooks.ts"] = `import type { SwarmExtension } from "swarm-extension";
+type WorkerManifest = {
+  name: "worker";
+  description: "worker";
+  version: "1.0.0";
+  runtime: "worker";
+  assets: { hooks: "hooks.ts" };
+};
+const workerExtension: SwarmExtension<WorkerManifest> = (api) => {
+  api.on("post.task.created", (_event, ctx) => { const id: string = ctx.worker.agentId; void id; });
+};
+const extension: SwarmExtension = () => { void workerExtension; };
+export default extension;
+`;
+    expect(await validateBundle(bundle)).toEqual({ ok: true, manifest: bundle.manifest });
+  });
+
+  test("rejects forbidden bare and relative imports", async () => {
+    const badImport = await validateBundle(await loadBundleFixture("bad-import"));
+    expect(badImport.ok).toBe(false);
+    if (!badImport.ok) expect(badImport.diagnostics.join("\n")).toContain("node:fs");
+
+    const relative = await loadBundleFixture("minimal");
+    relative.files["hooks.ts"] = `import "./helper";\n${relative.files["hooks.ts"]}`;
+    const relativeResult = await validateBundle(relative);
+    expect(relativeResult.ok).toBe(false);
+    if (!relativeResult.ok) {
+      expect(relativeResult.diagnostics.join("\n")).toContain("Relative imports are not allowed");
+    }
+  });
+
+  test("rejects computed imports, require, and import-equals", async () => {
+    const cases = [
+      ['const name = "zod"; void import(name);', "Computed import()"],
+      ['const name = "zod"; void require(name);', "Computed require()"],
+      ['import fs = require("node:fs"); void fs;', "node:fs"],
+    ] as const;
+
+    for (const [prefix, diagnostic] of cases) {
+      const bundle = await loadBundleFixture("minimal");
+      bundle.files["hooks.ts"] = `${prefix}\n${bundle.files["hooks.ts"]}`;
+      const result = await validateBundle(bundle);
+      expect(result.ok).toBe(false);
+      if (!result.ok) expect(result.diagnostics.join("\n")).toContain(diagnostic);
+    }
+  });
+
+  test("rejects worker runtime and reserved assets", async () => {
+    const worker = await validateBundle(await loadBundleFixture("worker-runtime"));
+    expect(worker.ok).toBe(false);
+    if (!worker.ok) expect(worker.diagnostics).toContain('runtime "worker" is not supported in v1');
+
+    const reserved = await validateBundle(await loadBundleFixture("reserved-assets"));
+    expect(reserved.ok).toBe(false);
+    if (!reserved.ok)
+      expect(reserved.diagnostics).toContain("assets.skills is not supported in v1");
+  });
+
+  test("rejects extra files and a missing hooks file", async () => {
+    const extra = await loadBundleFixture("minimal");
+    extra.files["helper.ts"] = "export const helper = true;";
+    const extraResult = await validateBundle(extra);
+    expect(extraResult.ok).toBe(false);
+    if (!extraResult.ok) expect(extraResult.diagnostics.join("\n")).toContain("helper.ts");
+
+    const missing = await loadBundleFixture("minimal");
+    missing.manifest.assets.hooks = "missing.ts";
+    const missingResult = await validateBundle(missing);
+    expect(missingResult.ok).toBe(false);
+    if (!missingResult.ok) expect(missingResult.diagnostics.join("\n")).toContain("missing.ts");
+  });
+
+  test("rejects an invalid modify result", async () => {
+    const result = await validateBundle(await loadBundleFixture("bad-return-shape"));
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.diagnostics.join("\n")).toContain("agentId");
+    }
+  });
+
+  test("rejects derived task fields in a modify result", async () => {
+    const bundle = await loadBundleFixture("minimal");
+    bundle.files["hooks.ts"] = `import type { SwarmExtension } from "swarm-extension";
+const extension: SwarmExtension = (api) => {
+  api.on("pre.task.create", () => ({ action: "modify", data: { status: "draft" } }));
+};
+export default extension;
+`;
+    const result = await validateBundle(bundle);
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.diagnostics.join("\n")).toContain("status");
+  });
+
+  test("rejects a non-Zod config export", async () => {
+    const bundle = await loadBundleFixture("minimal");
+    bundle.files["hooks.ts"] = `${bundle.files["hooks.ts"]}\nexport const config = {};\n`;
+    const result = await validateBundle(bundle);
+    expect(result.ok).toBe(false);
+    if (!result.ok)
+      expect(result.diagnostics.join("\n")).toContain("not assignable to type 'false'");
+  });
+});

package/src/tests/fixtures/extensions/bad-import/hooks.ts

@@ -0,0 +1,8 @@
+import fs from "node:fs";
+import type { SwarmExtension } from "swarm-extension";
+
+const extension: SwarmExtension = () => {
+  void fs;
+};
+
+export default extension;

package/src/tests/fixtures/extensions/bad-import/manifest.json

@@ -0,0 +1,9 @@
+{
+  "name": "bad-import",
+  "description": "Extension with a forbidden import",
+  "version": "1.0.0",
+  "runtime": "api",
+  "assets": {
+    "hooks": "hooks.ts"
+  }
+}

package/src/tests/fixtures/extensions/bad-return-shape/hooks.ts

@@ -0,0 +1,10 @@
+import type { SwarmExtension } from "swarm-extension";
+
+const extension: SwarmExtension = (api) => {
+  api.on("pre.slack.route", () => ({
+    action: "modify",
+    data: { target: { kind: "agent" } },
+  }));
+};
+
+export default extension;

package/src/tests/fixtures/extensions/bad-return-shape/manifest.json

@@ -0,0 +1,9 @@
+{
+  "name": "bad-return-shape",
+  "description": "Extension with an invalid modify result",
+  "version": "1.0.0",
+  "runtime": "api",
+  "assets": {
+    "hooks": "hooks.ts"
+  }
+}

package/src/tests/fixtures/extensions/block-tasks-from-source/hooks.ts

@@ -0,0 +1,22 @@
+import { block, type SwarmExtension } from "swarm-extension";
+import { z } from "zod";
+
+export const config = z.object({ source: z.string() });
+const manifest = {
+  name: "block-tasks-from-source",
+  description: "Blocks tasks from a configured source or origin",
+  version: "1.0.0",
+  runtime: "api",
+  assets: { hooks: "hooks.ts" },
+  config,
+} as const;
+
+const extension: SwarmExtension<typeof manifest> = (api) => {
+  api.on("pre.task.create", (event, ctx) => {
+    if (event.origin === ctx.config.source || event.options.source === ctx.config.source) {
+      return block(`Task source ${ctx.config.source} is blocked`);
+    }
+  });
+};
+
+export default extension;

package/src/tests/fixtures/extensions/block-tasks-from-source/manifest.json

@@ -0,0 +1,9 @@
+{
+  "name": "block-tasks-from-source",
+  "description": "Blocks tasks from a configured source or origin",
+  "version": "1.0.0",
+  "runtime": "api",
+  "assets": {
+    "hooks": "hooks.ts"
+  }
+}

package/src/tests/fixtures/extensions/ignore-channel/hooks.ts

@@ -0,0 +1,22 @@
+import type { SwarmExtension } from "swarm-extension";
+import { z } from "zod";
+
+export const config = z.object({ channelId: z.string() });
+
+const manifest = {
+  name: "ignore-channel",
+  description: "Ignores Slack messages in one configured channel",
+  version: "1.0.0",
+  runtime: "api",
+  assets: { hooks: "hooks.ts" },
+  config,
+} as const;
+
+const extension: SwarmExtension<typeof manifest> = (api) => {
+  api.on("pre.slack.route", (event, ctx) => {
+    if (event.channelId !== ctx.config.channelId) return;
+    return { action: "block", reason: "This channel is ignored" };
+  });
+};
+
+export default extension;

package/src/tests/fixtures/extensions/ignore-channel/manifest.json

@@ -0,0 +1,9 @@
+{
+  "name": "ignore-channel",
+  "description": "Ignores Slack messages in one configured channel",
+  "version": "1.0.0",
+  "runtime": "api",
+  "assets": {
+    "hooks": "hooks.ts"
+  }
+}

package/src/tests/fixtures/extensions/load.ts

@@ -0,0 +1,10 @@
+import type { ExtensionInstallBody } from "../../../types";
+
+export async function loadBundleFixture(name: string): Promise<ExtensionInstallBody> {
+  const directory = new URL(`./${name}/`, import.meta.url);
+  const manifest = (await Bun.file(
+    new URL("manifest.json", directory),
+  ).json()) as ExtensionInstallBody["manifest"];
+  const hooks = await Bun.file(new URL(manifest.assets.hooks, directory)).text();
+  return { manifest, files: { [manifest.assets.hooks]: hooks } };
+}

package/src/tests/fixtures/extensions/minimal/hooks.ts

@@ -0,0 +1,7 @@
+import type { SwarmExtension } from "swarm-extension";
+
+const extension: SwarmExtension = (api) => {
+  api.on("pre.task.create", () => ({ action: "continue" }));
+};
+
+export default extension;

package/src/tests/fixtures/extensions/minimal/manifest.json

@@ -0,0 +1,9 @@
+{
+  "name": "minimal",
+  "description": "Minimal extension",
+  "version": "1.0.0",
+  "runtime": "api",
+  "assets": {
+    "hooks": "hooks.ts"
+  }
+}

package/src/tests/fixtures/extensions/never-fail-long-tasks/hooks.ts

@@ -0,0 +1,11 @@
+import { modify, type SwarmExtension } from "swarm-extension";
+
+const extension: SwarmExtension = (api) => {
+  api.on("pre.heartbeat.remediate", (event) => {
+    if (event.proposedAction === "fail") {
+      return modify({ proposedAction: "record" });
+    }
+  });
+};
+
+export default extension;

package/src/tests/fixtures/extensions/never-fail-long-tasks/manifest.json

@@ -0,0 +1,9 @@
+{
+  "name": "never-fail-long-tasks",
+  "description": "Records stalled tasks instead of failing them",
+  "version": "1.0.0",
+  "runtime": "api",
+  "assets": {
+    "hooks": "hooks.ts"
+  }
+}

package/src/tests/fixtures/extensions/no-exclamation-marks/hooks.ts

@@ -0,0 +1,23 @@
+import { block, type SwarmExtension } from "swarm-extension";
+
+const extension: SwarmExtension = (api) => {
+  api.on("pre.tool.call", (event) => {
+    if (event.tool !== "store-progress") return;
+    if (!event.args || typeof event.args !== "object") return;
+    const progress = (event.args as { progress?: unknown }).progress;
+    if (typeof progress === "string" && progress.includes("!")) {
+      return block("Progress text must not contain exclamation marks.");
+    }
+  });
+
+  api.on("post.tool.call", async (event, ctx) => {
+    await ctx.state.set("last-post", {
+      tool: event.tool,
+      args: event.args,
+      result: event.result,
+      durationMs: event.durationMs,
+    });
+  });
+};
+
+export default extension;