@lostgradient/weft 0.2.0

package/dist/server/operations/get-update-result.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const getUpdateResultInput: z.ZodObject<{
+    updateId: z.ZodString;
+}, z.core.$strip>;
+export type GetUpdateResultInput = z.infer<typeof getUpdateResultInput>;
+export type GetUpdateResultOutput = {
+    status: 'pending';
+} | {
+    status: 'completed';
+    result: unknown;
+    error?: string;
+};
+export declare const getUpdateResultOperation: import("../operation-catalog.ts").OperationDefinition<{
+    updateId: string;
+}, GetUpdateResultOutput>;
+export declare const getUpdateResultRestBinding: UnknownRestBinding;
+export {};

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

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import { shapeRestFault } from "./operation-helpers.js";
+const getUpdateResultInput = z.object({
+  updateId: z.string().min(1)
+}), getUpdateResultOutput = z.unknown();
+export const getUpdateResultOperation = defineOperation({
+  name: "weft.updates.result.get",
+  mcpExposable: !1,
+  summary: "Get the result of an update request",
+  destructive: !1,
+  tags: ["Updates"],
+  inputSchema: getUpdateResultInput,
+  outputSchema: getUpdateResultOutput,
+  access: { kind: "public" },
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const response = await engine.getUpdateResult(input.updateId);
+    if (response === null)
+      return { status: "pending" };
+    return {
+      status: "completed",
+      result: response.result,
+      ...response.error !== void 0 ? { error: response.error } : {}
+    };
+  }
+});
+function shapeGetUpdateResultSuccess(result) {
+  if (result.status === "pending")
+    return new Response(JSON.stringify(result), {
+      status: 202,
+      headers: { "Content-Type": "application/json" }
+    });
+  return new Response(JSON.stringify(result), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function shapeGetUpdateResultFault(fault) {
+  return shapeRestFault(fault);
+}
+export const getUpdateResultRestBinding = {
+  method: "GET",
+  path: "/v1/updates/:updateId",
+  pathParamNames: ["updateId"],
+  operationName: "weft.updates.result.get",
+  inputSources: {
+    updateId: { kind: "path", pathParam: "updateId" }
+  },
+  extractInput: async (_request, pathParams) => ({ updateId: pathParams.updateId ?? "" }),
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => shapeGetUpdateResultSuccess(output),
+  shapeFault: shapeGetUpdateResultFault
+};

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

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import type { SearchAttributeValue } from '../../core/types.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const getWorkflowAttributesInput: z.ZodObject<{
+    workflowId: z.ZodString;
+}, z.core.$strip>;
+export type GetWorkflowAttributesInput = z.infer<typeof getWorkflowAttributesInput>;
+export type GetWorkflowAttributesOutput = Record<string, SearchAttributeValue>;
+export declare const getWorkflowAttributesOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+}, GetWorkflowAttributesOutput>;
+export declare const getWorkflowAttributesRestBinding: UnknownRestBinding;
+export {};

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

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import { shapeRestFault } from "./operation-helpers.js";
+const getWorkflowAttributesInput = z.object({
+  workflowId: z.string().min(1)
+}), getWorkflowAttributesOutput = z.unknown();
+export const getWorkflowAttributesOperation = defineOperation({
+  name: "weft.workflows.attributes.get",
+  mcpExposable: !1,
+  summary: "Get workflow attributes by id",
+  destructive: !1,
+  tags: ["Attributes"],
+  inputSchema: getWorkflowAttributesInput,
+  outputSchema: getWorkflowAttributesOutput,
+  access: { kind: "public" },
+  producibleFaults: ["NotFound"],
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const attributes = await engine.getAttributes(input.workflowId);
+    if (attributes === null)
+      throw {
+        code: "NotFound",
+        message: `Attributes for workflow "${input.workflowId}" not found`,
+        data: { resource: "attributes", identifier: input.workflowId }
+      };
+    return attributes;
+  }
+});
+function shapeGetWorkflowAttributesSuccess(result) {
+  return new Response(JSON.stringify(result), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function shapeGetWorkflowAttributesFault(fault) {
+  return shapeRestFault(fault);
+}
+export const getWorkflowAttributesRestBinding = {
+  method: "GET",
+  path: "/v1/workflows/:id/attributes",
+  pathParamNames: ["id"],
+  operationName: "weft.workflows.attributes.get",
+  inputSources: {
+    workflowId: { kind: "path", pathParam: "id" }
+  },
+  extractInput: async (_request, pathParams) => ({ workflowId: pathParams.id ?? "" }),
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => shapeGetWorkflowAttributesSuccess(output),
+  shapeFault: shapeGetWorkflowAttributesFault
+};

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

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import type { WorkflowEvent } from '../../core/types.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const getWorkflowEventsInput: z.ZodObject<{
+    workflowId: z.ZodString;
+}, z.core.$strip>;
+export type GetWorkflowEventsInput = z.infer<typeof getWorkflowEventsInput>;
+export type GetWorkflowEventsOutput = {
+    events: WorkflowEvent[];
+};
+export declare const getWorkflowEventsOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+}, GetWorkflowEventsOutput>;
+export declare const getWorkflowEventsRestBinding: UnknownRestBinding;
+export {};

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

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import { shapeRestFault } from "./operation-helpers.js";
+const getWorkflowEventsInput = z.object({
+  workflowId: z.string().min(1)
+}), getWorkflowEventsOutput = z.unknown();
+export const getWorkflowEventsOperation = defineOperation({
+  name: "weft.workflows.events.list",
+  mcpExposable: !1,
+  summary: "Get workflow events by id",
+  destructive: !1,
+  tags: ["Events"],
+  inputSchema: getWorkflowEventsInput,
+  outputSchema: getWorkflowEventsOutput,
+  access: { kind: "public" },
+  producibleFaults: ["NotFound"],
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const e = engine;
+    if (await e.get(input.workflowId) === null)
+      throw {
+        code: "NotFound",
+        message: `Workflow "${input.workflowId}" not found`,
+        data: { resource: "workflow", identifier: input.workflowId }
+      };
+    return { events: await e.getEvents(input.workflowId) };
+  }
+});
+function shapeGetWorkflowEventsSuccess(result) {
+  return new Response(JSON.stringify(result), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function shapeGetWorkflowEventsFault(fault) {
+  return shapeRestFault(fault);
+}
+export const getWorkflowEventsRestBinding = {
+  method: "GET",
+  path: "/v1/workflows/:id/events",
+  pathParamNames: ["id"],
+  operationName: "weft.workflows.events.list",
+  inputSources: {
+    workflowId: { kind: "path", pathParam: "id" }
+  },
+  extractInput: async (_request, pathParams) => ({ workflowId: pathParams.id ?? "" }),
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => shapeGetWorkflowEventsSuccess(output),
+  shapeFault: shapeGetWorkflowEventsFault
+};

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

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const getWorkflowResultInput: z.ZodObject<{
+    workflowId: z.ZodString;
+}, z.core.$strip>;
+export type GetWorkflowResultInput = z.infer<typeof getWorkflowResultInput>;
+export type GetWorkflowResultOutput = {
+    result: unknown;
+};
+export declare const getWorkflowResultOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+}, GetWorkflowResultOutput>;
+export declare const getWorkflowResultRestBinding: UnknownRestBinding;
+export {};

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

@@ -0,0 +1,93 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import { jsonErrorResponse, shapeRestFault } from "./operation-helpers.js";
+const getWorkflowResultInput = z.object({
+  workflowId: z.string().min(1)
+}), getWorkflowResultOutput = z.unknown();
+export const getWorkflowResultOperation = defineOperation({
+  name: "weft.workflows.result.get",
+  mcpExposable: !1,
+  summary: "Get workflow result by id",
+  destructive: !1,
+  tags: ["Workflows"],
+  inputSchema: getWorkflowResultInput,
+  outputSchema: getWorkflowResultOutput,
+  access: { kind: "public" },
+  producibleFaults: ["NotFound", "Unprocessable", "Timeout"],
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const e = engine, state = await e.get(input.workflowId);
+    if (state === null)
+      throw {
+        code: "NotFound",
+        message: `Workflow "${input.workflowId}" not found`,
+        data: { resource: "workflow", identifier: input.workflowId }
+      };
+    if (state.status === "completed")
+      return { result: state.result };
+    if (state.status === "failed") {
+      const message = state.error ?? "Workflow failed";
+      throw {
+        code: "Unprocessable",
+        message,
+        data: { reason: message }
+      };
+    }
+    if (state.status === "cancelled")
+      throw {
+        code: "Unprocessable",
+        message: "Workflow cancelled",
+        data: { reason: "Workflow cancelled" }
+      };
+    const handle = e.getHandle(input.workflowId), timeoutMilliseconds = 30000;
+    let timeoutId;
+    try {
+      return { result: await Promise.race([
+        handle.result(),
+        new Promise((_resolve, reject) => {
+          timeoutId = setTimeout(() => reject(Error("Timeout waiting for workflow result")), timeoutMilliseconds);
+        })
+      ]) };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("Timeout"))
+        throw {
+          code: "Timeout",
+          message: "Timeout waiting for workflow result",
+          data: {}
+        };
+      throw {
+        code: "EngineFailure",
+        message,
+        data: {}
+      };
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+});
+function shapeGetWorkflowResultSuccess(result) {
+  return new Response(JSON.stringify(result), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function shapeGetWorkflowResultFault(fault) {
+  if (fault.code === "Timeout")
+    return jsonErrorResponse("Timeout waiting for workflow result", 408);
+  return shapeRestFault(fault);
+}
+export const getWorkflowResultRestBinding = {
+  method: "GET",
+  path: "/v1/workflows/:id/result",
+  pathParamNames: ["id"],
+  operationName: "weft.workflows.result.get",
+  inputSources: {
+    workflowId: { kind: "path", pathParam: "id" }
+  },
+  extractInput: async (_request, pathParams) => ({ workflowId: pathParams.id ?? "" }),
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => shapeGetWorkflowResultSuccess(output),
+  shapeFault: shapeGetWorkflowResultFault
+};

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

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import type { WorkflowTimelineEntry } from '../../core/types.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const getWorkflowTimelineInput: z.ZodObject<{
+    workflowId: z.ZodString;
+}, z.core.$strip>;
+export type GetWorkflowTimelineInput = z.infer<typeof getWorkflowTimelineInput>;
+export type GetWorkflowTimelineOutput = WorkflowTimelineEntry[];
+export declare const getWorkflowTimelineOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+}, GetWorkflowTimelineOutput>;
+export declare const getWorkflowTimelineRestBinding: UnknownRestBinding;
+export {};

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

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { negotiatedResponse } from "../handler/response-helpers.js";
+import { defineOperation } from "../operation-registry.js";
+import { shapeRestFault } from "./operation-helpers.js";
+const getWorkflowTimelineInput = z.object({
+  workflowId: z.string().min(1)
+}), getWorkflowTimelineOutput = z.unknown();
+export const getWorkflowTimelineOperation = defineOperation({
+  name: "weft.workflows.timeline.get",
+  mcpExposable: !1,
+  summary: "Get the structured execution timeline for a workflow",
+  destructive: !1,
+  tags: ["Checkpoints"],
+  inputSchema: getWorkflowTimelineInput,
+  outputSchema: getWorkflowTimelineOutput,
+  access: { kind: "public" },
+  producibleFaults: ["NotFound"],
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const e = engine;
+    if (await e.get(input.workflowId) === null)
+      throw {
+        code: "NotFound",
+        message: `Workflow "${input.workflowId}" not found`,
+        data: { resource: "workflow", identifier: input.workflowId }
+      };
+    return e.getTimeline(input.workflowId);
+  }
+});
+function shapeGetWorkflowTimelineSuccess(result, request) {
+  return negotiatedResponse(request, result, 200);
+}
+function shapeGetWorkflowTimelineFault(fault) {
+  return shapeRestFault(fault);
+}
+export const getWorkflowTimelineRestBinding = {
+  method: "GET",
+  path: "/v1/workflows/:id/timeline",
+  pathParamNames: ["id"],
+  operationName: "weft.workflows.timeline.get",
+  inputSources: {
+    workflowId: { kind: "path", pathParam: "id" }
+  },
+  extractInput: async (_request, pathParams) => ({
+    workflowId: pathParams.id ?? ""
+  }),
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output, request) => shapeGetWorkflowTimelineSuccess(output, request),
+  shapeFault: shapeGetWorkflowTimelineFault
+};

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

