stageflow 0.18.0 → 0.23.0

package/dist/server/mcpHost.js

@@ -1,21 +1,20 @@
 import { bootstrapStageflowHost, } from "./bootstrap.js";
 import { createHttpHost, DEFAULT_PORT, } from "./createHttpHost.js";
+import { createOperatorRoutes } from "./http.js";
 export async function startMcpServer(options) {
     const host = options.host ?? "127.0.0.1";
     const port = options.port ?? DEFAULT_PORT;
     const boot = await bootstrapStageflowHost(options);
+    const { manager, store, cwd, agentDir, rootDir } = boot;
+    const providerAuthContext = boot.providerAuthContext;
     return createHttpHost({
         boot,
         host,
         port,
-        routes: async ({ method, pathname, res, json, boot: b }) => {
-            if (method === "GET" && pathname === "/api/health") {
-                json(res, 200, b.manager.getHealth());
-                return true;
-            }
-            json(res, 404, { error: "Not found" });
-            return true;
-        },
+        // Headless daemon: same REST API surface as `sf ui` (this is what lets
+        // `sf run`/`sf runs *` talk to an auto-started `sf mcp` over HTTP), just
+        // without serving the console's static UI files.
+        routes: createOperatorRoutes({ manager, store, cwd, agentDir, rootDir, providerAuthContext }),
     });
 }
 export { DEFAULT_PORT };

package/dist/server/operatorResults.d.ts

@@ -11,3 +11,13 @@ export declare function mapStartFailure(result: Extract<StartRunResult, {
 }>): {
     error: string;
 } & Record<string, unknown>;
+export type StoreLookupPolicy = "run" | "artifact" | "envelope";
+export type StoreLookupKind = "not_found" | "denied" | "error";
+export type StoreLookupMapped = {
+    error: string;
+    status: number;
+    kind: StoreLookupKind;
+};
+export declare function mapStoreLookupError(err: unknown, opts: {
+    policy: StoreLookupPolicy;
+}): StoreLookupMapped;

package/dist/server/operatorResults.js

@@ -22,3 +22,27 @@ export function mapStartFailure(result) {
     const { ok: _ok, status: _status, reason, ...rest } = result;
     return { error: reason, ...rest };
 }
+export function mapStoreLookupError(err, opts) {
+    const error = err instanceof Error ? err.message : String(err);
+    if (opts.policy === "artifact") {
+        if (error === "Artifact path denied") {
+            return { error, status: 400, kind: "denied" };
+        }
+        const notFound = error.startsWith("Run not found") ||
+            error.startsWith("Artifact not found") ||
+            /no such|not found/i.test(error);
+        return {
+            error,
+            status: notFound ? 404 : 400,
+            kind: notFound ? "not_found" : "error",
+        };
+    }
+    const notFound = opts.policy === "envelope"
+        ? /not found|no such|envelope/i.test(error)
+        : /not found|no such|unknown run/i.test(error);
+    return {
+        error,
+        status: notFound ? 404 : 500,
+        kind: notFound ? "not_found" : "error",
+    };
+}

package/dist/server/providerRoutes.d.ts

@@ -6,10 +6,4 @@ export type ProviderRoutesCtx = {
     json: (res: ServerResponse, status: number, body: unknown) => void;
     providerAuthContext?: ProviderAuthContext;
 };
-export declare function providerAuthErrorBody(err: unknown): {
-    status: number;
-    body: {
-        error: string;
-    };
-};
 export declare function handleProviderRoutes(req: IncomingMessage, res: ServerResponse, ctx: ProviderRoutesCtx): Promise<boolean>;

package/dist/server/providerRoutes.js

@@ -1,14 +1,6 @@
-import { defaultContext, detectPiHome, getAuthStatus, listProviders, loginWithApiKey, logoutProvider, ProviderAuthError, } from "../agent/providerAuth.js";
+import { defaultContext, detectPiHome, getAuthStatus, listProviders, loginWithApiKey, logoutProvider, } from "../agent/providerAuth.js";
+import { mapProviderAuthError } from "../agent/providerInspect.js";
 import { answerLoginSession, cancelLoginSession, getLoginSession, startOAuthLoginSession, } from "../agent/oauthSessionManager.js";
