@lostgradient/weft 0.2.0

package/dist/server/operations/create-schedule.js

@@ -0,0 +1,116 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+import { mapScheduleErrorToFault, validateScheduleInputCadence } from "./schedule-faults.js";
+const VALID_SCHEDULE_OVERLAP_POLICIES = new Set([
+  "skip",
+  "queue",
+  "cancel-running",
+  "allow"
+]), createScheduleInput = z.object({
+  type: z.unknown().describe("Workflow type name. Runtime validation requires a non-empty string."),
+  cronExpression: z.unknown().optional().describe("Cron expression. Supply exactly one of cronExpression or every; runtime validation requires a non-empty string."),
+  every: z.unknown().optional().describe("Interval period (duration string or milliseconds). Supply exactly one of cronExpression or every."),
+  input: z.unknown().optional(),
+  id: z.unknown().optional(),
+  overlap: z.unknown().optional(),
+  backfill: z.unknown().optional()
+}), createScheduleOutput = z.object({
+  id: z.string()
+});
+function validateRequiredScheduleFields(input) {
+  if (typeof input.type !== "string" || input.type.length === 0)
+    throw invalidParamsFault("Missing required field: type");
+  return { type: input.type, spec: validateScheduleInputCadence(input) };
+}
+function validateOptionalScheduleFields(input) {
+  let validatedId;
+  if (input.id !== void 0) {
+    if (typeof input.id !== "string" || input.id.length === 0)
+      throw invalidParamsFault('Field "id" must be a non-empty string');
+    validatedId = input.id;
+  }
+  let validatedOverlap;
+  if (input.overlap !== void 0) {
+    if (typeof input.overlap !== "string" || !isScheduleOverlapPolicy(input.overlap))
+      throw invalidParamsFault('Field "overlap" must be one of skip, queue, cancel-running, allow');
+    validatedOverlap = input.overlap;
+  }
+  let validatedBackfill;
+  if (input.backfill !== void 0) {
+    if (typeof input.backfill !== "boolean")
+      throw invalidParamsFault('Field "backfill" must be a boolean');
+    validatedBackfill = input.backfill;
+  }
+  return { id: validatedId, overlap: validatedOverlap, backfill: validatedBackfill };
+}
+function validateCreateScheduleInput(input) {
+  const { type, spec } = validateRequiredScheduleFields(input), { id, overlap, backfill } = validateOptionalScheduleFields(input);
+  return { type, spec, id, overlap, backfill };
+}
+export const createScheduleOperation = defineOperation({
+  name: "weft.schedules.create",
+  mcpExposable: !1,
+  summary: "Create a recurring schedule",
+  description: "Create a schedule that starts a workflow on a recurring cadence. Requires a schedule `id`, the target workflow `type`, and a recurrence specification (cron expression or interval); accepts the workflow `input` and start options. Returns the created schedule id. Faults with Conflict when a schedule with the same id already exists and InvalidParams for a malformed recurrence specification.",
+  destructive: !1,
+  tags: ["Schedules"],
+  inputSchema: createScheduleInput,
+  outputSchema: createScheduleOutput,
+  access: { kind: "public" },
+  producibleFaults: ["NotFound", "Conflict"],
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const typedEngine = engine, validated = validateCreateScheduleInput(input), options = {
+      ...validated.id !== void 0 ? { id: validated.id } : {},
+      ...validated.overlap !== void 0 ? { overlap: validated.overlap } : {},
+      ...validated.backfill !== void 0 ? { backfill: validated.backfill } : {}
+    };
+    try {
+      return { id: (await typedEngine.schedule(validated.type, input.input, validated.spec, options)).id };
+    } catch (error) {
+      throw mapScheduleErrorToFault(validated.id ?? "", error);
+    }
+  }
+});
+function isScheduleOverlapPolicy(value) {
+  return VALID_SCHEDULE_OVERLAP_POLICIES.has(value);
+}
+export const createScheduleRestBinding = {
+  method: "POST",
+  path: "/v1/schedules",
+  pathParamNames: [],
+  operationName: "weft.schedules.create",
+  inputSources: {
+    type: { kind: "body-field", bodyField: "type" },
+    cronExpression: { kind: "body-field", bodyField: "cronExpression" },
+    every: { kind: "body-field", bodyField: "every" },
+    input: { kind: "body-field", bodyField: "input" },
+    id: { kind: "body-field", bodyField: "id" },
+    overlap: { kind: "body-field", bodyField: "overlap" },
+    backfill: { kind: "body-field", bodyField: "backfill" }
+  },
+  extractInput: async (request) => {
+    let body;
+    try {
+      body = await request.json();
+    } catch {
+      throw invalidParamsFault("Invalid JSON body");
+    }
+    if (typeof body !== "object" || body === null)
+      throw invalidParamsFault("Request body must be a JSON object");
+    const record = body;
+    return {
+      type: record.type,
+      cronExpression: Object.hasOwn(record, "cronExpression") ? record.cronExpression : void 0,
+      every: Object.hasOwn(record, "every") ? record.every : void 0,
+      input: record.input,
+      id: record.id,
+      overlap: record.overlap,
+      backfill: record.backfill
+    };
+  },
+  success: { kind: "json", status: 201 },
+  shapeFault: shapeRestFault
+};

