sea-dev 1.0.0

package/apps/api/src/routes/v2/submissions/index.ts

@@ -0,0 +1,366 @@
+import { getChannel } from "@/lib/channel";
+import { type FastifyInstance } from "fastify";
+import { type ZodTypeProvider } from "fastify-type-provider-zod";
+import * as z from "zod/v4";
+import {
+  checkStatusHandler,
+  createFieldCorrectionHandler,
+  createSubmissionGroupHandler,
+  createSubmissionHandler,
+  extractDataHandler,
+  getDocumentExtractionHandler,
+  getFieldCorrectionsHandler,
+  getSubmissionDataHandler,
+  listSubmissionsHandler,
+  markCorrectionAddressedHandler,
+  submissionItemUpdate,
+  updateSubmissionGroupHandler,
+  updateSubmissionHandler,
+} from "./handlers";
+import {
+  createSubmissionGroupSchema,
+  extractDataFormSchema,
+  fieldCorrectionResponseSchema,
+  getFieldCorrectionsParamsSchema,
+  getSubmissionParamsSchema,
+  getSubmissionResponseSchema,
+  getSubmissionStatusParamsSchema,
+  getSubmissionStatusResponseSchema,
+  listSubmissionsQuerySchema,
+  listSubmissionsResponseSchema,
+  markCorrectionAddressedParamsSchema,
+  postFieldCorrectionBodySchema,
+  postFieldCorrectionParamsSchema,
+  postSubmissionItemValueBodySchema,
+  postSubmissionItemValueParamsSchema,
+  submissionCreateSchema,
+  submissionGroupResponseSchema,
+  submissionResponseSchema,
+  updateSubmissionGroupSchema,
+  updateSubmissionSchema,
+} from "./schemas";
+
+export async function v2SubmissionsRouter(app: FastifyInstance) {
+  app
+    .withTypeProvider<ZodTypeProvider>()
+
+    // List submissions
+    .route({
+      method: "GET",
+      url: "/",
+      schema: {
+        tags: ["Submissions"],
+        description:
+          "Retrieve all submissions, with optional filtering by form, deal and date. Returns an empty array if no submissions match the criteria. Each submission object includes basic metadata and status information.",
+        querystring: listSubmissionsQuerySchema,
+        response: {
+          200: listSubmissionsResponseSchema.array(),
+          400: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ query, member }, reply) => listSubmissionsHandler(query, member, reply),
+    })
+
+    // Create submission
+    .route({
+      method: "POST",
+      url: "/",
+      schema: {
+        tags: ["Submissions"],
+        description:
+          "Create a new submission linking a form to a deal. Requires formId in the request body. Must provide either dealId (direct deal ID) or dealRefId (external reference ID) but not both. If using dealRefId, the system will look up the corresponding deal. Creates a new conversation and initializes the submission with draft status. Returns the complete submission object with generated IDs and timestamps. The submission will be automatically synchronized with the form structure.",
+        body: submissionCreateSchema,
+        response: {
+          200: z.object({
+            id: z.string(),
+            name: z.string().nullable(),
+            summary: z.string().nullable(),
+            summarizedAt: z.date().nullable(),
+            formId: z.string(),
+            dealId: z.string(),
+            organizationId: z.string(),
+            conversationId: z.string(),
+            status: z.enum(["draft", "final"]),
+            deletedAt: z.date().nullable(),
+            createdAt: z.date(),
+            updatedAt: z.date(),
+          }),
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async (request, reply) =>
+        createSubmissionHandler(request.body, request.member, reply, getChannel(request)),
+    })
+
+    // Get submission status
+    // TODO this route needs to be sorted out...
+    .route({
+      method: "GET",
+      url: "/:submissionId/status",
+      schema: {
+        tags: ["Submissions"],
+        description:
+          "Check the processing status of all document extractions associated with a submission. Returns 'done' if all extractions have completed (either successfully or failed), or 'pending' if any extractions are still processing. This endpoint is useful for polling to determine when a submission's document processing is complete. The submission must exist and the user must have access to it.",
+        params: getSubmissionStatusParamsSchema,
+        response: {
+          200: getSubmissionStatusResponseSchema,
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params, member }, reply) => checkStatusHandler(params, member, reply),
+    })
+
+    // Get submission data and documents
+    .route({
+      method: "GET",
+      url: "/:submissionId/data",
+      schema: {
+        tags: ["Submissions"],
+        description: `Retrieve the complete processed data for a submission including structured field data and annotated PDF documents.
+Returns core submission details, along with the following nested data:
+
+- \`groups\`: all current data included in the submission, including citations where relevant
+- \`documents\`: the document inputs used in the submission, including URLs and citations where relevant
+- \`formGroups\`: details of the form the submission is based on.`,
+        params: getSubmissionParamsSchema,
+        response: {
+          200: getSubmissionResponseSchema,
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params, member }, reply) => getSubmissionDataHandler(params, member, reply),
+    })
+
+    // Submit a document for extraction
+    .route({
+      method: "POST",
+      url: "/:submissionId/extractions",
+      schema: {
+        tags: ["Submissions"],
+        description:
+          "Upload one or more documents and extract structured data using AI models. Accepts multipart/form-data with 'files' (single File or array of Files), 'model' (general, smart, bank_statement, financials - defaults to general), and optional 'userPrompt' for custom extraction instructions. Files are stored securely and processed asynchronously. Returns the submission ID for tracking. Extraction results can be retrieved via the data endpoint once processing completes. Subject to monthly usage limits - returns 429 if limits exceeded with retry information in headers.",
+        consumes: ["multipart/form-data"],
+        params: z.object({ submissionId: z.string() }),
+        body: extractDataFormSchema,
+        response: {
+          200: z.object({
+            submissionId: z.string(),
+            extractions: z.object({ extractionId: z.string(), documentId: z.string() }).array(),
+            failures: z.number(),
+          }),
+          400: z.object({ description: z.string() }),
+          429: z.object({ statusCode: z.number(), message: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async (request, reply) =>
+        extractDataHandler(
+          {
+            files: request.body.files,
+            model: request.body.model,
+            userPrompt: request.body.userPrompt,
+            submissionId: request.params.submissionId,
+          },
+          request.member,
+          request.apiKeyId,
+          reply,
+          getChannel(request),
+        ),
+    })
+
+    // Get extraction
+    .route({
+      method: "GET",
+      url: "/:submissionId/extractions/:documentExtractionId",
+      schema: {
+        tags: ["Submissions"],
+        description:
+          "Retrieve detailed information about a specific document extraction including the original document metadata and extraction results. Returns the complete extraction object with status (pending, processing, done, failed), extraction model used, extracted data (if completed), and full document information including secure download URL with expiry timestamp. The extraction must belong to the specified submission and the user must have access to both.",
+        params: z.object({
+          submissionId: z.string(),
+          documentExtractionId: z.string(),
+        }),
+        response: {
+          200: z.object({
+            id: z.string(),
+            documentId: z.string(),
+            submissionId: z.string(),
+            status: z.enum(["pending", "processing", "done", "failed"]),
+            extractionModel: z.string(),
+            data: z.any().nullable(),
+            createdAt: z.date(),
+            updatedAt: z.date(),
+            deletedAt: z.date().nullable(),
+            document: z.object({
+              id: z.string(),
+              dealId: z.string(),
+              name: z.string(),
+              contentType: z.string(),
+              blobKey: z.string(),
+              blobUrl: z.string().nullable(),
+              blobUrlExpiry: z.date().nullable(),
+              createdAt: z.date(),
+              updatedAt: z.date(),
+              deletedAt: z.date().nullable(),
+            }),
+          }),
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params, member }, reply) =>
+        getDocumentExtractionHandler(params, member, reply),
+    })
+
+    // Update submission metadata
+    .route({
+      method: "PATCH",
+      url: "/:submissionId",
+      schema: {
+        tags: ["Submissions"],
+        description:
+          "Update a submission's metadata (name and/or summary). Both fields are optional - provide only the ones you want to update. Returns the updated submission object. Will return 404 if the submission doesn't exist or the user doesn't have permission to modify it.",
+        params: z.object({ submissionId: z.string().min(1) }),
+        body: updateSubmissionSchema,
+        response: {
+          200: submissionResponseSchema,
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params, body, member }, reply) =>
+        updateSubmissionHandler({ submissionId: params.submissionId, ...body }, member, reply),
+    })
+
+    // Create submission group
+    .route({
+      method: "POST",
+      url: "/:submissionId/groups",
+      schema: {
+        tags: ["Submissions"],
+        description:
+          "Create a new submission group for multi-instance form groups. This adds a new row to a repeating group (e.g., for line items or multiple entries). The formGroupId must reference a form group where multi=true. The group is automatically synchronized with the form structure and fields are initialized. Returns the created submission group with its ID and metadata.",
+        params: z.object({ submissionId: z.string().min(1) }),
+        body: createSubmissionGroupSchema,
+        response: {
+          200: submissionGroupResponseSchema,
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params: { submissionId }, body: { formGroupId }, member }, reply) =>
+        createSubmissionGroupHandler({ submissionId, formGroupId }, member, reply),
+    })
+
+    // Update submission group
+    .route({
+      method: "PATCH",
+      url: "/:submissionId/groups/:groupId",
+      schema: {
+        tags: ["Submissions"],
+        description:
+          "Update a submission group's properties. You can update the isValid flag (to mark a group row as valid/invalid) and the order (to reorder rows within a multi-instance group). Both fields are optional - provide only the ones you want to update. Returns the updated submission group.",
+        params: z.object({ submissionId: z.string().min(1), groupId: z.string().min(1) }),
+        body: updateSubmissionGroupSchema,
+        response: {
+          200: submissionGroupResponseSchema,
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params: { submissionId, groupId }, body, member }, reply) =>
+        updateSubmissionGroupHandler({ submissionId, groupId, ...body }, member, reply),
+    })
+
+    // Update a submission item value
+    .route({
+      method: "PATCH",
+      url: "/:submissionId/items/:itemId",
+      schema: {
+        tags: ["Submissions"],
+        description:
+          "Update a submission item's value. This creates a new version with sourceType 'manual' and marks it as selected. The previous version is automatically deselected. Returns success status on completion.",
+        params: postSubmissionItemValueParamsSchema,
+        body: postSubmissionItemValueBodySchema,
+        response: {
+          200: z.object({ success: z.boolean() }),
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ body: { value }, params: { itemId, submissionId }, member }, reply) => {
+        await submissionItemUpdate({ value, submissionId, itemId }, member, reply);
+        return { success: true };
+      },
+    })
+
+    // Create field correction (feedback)
+    .route({
+      method: "POST",
+      url: "/:submissionId/items/:itemId/corrections",
+      schema: {
+        tags: ["Submissions"],
+        description:
+          "Submit feedback or corrections for an extracted field value. Provide either a corrected value, feedback text, or both. If a meaningful corrected value is provided, it will automatically update the field's value. This helps improve AI extraction accuracy over time.",
+        params: postFieldCorrectionParamsSchema,
+        body: postFieldCorrectionBodySchema,
+        response: {
+          200: fieldCorrectionResponseSchema,
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ body, params: { itemId }, member }, reply) =>
+        createFieldCorrectionHandler({ ...body, itemId }, member, reply),
+    })
+
+    // Get field corrections history
+    .route({
+      method: "GET",
+      url: "/:submissionId/items/:itemId/corrections",
+      schema: {
+        tags: ["Submissions"],
+        description:
+          "Retrieve the history of all corrections and feedback submitted for a specific field. Returns corrections in reverse chronological order.",
+        params: getFieldCorrectionsParamsSchema,
+        response: {
+          200: fieldCorrectionResponseSchema.array(),
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params: { itemId }, member }, reply) =>
+        getFieldCorrectionsHandler({ itemId }, member, reply),
+    })
+
+    // Mark correction as addressed
+    .route({
+      method: "PATCH",
+      url: "/:submissionId/corrections/:correctionId/addressed",
+      schema: {
+        tags: ["Submissions"],
+        description:
+          "Mark a correction as addressed. This updates the correction's status to 'addressed' without modifying any field hints. Use this to track which corrections have been reviewed and handled. Returns success status on completion.",
+        params: markCorrectionAddressedParamsSchema,
+        response: {
+          200: z.object({ success: z.boolean() }),
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params: { correctionId }, member }, reply) =>
+        markCorrectionAddressedHandler({ correctionId }, member, reply),
+    });
+}

package/apps/api/src/routes/v2/submissions/schemas.ts

@@ -0,0 +1,233 @@
+import * as z from "zod/v4";
+
+import { submissionStatusArray } from "@sea/db/schema";
+import {
+  documentSchema,
+  formGroupSchema,
+  submissionGroupSchema,
+} from "@sea/schemas/core/submission";
+
+export const getSubmissionStatusParamsSchema = z.object({
+  submissionId: z.string(),
+});
+export type GetSubmissionStatusParams = z.infer<typeof getSubmissionStatusParamsSchema>;
+export const getSubmissionStatusResponseSchema = z.object({ status: z.enum(["pending", "done"]) });
+export type GetSubmissionStatusResponse = z.infer<typeof getSubmissionStatusResponseSchema>;
+
+export const documentMetadataQuerySchema = z.object({
+  documentId: z.string(),
+});
+export type DocumentMetadataQuery = z.infer<typeof documentMetadataQuerySchema>;
+
+// ***********************
+// LIST SUBMISSIONS
+// ***********************
+export const listSubmissionsQuerySchema = z.object({
+  formId: z.string(),
+  dealId: z.string().optional(),
+  afterDate: z.iso.datetime().optional(),
+});
+export type ListSubmissionsQuery = z.infer<typeof listSubmissionsQuerySchema>;
+export const listSubmissionsResponseSchema = z.object({
+  id: z.string(),
+  name: z.string().nullable(),
+  summary: z.string().nullable(),
+  dealId: z.string(),
+  status: z.enum(["draft", "final"]),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+  form: z.object({
+    id: z.string(),
+    workflowId: z.string(),
+    name: z.string(),
+    hint: z.string(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    workflow: z.object({
+      id: z.string(),
+      slug: z.string(),
+      name: z.string(),
+      hint: z.string(),
+      createdAt: z.date(),
+      updatedAt: z.date(),
+    }),
+  }),
+});
+export type ListSubmissionsResponse = z.infer<typeof listSubmissionsResponseSchema>;
+
+// ***********************
+// GET SUBMISSION
+// ***********************
+export const getSubmissionParamsSchema = z.object({
+  submissionId: z.string(),
+});
+export type GetSubmissionParams = z.infer<typeof getSubmissionParamsSchema>;
+export const getSubmissionResponseSchema = z.object({
+  submissionId: z.string(),
+  name: z.string().nullable(),
+  formId: z.string(),
+  dealId: z.string(),
+  status: z.enum(submissionStatusArray),
+  formGroups: formGroupSchema.array(),
+  groups: submissionGroupSchema.array(),
+  documents: documentSchema.array(),
+});
+export type GetSubmissionResponse = z.infer<typeof getSubmissionResponseSchema>;
+
+// ***********************
+// DOC EXTRACTION
+// ***********************
+export const documentExtractionDataQuerySchema = z.object({
+  documentExtractionId: z.string(),
+});
+export type DocumentExtractionDataQuery = z.infer<typeof documentExtractionDataQuerySchema>;
+
+export const submissionGroupedDataQuerySchema = z.object({
+  submissionId: z.string(),
+});
+export type SubmissionGroupedDataQuery = z.infer<typeof submissionGroupedDataQuerySchema>;
+
+export const submissionCreateSchema = z.object({
+  formId: z.string(),
+  dealId: z.string().optional(),
+  dealRefId: z.string().optional(),
+});
+export type SubmissionCreate = z.infer<typeof submissionCreateSchema>;
+
+export const extractDataFormSchema = z.object({
+  files: z.instanceof(File).or(z.array(z.instanceof(File))),
+  model: z
+    .enum(["general", "smart", "bank_statement", "financials", "agentic_analyst"])
+    .default("general"),
+  userPrompt: z.string().optional(),
+});
+export const extractDataResponseSchema = z.object({
+  submissionId: z.string(),
+});
+export type ExtractDataBody = z.infer<typeof extractDataFormSchema>;
+
+// ***********************
+// MANUAL UPDATE
+// ***********************
+export const postSubmissionItemValueParamsSchema = z.object({
+  submissionId: z.string(),
+  itemId: z.string(),
+});
+export const postSubmissionItemValueBodySchema = z.object({
+  value: z.union([z.string(), z.number()]),
+});
+export type PostSubmissionItemValueBody = z.infer<typeof postSubmissionItemValueBodySchema> &
+  z.infer<typeof postSubmissionItemValueParamsSchema>;
+
+// ***********************
+// FIELD CORRECTION (FEEDBACK)
+// ***********************
+export const postFieldCorrectionParamsSchema = z.object({
+  submissionId: z.string(),
+  itemId: z.string(),
+});
+export const postFieldCorrectionBodySchema = z
+  .object({
+    extractedValue: z.union([z.string(), z.number()]).nullable(),
+    correctedValue: z
+      .string()
+      .optional()
+      .transform((v) => {
+        const t = v?.trim() ?? "";
+        return t.length ? t : null;
+      }),
+    feedback: z
+      .string()
+      .optional()
+      .transform((v) => {
+        const t = v?.trim() ?? "";
+        return t.length ? t : null;
+      }),
+  })
+  .refine((d) => d.correctedValue !== null || d.feedback !== null, {
+    message: "Provide either a corrected value or feedback.",
+    path: [],
+  });
+export type PostFieldCorrectionBody = z.infer<typeof postFieldCorrectionBodySchema> &
+  z.infer<typeof postFieldCorrectionParamsSchema>;
+
+export const getFieldCorrectionsParamsSchema = z.object({
+  submissionId: z.string(),
+  itemId: z.string(),
+});
+export const fieldCorrectionResponseSchema = z.object({
+  id: z.string(),
+  submissionItemId: z.string(),
+  extractedValue: z.union([z.string(), z.number()]).nullable(),
+  correctedValue: z.union([z.string(), z.number()]).nullable(),
+  feedback: z.string().nullable(),
+  status: z.enum(["pending", "addressed"]),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+export type FieldCorrectionResponse = z.infer<typeof fieldCorrectionResponseSchema>;
+
+// ***********************
+// UPDATE SUBMISSION
+// ***********************
+export const updateSubmissionSchema = z
+  .object({
+    name: z.string().min(1).optional(),
+    summary: z.string().optional(),
+  })
+  .refine((v) => Object.keys(v).length > 0, {
+    message: "At least one field must be supplied",
+  });
+export type UpdateSubmissionRequest = z.infer<typeof updateSubmissionSchema>;
+
+export const submissionResponseSchema = z.object({
+  id: z.string(),
+  name: z.string().nullable(),
+  summary: z.string().nullable(),
+  formId: z.string(),
+  dealId: z.string(),
+  organizationId: z.string(),
+  conversationId: z.string(),
+  status: z.enum(submissionStatusArray),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+export type SubmissionResponse = z.infer<typeof submissionResponseSchema>;
+
+// ***********************
+// MARK CORRECTION AS ADDRESSED
+// ***********************
+export const markCorrectionAddressedParamsSchema = z.object({
+  submissionId: z.string(),
+  correctionId: z.string(),
+});
+export type MarkCorrectionAddressedParams = z.infer<typeof markCorrectionAddressedParamsSchema>;
+
+// ***********************
+// SUBMISSION GROUPS
+// ***********************
+export const createSubmissionGroupSchema = z.object({
+  formGroupId: z.string().min(1),
+});
+export type CreateSubmissionGroupRequest = z.infer<typeof createSubmissionGroupSchema>;
+
+export const updateSubmissionGroupSchema = z
+  .object({
+    isValid: z.boolean().optional(),
+    order: z.number().int().min(0).optional(),
+  })
+  .refine((v) => Object.keys(v).length > 0, {
+    message: "At least one field must be supplied",
+  });
+export type UpdateSubmissionGroupRequest = z.infer<typeof updateSubmissionGroupSchema>;
+
+export const submissionGroupResponseSchema = z.object({
+  id: z.string(),
+  submissionId: z.string(),
+  formGroupId: z.string(),
+  isValid: z.boolean().nullable(),
+  order: z.number(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+export type SubmissionGroupResponse = z.infer<typeof submissionGroupResponseSchema>;

package/apps/api/src/routes/v2/workflows/handlers.ts

@@ -0,0 +1,81 @@
+import type { MemberHydrated } from "@sea/dal/member";
+import { createWorkflow, getWorkflows, updateWorkflow } from "@sea/dal/workflow";
+import type { FastifyReply } from "fastify";
+import type { CreateWorkflowRequest, PatchWorkflowRequest, UpdateWorkflowRequest } from "./schemas";
+
+export async function createWorkflowHandler(
+  { name, hint }: CreateWorkflowRequest,
+  member: MemberHydrated,
+  reply: FastifyReply,
+) {
+  try {
+    const workflow = await createWorkflow({ member, name, hint });
+    return workflow;
+  } catch (error) {
+    console.error(error);
+    return reply.code(500).send({ description: "Failed to create workflow" });
+  }
+}
+
+export async function getWorkflowsHandler(member: MemberHydrated, reply: FastifyReply) {
+  try {
+    const workflows = await getWorkflows({ member });
+    return workflows.map((workflow) => ({
+      ...workflow,
+      formCount: Number(workflow.formCount ?? 0),
+      submissionCount: Number(workflow.submissionCount ?? 0),
+    }));
+  } catch (error) {
+    console.error(error);
+    return reply.code(500).send({ description: "Failed to retrieve workflows" });
+  }
+}
+
+export async function updateWorkflowHandler(
+  { workflowId, ...updateData }: UpdateWorkflowRequest & { workflowId: string },
+  member: MemberHydrated,
+  reply: FastifyReply,
+) {
+  try {
+    if (!workflowId || workflowId.trim().length === 0) {
+      return reply.code(400).send({ description: "Workflow ID is required" });
+    }
+
+    const workflow = await updateWorkflow({ member, workflowId, ...updateData });
+    if (!workflow) {
+      return reply.code(404).send({ description: "Workflow not found" });
+    }
+
+    return { success: true };
+  } catch (error) {
+    console.error(error);
+    return reply.code(500).send({ description: "Failed to update workflow" });
+  }
+}
+
+export async function patchWorkflowHandler(
+  { workflowId, ...updateData }: PatchWorkflowRequest & { workflowId: string },
+  member: MemberHydrated,
+  reply: FastifyReply,
+) {
+  try {
+    if (!workflowId || workflowId.trim().length === 0) {
+      return reply.code(400).send({ description: "Workflow ID is required" });
+    }
+    if (updateData.name === undefined && updateData.hint === undefined) {
+      return reply
+        .code(400)
+        .send({ description: "At least one field (name or hint) must be provided" });
+    }
+
+    const workflow = await updateWorkflow({ member, workflowId, ...updateData });
+    if (!workflow) {
+      return reply.code(404).send({ description: "Workflow not found" });
+    }
+
+    return { success: true };
+  } catch (error) {
+    console.error(error);
+    return reply.code(500).send({ description: "Failed to update workflow" });
+  }
+}