@stigmer/mcp-server 3.34.0 → 3.36.0

package/src/domains/rpcerr.test.ts

@@ -1,62 +0,0 @@
-import { Code, ConnectError } from "@connectrpc/connect";
-import { beforeAll, describe, expect, it } from "vitest";
-
-import { configureLogger } from "../logger";
-import { rpcError } from "./rpcerr";
-
-beforeAll(() => configureLogger({ level: "error", format: "text" }));
-
-const resource = 'agent "code-reviewer" in org "stigmer"';
-
-describe("rpcError", () => {
-  it("maps NotFound to a slug-guidance message", () => {
-    expect(rpcError(new ConnectError("missing", Code.NotFound), resource).message).toBe(
-      'agent "code-reviewer" in org "stigmer" not found. Verify the org and slug are correct.',
-    );
-  });
-
-  it("maps PermissionDenied to an API-key-permissions message", () => {
-    expect(rpcError(new ConnectError("nope", Code.PermissionDenied), resource).message).toBe(
-      'Permission denied for agent "code-reviewer" in org "stigmer". Check your API key permissions.',
-    );
-  });
-
-  it("maps Unauthenticated", () => {
-    expect(rpcError(new ConnectError("bad token", Code.Unauthenticated), resource).message).toBe(
-      "Authentication failed. Check your API key.",
-    );
-  });
-
-  it("maps Unavailable", () => {
-    expect(rpcError(new ConnectError("down", Code.Unavailable), resource).message).toBe(
-      "Stigmer server is unavailable. Ensure it is running and reachable.",
-    );
-  });
-
-  it("maps DeadlineExceeded", () => {
-    expect(rpcError(new ConnectError("slow", Code.DeadlineExceeded), resource).message).toBe(
-      "Request timed out contacting stigmer-server.",
-    );
-  });
-
-  it("passes through the raw message for InvalidArgument", () => {
-    expect(rpcError(new ConnectError("field x is required", Code.InvalidArgument), resource).message).toBe(
-      "field x is required",
-    );
-  });
-
-  it("wraps non-gRPC/unknown errors", () => {
-    expect(rpcError(new Error("boom"), resource).message).toBe("unexpected error: boom");
-  });
-
-  it("maps every gRPC code to a non-empty message without throwing", () => {
-    // Completeness guard: the default branch must catch any code the explicit
-    // switch does not handle, so no gRPC status can ever surface a blank or
-    // thrown error to the client.
-    const codes = Object.values(Code).filter((c): c is Code => typeof c === "number");
-    for (const code of codes) {
-      const msg = rpcError(new ConnectError("detail", code), resource).message;
-      expect(msg, `code ${Code[code]}`).toBeTruthy();
-    }
-  });
-});

package/src/domains/search/search.integration.test.ts