package/dist/server/operations/failure-category-filter.d.ts

@@ -0,0 +1,2 @@
+import type { FailureCategory } from '../../core/types.ts';
+export declare function parseOptionalFailureCategoryFilter(value: unknown): FailureCategory | FailureCategory[] | undefined;

package/dist/server/operations/failure-category-filter.js

@@ -0,0 +1,19 @@
+import { FAILURE_CATEGORIES, isFailureCategory } from "../../core/failure-categories.js";
+const failureCategoryErrorMessage = `Field "filter.failureCategory" must be one of ${FAILURE_CATEGORIES.join(", ")}`, failureCategoryShapeErrorMessage = 'Field "filter.failureCategory" must be a string or an array of strings';
+export function parseOptionalFailureCategoryFilter(value) {
+  if (value === void 0)
+    return;
+  if (typeof value === "string")
+    return parseFailureCategory(value);
+  if (Array.isArray(value)) {
+    if (!value.every((entry) => typeof entry === "string"))
+      throw Error(failureCategoryShapeErrorMessage);
+    return value.map(parseFailureCategory);
+  }
+  throw Error(failureCategoryShapeErrorMessage);
+}
+function parseFailureCategory(value) {
+  if (isFailureCategory(value))
+    return value;
+  throw Error(failureCategoryErrorMessage);
+}

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

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const forkWorkflowInput: z.ZodObject<{
+    workflowId: z.ZodString;
+    fromStep: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+declare const forkWorkflowOutput: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export type ForkWorkflowInput = z.infer<typeof forkWorkflowInput>;
+export type ForkWorkflowOutput = z.infer<typeof forkWorkflowOutput>;
+/**
+ * Map an engine error thrown by `engine.fork` to the canonical operation fault.
+ *
+ * Routing order:
+ *   1. 'fromStep' / 'Checkpoint not found at step' → InvalidParams (400)
+ *   2. 'Checkpoint not found'                       → NotFound, resource: 'checkpoint'
+ *   3. 'not found'                                  → NotFound, resource: 'workflow'
+ *   4. otherwise                                    → EngineFailure
+ */
+export declare function resolveForkAccess(error: unknown): never;
+export declare const forkWorkflowOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+    fromStep?: unknown;
+}, {
+    id: string;
+}>;
+export declare const forkWorkflowRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/fork-workflow.js

