stageflow 0.40.0 → 0.44.0

package/dist/mcp/connectionTools.js

@@ -0,0 +1,85 @@
+import { z } from "zod";
+import { ChannelError } from "../channels/errors.js";
+import { textResult } from "./toolResults.js";
+const secretValues = z
+    .record(z.string(), z.string())
+    .describe("Provider field name to secret value. Values are stored and never returned.");
+const configValues = z.record(z.string(), z.unknown()).describe("Non-secret provider settings.");
+const credentialInput = z.union([
+    z.string().describe("Id of a credential that already exists."),
+    z.object({
+        id: z.string().optional().describe("Id for a new credential. The host chooses one when omitted."),
+        secrets: secretValues,
+    }),
+]).describe("Credential id, or a new credential to store with this connection.");
+const createSchema = z.object({
+    provider: z.string().describe("Provider id."),
+    id: z.string().optional().describe("Connection id. The host chooses one when omitted."),
+    displayName: z.string().optional().describe("Label shown for the connection."),
+    config: configValues.optional(),
+    secrets: secretValues.optional(),
+    credential: credentialInput.optional(),
+}).strict();
+const updateSchema = z.object({
+    id: z.string().describe("Connection id."),
+    enabled: z.boolean().optional().describe("Whether stages may use this connection."),
+    displayName: z.string().nullable().optional().describe("Replacement label, or null to clear it."),
+    config: configValues.optional(),
+    secrets: secretValues.optional().describe("Secret fields to replace. Omitted fields are left unchanged."),
+}).strict();
+const targetValue = z.union([z.string(), z.number().int()]);
+const validateSchema = z.object({
+    id: z.string().describe("Connection id."),
+    to: z.union([targetValue, z.array(targetValue).min(1)]).describe("Pinned recipient."),
+    cc: z.array(targetValue).min(1).optional().describe("Copied recipients, when the provider allows them."),
+    template: z.record(z.string(), z.unknown()).optional().describe("Provider template fields, when required."),
+}).strict();
+function jsonBody(value) {
+    return Object.fromEntries(Object.entries(value).filter((entry) => entry[1] !== undefined));
+}
+export function registerConnectionTools(server, deps) {
+    const run = async (work) => {
+        const channels = deps.channels;
+        if (channels === undefined)
+            return textResult({ error: "CHANNELS_UNAVAILABLE" }, true);
+        try {
+            return textResult(await work(channels));
+        }
+        catch (error) {
+            const code = error instanceof ChannelError ? error.code : "CHANNEL_STORAGE_FAILED";
+            return textResult({ error: code }, true);
+        }
+    };
+    server.registerTool("list_connections", {
+        description: "List host connections, same as GET /api/connections. Read-only. Each secret field is \"env\" or \"store\", never the secret value.",
+        inputSchema: z.object({}),
+        annotations: { readOnlyHint: true },
+    }, async () => run((service) => service.list()));
+    server.registerTool("create_connection", {
+        description: "Create a host connection, same as POST /api/connections. Returns { id, health }. Secret values are stored and are not in the result.",
+        inputSchema: createSchema,
+    }, async (input) => run((service) => service.create(jsonBody(input))));
+    server.registerTool("update_connection", {
+        description: "Update one connection, same as PATCH /api/connections/:id. Changes enabled, displayName, config, or replaces secrets. Returns { health } when the connection stays enabled, otherwise {}. Secret values are not in the result.",
+        inputSchema: updateSchema,
+    }, async ({ id, ...patch }) => run((service) => service.update(id, jsonBody(patch))));
+    server.registerTool("remove_connection", {
+        description: "Remove one connection and its stored secrets, same as DELETE /api/connections/:id. Returns { removed: true }.",
+        inputSchema: z.object({
+            id: z.string().describe("Connection id."),
+        }).strict(),
+    }, async ({ id }) => run(async (service) => {
+        await service.remove(id);
+        return { removed: true };
+    }));
+    server.registerTool("test_connection", {
+        description: "Check connection values without saving them, same as POST /api/connections/test. Does not write the connection or its secrets. Returns the health check.",
+        inputSchema: createSchema,
+        annotations: { readOnlyHint: true },
+    }, async (input) => run((service) => service.test(jsonBody(input))));
+    server.registerTool("validate_connection_target", {
+        description: "Check a pinned recipient for a saved connection, same as POST /api/connections/:id/validate-target. No network and no secret read. Returns { ok: true } or { ok: false, issues }.",
+        inputSchema: validateSchema,
+        annotations: { readOnlyHint: true },
+    }, async ({ id, ...target }) => run((service) => service.validateTarget(id, jsonBody(target))));
+}

