stageflow 0.3.0 → 0.8.0

package/dist/server/mcpHost.d.ts

@@ -0,0 +1,22 @@
+import type { AgentPort } from "../agent/port.js";
+import type { ProviderAuthContext } from "../agent/providerAuth.js";
+import type { RunStoreKind } from "../runstore/createStore.js";
+import type { RunStore } from "../runstore/port.js";
+import type { RunChangeBus } from "../runtime/runChangeBus.js";
+import { DEFAULT_PORT, type HttpHostEnvelope } from "./createHttpHost.js";
+export type McpServerOptions = {
+    agent: AgentPort;
+    cwd?: string;
+    agentDir?: string;
+    rootDir?: string;
+    store?: RunStore;
+    storeKind?: RunStoreKind;
+    port?: number;
+    host?: string;
+    maxConcurrent?: number;
+    providerAuthContext?: ProviderAuthContext;
+    mcpStateless?: boolean;
+    runChangeBus?: RunChangeBus;
+};
+export declare function startMcpServer(options: McpServerOptions): Promise<HttpHostEnvelope>;
+export { DEFAULT_PORT };

package/dist/server/mcpHost.js

@@ -0,0 +1,21 @@
+import { bootstrapStageflowHost, } from "./bootstrap.js";
+import { createHttpHost, DEFAULT_PORT, } from "./createHttpHost.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);
+    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;
+        },
+    });
+}
+export { DEFAULT_PORT };

package/dist/server/operatorResults.d.ts

@@ -0,0 +1,13 @@
+import type { RetryStageResult, StartRunResult } from "../runtime/runManager.js";
+export declare function inferRetryStageErrorCode(reason: string): string | undefined;
+export declare function mapRetryStageFailure(result: Extract<RetryStageResult, {
+    ok: false;
+}>): {
+    error: string;
+    code?: string;
+} & Record<string, unknown>;
+export declare function mapStartFailure(result: Extract<StartRunResult, {
+    ok: false;
+}>): {
+    error: string;
+} & Record<string, unknown>;

package/dist/server/operatorResults.js

@@ -0,0 +1,22 @@
+export function inferRetryStageErrorCode(reason) {
+    if (/retry already in progress/i.test(reason))
+        return "retry_in_progress";
+    if (/waiting for input/i.test(reason))
+        return "hitl_not_retriable";
+    if (/already has active orchestration/i.test(reason))
+        return "run_not_retryable";
+    if (/run is not failed/i.test(reason))
+        return "run_not_retryable";
+    if (/stage is not failed/i.test(reason))
+        return "stage_not_failed";
+    return undefined;
+}
+export function mapRetryStageFailure(result) {
+    const { ok: _ok, status: _status, reason, ...rest } = result;
+    const code = inferRetryStageErrorCode(reason);
+    return { error: reason, ...(code ? { code } : {}), ...rest };
+}
+export function mapStartFailure(result) {
+    const { ok: _ok, status: _status, reason, ...rest } = result;
+    return { error: reason, ...rest };
+}

package/dist/tools/emitStageEnvelope.d.ts

@@ -11,12 +11,12 @@
  */
 import { Type } from "typebox";
 import type { StageEnvelope } from "../types/envelope.js";
-import type { ForkEmitContext } from "../types/forkChoice.js";
+import type { CloneEmitContext, ForkEmitContext } from "../types/forkChoice.js";
 export type EmitCapture = {
     envelope?: StageEnvelope;
     error?: string;
 };