@@ -0,0 +1,88 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+const forkWorkflowInput = z.object({
+  workflowId: z.string().min(1),
+  fromStep: z.unknown().optional()
+}), forkWorkflowOutput = z.object({
+  id: z.string()
+});
+function validateForkInput(input) {
+  if (input.fromStep === void 0)
+    return;
+  if (typeof input.fromStep !== "number" || !Number.isSafeInteger(input.fromStep) || input.fromStep < 0)
+    throw invalidParamsFault('Field "fromStep" must be a non-negative safe integer');
+  return { fromStep: input.fromStep };
+}
+export function resolveForkAccess(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (message.includes("fromStep") || message.includes("Checkpoint not found at step"))
+    throw invalidParamsFault(message);
+  if (message.includes("Checkpoint not found"))
+    throw {
+      code: "NotFound",
+      message,
+      data: { resource: "checkpoint" }
+    };
+  if (message.includes("not found"))
+    throw {
+      code: "NotFound",
+      message,
+      data: { resource: "workflow" }
+    };
+  throw {
+    code: "EngineFailure",
+    message,
+    data: {}
+  };
+}
+export const forkWorkflowOperation = defineOperation({
+  name: "weft.workflows.fork",
+  mcpExposable: !1,
+  summary: "Fork a workflow from a checkpoint",
+  destructive: !1,
+  tags: ["Workflows"],
+  inputSchema: forkWorkflowInput,
+  outputSchema: forkWorkflowOutput,
+  access: { kind: "public" },
+  producibleFaults: ["NotFound"],
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const typedEngine = engine, options = validateForkInput(input);
+    try {
+      return { id: (await typedEngine.fork(input.workflowId, options)).id };
+    } catch (error) {
+      resolveForkAccess(error);
+    }
+  }
+}), forkWorkflowRestBinding = {
+  method: "POST",
+  path: "/v1/workflows/:id/fork",
+  pathParamNames: ["id"],
+  operationName: "weft.workflows.fork",
+  inputSources: {
+    workflowId: { kind: "path", pathParam: "id" },
+    fromStep: { kind: "body-field", bodyField: "fromStep" }
+  },
+  extractInput: async (request, pathParams) => {
+    const rawBody = await request.text();
+    if (rawBody.trim().length === 0)
+      return { workflowId: pathParams.id ?? "" };
+    let body;
+    try {
+      body = JSON.parse(rawBody);
+    } catch {
+      throw invalidParamsFault("Invalid JSON body");
+    }
+    if (typeof body !== "object" || body === null || Array.isArray(body))
+      throw invalidParamsFault("Request body must be a JSON object");
+    const record = body;
+    return {
+      workflowId: pathParams.id ?? "",
+      fromStep: record.fromStep
+    };
+  },
+  success: { kind: "json", status: 201 },
+  shapeFault: shapeRestFault
+};

package/dist/server/operations/get-checkpoint-at.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import type { CheckpointState } from '../../core/types.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const getCheckpointAtInput: z.ZodObject<{
+    workflowId: z.ZodString;
+    step: z.ZodNumber;
+}, z.core.$strip>;
+export type GetCheckpointAtInput = z.infer<typeof getCheckpointAtInput>;
+export type GetCheckpointAtOutput = CheckpointState;
+export declare const getCheckpointAtOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+    step: number;
+}, CheckpointState>;
+export declare const getCheckpointAtRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/get-checkpoint-at.js