package/dist/mcp/controlTools.js

@@ -12,6 +12,39 @@ import { textResult } from "./toolResults.js";
 import { projectWaitingGates } from "./waitingGates.js";
 import { readStageVerificationHistory } from "../runstore/verificationHistory.js";
 const auditLog = rootLogger.child({ component: "audit" });
+const decisionAnswer = z.enum(["accept", "reject"]);
+const freeTextOrConfirmAnswer = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("free_text"), text: z.string() }),
+    z.object({
+        kind: z.literal("confirm"),
+        decision: decisionAnswer,
+        text: z.string().optional(),
+    }),
+]);
+const askOperatorAnswerInput = z.discriminatedUnion("kind", [
+    z.object({
+        promptId: z.string().min(1),
+        kind: z.literal("free_text"),
+        text: z.string(),
+    }),
+    z.object({
+        promptId: z.string().min(1),
+        kind: z.literal("confirm"),
+        decision: decisionAnswer,
+        text: z.string().optional(),
+    }),
+    z.object({
+        promptId: z.string().min(1),
+        kind: z.literal("artifact_backed"),
+        decision: decisionAnswer,
+        text: z.string().optional(),
+    }),
+    z.object({
+        promptId: z.string().min(1),
+        kind: z.literal("multi_question"),
+        answers: z.record(z.string(), freeTextOrConfirmAnswer),
+    }),
+]);
 export function registerControlTools(server, deps) {
     const { manager, store, cwd } = deps;
     server.registerTool("list_waiting", {
@@ -46,7 +79,7 @@ export function registerControlTools(server, deps) {
         inputSchema: z.object({
             runId: z.string(),
             stageId: z.string(),
-            answer: z.record(z.string(), z.unknown()),
+            answer: askOperatorAnswerInput,
         }),
     }, async ({ runId, stageId, answer }) => {
         let parsed;

package/dist/mcp/deps.d.ts

@@ -5,6 +5,12 @@ import type { ConversationBackend } from "../agents/sessions.js";
 import type { AgentService } from "../agents/service.js";
 import type { RunStore } from "../runstore/port.js";
 import type { RunChangeBus } from "../runtime/runChangeBus.js";
+import type { EngineStatus } from "../evals/engine/promptfoo/status.js";
+import type { EvalRunManager } from "../evals/manager.js";
+import type { TriageDeps } from "../evals/triage/service.js";
+import type { ChannelService } from "../channels/service.js";
+import type { IssueFetch } from "../config/importTask.js";
+import type { MemoryHost } from "../memory/host.js";
 import type { RunManager } from "../runtime/runManager.js";
 export type McpToolDeps = {
     manager: RunManager;
@@ -17,6 +23,16 @@ export type McpToolDeps = {
     agentService?: AgentService;
     agentChat?: AgentChatController;
     agentConversationBackend?: ConversationBackend;
+    evalRunManager?: EvalRunManager;
+    evalEngineStatus?: () => EngineStatus;
+    /** Failure sorting seams: key lookup, fetch and base URL for the Jev classifier, or a judge model (tests). */
+    triage?: Omit<TriageDeps, "store">;
+    /** Host connections. Absent when the process has no channel service. */
+    channels?: ChannelService;
+    /** Host memories under $STAGEFLOW_HOME. Absent when memory is not configured. */
+    memories?: MemoryHost;
+    /** GitHub issue fetch for `import_task_file`. Tests inject this. Production uses the default client. */
+    issueFetch?: IssueFetch;
 };
 export type McpHttpDeps = McpToolDeps & {
     runChangeBus: RunChangeBus;

package/dist/mcp/evalTools.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/server";
+import type { McpToolDeps } from "./deps.js";
+export declare function registerEvalTools(server: McpServer, deps: McpToolDeps): void;