@@ -0,0 +1,36 @@
+/**
+ * `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
+ * `shapeFault` below.
+ *
+ * @module server/operations/get-workflow
+ */
+import { z } from 'zod';
+import type { WorkflowState } from '../../core/types.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const getWorkflowInput: z.ZodObject<{
+    workflowId: z.ZodString;
+}, z.core.$strip>;
+export type GetWorkflowInput = z.infer<typeof getWorkflowInput>;
+export type GetWorkflowOutput = WorkflowState;
+export declare const getWorkflowOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+}, WorkflowState>;
+/**
+ * RestBinding for `GET /v1/workflows/:id`. Pulls the workflow id from
+ * the path param, invokes the operation, maps success/fault to the
+ * REST response shape.
+ *
+ * Typed as `UnknownRestBinding` at the module boundary so the router's
+ * heterogeneous `ReadonlyArray<UnknownRestBinding>` storage doesn't
+ * run into `exactOptionalPropertyTypes` contravariance on
+ * `shapeSuccess`. The concrete `GetWorkflowOutput` typing remains at
+ * the `shapeGetWorkflowSuccess` function signature above — that's
+ * where real type checking matters (did the output come out wrong?).
+ * The router itself only sees a shape-uniform `RestBinding<any, any>`.
+ */
+export declare const getWorkflowRestBinding: UnknownRestBinding;
+export {};

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

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import { shapeRestFault } from "./operation-helpers.js";
+const getWorkflowInput = z.object({
+  workflowId: z.string().min(1)
+}), getWorkflowOutput = z.unknown();
+export const getWorkflowOperation = defineOperation({
+  name: "weft.workflows.get",
+  mcpExposable: !1,
+  summary: "Get workflow state by id",
+  description: "Read the current state of a single workflow by `id`, including its status, timestamps, tags, and search attributes. Read-only. Faults with NotFound when no workflow with the given id is visible.",
+  destructive: !1,
+  tags: ["Workflows"],
+  inputSchema: getWorkflowInput,
+  outputSchema: getWorkflowOutput,
+  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.get(input.workflowId);
+    if (state === null)
+      throw {
+        code: "NotFound",
+        message: `Workflow "${input.workflowId}" not found`,
+        data: { resource: "workflow", identifier: input.workflowId }
+      };
+    return state;
+  }
+});
+function shapeGetWorkflowSuccess(state) {
+  return new Response(JSON.stringify(state), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+export const getWorkflowRestBinding = {
+  method: "GET",
+  path: "/v1/workflows/:id",
+  pathParamNames: ["id"],
+  operationName: "weft.workflows.get",
+  inputSources: {
+    workflowId: { kind: "path", pathParam: "id" }
+  },
+  extractInput: async (_request, pathParams) => ({ workflowId: pathParams.id ?? "" }),
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => shapeGetWorkflowSuccess(output),
+  shapeFault: shapeRestFault
+};

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

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import type { CheckpointSummary } from '../../core/types.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const listCheckpointsInput: z.ZodObject<{
+    workflowId: z.ZodString;
+}, z.core.$strip>;
+export type ListCheckpointsInput = z.infer<typeof listCheckpointsInput>;
+export type ListCheckpointsOutput = CheckpointSummary[];
+export declare const listCheckpointsOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+}, ListCheckpointsOutput>;
+export declare const listCheckpointsRestBinding: UnknownRestBinding;
+export {};

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

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { negotiatedResponse } from "../handler/response-helpers.js";
+import { defineOperation } from "../operation-registry.js";
+import { shapeRestFault } from "./operation-helpers.js";
+const listCheckpointsInput = z.object({
+  workflowId: z.string().min(1)
+}), listCheckpointsOutput = z.unknown();
+export const listCheckpointsOperation = defineOperation({
+  name: "weft.workflows.checkpoints.list",
+  mcpExposable: !1,
+  summary: "List checkpoint history for a workflow",
+  destructive: !1,
+  tags: ["Checkpoints"],
+  inputSchema: listCheckpointsInput,
+  outputSchema: listCheckpointsOutput,
+  access: { kind: "public" },
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    return engine.listCheckpoints(input.workflowId);
+  }
+});
+function shapeListCheckpointsSuccess(result, request) {
+  return negotiatedResponse(request, result, 200);
+}
+function shapeListCheckpointsFault(fault) {
+  return shapeRestFault(fault);
+}
+export const listCheckpointsRestBinding = {
+  method: "GET",
+  path: "/v1/workflows/:id/checkpoints",
+  pathParamNames: ["id"],
+  operationName: "weft.workflows.checkpoints.list",
+  inputSources: {
+    workflowId: { kind: "path", pathParam: "id" }
+  },
+  extractInput: async (_request, pathParams) => ({
+    workflowId: pathParams.id ?? ""
+  }),
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output, request) => shapeListCheckpointsSuccess(output, request),
+  shapeFault: shapeListCheckpointsFault
+};