@@ -1,141 +0,0 @@
-// In-process integration test for the search tool. Verifies resource_uri
-// enrichment for every searchable kind, the empty-response short-circuit,
-// the unknown-kind validation error, and pagination passthrough.
-
-import { create, toJson } from "@bufbuild/protobuf";
-import type { ConnectRouter } from "@connectrpc/connect";
-import { connectNodeAdapter } from "@connectrpc/connect-node";
-import {
-  createServer as createHttp2Server,
-  type Http2Server,
-  type ServerHttp2Session,
-} from "node:http2";
-import type { AddressInfo } from "node:net";
-
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
-import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
-import type { PageInfo } from "@stigmer/protos/ai/stigmer/commons/rpc/pagination_pb";
-import {
-  type SearchResponse,
-  SearchResponseSchema,
-  SearchResultSchema,
-} from "@stigmer/protos/ai/stigmer/search/v1/io_pb";
-import { SearchService } from "@stigmer/protos/ai/stigmer/search/v1/query_pb";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-
-import { configureLogger } from "../../logger";
-import { createServer } from "../../server";
-
-configureLogger({ level: "error", format: "text" });
-
-const allKindsResponse = create(SearchResponseSchema, {
-  entries: [
-    create(SearchResultSchema, { kind: ApiResourceKind.agent, org: "acme", slug: "code-reviewer" }),
-    create(SearchResultSchema, { kind: ApiResourceKind.skill, org: "acme", slug: "code-review" }),
-    create(SearchResultSchema, { kind: ApiResourceKind.mcp_server, org: "acme", slug: "github" }),
-    create(SearchResultSchema, { kind: ApiResourceKind.workflow, org: "acme", slug: "release" }),
-    create(SearchResultSchema, {
-      kind: ApiResourceKind.environment,
-      org: "acme",
-      slug: "github-creds",
-    }),
-  ],
-});
-const emptyResponse = create(SearchResponseSchema, { entries: [] });
-
-let backend: Http2Server;
-let client: Client;
-let nextResponse: SearchResponse = allKindsResponse;
-let lastPage: PageInfo | undefined;
-const openSessions = new Set<ServerHttp2Session>();
-
-interface ToolResult {
-  content: Array<{ type: string; text?: string }>;
-  isError?: boolean;
-}
-
-async function callSearch(args: Record<string, unknown>): Promise<ToolResult> {
-  return (await client.callTool({ name: "search", arguments: args })) as ToolResult;
-}
-
-beforeAll(async () => {
-  const routes = (router: ConnectRouter) => {
-    router.service(SearchService, {
-      search: (req) => {
-        lastPage = req.page;
-        return nextResponse;
-      },
-    });
-  };
-  backend = createHttp2Server(connectNodeAdapter({ routes }));
-  backend.on("session", (session) => {
-    openSessions.add(session);
-    session.on("close", () => openSessions.delete(session));
-  });
-  await new Promise<void>((resolve) => backend.listen(0, "127.0.0.1", resolve));
-  const port = (backend.address() as AddressInfo).port;
-
-  const mcp = createServer({ serverAddress: `127.0.0.1:${port}`, apiKey: "" });
-  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-  client = new Client({ name: "search-integration", version: "test" });
-  await Promise.all([mcp.connect(serverTransport), client.connect(clientTransport)]);
-});
-
-afterAll(async () => {
-  await client?.close();
-  for (const session of openSessions) session.destroy();
-  await new Promise<void>((resolve) => backend.close(() => resolve()));
-});
-
-describe("search tool integration", () => {
-  it("enriches every kind with a resource_uri", async () => {
-    nextResponse = allKindsResponse;
-    const result = await callSearch({ query: "code" });
-    expect(result.isError).toBeFalsy();
-    const data = JSON.parse(result.content[0]?.text ?? "{}") as {
-      entries: Array<{ resource_uri?: string }>;
-    };
-    expect(data.entries.map((e) => e.resource_uri)).toEqual([
-      "stigmer://agents/acme/code-reviewer",
-      "stigmer://skills/acme/code-review",
-      "stigmer://mcp-servers/acme/github",
-      "stigmer://workflows/acme/release",
-      "stigmer://environments/acme/github-creds",
-    ]);
-  });
-
-  it("short-circuits an empty response to the plain marshal", async () => {
-    nextResponse = emptyResponse;
-    const result = await callSearch({ query: "nothing" });
-    expect(result.isError).toBeFalsy();
-    expect(JSON.parse(result.content[0]?.text ?? "{}")).toEqual(
-      toJson(SearchResponseSchema, emptyResponse, { useProtoFieldName: true }),
-    );
-  });
-
-  it("rejects an unknown kind without calling the backend", async () => {
-    const result = await callSearch({ kinds: ["bogus"] });
-    expect(result.isError).toBe(true);
-    expect(result.content[0]?.text).toContain('unknown resource kind "bogus"');
-    expect(result.content[0]?.text).toContain(
-      "valid kinds: agent, skill, mcp_server, workflow, environment",
-    );
-  });
-
-  it("accepts the environment kind", async () => {
-    nextResponse = emptyResponse;
-    const result = await callSearch({ kinds: ["environment"] });
-    expect(result.isError).toBeFalsy();
-  });
-
-  it("forwards pagination only when requested", async () => {
-    nextResponse = allKindsResponse;
-    lastPage = undefined;
-    await callSearch({ query: "code" });
-    expect(lastPage).toBeUndefined();
-
-    await callSearch({ query: "code", page_size: 5, page_num: 2 });
-    expect(lastPage).toMatchObject({ size: 5, num: 2 });
-  });
-});