-export declare function createEmitStageEnvelopeTool(capture: EmitCapture, payloadSchema?: unknown, forkEmitContext?: ForkEmitContext): {
+export declare function createEmitStageEnvelopeTool(capture: EmitCapture, payloadSchema?: unknown, forkEmitContext?: ForkEmitContext, cloneEmitContext?: CloneEmitContext): {
     name: string;
     label: string;
     description: string;
@@ -26,6 +26,15 @@ export declare function createEmitStageEnvelopeTool(capture: EmitCapture, payloa
         artifacts: Type.TArray<Type.TString>;
         payload: Type.TSchema;
         fork_choice: Type.TArray<Type.TString>;
+        clone_forks?: Type.TArray<Type.TObject<{
+            successor_id: Type.TString;
+            action: Type.TUnion<[Type.TLiteral<"skip">, Type.TLiteral<"once">, Type.TLiteral<"fanout">]>;
+            envelope: Type.TOptional<Type.TUnknown>;
+            mode: Type.TOptional<Type.TUnion<[Type.TLiteral<"parallel">, Type.TLiteral<"sequential">]>>;
+            clones: Type.TOptional<Type.TArray<Type.TObject<{
+                envelope: Type.TUnknown;
+            }>>>;
+        }>> | undefined;
         stage_id: Type.TOptional<Type.TString>;
         notes: Type.TOptional<Type.TString>;
     }>;

package/dist/tools/emitStageEnvelope.js

@@ -11,6 +11,7 @@
  */
 import { Type } from "typebox";
 import { assertRequiredEnvelope, isAdvancingEnvelope, } from "../envelope/check.js";
+import { assertCloneForks } from "../envelope/cloneForks.js";
 import { normalizeForkChoice } from "../envelope/forkChoice.js";
 import { assertEnvelopePayload, compilePayloadSchema, } from "../envelope/payloadSchema.js";
 function toolResult(text, details, options) {
@@ -21,10 +22,23 @@ function toolResult(text, details, options) {
         ...(options?.terminate ? { terminate: true } : {}),
     };
 }
-export function createEmitStageEnvelopeTool(capture, payloadSchema, forkEmitContext) {
+export function createEmitStageEnvelopeTool(capture, payloadSchema, forkEmitContext, cloneEmitContext) {
     const compiledPayload = payloadSchema !== undefined
         ? compilePayloadSchema(payloadSchema)
         : undefined;
+    const cloneForksSchema = Type.Array(Type.Object({
+        successor_id: Type.String(),
+        action: Type.Union([
+            Type.Literal("skip"),
+            Type.Literal("once"),
+            Type.Literal("fanout"),
+        ]),
+        envelope: Type.Optional(Type.Unknown()),
+        mode: Type.Optional(Type.Union([Type.Literal("parallel"), Type.Literal("sequential")])),
+        clones: Type.Optional(Type.Array(Type.Object({
+            envelope: Type.Unknown(),
+        }))),
+    }));
     return {
         name: "emit_stage_envelope",
         label: "Emit stage envelope",
@@ -39,6 +53,7 @@ export function createEmitStageEnvelopeTool(capture, payloadSchema, forkEmitCont
             fork_choice: forkEmitContext !== undefined
                 ? Type.Array(Type.String())
                 : Type.Optional(Type.Array(Type.String())),
+            ...(cloneEmitContext !== undefined ? { clone_forks: cloneForksSchema } : {}),
             stage_id: Type.Optional(Type.String()),
             notes: Type.Optional(Type.String()),
         }),
@@ -47,11 +62,12 @@ export function createEmitStageEnvelopeTool(capture, payloadSchema, forkEmitCont
                 return toolResult("Envelope already accepted; later emits are ignored.", { advancing: isAdvancingEnvelope(capture.envelope), error: "" }, { terminate: true });
             }
             try {
-                if (forkEmitContext !== undefined) {
-                    const record = params;
-                    if (record.status !== "failure") {
-                        normalizeForkChoice(record.fork_choice, "emit", forkEmitContext);
-                    }
+                const record = params;
+                if (record.status !== "failure" && forkEmitContext !== undefined) {
+                    normalizeForkChoice(record.fork_choice, "emit", forkEmitContext);
+                }
+                if (record.status !== "failure" && cloneEmitContext !== undefined) {
+                    assertCloneForks(params, cloneEmitContext);
                 }
                 const envelope = assertRequiredEnvelope(params);
                 assertEnvelopePayload(envelope, payloadSchema);

package/dist/types/envelope.d.ts

@@ -1,3 +1,4 @@
+import type { CloneForkItem } from "./forkChoice.js";
 export type EnvelopeStatus = "success" | "failure";
 export type StageEnvelope = {
     status: EnvelopeStatus;
@@ -5,6 +6,7 @@ export type StageEnvelope = {
     artifacts: string[];
     payload?: Record<string, unknown>;
     fork_choice?: string[];
+    clone_forks?: CloneForkItem[];
     stage_id?: string;
     notes?: string;
 };

package/dist/types/forkChoice.d.ts

@@ -1,3 +1,4 @@
+import type { StageEnvelope } from "./envelope.js";
 export type ForkChoiceShape = {
     cardinality: "one" | "subset";
     allowNone: boolean;
@@ -6,3 +7,24 @@ export type ForkEmitContext = {
     immediateSuccessorIds: string[];
     forkShape: ForkChoiceShape | null;
 };
+export type CloneForkItem = {
+    successor_id: string;
+    action: "skip";
+} | {
+    successor_id: string;
+    action: "once";
+    envelope: StageEnvelope;
+} | {
+    successor_id: string;
+    action: "fanout";
+    mode: "parallel" | "sequential";
+    clones: Array<{
+        envelope: StageEnvelope;
+    }>;
+};
+export type CloneEmitContext = {
+    clonableSuccessors: Array<{
+        successorId: string;
+        cloneCap: number;
+    }>;
+};

package/dist/types/pipeline.d.ts

@@ -14,6 +14,8 @@ export type PipelineStageRef = {
         select: "one" | "subset";
         allow_none?: boolean;
     };
+    clonable?: boolean;
+    clone_cap?: number;
 };
 export type PipelineStageYamlEntry = PipelineStageRef & {
     uses?: string;
@@ -37,6 +39,9 @@ export type NormalizedPipelineStageEntry = {
         select: "one" | "subset";
         allow_none?: boolean;
     };
+    clonable?: boolean;
+    clone_cap?: number;
+    skill?: string;
     body: {
         kind: "inline";
         raw: Record<string, unknown>;
@@ -59,6 +64,9 @@ export type ResolvedPipelineStageNode = {
     ancestors: string[];
     stageIndex: number;
     fork?: PipelineForkConfig;
+    clonable?: boolean;
+    clone_cap?: number;
+    definition_id?: string;
 };
 export type ResolvedPipelineDag = {
     nodes: ResolvedPipelineStageNode[];