@minicor/mcp-server 3.3.5 → 3.5.0

package/dist/tools/jobs.js

@@ -0,0 +1,624 @@
+/**
+ * MCP tools for Jobs + Test Cases.
+ *
+ * A Job is a middleware route whose behavior is a structured `definition`
+ * (step graph) instead of freeform handler code. Jobs sit *above* workflows: a
+ * job step calls an entire Minicor workflow (by workflowId) or runs a code
+ * block. Test cases attach to a job (route): a named input + code-block
+ * assertions `[{ name, expr }]` evaluated against the execution.
+ *
+ * See middlewares/JOBS-DESIGN.md for the full model + API contract (v1).
+ *
+ * Auth/transport is handled by MiddlewareServiceClient, which by default calls
+ * the region's public middleware-service Cloud Run directly with the MCP's user
+ * bearer token. Set MIDDLEWARE_SERVICE_PROXY_BASE to route through a deployed
+ * frontend proxy instead, or MIDDLEWARE_SERVICE_URL[_US|_CA] to hit a specific
+ * reachable instance (dev/local). See middleware-service-client.ts for the full
+ * precedence.
+ */
+import { z } from "zod";
+import { ok, text, analyzeRpaFailure } from "../helpers.js";
+import { MiddlewareServiceClient } from "../middleware-service-client.js";
+import { getWorkspaceRegion } from "../state.js";
+const regionParam = z
+    .enum(["us", "ca"])
+    .optional()
+    .describe("Region (us or ca). Auto-detected from workspace if omitted.");
+// ── Zod schemas mirroring the JobDefinition entities ───────────
+const jobStepSchema = z
+    .object({
+    id: z.string().describe("Stable step id (referenced by goto/saveAs)"),
+    name: z.string().describe("Human-readable step name"),
+    kind: z.enum(["workflow", "code"]),
+    saveAs: z
+        .string()
+        .optional()
+        .describe("ctx key to store this step's result under"),
+    when: z
+        .string()
+        .optional()
+        .describe("Conditional-skip: TS expression over ctx that must be truthy"),
+    forEach: z
+        .string()
+        .optional()
+        .describe("Fan-out: TS expression over ctx yielding a collection"),
+    onError: z
+        .union([
+        z.enum(["abort", "skip", "continue"]),
+        z.object({ goto: z.string() }),
+    ])
+        .optional(),
+    retry: z
+        .object({ max: z.number(), backoffMs: z.number().optional() })
+        .optional(),
+    cache: z
+        .object({ key: z.string(), ttlMs: z.number() })
+        .optional()
+        .describe("Login / smart-launch gate — reuse a cached result"),
+    // workflow
+    workflowId: z
+        .number()
+        .optional()
+        .describe("kind=workflow: the Minicor workflow id to call"),
+    configStoreId: z
+        .string()
+        .optional()
+        .describe("kind=workflow: override resource.configStoreId"),
+    input: z
+        .union([z.record(z.string(), z.unknown()), z.string()])
+        .optional()
+        .describe("kind=workflow: input object with {{ctx.x}} templates, OR a CodeBlock '(ctx) => ({...})'"),
+    // code
+    code: z
+        .string()
+        .optional()
+        .describe("kind=code: a CodeBlock '(ctx) => { ... }' run in the vm sandbox"),
+})
+    .describe("A single job step — calls a whole workflow or runs a code block");
+const jobDefinitionSchema = z
+    .object({
+    region: z.enum(["us", "ca"]),
+    resource: z
+        .object({
+        configStoreId: z.string().optional(),
+        lockKey: z
+            .string()
+            .optional()
+            .describe("Serialize execution per desktop/VM"),
+    })
+        .optional(),
+    inputSchema: z
+        .record(z.string(), z.unknown())
+        .describe("JSON Schema for the job input"),
+    outputSchema: z
+        .record(z.string(), z.unknown())
+        .describe("JSON Schema for the job output"),
+    steps: z.array(jobStepSchema).describe("Ordered step graph"),
+    output: z
+        .string()
+        .optional()
+        .describe("CodeBlock '(ctx) => response' producing the final output; also where partial/review status is decided"),
+})
+    .describe("The structured job definition (step graph)");
+const assertionSchema = z.object({
+    name: z.string().describe("Assertion name shown in the report"),
+    expr: z
+        .string()
+        .describe("TS boolean expression over `{ input, output, ctx, steps }`, e.g. 'output.status === \"ok\"'"),
+});
+export function register(deps) {
+    const { server } = deps;
+    function getClient(region) {
+        const token = deps.getAuthToken?.(region) || "";
+        return new MiddlewareServiceClient(deps.getApiBase(region), token);
+    }
+    function resolveRegion(workspaceId, explicit) {
+        if (explicit)
+            return explicit;
+        return getWorkspaceRegion(workspaceId) ?? undefined;
+    }
+    /**
+     * Fetch the workspace's first API key value via the Laminar core API
+     * (`GET /workspaces/:ws/api-keys` -> `[{ id, apiKey, name }]`). Returns
+     * undefined if the workspace has no keys.
+     */
+    async function firstWorkspaceApiKey(workspaceId, region) {
+        const keys = await deps.client(region).listApiKeys(workspaceId);
+        const list = Array.isArray(keys)
+            ? keys
+            : (keys?.content ?? keys?.apiKeys ?? []);
+        const first = list.find((k) => !!k?.apiKey);
+        return first?.apiKey;
+    }
+    // ── list_middlewares ───────────────────────────────────────
+    server.tool("list_middlewares", "List the routers (middlewares) in a workspace. A Job is a route on a router, so you need a middlewareId (from here) before register_job. If none exist, create one with register_middleware.", {
+        workspaceId: z.number().describe("Workspace ID"),
+        region: regionParam,
+    }, async ({ workspaceId, region }) => {
+        const r = resolveRegion(workspaceId, region);
+        try {
+            const middlewares = await getClient(r).listMiddlewares(workspaceId);
+            return ok({ middlewares });
+        }
+        catch (e) {
+            return text(`Error listing middlewares: ${e.message}`);
+        }
+    });
+    // ── register_middleware ────────────────────────────────────
+    server.tool("register_middleware", "Create a router (middleware) that Jobs attach to. Returns the middleware (use its id with register_job). The router needs a workspaceApiKey so its job workflow steps can call the Laminar API: pass `workspaceApiKey` explicitly, or leave autoConfigure=true (default) to fetch + set the workspace's first API key automatically. `workspaceApiKeyConfigured` in the result reflects whether the key actually stuck.", {
+        workspaceId: z.number().describe("Workspace ID"),
+        name: z.string().describe("Human-readable router name"),
+        slug: z
+            .string()
+            .describe("URL-safe slug (used in the runtime path /m/<slug>/*)"),
+        description: z.string().optional(),
+        workspaceApiKey: z
+            .string()
+            .optional()
+            .describe("Explicit workspace API key to set on the router. Takes precedence over autoConfigure. Use list_workspace_api_keys to find one."),
+        autoConfigure: z
+            .boolean()
+            .optional()
+            .describe("Fetch + set the workspace's first API key after creating (default true). Ignored if workspaceApiKey is provided."),
+        region: regionParam,
+    }, async ({ workspaceId, name, slug, description, workspaceApiKey, autoConfigure, region }) => {
+        const r = resolveRegion(workspaceId, region);
+        try {
+            const client = getClient(r);
+            const middleware = await client.createMiddleware(workspaceId, {
+                name,
+                slug,
+                description,
+            });
+            // Resolve the key to set: explicit param wins; otherwise (autoConfigure)
+            // fetch the workspace's first API key.
+            let keyToSet = workspaceApiKey;
+            if (!keyToSet && autoConfigure !== false) {
+                try {
+                    keyToSet = await firstWorkspaceApiKey(workspaceId, r);
+                }
+                catch {
+                    /* non-fatal: fall through to "not configured" below */
+                }
+            }
+            let configured = false;
+            if (keyToSet) {
+                try {
+                    const updated = await client.setWorkspaceApiKey(workspaceId, middleware.id, keyToSet);
+                    configured = !!updated?.workspaceApiKey;
+                    if (updated)
+                        Object.assign(middleware, updated);
+                }
+                catch {
+                    /* non-fatal: report not-configured below */
+                }
+            }
+            if (configured) {
+                return ok({ status: "created", middleware, workspaceApiKeyConfigured: true });
+            }
+            return ok({
+                status: "created",
+                middleware,
+                workspaceApiKeyConfigured: false,
+                note: "Router has no workspace API key set. Set one with set_middleware_api_key (find a key via list_workspace_api_keys) so job workflow steps can run.",
+            });
+        }
+        catch (e) {
+            return text(`Error creating middleware: ${e.message}`);
+        }
+    });
+    // ── list_workspace_api_keys ────────────────────────────────
+    server.tool("list_workspace_api_keys", "List a workspace's API keys (id, apiKey, name) via the Laminar core API. Use to find a key for set_middleware_api_key or register_middleware's workspaceApiKey param.", {
+        workspaceId: z.number().describe("Workspace ID"),
+        region: regionParam,
+    }, async ({ workspaceId, region }) => {
+        const r = resolveRegion(workspaceId, region);
+        try {
+            const apiKeys = await deps.client(r).listApiKeys(workspaceId);
+            return ok({ apiKeys });
+        }
+        catch (e) {
+            return text(`Error listing workspace API keys: ${e.message}`);
+        }
+    });
+    // ── set_middleware_api_key ─────────────────────────────────
+    server.tool("set_middleware_api_key", "Set a router (middleware)'s workspaceApiKey. PUTs the key to the middleware and re-reads it, returning the updated middleware so you can confirm workspaceApiKey is now set.", {
+        workspaceId: z.number().describe("Workspace ID"),
+        middlewareId: z.string().describe("Router (middleware) ID"),
+        workspaceApiKey: z
+            .string()
+            .describe("Workspace API key to set on the router (from list_workspace_api_keys)"),
+        region: regionParam,
+    }, async ({ workspaceId, middlewareId, workspaceApiKey, region }) => {
+        const r = resolveRegion(workspaceId, region);
+        try {
+            const middleware = await getClient(r).setWorkspaceApiKey(workspaceId, middlewareId, workspaceApiKey);
+            if (!middleware) {
+                return text(`No middleware found with id ${middlewareId} after update.`);
+            }
+            return ok({
+                status: "updated",
+                middleware,
+                workspaceApiKeyConfigured: !!middleware.workspaceApiKey,
+            });
+        }
+        catch (e) {
+            return text(`Error setting middleware API key: ${e.message}`);
+        }
+    });
+    // ── register_job ───────────────────────────────────────────
+    server.tool("register_job", "Create a Job — a middleware route backed by a structured `definition` (step graph) instead of freeform handler code. A job step calls an entire Minicor workflow (by workflowId) or runs a code block; the job layer never touches a workflow's internal steps. Returns the created route (the job). Use add_test_case + run_tests to verify it.", {
+        workspaceId: z.number().describe("Workspace ID"),
+        middlewareId: z
+            .string()
+            .describe("Router (middleware) ID this job/route belongs to"),
+        path: z
+            .string()
+            .describe("Route path for the job, e.g. '/coi' or '/account-lookup'"),
+        method: z
+            .string()
+            .optional()
+            .describe("HTTP method (default POST)"),
+        description: z.string().optional().describe("What this job does"),
+        definition: jobDefinitionSchema,
+        region: regionParam,
+    }, async ({ workspaceId, middlewareId, path, method, description, definition, region }) => {
+        const r = resolveRegion(workspaceId, region);
+        try {
+            const job = await getClient(r).createJob(workspaceId, middlewareId, {
+                path,
+                method,
+                description,
+                definition: definition,
+            });
+            return ok({ status: "created", job });
+        }
+        catch (e) {
+            return text(`Error registering job: ${e.message}`);
+        }
+    });
+    // ── update_job ─────────────────────────────────────────────
+    server.tool("update_job", "Update a Job's definition (step graph), path, method, or description. Versioning a job creates a new route_version snapshot.", {
+        workspaceId: z.number().describe("Workspace ID"),
+        middlewareId: z.string().describe("Router (middleware) ID"),
+        routeId: z.string().describe("Route ID (the job) to update"),
+        path: z.string().optional(),
+        method: z.string().optional(),
+        description: z.string().optional(),
+        definition: jobDefinitionSchema.optional(),
+        region: regionParam,
+    }, async ({ workspaceId, middlewareId, routeId, path, method, description, definition, region }) => {
+        const r = resolveRegion(workspaceId, region);
+        try {
+            const body = {};
+            if (path !== undefined)
+                body.path = path;
+            if (method !== undefined)
+                body.method = method;
+            if (description !== undefined)
+                body.description = description;
+            if (definition !== undefined)
+                body.definition = definition;
+            const job = await getClient(r).updateJob(workspaceId, middlewareId, routeId, body);
+            return ok({ status: "updated", job });
+        }
+        catch (e) {
+            return text(`Error updating job: ${e.message}`);
+        }
+    });
+    // ── get_job ────────────────────────────────────────────────
+    server.tool("get_job", "Get a Job (route) including its `definition`. The management API has no single-route GET, so this lists the router's routes and filters by routeId. Omit routeId to list all routes (job-backed ones have `definition` set).", {
+        workspaceId: z.number().describe("Workspace ID"),
+        middlewareId: z.string().describe("Router (middleware) ID"),
+        routeId: z
+            .string()
+            .optional()
+            .describe("Route ID (the job). Omit to list all routes on the router."),
+        region: regionParam,
+    }, async ({ workspaceId, middlewareId, routeId, region }) => {
+        const r = resolveRegion(workspaceId, region);
+        try {
+            const client = getClient(r);
+            if (!routeId) {
+                const routes = await client.listRoutes(workspaceId, middlewareId);
+                return ok({ routes });
+            }
+            const job = await client.getJob(workspaceId, middlewareId, routeId);
+            if (!job)
+                return text(`No route found with id ${routeId} on router ${middlewareId}.`);
+            return ok({ job });
+        }
+        catch (e) {
+            return text(`Error fetching job: ${e.message}`);
+        }
+    });
+    // ── delete_job ─────────────────────────────────────────────
+    server.tool("delete_job", "Delete a Job (route) from a router. Destructive: also removes the job's version snapshots and test cases (cascade). The router (middleware) itself is left intact. Use get_job (omit routeId) first to confirm which route you're deleting.", {
+        workspaceId: z.number().describe("Workspace ID"),
+        middlewareId: z.string().describe("Router (middleware) ID"),
+        routeId: z.string().describe("Route ID (the job) to delete"),
+        region: regionParam,
+    }, async ({ workspaceId, middlewareId, routeId, region }) => {
+        const r = resolveRegion(workspaceId, region);
+        try {
+            const result = await getClient(r).deleteJob(workspaceId, middlewareId, routeId);
+            return ok({ status: "deleted", routeId, ...result });
+        }
+        catch (e) {
+            return text(`Error deleting job: ${e.message}`);
+        }
+    });
+    // ── delete_middleware ──────────────────────────────────────
+    server.tool("delete_middleware", "Delete a router (middleware) AND every Job/route on it. Destructive and cascading — all of the router's routes, versions, and test cases go with it. Use list_middlewares / get_job to confirm scope before calling.", {
+        workspaceId: z.number().describe("Workspace ID"),
+        middlewareId: z.string().describe("Router (middleware) ID to delete"),
+        region: regionParam,
+    }, async ({ workspaceId, middlewareId, region }) => {
+        const r = resolveRegion(workspaceId, region);
+        try {
+            const result = await getClient(r).deleteMiddleware(workspaceId, middlewareId);
+            return ok({ status: "deleted", middlewareId, ...result });
+        }
+        catch (e) {
+            return text(`Error deleting middleware: ${e.message}`);
+        }
+    });
+    // ── run_job ────────────────────────────────────────────────
+    server.tool("run_job", "Run a Job once with the given input, then poll the job execution to completion and return the full JobExecution (status, output, per-step results with Minicor deep-links). Async under the hood — this tool waits for the result.", {
+        workspaceId: z.number().describe("Workspace ID"),
+        middlewareId: z.string().describe("Router (middleware) ID"),
+        routeId: z.string().describe("Route ID (the job) to run"),
+        input: z
+            .record(z.string(), z.unknown())
+            .describe("Input payload for the job (validated against inputSchema)"),
+        trigger: z
+            .enum(["mcp", "api", "test"])
+            .optional()
+            .describe("Trigger label recorded on the execution (default mcp)"),
+        timeoutMs: z
+            .number()
+            .optional()
+            .describe("Max ms to poll before giving up (default 300000)"),
+        region: regionParam,
+    }, async ({ workspaceId, middlewareId, routeId, input, trigger, timeoutMs, region }) => {
+        const r = resolveRegion(workspaceId, region);
+        try {
+            const client = getClient(r);
+            const { jobExecutionId } = await client.runJob(workspaceId, middlewareId, routeId, input, trigger ?? "mcp");
+            const execution = await client.pollExecution(workspaceId, middlewareId, routeId, jobExecutionId, { timeoutMs });
+            return ok({ jobExecutionId, execution });
+        }
+        catch (e) {
+            return text(`Error running job: ${e.message}`);
+        }
+    });
+    // ── get_job_execution ──────────────────────────────────────
+    server.tool("get_job_execution", "Fetch one past JobExecution by id — the full trace for playing detective on a test case or run: status, input, the final output, the accumulated `context` (the through-line of data between steps), and per-step results (status ran/skipped/failed, the runtime input/output each step received, `workflowRuns[]` = one Minicor execution + replay per forEach iteration, and any logs). Use the jobExecutionId from run_job / run_tests / a test result.", {
+        workspaceId: z.number().describe("Workspace ID"),
+        middlewareId: z.string().describe("Router (middleware) ID"),
+        routeId: z.string().describe("Route ID (the job)"),
+        executionId: z.string().describe("Job execution ID to fetch"),
+        region: regionParam,
+    }, async ({ workspaceId, middlewareId, routeId, executionId, region }) => {
+        const r = resolveRegion(workspaceId, region);
+        try {
+            const execution = await getClient(r).getExecution(workspaceId, middlewareId, routeId, executionId);
+            return ok({ execution });
+        }
+        catch (e) {
+            return text(`Error fetching job execution: ${e.message}`);
+        }
+    });
+    // ── inspect_job_execution ──────────────────────────────────
+    server.tool("inspect_job_execution", "Deep-drill a JobExecution end to end: returns the nested tree job -> steps -> (for workflow steps) the underlying Minicor workflow execution's INTERNAL flow-runs (each flow-run's status, error, response, and — on failures — RPA failure-pattern analysis). This is the 'all the way down to the step' view: it stitches the job step's workflowExecutionId to the job definition's workflowId for you, so you don't have to call diagnose_execution manually. Use the jobExecutionId from run_job / run_tests / a test result.", {
+        workspaceId: z.number().describe("Workspace ID"),
+        middlewareId: z.string().describe("Router (middleware) ID"),
+        routeId: z.string().describe("Route ID (the job)"),
+        executionId: z.string().describe("Job execution ID to inspect"),
+        includeFlowRunPrograms: z
+            .boolean()
+            .optional()
+            .describe("Include each internal flow-run's program source (verbose). Default false."),
+        region: regionParam,
+    }, async ({ workspaceId, middlewareId, routeId, executionId, includeFlowRunPrograms, region, }) => {
+        const r = resolveRegion(workspaceId, region);
+        try {
+            const msClient = getClient(r);
+            const [execution, job] = await Promise.all([
+                msClient.getExecution(workspaceId, middlewareId, routeId, executionId),
+                msClient.getJob(workspaceId, middlewareId, routeId),
+            ]);
+            const defSteps = job?.definition?.steps ?? [];
+            const execSteps = Array.isArray(execution.steps)
+                ? execution.steps
+                : [];
+            const steps = await Promise.all(execSteps.map(async (se) => {
+                const base = {
+                    stepId: se.stepId,
+                    name: se.name,
+                    kind: se.kind,
+                    status: se.status,
+                    attempts: se.attempts,
+                    error: se.error,
+                    durationMs: se.durationMs,
+                };
+                if (se.kind !== "workflow") {
+                    return { ...base, output: se.output };
+                }
+                const def = defSteps.find((d) => d.id === se.stepId);
+                const workflowId = def?.workflowId;
+                // A plain workflow step has one run; a forEach step has one per item.
+                const runs = Array.isArray(se.workflowRuns) && se.workflowRuns.length
+                    ? se.workflowRuns
+                    : [
+                        {
+                            workflowExecutionId: se.workflowExecutionId,
+                            region: se.region,
+                            recordingUrl: se.recordingUrl,
+                        },
+                    ];
+                const workflowExecutions = await Promise.all(runs
+                    .filter((run) => run.workflowExecutionId != null)
+                    .map(async (run) => {
+                    const runRegion = (run.region ?? se.region ?? r);
+                    if (workflowId == null) {
+                        return {
+                            workflowExecutionId: run.workflowExecutionId,
+                            region: runRegion,
+                            error: "Could not resolve workflowId from the job definition for this step.",
+                        };
+                    }
+                    try {
+                        const wfExec = await deps
+                            .client(runRegion)
+                            .getExecution(workflowId, run.workflowExecutionId);
+                        const flowRuns = (wfExec?.flowRuns ?? []).map((fr) => {
+                            const failed = fr.status === "FAILED";
+                            const errorStr = JSON.stringify(fr.executionLog || fr.response || "");
+                            const programStr = JSON.stringify(fr.program || "");
+                            const rpa = failed
+                                ? analyzeRpaFailure(errorStr, programStr)
+                                : null;
+                            return {
+                                executionOrder: fr.executionOrder,
+                                name: fr.flowName,
+                                status: fr.status,
+                                durationMs: fr.durationMs,
+                                ...(failed
+                                    ? { error: fr.executionLog || fr.response }
+                                    : { response: fr.response }),
+                                ...(includeFlowRunPrograms
+                                    ? { program: fr.program }
+                                    : {}),
+                                ...(rpa ? { rpaFailureAnalysis: rpa } : {}),
+                            };
+                        });
+                        return {
+                            workflowId,
+                            workflowExecutionId: run.workflowExecutionId,
+                            region: runRegion,
+                            status: wfExec?.status,
+                            recordingUrl: run.recordingUrl,
+                            flowRuns,
+                        };
+                    }
+                    catch (e) {
+                        return {
+                            workflowId,
+                            workflowExecutionId: run.workflowExecutionId,
+                            region: runRegion,
+                            error: `Failed to load workflow execution: ${e.message}`,
+                        };
+                    }
+                }));
+                return { ...base, workflowId, workflowExecutions };
+            }));
+            return ok({
+                execution: {
+                    id: execution.id,
+                    status: execution.status,
+                    trigger: execution.trigger,
+                    input: execution.input,
+                    output: execution.output,
+                    error: execution.error,
+                    startedAt: execution.startedAt,
+                    completedAt: execution.completedAt,
+                    durationMs: execution.durationMs,
+                },
+                steps,
+            });
+        }
+        catch (e) {
+            return text(`Error inspecting job execution: ${e.message}`);
+        }
+    });
+    // ── add_test_case ──────────────────────────────────────────
+    server.tool("add_test_case", "Attach a test case to a Job (route): a named input + code-block assertions `[{ name, expr }]`. Each `expr` is a TS boolean over `{ input, output, ctx, steps }` evaluated against the job execution. This is the green-gate for the build loop — define the expected behavior, then build the job to satisfy it.", {
+        workspaceId: z.number().describe("Workspace ID"),
+        middlewareId: z.string().describe("Router (middleware) ID"),
+        routeId: z.string().describe("Route ID (the job) the case belongs to"),
+        name: z.string().describe("Test case name"),
+        description: z.string().optional(),
+        input: z
+            .record(z.string(), z.unknown())
+            .describe("Request payload to run the job with"),
+        assertions: z
+            .array(assertionSchema)
+            .describe("Code-block assertions: [{ name, expr }]"),
+        tags: z.array(z.string()).optional(),
+        enabled: z.boolean().optional().describe("Default true"),
+        region: regionParam,
+    }, async ({ workspaceId, middlewareId, routeId, name, description, input, assertions, tags, enabled, region }) => {
+        const r = resolveRegion(workspaceId, region);
+        try {
+            const testCase = await getClient(r).addTestCase(workspaceId, middlewareId, routeId, {
+                name,
+                description,
+                input,
+                assertions,
+                tags,
+                enabled,
+            });
+            return ok({ status: "created", testCase });
+        }
+        catch (e) {
+            return text(`Error adding test case: ${e.message}`);
+        }
+    });
+    // ── run_tests ──────────────────────────────────────────────
+    server.tool("run_tests", "Run a Job's test suite (all enabled cases, or a subset via testCaseIds), poll the test run to completion, and return the report (totals + per-case results with drill-down into the job execution). Use as the green-gate before declaring a job done.", {
+        workspaceId: z.number().describe("Workspace ID"),
+        middlewareId: z.string().describe("Router (middleware) ID"),
+        routeId: z.string().describe("Route ID (the job) to test"),
+        testCaseIds: z
+            .array(z.string())
+            .optional()
+            .describe("Specific test case IDs to run (omit = all enabled)"),
+        timeoutMs: z
+            .number()
+            .optional()
+            .describe("Max ms to poll before giving up (default 600000)"),
+        region: regionParam,
+    }, async ({ workspaceId, middlewareId, routeId, testCaseIds, timeoutMs, region }) => {
+        const r = resolveRegion(workspaceId, region);
+        try {
+            const client = getClient(r);
+            const { testRunId } = await client.startTestRun(workspaceId, middlewareId, routeId, testCaseIds);
+            const report = await client.pollTestRun(workspaceId, middlewareId, routeId, testRunId, { timeoutMs });
+            const passed = report.testRun.status === "passed";
+            return ok({
+                testRunId,
+                status: report.testRun.status,
+                green: passed,
+                totals: report.testRun.totals,
+                results: report.results,
+            });
+        }
+        catch (e) {
+            return text(`Error running tests: ${e.message}`);
+        }
+    });
+    // ── get_test_report ────────────────────────────────────────
+    server.tool("get_test_report", "Fetch a test run report by id (totals + per-case results, each linking to its job execution for step-level drill-down). Use after run_tests, or to re-read an older run.", {
+        workspaceId: z.number().describe("Workspace ID"),
+        middlewareId: z.string().describe("Router (middleware) ID"),
+        routeId: z.string().describe("Route ID (the job)"),
+        testRunId: z.string().describe("Test run ID"),
+        region: regionParam,
+    }, async ({ workspaceId, middlewareId, routeId, testRunId, region }) => {
+        const r = resolveRegion(workspaceId, region);
+        try {
+            const report = await getClient(r).getTestRun(workspaceId, middlewareId, routeId, testRunId);
+            return ok({
+                status: report.testRun.status,
+                green: report.testRun.status === "passed",
+                totals: report.testRun.totals,
+                results: report.results,
+            });
+        }
+        catch (e) {
+            return text(`Error fetching test report: ${e.message}`);
+        }
+    });
+}
+//# sourceMappingURL=jobs.js.map