package/src/domains/versions.integration.test.ts

@@ -1,212 +0,0 @@
-// In-process integration test for the versioning tools: list_workflow_versions
-// (timeline projection — validated_yaml stripped), get_workflow's version
-// argument (slug→ID two-step into getVersion), tag_workflow_version, and
-// list_skill_versions. Same harness as reads.integration.test.ts.
-
-import { create, toJson } from "@bufbuild/protobuf";
-import type { ConnectRouter } from "@connectrpc/connect";
-import { connectNodeAdapter } from "@connectrpc/connect-node";
-import {
-  createServer as createHttp2Server,
-  type Http2Server,
-  type ServerHttp2Session,
-} from "node:http2";
-import type { AddressInfo } from "node:net";
-
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
-import { SkillQueryController } from "@stigmer/protos/ai/stigmer/agentic/skill/v1/query_pb";
-import {
-  ListSkillVersionsResponseSchema,
-  type ListSkillVersionsInput,
-} from "@stigmer/protos/ai/stigmer/agentic/skill/v1/io_pb";
-import { WorkflowSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/api_pb";
-import { WorkflowCommandController } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/command_pb";
-import { WorkflowQueryController } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/query_pb";
-import {
-  ListWorkflowVersionsResponseSchema,
-  WorkflowVersionEntrySchema,
-  type GetWorkflowVersionInput,
-  type TagWorkflowVersionInput,
-} from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/version_pb";
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
-
-import { configureLogger } from "../logger";
-import { createServer } from "../server";
-
-configureLogger({ level: "error", format: "text" });
-
-const HASH_A = "a".repeat(64);
-const HASH_B = "b".repeat(64);
-
-const knownWorkflow = create(WorkflowSchema, {
-  apiVersion: "v1",
-  kind: "workflow",
-  metadata: { name: "Release", slug: "release", org: "acme", id: "wkf_1" },
-});
-
-const workflowVersions = create(ListWorkflowVersionsResponseSchema, {
-  versions: [
-    { versionHash: HASH_A, tag: "stable", isCurrent: true, validatedYaml: "document: {}" },
-    { versionHash: HASH_B, validatedYaml: "document: {old: true}" },
-  ],
-  totalCount: 2,
-});
-
-const versionEntry = create(WorkflowVersionEntrySchema, {
-  versionHash: HASH_B,
-  validatedYaml: "document: {old: true}",
-});
-
-const skillVersions = create(ListSkillVersionsResponseSchema, {
-  versions: [{ versionHash: HASH_A, tag: "stable", isCurrent: true }],
-  totalCount: 1,
-});
-
-let backend: Http2Server;
-let client: Client;
-let lastGetVersion: GetWorkflowVersionInput | undefined;
-let lastTagVersion: TagWorkflowVersionInput | undefined;
-let lastSkillVersionsRequest: ListSkillVersionsInput | undefined;
-const openSessions = new Set<ServerHttp2Session>();
-
-interface ToolResult {
-  content: Array<{ type: string; text?: string }>;
-  isError?: boolean;
-}
-
-async function callTool(name: string, args: Record<string, unknown>): Promise<ToolResult> {
-  return (await client.callTool({ name, arguments: args })) as ToolResult;
-}
-
-function parseText(result: ToolResult): Record<string, unknown> {
-  return JSON.parse(result.content[0]?.text ?? "{}") as Record<string, unknown>;
-}
-
-beforeAll(async () => {
-  const routes = (router: ConnectRouter) => {
-    router.service(WorkflowQueryController, {
-      getByReference: () => knownWorkflow,
-      listVersions: () => workflowVersions,
-      getVersion: (req) => {
-        lastGetVersion = req;
-        return versionEntry;
-      },
-    });
-    router.service(WorkflowCommandController, {
-      tagVersion: (req) => {
-        lastTagVersion = req;
-        return knownWorkflow;
-      },
-    });
-    router.service(SkillQueryController, {
-      listVersions: (req) => {
-        lastSkillVersionsRequest = req;
-        return skillVersions;
-      },
-    });
-  };
-  backend = createHttp2Server(connectNodeAdapter({ routes }));
-  backend.on("session", (session) => {
-    openSessions.add(session);
-    session.on("close", () => openSessions.delete(session));
-  });
-  await new Promise<void>((resolve) => backend.listen(0, "127.0.0.1", resolve));
-  const port = (backend.address() as AddressInfo).port;
-
-  const mcp = createServer({ serverAddress: `127.0.0.1:${port}`, apiKey: "" });
-  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-  client = new Client({ name: "versions-integration", version: "test" });
-  await Promise.all([mcp.connect(serverTransport), client.connect(clientTransport)]);
-});
-
-beforeEach(() => {
-  lastGetVersion = undefined;
-  lastTagVersion = undefined;
-  lastSkillVersionsRequest = undefined;
-});
-
-afterAll(async () => {
-  await client?.close();
-  for (const session of openSessions) session.destroy();
-  await new Promise<void>((resolve) => backend.close(() => resolve()));
-});
-
-describe("versioning tools integration", () => {
-  it("advertises the versioning tools", async () => {
-    const { tools } = await client.listTools();
-    expect(tools.map((t) => t.name)).toEqual(
-      expect.arrayContaining([
-        "list_workflow_versions",
-        "tag_workflow_version",
-        "list_skill_versions",
-      ]),
-    );
-  });
-
-  it("list_workflow_versions strips validated_yaml from the timeline", async () => {
-    const result = await callTool("list_workflow_versions", { org: "acme", slug: "release" });
-    expect(result.isError).toBeFalsy();
-
-    const body = parseText(result);
-    expect(body.total_count).toBe(2);
-    const versions = body.versions as Array<Record<string, unknown>>;
-    expect(versions).toHaveLength(2);
-    expect(versions[0]).toMatchObject({ version_hash: HASH_A, tag: "stable", is_current: true });
-    for (const entry of versions) {
-      expect(entry.validated_yaml).toBeUndefined();
-    }
-  });
-
-  it("get_workflow with a version resolves the id and fetches that version", async () => {
-    const result = await callTool("get_workflow", {
-      org: "acme",
-      slug: "release",
-      version: HASH_B,
-    });
-    expect(result.isError).toBeFalsy();
-    expect(lastGetVersion?.workflowId).toBe("wkf_1");
-    expect(lastGetVersion?.versionHash).toBe(HASH_B);
-    // The version entry carries the YAML the timeline omits.
-    expect(parseText(result)).toEqual(
-      toJson(WorkflowVersionEntrySchema, versionEntry, { useProtoFieldName: true }),
-    );
-  });
-
-  it("get_workflow without a version returns the live workflow", async () => {
-    const result = await callTool("get_workflow", { org: "acme", slug: "release" });
-    expect(result.isError).toBeFalsy();
-    expect(lastGetVersion).toBeUndefined();
-    expect(parseText(result)).toEqual(
-      toJson(WorkflowSchema, knownWorkflow, { useProtoFieldName: true }),
-    );
-  });
-
-  it("tag_workflow_version resolves the id and forwards hash and tag", async () => {
-    const result = await callTool("tag_workflow_version", {
-      org: "acme",
-      slug: "release",
-      version: HASH_B,
-      tag: "stable",
-    });
-    expect(result.isError).toBeFalsy();
-    expect(lastTagVersion?.workflowId).toBe("wkf_1");
-    expect(lastTagVersion?.versionHash).toBe(HASH_B);
-    expect(lastTagVersion?.tag).toBe("stable");
-  });
-
-  it("list_skill_versions forwards the reference and returns the timeline", async () => {
-    const result = await callTool("list_skill_versions", {
-      org: "acme",
-      slug: "code-review",
-      page_size: 10,
-    });
-    expect(result.isError).toBeFalsy();
-    expect(lastSkillVersionsRequest?.org).toBe("acme");
-    expect(lastSkillVersionsRequest?.slug).toBe("code-review");
-    expect(lastSkillVersionsRequest?.pageSize).toBe(10);
-    expect(parseText(result)).toEqual(
-      toJson(ListSkillVersionsResponseSchema, skillVersions, { useProtoFieldName: true }),
-    );
-  });
-});

package/src/domains/workflows/validate.integration.test.ts

@@ -1,117 +0,0 @@
-// In-process integration test for validate_workflow_yaml. Verifies the
-// required-yaml and parse errors, that every registry task kind (including
-// `eval`, which the Go map omits) is accepted, and that the parsed Workflow is
-// forwarded to validateSpec.
-
-import { create, toJson } from "@bufbuild/protobuf";
-import type { ConnectRouter } from "@connectrpc/connect";
-import { connectNodeAdapter } from "@connectrpc/connect-node";
-import {
-  createServer as createHttp2Server,
-  type Http2Server,
-  type ServerHttp2Session,
-} from "node:http2";
-import type { AddressInfo } from "node:net";
-
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
-import { WorkflowCommandController } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/command_pb";
-import { WorkflowTaskKind } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/enum_pb";
-import { ServerlessWorkflowValidationSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/serverless/validation_pb";
-import type { Workflow } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/api_pb";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { stringify as stringifyYaml } from "yaml";
-
-import { configureLogger } from "../../logger";
-import { createServer } from "../../server";
-
-configureLogger({ level: "error", format: "text" });
-
-const registryKinds = Object.values(WorkflowTaskKind).filter(
-  (v): v is string => typeof v === "string" && v !== "workflow_task_kind_unspecified",
-);
-const validation = create(ServerlessWorkflowValidationSchema, {});
-
-let backend: Http2Server;
-let client: Client;
-let lastWorkflow: Workflow | undefined;
-const openSessions = new Set<ServerHttp2Session>();
-
-interface ToolResult {
-  content: Array<{ type: string; text?: string }>;
-  isError?: boolean;
-}
-
-async function validate(yaml: string): Promise<ToolResult> {
-  return (await client.callTool({ name: "validate_workflow_yaml", arguments: { yaml } })) as ToolResult;
-}
-
-beforeAll(async () => {
-  const routes = (router: ConnectRouter) => {
-    router.service(WorkflowCommandController, {
-      validateSpec: (req) => {
-        lastWorkflow = req;
-        return validation;
-      },
-    });
-  };
-  backend = createHttp2Server(connectNodeAdapter({ routes }));
-  backend.on("session", (session) => {
-    openSessions.add(session);
-    session.on("close", () => openSessions.delete(session));
-  });
-  await new Promise<void>((resolve) => backend.listen(0, "127.0.0.1", resolve));
-  const port = (backend.address() as AddressInfo).port;
-
-  const mcp = createServer({ serverAddress: `127.0.0.1:${port}`, apiKey: "" });
-  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-  client = new Client({ name: "validate-integration", version: "test" });
-  await Promise.all([mcp.connect(serverTransport), client.connect(clientTransport)]);
-});
-
-afterAll(async () => {
-  await client?.close();
-  for (const session of openSessions) session.destroy();
-  await new Promise<void>((resolve) => backend.close(() => resolve()));
-});
-
-describe("validate_workflow_yaml integration", () => {
-  it("requires non-empty yaml", async () => {
-    const result = await validate("   ");
-    expect(result.isError).toBe(true);
-    expect(result.content[0]?.text).toContain("yaml is required");
-  });
-
-  it("rejects yaml without a spec", async () => {
-    const result = await validate(stringifyYaml({ apiVersion: "v1", kind: "workflow" }));
-    expect(result.isError).toBe(true);
-    expect(result.content[0]?.text).toContain(
-      "failed to parse workflow YAML: missing or invalid 'spec' field",
-    );
-  });
-
-  it("rejects an unknown task kind with its index", async () => {
-    const doc = { spec: { tasks: [{ name: "t0", kind: "bogus_kind" }] } };
-    const result = await validate(stringifyYaml(doc));
-    expect(result.isError).toBe(true);
-    expect(result.content[0]?.text).toContain(
-      'failed to parse workflow YAML: unknown task kind "bogus_kind" at tasks[0]',
-    );
-  });
-
-  it("accepts every registry task kind (including eval) and forwards the workflow", async () => {
-    const doc = {
-      apiVersion: "v1",
-      kind: "workflow",
-      metadata: { name: "wf", org: "acme", slug: "wf" },
-      spec: { tasks: registryKinds.map((kind, i) => ({ name: `t${i}`, kind })) },
-    };
-    const result = await validate(stringifyYaml(doc));
-    expect(result.isError).toBeFalsy();
-    expect(JSON.parse(result.content[0]?.text ?? "{}")).toEqual(
-      toJson(ServerlessWorkflowValidationSchema, validation, { useProtoFieldName: true }),
-    );
-    expect(lastWorkflow?.spec?.tasks.length).toBe(registryKinds.length);
-    expect(lastWorkflow?.spec?.tasks.some((t) => t.kind === WorkflowTaskKind.eval)).toBe(true);
-  });
-});

package/src/domains/workflows/workflow-tools.integration.test.ts

@@ -1,148 +0,0 @@
-// In-process integration test for the workflow query tools: the task-kind
-// registry pair (get_task_kind_registry, get_task_kind) and the execution pair
-// (get_workflow_execution, get_workflow_execution_events). Verifies registry
-// selection (case-insensitive), the required-field and not-found errors, and
-// that page_size is forwarded only when set.
-
-import { create, toJson } from "@bufbuild/protobuf";
-import type { ConnectRouter } from "@connectrpc/connect";
-import { connectNodeAdapter } from "@connectrpc/connect-node";
-import {
-  createServer as createHttp2Server,
-  type Http2Server,
-  type ServerHttp2Session,
-} from "node:http2";
-import type { AddressInfo } from "node:net";
-
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
-import { WorkflowTaskKind } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/enum_pb";
-import {
-  GetTaskKindRegistryResponseSchema,
-  TaskKindDescriptorSchema,
-} from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/task_kind_descriptor_pb";
-import { TaskKindRegistryQueryController } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/task_kind_registry_query_pb";
-import { WorkflowExecutionSchema } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/api_pb";
-import {
-  type GetEventLogRequest,
-  GetEventLogResponseSchema,
-} from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/io_pb";
-import { WorkflowExecutionQueryController } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/query_pb";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-
-import { configureLogger } from "../../logger";
-import { createServer } from "../../server";
-
-configureLogger({ level: "error", format: "text" });
-
-const registry = create(GetTaskKindRegistryResponseSchema, {
-  descriptors: [
-    create(TaskKindDescriptorSchema, { kind: WorkflowTaskKind.set_vars }),
-    create(TaskKindDescriptorSchema, { kind: WorkflowTaskKind.for_each }),
-  ],
-});
-const execution = create(WorkflowExecutionSchema, { apiVersion: "v1", kind: "workflow_execution" });
-const eventLog = create(GetEventLogResponseSchema, {});
-
-let backend: Http2Server;
-let client: Client;
-let lastExecutionId: string | undefined;
-let lastEventReq: GetEventLogRequest | undefined;
-const openSessions = new Set<ServerHttp2Session>();
-
-interface ToolResult {
-  content: Array<{ type: string; text?: string }>;
-  isError?: boolean;
-}
-
-async function callTool(name: string, args: Record<string, unknown>): Promise<ToolResult> {
-  return (await client.callTool({ name, arguments: args })) as ToolResult;
-}
-
-beforeAll(async () => {
-  const routes = (router: ConnectRouter) => {
-    router.service(TaskKindRegistryQueryController, { getTaskKindRegistry: () => registry });
-    router.service(WorkflowExecutionQueryController, {
-      get: (req) => {
-        lastExecutionId = req.value;
-        return execution;
-      },
-      getEventLog: (req) => {
-        lastEventReq = req;
-        return eventLog;
-      },
-    });
-  };
-  backend = createHttp2Server(connectNodeAdapter({ routes }));
-  backend.on("session", (session) => {
-    openSessions.add(session);
-    session.on("close", () => openSessions.delete(session));
-  });
-  await new Promise<void>((resolve) => backend.listen(0, "127.0.0.1", resolve));
-  const port = (backend.address() as AddressInfo).port;
-
-  const mcp = createServer({ serverAddress: `127.0.0.1:${port}`, apiKey: "" });
-  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-  client = new Client({ name: "workflow-tools-integration", version: "test" });
-  await Promise.all([mcp.connect(serverTransport), client.connect(clientTransport)]);
-});
-
-afterAll(async () => {
-  await client?.close();
-  for (const session of openSessions) session.destroy();
-  await new Promise<void>((resolve) => backend.close(() => resolve()));
-});
-
-describe("workflow query tools integration", () => {
-  it("get_task_kind_registry returns the full registry", async () => {
-    const result = await callTool("get_task_kind_registry", {});
-    expect(result.isError).toBeFalsy();
-    expect(JSON.parse(result.content[0]?.text ?? "{}")).toEqual(
-      toJson(GetTaskKindRegistryResponseSchema, registry, { useProtoFieldName: true }),
-    );
-  });
-
-  it("get_task_kind selects one descriptor case-insensitively", async () => {
-    const result = await callTool("get_task_kind", { kind: "FOR_EACH" });
-    expect(result.isError).toBeFalsy();
-    expect(JSON.parse(result.content[0]?.text ?? "{}")).toEqual(
-      toJson(TaskKindDescriptorSchema, registry.descriptors[1]!, { useProtoFieldName: true }),
-    );
-  });
-
-  it("get_task_kind requires a kind", async () => {
-    const result = await callTool("get_task_kind", { kind: "" });
-    expect(result.isError).toBe(true);
-    expect(result.content[0]?.text).toContain("kind is required");
-  });
-
-  it("get_task_kind reports an unknown kind", async () => {
-    const result = await callTool("get_task_kind", { kind: "does_not_exist" });
-    expect(result.isError).toBe(true);
-    expect(result.content[0]?.text).toContain('task kind "does_not_exist" not found in registry');
-  });
-
-  it("get_workflow_execution requires an execution_id", async () => {
-    const result = await callTool("get_workflow_execution", { execution_id: "" });
-    expect(result.isError).toBe(true);
-    expect(result.content[0]?.text).toContain("execution_id is required");
-  });
-
-  it("get_workflow_execution forwards the id and returns the execution", async () => {
-    const result = await callTool("get_workflow_execution", { execution_id: "wex_123" });
-    expect(result.isError).toBeFalsy();
-    expect(lastExecutionId).toBe("wex_123");
-    expect(JSON.parse(result.content[0]?.text ?? "{}")).toEqual(
-      toJson(WorkflowExecutionSchema, execution, { useProtoFieldName: true }),
-    );
-  });
-
-  it("get_workflow_execution_events forwards page_size only when set", async () => {
-    await callTool("get_workflow_execution_events", { execution_id: "wex_123", task_name: "build" });
-    expect(lastEventReq?.taskName).toBe("build");
-    expect(lastEventReq?.pageSize).toBe(0);
-
-    await callTool("get_workflow_execution_events", { execution_id: "wex_123", page_size: 50 });
-    expect(lastEventReq?.pageSize).toBe(50);
-  });
-});