-export function providerAuthErrorBody(err) {
-    if (err instanceof ProviderAuthError) {
-        return { status: err.status, body: { error: err.message } };
-    }
-    return {
-        status: 500,
-        body: { error: "Provider auth operation failed" },
-    };
-}
 export async function handleProviderRoutes(req, res, ctx) {
     const { cwd, readJsonBody, json } = ctx;
     const authCtx = ctx.providerAuthContext ?? defaultContext;
@@ -20,7 +12,7 @@ export async function handleProviderRoutes(req, res, ctx) {
             json(res, 200, detectPiHome(cwd));
         }
         catch (err) {
-            const mapped = providerAuthErrorBody(err);
+            const mapped = mapProviderAuthError(err);
             json(res, mapped.status, mapped.body);
         }
         return true;
@@ -30,7 +22,7 @@ export async function handleProviderRoutes(req, res, ctx) {
             json(res, 200, await listProviders(cwd, authCtx));
         }
         catch (err) {
-            const mapped = providerAuthErrorBody(err);
+            const mapped = mapProviderAuthError(err);
             json(res, mapped.status, mapped.body);
         }
         return true;
@@ -44,7 +36,7 @@ export async function handleProviderRoutes(req, res, ctx) {
             });
         }
         catch (err) {
-            const mapped = providerAuthErrorBody(err);
+            const mapped = mapProviderAuthError(err);
             json(res, mapped.status, mapped.body);
         }
         return true;
@@ -70,7 +62,7 @@ export async function handleProviderRoutes(req, res, ctx) {
                 json(res, 200, { ok: true, session });
             }
             catch (err) {
-                const mapped = providerAuthErrorBody(err);
+                const mapped = mapProviderAuthError(err);
                 json(res, mapped.status, mapped.body);
             }
             return true;
@@ -89,7 +81,7 @@ export async function handleProviderRoutes(req, res, ctx) {
             json(res, 200, { ok: true, provider });
         }
         catch (err) {
-            const mapped = providerAuthErrorBody(err);
+            const mapped = mapProviderAuthError(err);
             json(res, mapped.status, mapped.body);
         }
         return true;
@@ -135,7 +127,7 @@ export async function handleProviderRoutes(req, res, ctx) {
                 json(res, 200, { ok: true, session });
             }
             catch (err) {
-                const mapped = providerAuthErrorBody(err);
+                const mapped = mapProviderAuthError(err);
                 json(res, mapped.status, mapped.body);
             }
             return true;
@@ -157,7 +149,7 @@ export async function handleProviderRoutes(req, res, ctx) {
                 json(res, 200, { ok: true, session });
             }
             catch (err) {
-                const mapped = providerAuthErrorBody(err);
+                const mapped = mapProviderAuthError(err);
                 json(res, mapped.status, mapped.body);
             }
             return true;
@@ -177,7 +169,7 @@ export async function handleProviderRoutes(req, res, ctx) {
             json(res, 200, { ok: true, provider });
         }
         catch (err) {
-            const mapped = providerAuthErrorBody(err);
+            const mapped = mapProviderAuthError(err);
             json(res, mapped.status, mapped.body);
         }
         return true;

package/dist/tools/askOperator.d.ts

@@ -330,6 +330,7 @@ export declare function createAskOperatorTool(options: AskOperatorToolOptions):
         artifacts: Type.TArray<Type.TString>;
         id: Type.TOptional<Type.TString>;
     }>)[]]>;