@@ -0,0 +1,74 @@
+import { z } from "zod";
+import { negotiatedResponse } from "../handler/response-helpers.js";
+import { defineOperation } from "../operation-registry.js";
+import { shapeRestFault } from "./operation-helpers.js";
+const getCheckpointAtInput = z.object({
+  workflowId: z.string().min(1),
+  step: z.number().int().nonnegative()
+}), getCheckpointAtOutput = z.unknown();
+export const getCheckpointAtOperation = defineOperation({
+  name: "weft.workflows.checkpoints.get",
+  mcpExposable: !1,
+  summary: "Get a specific checkpoint by step number",
+  destructive: !1,
+  tags: ["Checkpoints"],
+  inputSchema: getCheckpointAtInput,
+  outputSchema: getCheckpointAtOutput,
+  access: { kind: "public" },
+  producibleFaults: ["NotFound"],
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const state = await engine.getCheckpointAt(input.workflowId, input.step);
+    if (state === null)
+      throw {
+        code: "NotFound",
+        message: `Checkpoint not found at step ${input.step} for workflow ${input.workflowId}`,
+        data: { resource: "checkpoint", identifier: `${input.workflowId}:${input.step}` }
+      };
+    return state;
+  }
+});
+function shapeGetCheckpointAtSuccess(result, request) {
+  return negotiatedResponse(request, result, 200);
+}
+function shapeGetCheckpointAtFault(fault) {
+  return shapeRestFault(fault);
+}
+export const getCheckpointAtRestBinding = {
+  method: "GET",
+  path: "/v1/workflows/:id/checkpoints/:step",
+  pathParamNames: ["id", "step"],
+  operationName: "weft.workflows.checkpoints.get",
+  inputSources: {
+    workflowId: { kind: "path", pathParam: "id" },
+    step: { kind: "path", pathParam: "step" }
+  },
+  extractInput: async (_request, pathParams) => {
+    const stepParam = pathParams.step ?? "";
+    if (!/^\d+$/.test(stepParam))
+      throw {
+        code: "InvalidParams",
+        message: `Invalid step: ${stepParam}`,
+        data: {
+          issues: [{ path: ["step"], message: `Invalid step: ${stepParam}`, code: "custom" }]
+        }
+      };
+    const step = Number(stepParam);
+    if (!Number.isSafeInteger(step) || step < 0)
+      throw {
+        code: "InvalidParams",
+        message: `Invalid step: ${stepParam}`,
+        data: {
+          issues: [{ path: ["step"], message: `Invalid step: ${stepParam}`, code: "custom" }]
+        }
+      };
+    return {
+      workflowId: pathParams.id ?? "",
+      step
+    };
+  },
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output, request) => shapeGetCheckpointAtSuccess(output, request),
+  shapeFault: shapeGetCheckpointAtFault
+};

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

