@lostgradient/weft 0.11.0 → 0.13.0

package/dist/server/operations/async-activity.js

@@ -1,11 +1,24 @@
 import { z } from "zod";
 import { AsyncActivityTokenNotFoundError } from "../../core/engine.js";
+import {
+  DEFAULT_PENDING_ASYNC_ACTIVITY_LIMIT,
+  isPendingAsyncActivityCursor,
+  isPendingAsyncActivityCursorForWorkflow,
+  MAX_PENDING_ASYNC_ACTIVITY_CURSOR_LENGTH,
+  MAX_PENDING_ASYNC_ACTIVITY_LIMIT
+} from "../../core/engine/async-activity-records.js";
 import { PayloadSizeExceededError } from "../../core/payload-size.js";
 import { raiseFault } from "../operation-catalog.js";
 import { defineOperation } from "../operation-registry.js";
 import { readRestJsonBody } from "../rest-body.js";
 import { invalidParamsFault, isOperationFault, shapeRestFault } from "./operation-helpers.js";
-const asyncActivityAccess = { kind: "public" }, httpAndJsonRpcTransports = {
+const asyncActivityReadAccess = {
+  kind: "scoped",
+  scopes: { kind: "anyOf", scopes: ["workflows:read"] }
+}, asyncActivityWriteAccess = {
+  kind: "scoped",
+  scopes: { kind: "anyOf", scopes: ["workflows:write"] }
+}, httpAndJsonRpcTransports = {
   http: !0,
   jsonRpcHttp: !0,
   jsonRpcStdio: !0,
@@ -13,13 +26,56 @@ const asyncActivityAccess = { kind: "public" }, httpAndJsonRpcTransports = {
 }, completeAsyncActivityInput = z.object({
   token: z.string().min(1),
   result: z.unknown().optional()
-}), failAsyncActivityInput = z.object({
+}), pendingAsyncActivityItemSchema = z.object({
+  token: z.string(),
+  operationId: z.string(),
+  activityName: z.string(),
+  step: z.number().int().nonnegative(),
+  attempt: z.number().int().positive(),
+  createdAt: z.number()
+}).strict(), listPendingAsyncActivitiesInput = z.object({
+  workflowId: z.string().min(1),
+  limit: z.number().int().min(1).max(MAX_PENDING_ASYNC_ACTIVITY_LIMIT).default(DEFAULT_PENDING_ASYNC_ACTIVITY_LIMIT),
+  cursor: z.string().max(MAX_PENDING_ASYNC_ACTIVITY_CURSOR_LENGTH).refine(isPendingAsyncActivityCursor, { message: "Invalid cursor" }).optional()
+}), listPendingAsyncActivitiesOutput = z.object({
+  items: z.array(pendingAsyncActivityItemSchema),
+  nextCursor: z.string().optional()
+}).strict(), failAsyncActivityInput = z.object({
   token: z.string().min(1),
   error: z.object({
     message: z.string(),
     name: z.string().optional()
   })
 }), okOutput = z.object({ ok: z.literal(!0) });
+export const listPendingAsyncActivitiesOperation = defineOperation({
+  name: "weft.workflows.activities.pending.list",
+  mcpExposable: !1,
+  summary: "List pending async activities for a workflow",
+  description: "Read a bounded, deterministic page of durable activity task tokens awaiting out-of-band completion. The cursor is opaque and scoped to the selected workflow. A listed token may be consumed concurrently, so a later completion can return NotFound.",
+  destructive: !1,
+  tags: ["Activities"],
+  inputSchema: listPendingAsyncActivitiesInput,
+  outputSchema: listPendingAsyncActivitiesOutput,
+  access: asyncActivityReadAccess,
+  producibleFaults: ["NotFound", "InvalidParams"],
+  transports: httpAndJsonRpcTransports,
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const liveEngine = engine;
+    if (input.cursor !== void 0 && !isPendingAsyncActivityCursorForWorkflow(input.cursor, input.workflowId))
+      raiseFault(listPendingAsyncActivitiesOperation, invalidParamsFault("Cursor does not belong to this workflow."));
+    if (await liveEngine.get(input.workflowId) === null)
+      raiseFault(listPendingAsyncActivitiesOperation, {
+        code: "NotFound",
+        message: `Workflow "${input.workflowId}" not found`,
+        data: { resource: "workflow", identifier: input.workflowId }
+      });
+    return liveEngine.listPendingAsyncActivities(input.workflowId, {
+      limit: input.limit,
+      ...input.cursor === void 0 ? {} : { cursor: input.cursor }
+    });
+  }
+});
 function errorFromFailInput(input) {
   const error = Error(input.error.message);
   if (input.error.name !== void 0)
@@ -46,7 +102,7 @@ export const completeAsyncActivityOperation = defineOperation({
   tags: ["Activities"],
   inputSchema: completeAsyncActivityInput,
   outputSchema: okOutput,
-  access: asyncActivityAccess,
+  access: asyncActivityWriteAccess,
   producibleFaults: ["NotFound", "InvalidParams"],
   transports: httpAndJsonRpcTransports,
   unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
@@ -68,7 +124,7 @@ export const completeAsyncActivityOperation = defineOperation({
   tags: ["Activities"],
   inputSchema: failAsyncActivityInput,
   outputSchema: okOutput,
-  access: asyncActivityAccess,
+  access: asyncActivityWriteAccess,
   producibleFaults: ["NotFound", "InvalidParams"],
   transports: httpAndJsonRpcTransports,
   unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
@@ -88,6 +144,34 @@ function shapeAsyncActivitySuccess(output) {
     headers: { "Content-Type": "application/json" }
   });
 }
+function shapePendingAsyncActivitiesSuccess(output) {
+  return new Response(JSON.stringify(output), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+export const listPendingAsyncActivitiesRestBinding = {
+  method: "GET",
+  path: "/v1/workflows/:id/pending-async-activities",
+  pathParamNames: ["id"],
+  operationName: "weft.workflows.activities.pending.list",
+  inputSources: {
+    workflowId: { kind: "path", pathParam: "id" },
+    limit: { kind: "query", queryParam: "limit" },
+    cursor: { kind: "query", queryParam: "cursor" }
+  },
+  extractInput: async (request, pathParams) => {
+    const search = new URL(request.url).searchParams, limit = search.get("limit"), cursor = search.get("cursor");
+    return {
+      workflowId: pathParams.id ?? "",
+      ...limit === null ? {} : { limit: Number(limit) },
+      ...cursor === null ? {} : { cursor }
+    };
+  },
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => shapePendingAsyncActivitiesSuccess(output),
+  shapeFault: shapeRestFault
+};
 async function readJsonObjectBody(request, context) {
   const body = await readRestJsonBody(request, context).catch((error) => {
     if (isOperationFault(error))

package/dist/server/operations/bulk-filter-helpers.d.ts

@@ -6,6 +6,9 @@ import type { RestInputContext } from '../rest-binding.ts';
 export declare const bulkListFilterInputSchema: z.ZodObject<{
     status: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<WorkflowStatus, WorkflowStatus>, z.ZodArray<z.ZodCustom<WorkflowStatus, WorkflowStatus>>]>>;
     type: z.ZodOptional<z.ZodString>;
+    scheduleId: z.ZodOptional<z.ZodString>;
+    parentWorkflowId: z.ZodOptional<z.ZodString>;
+    parentWorkflowExecutionToken: z.ZodOptional<z.ZodString>;
     tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
     attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
         key: z.ZodString;

package/dist/server/operations/bulk-filter-helpers.js

@@ -29,6 +29,9 @@ const workflowStatusSchema = z.custom((value) => typeof value === "string"), sea
 export const bulkListFilterInputSchema = z.object({
   status: z.union([workflowStatusSchema, z.array(workflowStatusSchema)]).optional(),
   type: z.string().optional(),
+  scheduleId: z.string().min(1).optional(),
+  parentWorkflowId: z.string().min(1).optional(),
+  parentWorkflowExecutionToken: z.string().min(1).optional(),
   tags: z.array(z.string()).optional(),
   attributes: z.array(attributeFilterSchema).optional(),
   limit: z.number().int().min(0).optional(),
@@ -117,12 +120,12 @@ function parseFilterStatus(value) {
     return value;
   throw Error('Field "filter.status" must be a string or an array of strings');
 }
-function parseOptionalFilterType(value) {
+function parseOptionalFilterString(value, fieldName) {
   if (value === void 0)
     return;
   if (typeof value === "string")
     return value;
-  throw Error('Field "filter.type" must be a string');
+  throw Error(`Field "filter.${fieldName}" must be a string`);
 }
 function parseOptionalFilterTags(value) {
   if (value === void 0)
@@ -143,10 +146,25 @@ const BULK_FILTER_DIMENSION_PARSERS = [
       filter.status = status;
   },
   (filter, record) => {
-    const type = parseOptionalFilterType(record.type);
+    const type = parseOptionalFilterString(record.type, "type");
     if (type !== void 0)
       filter.type = type;
   },
+  (filter, record) => {
+    const scheduleId = parseOptionalFilterString(record.scheduleId, "scheduleId");
+    if (scheduleId !== void 0)
+      filter.scheduleId = scheduleId;
+  },
+  (filter, record) => {
+    const parentWorkflowId = parseOptionalFilterString(record.parentWorkflowId, "parentWorkflowId");
+    if (parentWorkflowId !== void 0)
+      filter.parentWorkflowId = parentWorkflowId;
+  },
+  (filter, record) => {
+    const parentWorkflowExecutionToken = parseOptionalFilterString(record.parentWorkflowExecutionToken, "parentWorkflowExecutionToken");
+    if (parentWorkflowExecutionToken !== void 0)
+      filter.parentWorkflowExecutionToken = parentWorkflowExecutionToken;
+  },
   (filter, record) => {
     const tags = parseOptionalFilterTags(record.tags);
     if (tags !== void 0)
@@ -272,6 +290,12 @@ function copyAttributeRangeBound(value, property) {
   return value;
 }
 function applyExtendedBulkFilterFields(filter, input) {
+  if (input.scheduleId !== void 0)
+    filter.scheduleId = input.scheduleId;
+  if (input.parentWorkflowId !== void 0)
+    filter.parentWorkflowId = input.parentWorkflowId;
+  if (input.parentWorkflowExecutionToken !== void 0)
+    filter.parentWorkflowExecutionToken = input.parentWorkflowExecutionToken;
   if (input.idPrefix !== void 0)
     filter.idPrefix = input.idPrefix;
   if (input.failureCategory !== void 0)

package/dist/server/operations/bulk-mutate-workflow-tags.d.ts

@@ -5,6 +5,9 @@ declare const bulkMutateWorkflowTagsInput: z.ZodObject<{
     filter: z.ZodOptional<z.ZodObject<{
         status: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<import("../../index.ts").WorkflowStatus, import("../../index.ts").WorkflowStatus>, z.ZodArray<z.ZodCustom<import("../../index.ts").WorkflowStatus, import("../../index.ts").WorkflowStatus>>]>>;
         type: z.ZodOptional<z.ZodString>;
+        scheduleId: z.ZodOptional<z.ZodString>;
+        parentWorkflowId: z.ZodOptional<z.ZodString>;
+        parentWorkflowExecutionToken: z.ZodOptional<z.ZodString>;
         tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
         attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
             key: z.ZodString;
@@ -55,6 +58,9 @@ export declare const bulkMutateWorkflowTagsOperation: import("../operation-catal
     filter?: {
         status?: import("../../index.ts").WorkflowStatus | import("../../index.ts").WorkflowStatus[] | undefined;
         type?: string | undefined;
+        scheduleId?: string | undefined;
+        parentWorkflowId?: string | undefined;
+        parentWorkflowExecutionToken?: string | undefined;
         tags?: string[] | undefined;
         attributes?: {
             key: string;

package/dist/server/operations/bulk-signal-workflows.d.ts

@@ -4,6 +4,9 @@ import type { UnknownRestBinding } from '../rest-bindings.ts';
 declare const bulkSignalWorkflowsInput: z.ZodObject<{
     status: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<import("../../index.ts").WorkflowStatus, import("../../index.ts").WorkflowStatus>, z.ZodArray<z.ZodCustom<import("../../index.ts").WorkflowStatus, import("../../index.ts").WorkflowStatus>>]>>;
     type: z.ZodOptional<z.ZodString>;
+    scheduleId: z.ZodOptional<z.ZodString>;
+    parentWorkflowId: z.ZodOptional<z.ZodString>;
+    parentWorkflowExecutionToken: z.ZodOptional<z.ZodString>;
     tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
     attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
         key: z.ZodString;
@@ -48,6 +51,9 @@ export declare const bulkSignalWorkflowsOperation: import("../operation-catalog.
     name: string;
     status?: import("../../index.ts").WorkflowStatus | import("../../index.ts").WorkflowStatus[] | undefined;
     type?: string | undefined;
+    scheduleId?: string | undefined;
+    parentWorkflowId?: string | undefined;
+    parentWorkflowExecutionToken?: string | undefined;
     tags?: string[] | undefined;
     attributes?: {
         key: string;

package/dist/server/operations/get-stream-chunks.js

@@ -1,8 +1,7 @@
 import { z } from "zod";
-import { FAULT_CODE_TO_HTTP_STATUS } from "../operation-fault.js";
 import { defineOperation } from "../operation-registry.js";
 import { parseOptionalSequenceCursor } from "../sequence-cursor.js";
-import { invalidParamsFault, jsonErrorResponse } from "./operation-helpers.js";
+import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
 import { createStoredChunkSSEStream, SSE_RESPONSE_HEADERS } from "./sse-stream.js";
 const getStreamChunksInput = z.object({
   workflowId: z.string().min(1),
@@ -33,11 +32,7 @@ export const getStreamChunksOperation = defineOperation({
   }
 });
 function shapeGetStreamChunksFault(fault) {
-  if (fault.code === "InvalidParams")
-    return jsonErrorResponse(fault.message, 400);
-  if (fault.code === "EngineFailure")
-    return jsonErrorResponse("Internal server error", 500);
-  return jsonErrorResponse(fault.message, FAULT_CODE_TO_HTTP_STATUS[fault.code]);
+  return shapeRestFault(fault);
 }
 function shapeGetStreamChunksSuccess(output, request) {
   if ((request.headers.get("Accept") ?? "").includes("text/event-stream"))

package/dist/server/operations/get-system-lease.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `weft.system.lease` operation + REST binding.
+ *
+ * Returns the serving engine process's last-known ownership-lease state. This
+ * is deliberately separate from anonymous `GET /v1/health`: load balancers need
+ * a stable liveness probe, while holder identifiers and fencing state are scoped
+ * operator diagnostics that require `system:read`.
+ *
+ * @module server/operations/get-system-lease
+ */
+import { z } from 'zod';
+import { type EngineLeaseHealth } from '../../core/engine.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const getSystemLeaseInput: z.ZodObject<{}, z.core.$strip>;
+export type GetSystemLeaseInput = z.infer<typeof getSystemLeaseInput>;
+export type GetSystemLeaseOutput = EngineLeaseHealth;
+export declare const getSystemLeaseOperation: import("../operation-catalog.ts").OperationDefinition<Record<string, never>, EngineLeaseHealth, unknown>;
+export declare const getSystemLeaseRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/get-system-lease.js

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import { shapeRestFault } from "./operation-helpers.js";
+const getSystemLeaseInput = z.object({}), getSystemLeaseOutput = z.object({
+  mode: z.enum(["none", "lease"]),
+  status: z.enum(["disabled", "healthy", "no-lease", "contested"]),
+  holdsLease: z.boolean(),
+  holderId: z.string().min(1).optional(),
+  heldSince: z.number().int().nonnegative().optional(),
+  expiresAt: z.number().int().nonnegative().optional(),
+  lastRenewedAt: z.number().int().nonnegative().optional(),
+  fencingEpoch: z.number().int().positive().safe().optional(),
+  lossReason: z.enum(["deposed", "renewal-unconfirmable"]).optional()
+}).strict();
+export const getSystemLeaseOperation = defineOperation({
+  name: "weft.system.lease",
+  mcpExposable: !1,
+  summary: "Get ownership-lease health for this engine process",
+  description: "Reports whether lease ownership is disabled, not yet held, healthy, or contested. Contested results preserve the confirmed deposed or renewal-unconfirmable reason.",
+  destructive: !1,
+  tags: ["System"],
+  inputSchema: getSystemLeaseInput,
+  outputSchema: getSystemLeaseOutput,
+  access: {
+    kind: "scoped",
+    scopes: { kind: "anyOf", scopes: ["system:read"] }
+  },
+  producibleFaults: [],
+  discoverable: !0,
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ engine }) => {
+    return engine.getLeaseHealth();
+  }
+}), getSystemLeaseRestBinding = {
+  method: "GET",
+  path: "/v1/system/lease",
+  pathParamNames: [],
+  operationName: "weft.system.lease",
+  inputSources: {},
+  extractInput: async () => ({}),
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => new Response(JSON.stringify(output), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  }),
+  shapeFault: shapeRestFault
+};

package/dist/server/operations/get-workflow-observability.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import type { WorkflowFinalizerStatus, WorkflowScheduleProvenance } from '../../core/types.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const workflowObservabilityInput: z.ZodObject<{
+    workflowId: z.ZodString;
+}, z.core.$strip>;
+export type GetWorkflowObservabilityInput = z.infer<typeof workflowObservabilityInput>;
+export type GetWorkflowScheduleProvenanceOutput = WorkflowScheduleProvenance | null;
+export type GetWorkflowFinalizerOutput = WorkflowFinalizerStatus | null;
+export declare const getWorkflowScheduleProvenanceOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+}, GetWorkflowScheduleProvenanceOutput, unknown>;
+export declare const getWorkflowFinalizerOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+}, GetWorkflowFinalizerOutput, unknown>;
+export declare const getWorkflowScheduleProvenanceRestBinding: UnknownRestBinding;
+export declare const getWorkflowFinalizerRestBinding: UnknownRestBinding;
+export declare const workflowObservabilityRestBindings: readonly [UnknownRestBinding, UnknownRestBinding];
+export declare const workflowObservabilityOperations: readonly [import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+}, GetWorkflowScheduleProvenanceOutput, unknown>, import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+}, GetWorkflowFinalizerOutput, unknown>];
+export {};

package/dist/server/operations/get-workflow-observability.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import { shapeRestFault } from "./operation-helpers.js";
+const workflowObservabilityInput = z.object({
+  workflowId: z.string().min(1)
+}), scheduleProvenanceOutput = z.object({
+  scheduleId: z.string(),
+  occurrence: z.number().optional()
+}).nullable(), finalizerStatusOutput = z.discriminatedUnion("status", [
+  z.object({ status: z.literal("pending"), attempts: z.number().int().nonnegative() }),
+  z.object({
+    status: z.literal("running"),
+    attempts: z.number().int().positive(),
+    startedAt: z.number().nonnegative()
+  }),
+  z.object({
+    status: z.literal("succeeded"),
+    attempts: z.number().int().positive(),
+    completedAt: z.number().nonnegative()
+  }),
+  z.object({
+    status: z.literal("failed"),
+    attempts: z.number().int().nonnegative(),
+    failedAt: z.number().nonnegative(),
+    error: z.string()
+  })
+]).nullable();
+export const getWorkflowScheduleProvenanceOperation = defineOperation({
+  name: "weft.workflows.scheduleprovenance.get",
+  mcpExposable: !1,
+  summary: "Get the schedule occurrence that launched a workflow",
+  description: "Read the durable schedule id and optional occurrence timestamp that launched a workflow. Returns null for runs that were not launched by a schedule or whose workflow history was purged.",
+  destructive: !1,
+  tags: ["Workflows"],
+  inputSchema: workflowObservabilityInput,
+  outputSchema: scheduleProvenanceOutput,
+  access: { kind: "public" },
+  producibleFaults: [],
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => engine.getScheduleProvenance(input.workflowId)
+}), getWorkflowFinalizerOperation = defineOperation({
+  name: "weft.workflows.finalizer.get",
+  mcpExposable: !1,
+  summary: "Get workflow finalizer progress and outcome",
+  description: "Read durable post-terminal finalizer progress or its succeeded or failed outcome. Returns null when the workflow did not record finalizer work.",
+  destructive: !1,
+  tags: ["Workflows"],
+  inputSchema: workflowObservabilityInput,
+  outputSchema: finalizerStatusOutput,
+  access: { kind: "public" },
+  producibleFaults: [],
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => engine.getFinalizerStatus(input.workflowId)
+}), getWorkflowScheduleProvenanceRestBinding = {
+  method: "GET",
+  path: "/v1/workflows/:id/schedule-provenance",
+  pathParamNames: ["id"],
+  operationName: "weft.workflows.scheduleprovenance.get",
+  inputSources: { workflowId: { kind: "path", pathParam: "id" } },
+  extractInput: async (_request, pathParams) => ({ workflowId: pathParams.id ?? "" }),
+  success: { kind: "json", status: 200 },
+  shapeFault: shapeRestFault
+}, getWorkflowFinalizerRestBinding = {
+  method: "GET",
+  path: "/v1/workflows/:id/finalizer",
+  pathParamNames: ["id"],
+  operationName: "weft.workflows.finalizer.get",
+  inputSources: { workflowId: { kind: "path", pathParam: "id" } },
+  extractInput: async (_request, pathParams) => ({ workflowId: pathParams.id ?? "" }),
+  success: { kind: "json", status: 200 },
+  shapeFault: shapeRestFault
+}, workflowObservabilityRestBindings = [
+  getWorkflowScheduleProvenanceRestBinding,
+  getWorkflowFinalizerRestBinding
+], workflowObservabilityOperations = [
+  getWorkflowScheduleProvenanceOperation,
+  getWorkflowFinalizerOperation
+];

package/dist/server/operations/get-workflow-result.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { defineOperation } from "../operation-registry.js";
-import { jsonErrorResponse, shapeRestFault } from "./operation-helpers.js";
+import { shapeRestFault } from "./operation-helpers.js";
 const getWorkflowResultInput = z.object({
   workflowId: z.string().min(1)
 }), getWorkflowResultOutput = z.unknown();
@@ -75,7 +75,7 @@ function shapeGetWorkflowResultSuccess(result) {
 }
 function shapeGetWorkflowResultFault(fault) {
   if (fault.code === "Timeout")
-    return jsonErrorResponse("Timeout waiting for workflow result", 408);
+    return shapeRestFault(fault, { message: "Timeout waiting for workflow result", status: 408 });
   return shapeRestFault(fault);
 }
 export const getWorkflowResultRestBinding = {

package/dist/server/operations/get-workflow.d.ts

@@ -2,8 +2,8 @@
  * `weft.workflows.get` operation + REST binding.
  *
  * Returns a workflow's state by id. REST response shape preserves the
- * historical format: 200 with the serialized `WorkflowState`, or a
- * 4xx/5xx with `{ error: <message> }` (a bare string), as emitted by
+ * historical format: 200 with the serialized `WorkflowState`, or a 4xx/5xx
+ * with the string `error` plus audited structured `data`, as emitted by
  * `shapeFault` below.
  *
  * @module server/operations/get-workflow

package/dist/server/operations/list-filter-query-extractor.js

@@ -11,6 +11,18 @@ function parseType(params) {
   const type = params.get("type");
   return type === null ? void 0 : type;
 }
+function parseScheduleId(params) {
+  const scheduleId = params.get("schedule_id");
+  return scheduleId === null ? void 0 : scheduleId;
+}
+function parseParentWorkflowId(params) {
+  const parentWorkflowId = params.get("parent_workflow_id");
+  return parentWorkflowId === null ? void 0 : parentWorkflowId;
+}
+function parseParentWorkflowExecutionToken(params) {
+  const parentWorkflowExecutionToken = params.get("parent_workflow_execution_token");
+  return parentWorkflowExecutionToken === null ? void 0 : parentWorkflowExecutionToken;
+}
 function parseTags(params) {
   const tags = params.getAll("tag");
   return tags.length > 0 ? tags : void 0;
@@ -52,6 +64,9 @@ function parseExecutionDeadline(params) {
 const LIST_FILTER_QUERY_PARSERS = {
   status: parseStatus,
   type: parseType,
+  scheduleId: parseScheduleId,
+  parentWorkflowId: parseParentWorkflowId,
+  parentWorkflowExecutionToken: parseParentWorkflowExecutionToken,
   tags: parseTags,
   attributes: parseAttributes,
   idPrefix: parseIdPrefix,

package/dist/server/operations/list-workflows.d.ts

@@ -4,6 +4,9 @@ import type { UnknownRestBinding } from '../rest-bindings.ts';
 declare const listWorkflowsInput: z.ZodObject<{
     status: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<WorkflowStatus, WorkflowStatus>, z.ZodArray<z.ZodCustom<WorkflowStatus, WorkflowStatus>>]>>;
     type: z.ZodOptional<z.ZodString>;
+    scheduleId: z.ZodOptional<z.ZodString>;
+    parentWorkflowId: z.ZodOptional<z.ZodString>;
+    parentWorkflowExecutionToken: z.ZodOptional<z.ZodString>;
     tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
     attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
         key: z.ZodString;
@@ -42,6 +45,9 @@ export type ListWorkflowsOutput = PaginatedResult<WorkflowSummary>;
 export declare const listWorkflowsOperation: import("../operation-catalog.ts").OperationDefinition<{
     status?: WorkflowStatus | WorkflowStatus[] | undefined;
     type?: string | undefined;
+    scheduleId?: string | undefined;
+    parentWorkflowId?: string | undefined;
+    parentWorkflowExecutionToken?: string | undefined;
     tags?: string[] | undefined;
     attributes?: {
         key: string;

package/dist/server/operations/list-workflows.js

@@ -7,7 +7,7 @@ import {
 import { coerceStartWorkflowTags } from "../../core/start-workflow-validation.js";
 import { defineOperation } from "../operation-registry.js";
 import { extractListFilterFromQuery } from "./list-filter-query-extractor.js";
-import { jsonErrorResponse, shapeRestFault } from "./operation-helpers.js";
+import { shapeRestFault } from "./operation-helpers.js";
 const workflowStatusSchema = z.custom((value) => typeof value === "string"), failureCategorySchema = z.custom((value) => typeof value === "string"), searchAttributeValueSchema = z.custom((value) => {
   if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
     return !0;
@@ -27,6 +27,9 @@ const workflowStatusSchema = z.custom((value) => typeof value === "string"), fai
 }), listIncludeSchema = z.union([z.string(), z.array(z.string()).min(1)]).refine((value) => Array.isArray(value) ? value.every((entry) => entry === "failureCategory") : value === "failureCategory", { message: 'include must be "failureCategory"' }), listWorkflowsInput = z.object({
   status: z.union([workflowStatusSchema, z.array(workflowStatusSchema)]).optional(),
   type: z.string().optional(),
+  scheduleId: z.string().min(1).optional(),
+  parentWorkflowId: z.string().min(1).optional(),
+  parentWorkflowExecutionToken: z.string().min(1).optional(),
   tags: z.array(z.string()).optional(),
   attributes: z.array(attributeFilterSchema).optional(),
   limit: z.number().int().min(1).max(1000).optional(),
@@ -42,7 +45,7 @@ export const listWorkflowsOperation = defineOperation({
   name: "weft.workflows.list",
   mcpExposable: !1,
   summary: "List workflows",
-  description: "List workflows visible to the caller, optionally filtered by status, type, tags, id prefix, failure category, and time range, with pagination via `limit`/`offset`. Read-only. Returns the matching workflow summaries in the engine default ordering.",
+  description: "List workflows visible to the caller, optionally filtered by status, type, originating schedule, direct parent run, tags, id prefix, failure category, and time range, with pagination via `limit`/`offset`. Read-only. Returns the matching workflow summaries in the engine default ordering.",
   destructive: !1,
   tags: ["Workflows"],
   inputSchema: listWorkflowsInput,
@@ -113,7 +116,7 @@ function shapeListWorkflowsSuccess(result) {
 }
 function shapeListWorkflowsFault(fault) {
   if (fault.code === "Unprocessable")
-    return jsonErrorResponse(fault.message, 400);
+    return shapeRestFault(fault, { status: 400 });
   return shapeRestFault(fault);
 }
 export const listWorkflowsRestBinding = {
@@ -124,6 +127,12 @@ export const listWorkflowsRestBinding = {
   inputSources: {
     status: { kind: "query", queryParam: "status", repeating: !0 },
     type: { kind: "query", queryParam: "type" },
+    scheduleId: { kind: "query", queryParam: "schedule_id" },
+    parentWorkflowId: { kind: "query", queryParam: "parent_workflow_id" },
+    parentWorkflowExecutionToken: {
+      kind: "query",
+      queryParam: "parent_workflow_execution_token"
+    },
     tags: { kind: "query", queryParam: "tag", repeating: !0 },
     limit: { kind: "query", queryParam: "limit" },
     offset: { kind: "query", queryParam: "offset" },

package/dist/server/operations/operation-helpers.d.ts

@@ -1,13 +1,7 @@
-import { type WeftErrorCode } from '../../core/weft-error.ts';
-import { type OperationFault } from '../operation-fault.ts';
+import type { WeftErrorCode } from '../../core/weft-error.ts';
+import { type OperationFault, type RestFaultResponseOptions } from '../operation-fault.ts';
 /** Type guard distinguishing an `OperationFault` from a value type. */
 export declare function isOperationFault(value: unknown): value is OperationFault;
-/**
- * Build a JSON error response with the flat shape `{ error: <message> }` and
- * `Content-Type: application/json`. Used by per-operation `shapeFault`
- * implementations that need ad-hoc status codes outside the canonical map.
- */
-export declare function jsonErrorResponse(message: string, status: number): Response;
 /**
  * Construct an `InvalidParams` fault with the `{ issues: [] }` data
  * shape. This is the canonical 400-class fault for caller-input validation
@@ -21,16 +15,13 @@ export declare function jsonErrorResponse(message: string, status: number): Resp
  */
 export declare function invalidParamsFault(message: string, weftCode?: WeftErrorCode): OperationFault;
 /**
- * Default REST fault shaper: masks `EngineFailure` to a generic
- * `"Internal server error"` 500; other faults map by `FAULT_CODE_TO_HTTP_STATUS`.
- * REST-only — JSON-RPC transports receive unmasked faults.
+ * Default REST fault shaper. Delegates to the centralized, exhaustively
+ * audited REST projection so direct and per-operation bindings cannot drift.
+ * REST-only — JSON-RPC transports receive their distinct operation fault data.
  *
  * When the fault carries a fine-grained `data.weftCode` (set only at sites that
- * hold a typed `WeftError`, e.g. `WorkflowNotFoundError` /
- * `WorkflowNotRegisteredError`), it is emitted as a top-level `weftCode` sibling
- * of the flat `{ error }` body so REST clients can branch transport-uniformly
- * via `isWeftFault`. The body's `error` stays a plain string, so the new field
- * is a sibling rather than nested. Faults without a `weftCode` keep their exact
- * `{ error }` shape, and `EngineFailure` stays masked (it carries no weftCode).
+ * hold a typed `WeftError`), it remains a top-level `weftCode` sibling. Safe
+ * structured fields are added under `data`; fields outside the per-code
+ * allowlist are withheld. `EngineFailure` stays byte-identically masked.
  */
-export declare function shapeRestFault(fault: OperationFault): Response;
+export declare function shapeRestFault(fault: OperationFault, options?: RestFaultResponseOptions): Response;