+    prepareArguments: (args: unknown) => never;
     execute: (_toolCallId: string, params: unknown) => Promise<{
         content: {
             type: "text";

package/dist/tools/askOperator.js

@@ -9,6 +9,7 @@
  */
 import { randomUUID } from "node:crypto";
 import { Type } from "typebox";
+import { prepareAskOperatorArguments } from "./prepareToolArguments.js";
 export class AskOperatorError extends Error {
     constructor(message) {
         super(message);
@@ -168,10 +169,11 @@ function parseSubQuestion(value, path) {
     };
 }
 export function parseAskOperatorParams(value) {
-    if (!isRecord(value)) {
+    const prepared = prepareAskOperatorArguments(value);
+    if (!isRecord(prepared)) {
         throw new AskOperatorError("ask_operator params must be an object");
     }
-    const kind = value.kind;
+    const kind = prepared.kind;
     if (typeof kind !== "string") {
         throw new AskOperatorError("kind is required");
     }
@@ -181,36 +183,36 @@ export function parseAskOperatorParams(value) {
         kind !== "artifact_backed") {
         throw new AskOperatorError(`unsupported prompt kind "${kind}" (allowed: free_text, confirm, multi_question, artifact_backed)`);
     }
-    const id = optionalId(value.id, "id");
+    const id = optionalId(prepared.id, "id");
     if (kind === "free_text" || kind === "confirm") {
         return {
             kind,
-            message: requireNonEmptyString(value.message, "message"),
+            message: requireNonEmptyString(prepared.message, "message"),
             ...(id !== undefined ? { id } : {}),
         };
     }
     if (kind === "artifact_backed") {
-        if (!Array.isArray(value.artifacts)) {
+        if (!Array.isArray(prepared.artifacts)) {
             throw new AskOperatorError("artifacts must be an array");
         }
-        if (value.artifacts.length < 1) {
+        if (prepared.artifacts.length < 1) {
             throw new AskOperatorError("artifacts must contain at least one path");
         }
-        const artifacts = value.artifacts.map((item, index) => requireNonEmptyString(item, `artifacts[${index}]`));
+        const artifacts = prepared.artifacts.map((item, index) => requireNonEmptyString(item, `artifacts[${index}]`));
         return {
             kind,
-            message: requireNonEmptyString(value.message, "message"),
+            message: requireNonEmptyString(prepared.message, "message"),
             artifacts,
             ...(id !== undefined ? { id } : {}),
         };
     }
-    if (!Array.isArray(value.questions)) {
+    if (!Array.isArray(prepared.questions)) {
         throw new AskOperatorError("questions must be an array");
     }
-    if (value.questions.length < 1) {
+    if (prepared.questions.length < 1) {
         throw new AskOperatorError("questions must contain at least one item");
     }
-    const questions = value.questions.map((item, index) => parseSubQuestion(item, `questions[${index}]`));
+    const questions = prepared.questions.map((item, index) => parseSubQuestion(item, `questions[${index}]`));
     return {
         kind,
         questions,
@@ -401,6 +403,7 @@ export function createAskOperatorTool(options) {
         label: "Ask operator",
         description: `Ask the operator a question and wait for their answer. Supports ${kindList} prompts. Does not complete the stage — call emit_stage_envelope when finished.`,
         parameters: askOperatorParamsSchemaFor(allowedKinds),
+        prepareArguments: prepareAskOperatorArguments,
         execute: async (_toolCallId, params) => {
             let prompt;
             try {

package/dist/tools/emitStageEnvelope.d.ts

@@ -37,6 +37,7 @@ export declare function createEmitStageEnvelopeTool(capture: EmitCapture, payloa
         stage_id: Type.TOptional<Type.TString>;
         notes: Type.TOptional<Type.TString>;
     }>;
+    prepareArguments: (args: unknown) => never;
     execute: (_toolCallId: string, params: unknown) => Promise<{
         content: {
             type: "text";

package/dist/tools/emitStageEnvelope.js

@@ -15,6 +15,7 @@ import { assertFeedbackLoopAction } from "../envelope/feedbackLoop.js";
 import { normalizeForkChoice } from "../envelope/forkChoice.js";
 import { assertEnvelopePayload, compilePayloadSchema, } from "../envelope/payloadSchema.js";
 import { assertPreEmitChecks, } from "../envelope/preEmitChecks.js";
+import { prepareEmitStageEnvelopeArguments } from "./prepareToolArguments.js";
 function stringLiteralsSchema(values) {
     if (values.length === 1) {
         return Type.Literal(values[0]);
@@ -78,12 +79,13 @@ export function createEmitStageEnvelopeTool(capture, payloadSchema, forkEmitCont
             stage_id: Type.Optional(Type.String()),
             notes: Type.Optional(Type.String()),
         }),
+        prepareArguments: prepareEmitStageEnvelopeArguments,
         execute: async (_toolCallId, params) => {
             if (capture.envelope) {
                 return toolResult("Envelope already accepted; later emits are ignored.", { advancing: isAdvancingEnvelope(capture.envelope), error: "" }, { terminate: true });
             }
             try {
-                const envelope = assertRequiredEnvelope(params);
+                const envelope = assertRequiredEnvelope(prepareEmitStageEnvelopeArguments(params));
                 assertFeedbackLoopAction(envelope, feedbackLoopEmitContext);
                 const isSendBack = envelope.feedback_loop?.action === "send_back";
                 if (envelope.status !== "failure" &&

package/dist/tools/prepareToolArguments.d.ts

@@ -0,0 +1,4 @@
+export declare function coerceJsonArrayField(args: Record<string, unknown>, key: string): void;
+export declare function coerceJsonObjectField(args: Record<string, unknown>, key: string): void;
+export declare function prepareAskOperatorArguments(input: unknown): unknown;
+export declare function prepareEmitStageEnvelopeArguments(input: unknown): unknown;

package/dist/tools/prepareToolArguments.js

@@ -0,0 +1,79 @@
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseJsonArrayString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("["))
+        return undefined;
+    try {
+        const parsed = JSON.parse(trimmed);
+        return Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseJsonObjectString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("{"))
+        return undefined;
+    try {
+        const parsed = JSON.parse(trimmed);
+        return isRecord(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function coerceJsonArrayField(args, key) {
+    const parsed = parseJsonArrayString(args[key]);
+    if (parsed !== undefined) {
+        args[key] = parsed;
+    }
+}
+export function coerceJsonObjectField(args, key) {
+    const parsed = parseJsonObjectString(args[key]);
+    if (parsed !== undefined) {
+        args[key] = parsed;
+    }
+}
+function coerceJsonObjectArrayElements(args, key) {
+    const value = args[key];
+    if (!Array.isArray(value))
+        return;
+    args[key] = value.map((item) => parseJsonObjectString(item) ?? item);
+}
+export function prepareAskOperatorArguments(input) {
+    if (!isRecord(input))
+        return input;
+    const args = { ...input };
+    coerceJsonArrayField(args, "questions");
+    coerceJsonObjectArrayElements(args, "questions");
+    coerceJsonArrayField(args, "artifacts");
+    return args;
+}
+export function prepareEmitStageEnvelopeArguments(input) {
+    if (!isRecord(input))
+        return input;
+    const args = { ...input };
+    coerceJsonObjectField(args, "payload");
+    coerceJsonObjectField(args, "feedback_loop");
+    coerceJsonArrayField(args, "artifacts");
+    coerceJsonArrayField(args, "fork_choice");
+    coerceJsonArrayField(args, "checklist_attestations");
+    coerceJsonObjectArrayElements(args, "checklist_attestations");
+    if (Array.isArray(args.checklist_attestations)) {
+        args.checklist_attestations = args.checklist_attestations.map((item) => {
+            if (!isRecord(item))
+                return item;
+            const next = { ...item };
+            coerceJsonArrayField(next, "items");
+            return next;
+        });
+    }
+    return args;
+}

package/dist/types/pipeline.d.ts

@@ -10,6 +10,14 @@ export type PipelineConfig = {
     /** Pipeline-file `$ref` root (`#/schemas/<name>`). */
     schemas?: Record<string, unknown>;
 };
+/** An inline pipeline definition authored directly in a `start_run` call, with no backing file. */
+export type InlinePipelineDefinition = {
+    id: string;
+    stages: Array<Record<string, unknown>>;
+    agent?: unknown;
+    model?: unknown;
+    schemas?: unknown;
+};
 export type PipelineForkConfig = {
     select: "one" | "subset";
     allow_none: boolean;