@@ -0,0 +1,26 @@
+/**
+ * `weft.system.registry` operation + REST binding.
+ *
+ * Returns a JSON snapshot of every locally-registered workflow and activity,
+ * with their JSON Schemas. Powers the `weft codegen` CLI: a downstream
+ * project fetches this document, validates it, and emits a `.d.ts` that
+ * augments `WorkflowRegistry` with the locally-registered workflow names.
+ *
+ * Access is scoped to `system:read` — schemas can leak internal data shapes
+ * so the endpoint sits behind the same scope as the JSON metrics endpoint.
+ *
+ * The actual snapshot assembly lives in {@link buildRegistrySnapshot} so the
+ * MCP server (Section 2 of the roadmap) can reuse the builder without going
+ * through HTTP.
+ *
+ * @module server/operations/get-registry
+ */
+import { z } from 'zod';
+import { type RegistrySnapshot } from '../../core/registry-snapshot.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const getRegistryInput: z.ZodObject<{}, z.core.$strip>;
+export type GetRegistryInput = z.infer<typeof getRegistryInput>;
+export type GetRegistryOutput = RegistrySnapshot;
+export declare const getRegistryOperation: import("../operation-catalog.ts").OperationDefinition<Record<string, never>, RegistrySnapshot>;
+export declare const getRegistryRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/get-registry.js

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import {
+  buildRegistrySnapshot,
+  RegistrySchemaConversionError
+} from "../../core/registry-snapshot.js";
+import { defineOperation } from "../operation-registry.js";
+import { shapeRestFault } from "./operation-helpers.js";
+const getRegistryInput = z.object({}), objectValue = z.unknown().refine((value) => typeof value === "object" && value !== null && !Array.isArray(value), {
+  message: "expected an object"
+}), getRegistryOutput = z.object({
+  registryVersion: z.literal(1),
+  workflows: objectValue,
+  activities: objectValue
+}).strict();
+export const getRegistryOperation = defineOperation({
+  name: "weft.system.registry",
+  mcpExposable: !1,
+  summary: "Get a snapshot of registered workflows and activities with their JSON Schemas",
+  destructive: !1,
+  tags: ["System"],
+  inputSchema: getRegistryInput,
+  outputSchema: getRegistryOutput,
+  access: {
+    kind: "scoped",
+    scopes: { kind: "anyOf", scopes: ["system:read"] }
+  },
+  discoverable: !0,
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ engine }) => {
+    try {
+      return buildRegistrySnapshot(engine);
+    } catch (error) {
+      if (error instanceof RegistrySchemaConversionError)
+        console.error(`[weft.system.registry] ${error.message}`, {
+          entityKind: error.entityKind,
+          entityName: error.entityName,
+          direction: error.direction
+        });
+      throw error;
+    }
+  }
+}), getRegistryRestBinding = {
+  method: "GET",
+  path: "/v1/registry",
+  pathParamNames: [],
+  operationName: "weft.system.registry",
+  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-retention-overview.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import type { RetentionOverview } from '../../core/types.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const getRetentionOverviewInput: z.ZodObject<{}, z.core.$strip>;
+export type GetRetentionOverviewInput = z.infer<typeof getRetentionOverviewInput>;
+export type GetRetentionOverviewOutput = RetentionOverview;
+export declare const getRetentionOverviewOperation: import("../operation-catalog.ts").OperationDefinition<Record<string, never>, RetentionOverview>;
+export declare const getRetentionOverviewRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/get-retention-overview.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import { shapeRestFault } from "./operation-helpers.js";
+const getRetentionOverviewInput = z.object({}), getRetentionOverviewOutput = z.unknown();
+export const getRetentionOverviewOperation = defineOperation({
+  name: "weft.retention.get",
+  mcpExposable: !1,
+  summary: "Get retention policy overview",
+  destructive: !1,
+  tags: ["System"],
+  inputSchema: getRetentionOverviewInput,
+  outputSchema: getRetentionOverviewOutput,
+  access: { kind: "public" },
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ engine }) => {
+    return engine.getRetentionOverview();
+  }
+});
+function shapeGetRetentionOverviewSuccess(result) {
+  return new Response(JSON.stringify(result), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function shapeGetRetentionOverviewFault(fault) {
+  return shapeRestFault(fault);
+}
+export const getRetentionOverviewRestBinding = {
+  method: "GET",
+  path: "/v1/retention",
+  pathParamNames: [],
+  operationName: "weft.retention.get",
+  inputSources: {},
+  extractInput: async () => ({}),
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => shapeGetRetentionOverviewSuccess(output),
+  shapeFault: shapeGetRetentionOverviewFault
+};

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

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import type { ReviewRequest } from '../../core/review/index.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const getReviewInput: z.ZodObject<{
+    workflowId: z.ZodString;
+    reviewId: z.ZodString;
+}, z.core.$strip>;
+export type GetReviewInput = z.infer<typeof getReviewInput>;
+export type GetReviewOutput = ReviewRequest;
+export declare const getReviewOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+    reviewId: string;
+}, ReviewRequest>;
+export declare const getReviewRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/get-review.js

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import { shapeRestFault } from "./operation-helpers.js";
+const getReviewInput = z.object({
+  workflowId: z.string().min(1),
+  reviewId: z.string().min(1)
+}), getReviewOutput = z.unknown();
+export const getReviewOperation = defineOperation({
+  name: "weft.reviews.get",
+  mcpExposable: !1,
+  summary: "Get a specific review for a workflow",
+  description: "Read a single human review request for a workflow by its identifiers, including the review prompt, available options, and current decision state. Read-only. Faults with NotFound when the review is not visible.",
+  destructive: !1,
+  tags: ["Reviews"],
+  inputSchema: getReviewInput,
+  outputSchema: getReviewOutput,
+  access: { kind: "public" },
+  producibleFaults: ["NotFound"],
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const review = await engine.getReview(input.workflowId, input.reviewId);
+    if (review === null)
+      throw {
+        code: "NotFound",
+        message: `Review "${input.reviewId}" not found for workflow "${input.workflowId}"`,
+        data: { resource: "review", identifier: input.reviewId }
+      };
+    return review;
+  }
+});
+function shapeGetReviewSuccess(result) {
+  return new Response(JSON.stringify(result), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function shapeGetReviewFault(fault) {
+  return shapeRestFault(fault);
+}
+export const getReviewRestBinding = {
+  method: "GET",
+  path: "/v1/workflows/:id/review/:reviewId",
+  pathParamNames: ["id", "reviewId"],
+  operationName: "weft.reviews.get",
+  inputSources: {
+    workflowId: { kind: "path", pathParam: "id" },
+    reviewId: { kind: "path", pathParam: "reviewId" }
+  },
+  extractInput: async (_request, pathParams) => ({
+    workflowId: pathParams.id ?? "",
+    reviewId: pathParams.reviewId ?? ""
+  }),
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => shapeGetReviewSuccess(output),
+  shapeFault: shapeGetReviewFault
+};

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

@@ -0,0 +1,20 @@
+/**
+ * `weft.schedules.get` operation + REST binding.
+ *
+ * Returns a single recurring schedule by id.
+ *
+ * @module server/operations/get-schedule
+ */
+import { z } from 'zod';
+import type { ScheduleSummary } from '../../core/types.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const getScheduleInput: z.ZodObject<{
+    scheduleId: z.ZodString;
+}, z.core.$strip>;
+export type GetScheduleInput = z.infer<typeof getScheduleInput>;
+export type GetScheduleOutput = ScheduleSummary;
+export declare const getScheduleOperation: import("../operation-catalog.ts").OperationDefinition<{
+    scheduleId: string;
+}, ScheduleSummary>;
+export declare const getScheduleRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/get-schedule.js

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import { shapeRestFault } from "./operation-helpers.js";
+const getScheduleInput = z.object({
+  scheduleId: z.string().min(1)
+}), getScheduleOutput = z.unknown();
+export const getScheduleOperation = defineOperation({
+  name: "weft.schedules.get",
+  mcpExposable: !1,
+  summary: "Get a recurring schedule by id",
+  description: "Read a single recurring schedule by `id`, including its recurrence specification, target workflow type, paused state, and next-run information. Read-only. Faults with NotFound when no schedule with the given id exists.",
+  destructive: !1,
+  tags: ["Schedules"],
+  inputSchema: getScheduleInput,
+  outputSchema: getScheduleOutput,
+  access: { kind: "authenticated" },
+  producibleFaults: ["NotFound", "Conflict"],
+  discoverable: !0,
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const schedule = await engine.getSchedule(input.scheduleId);
+    if (schedule === null)
+      throw {
+        code: "NotFound",
+        message: `Schedule "${input.scheduleId}" not found`,
+        data: { resource: "schedule", identifier: input.scheduleId }
+      };
+    return schedule;
+  }
+});
+function shapeGetScheduleFault(fault) {
+  return shapeRestFault(fault);
+}
+export const getScheduleRestBinding = {
+  method: "GET",
+  path: "/v1/schedules/:id",
+  pathParamNames: ["id"],
+  operationName: "weft.schedules.get",
+  inputSources: {
+    scheduleId: { kind: "path", pathParam: "id" }
+  },
+  extractInput: async (_request, pathParams) => ({
+    scheduleId: pathParams.id ?? ""
+  }),
+  success: { kind: "json", status: 200 },
+  shapeFault: shapeGetScheduleFault
+};

package/dist/server/operations/get-stream-chunks.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import type { StoredStreamChunk } from '../../core/context.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const getStreamChunksInput: z.ZodObject<{
+    workflowId: z.ZodString;
+    key: z.ZodString;
+    after: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type GetStreamChunksInput = z.infer<typeof getStreamChunksInput>;
+export type GetStreamChunksOutput = {
+    chunks: StoredStreamChunk[];
+};
+export declare const getStreamChunksOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+    key: string;
+    after?: unknown;
+}, GetStreamChunksOutput>;
+export declare const getStreamChunksRestBinding: UnknownRestBinding;
+export {};