package/dist/server/operations/list-filter-query-extractor.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared REST query-parameter extractor for the `ListFilter` shape. Both
+ * `GET /v1/workflows` and `GET /v1/workflows/aggregate` accept the same
+ * filter dimensions, so the parsing lives here to keep the two endpoints
+ * in lock-step.
+ *
+ * @module server/operations/list-filter-query-extractor
+ */
+import type { ListFilter, TimeRange } from '../../core/types.ts';
+/**
+ * Extract every supported `ListFilter` dimension from a request URL's
+ * query string. `limit` and `offset` are NOT extracted — callers that
+ * support pagination layer them on top.
+ */
+export declare function extractListFilterFromQuery(url: URL): ListFilter;
+/**
+ * Parse one of the three `*_at` time-range filters from the query
+ * string. The four bounds map to `{prefix}_gte`, `{prefix}_gt`,
+ * `{prefix}_lte`, `{prefix}_lt`. Returns `undefined` when none of the
+ * bounds were specified so the omitted-vs-empty distinction is preserved
+ * for the downstream `normalizeListFilter` validation.
+ */
+export declare function extractTimeRangeFromQuery(params: URLSearchParams, prefix: 'created_at' | 'updated_at' | 'execution_deadline'): TimeRange | undefined;

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

@@ -0,0 +1,87 @@
+import { parseAttributeFilters } from "../attribute-filters.js";
+function parseStatus(params) {
+  const statuses = params.getAll("status");
+  if (statuses.length === 0)
+    return;
+  if (statuses.length === 1)
+    return statuses[0];
+  return statuses;
+}
+function parseType(params) {
+  const type = params.get("type");
+  return type === null ? void 0 : type;
+}
+function parseTags(params) {
+  const tags = params.getAll("tag");
+  return tags.length > 0 ? tags : void 0;
+}
+function parseAttributes(params) {
+  const attributeFilters = parseAttributeFilters(params);
+  if (attributeFilters.length === 0)
+    return;
+  return attributeFilters.map((attribute) => ({
+    key: attribute.key,
+    ...attribute.value === void 0 ? {} : { value: attribute.value },
+    ...attribute.gt === void 0 ? {} : { gt: attribute.gt },
+    ...attribute.lt === void 0 ? {} : { lt: attribute.lt },
+    ...attribute.gte === void 0 ? {} : { gte: attribute.gte },
+    ...attribute.lte === void 0 ? {} : { lte: attribute.lte }
+  }));
+}
+function parseIdPrefix(params) {
+  const idPrefix = params.get("id_prefix");
+  return idPrefix === null ? void 0 : idPrefix;
+}
+function parseFailureCategory(params) {
+  const categories = params.getAll("failure_category");
+  if (categories.length === 0)
+    return;
+  if (categories.length === 1)
+    return categories[0];
+  return categories;
+}
+function parseCreatedAt(params) {
+  return extractTimeRangeFromQuery(params, "created_at");
+}
+function parseUpdatedAt(params) {
+  return extractTimeRangeFromQuery(params, "updated_at");
+}
+function parseExecutionDeadline(params) {
+  return extractTimeRangeFromQuery(params, "execution_deadline");
+}
+const LIST_FILTER_QUERY_PARSERS = {
+  status: parseStatus,
+  type: parseType,
+  tags: parseTags,
+  attributes: parseAttributes,
+  idPrefix: parseIdPrefix,
+  failureCategory: parseFailureCategory,
+  createdAt: parseCreatedAt,
+  updatedAt: parseUpdatedAt,
+  executionDeadline: parseExecutionDeadline
+};
+export function extractListFilterFromQuery(url) {
+  const params = url.searchParams, filter = {};
+  for (const [dimension, parse] of Object.entries(LIST_FILTER_QUERY_PARSERS)) {
+    const value = parse(params);
+    if (value === void 0)
+      continue;
+    filter[dimension] = value;
+  }
+  return filter;
+}
+export function extractTimeRangeFromQuery(params, prefix) {
+  const range = {}, gte = params.get(`${prefix}_gte`);
+  if (gte !== null && Number.isFinite(Number(gte)))
+    range.gte = Number(gte);
+  const gt = params.get(`${prefix}_gt`);
+  if (gt !== null && Number.isFinite(Number(gt)))
+    range.gt = Number(gt);
+  const lte = params.get(`${prefix}_lte`);
+  if (lte !== null && Number.isFinite(Number(lte)))
+    range.lte = Number(lte);
+  const lt = params.get(`${prefix}_lt`);
+  if (lt !== null && Number.isFinite(Number(lt)))
+    range.lt = Number(lt);
+  return Object.keys(range).length > 0 ? range : void 0;
+}

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

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import type { ReviewListEntry, ReviewStatus } from '../../core/types.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const listReviewsInput: z.ZodObject<{
+    status: z.ZodOptional<z.ZodType<ReviewStatus, unknown, z.core.$ZodTypeInternals<ReviewStatus, unknown>>>;
+    workflowId: z.ZodOptional<z.ZodString>;
+    reviewType: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ListReviewsInput = z.infer<typeof listReviewsInput>;
+export type ListReviewsOutput = {
+    items: ReviewListEntry[];
+};
+export declare const listReviewsOperation: import("../operation-catalog.ts").OperationDefinition<{
+    status?: ReviewStatus | undefined;
+    workflowId?: string | undefined;
+    reviewType?: string | undefined;
+}, ListReviewsOutput>;
+export declare const listReviewsRestBinding: UnknownRestBinding;
+export {};