sea-dev 1.0.0

package/libs/core/src/chat/tools/workflow.ts

@@ -0,0 +1,684 @@
+import { updateAgentConversation } from "@sea/dal/conversation";
+import { getPipelineWithSteps } from "@sea/dal/pipeline";
+import { db, schema } from "@sea/db";
+import { memorySchema } from "@sea/db/schema";
+import type { Member, PipelineStep } from "@sea/db/types";
+import { invariant } from "@sea/util/invariant";
+import { tool } from "ai";
+import { and, asc, desc, eq, isNull } from "drizzle-orm";
+import * as z from "zod/v4";
+import { returnErr } from "./helpers";
+
+export function createWorkflow({
+  member,
+  conversationId,
+}: {
+  member: Member;
+  conversationId: string;
+}) {
+  return tool({
+    description: "Create a new workflow. A workflow is contains several forms.",
+    inputSchema: z.object({
+      name: z.string().describe("The name of the workflow"),
+      hint: z
+        .string()
+        .describe("A hint or description of what this workflow is for"),
+    }),
+    execute: async ({ name, hint }) => {
+      try {
+        const [workflow] = await db
+          .insert(schema.workflow)
+          .values({
+            organizationId: member.organizationId,
+            name,
+            hint,
+          })
+          .returning();
+        invariant(workflow);
+
+        const conversation = await db.query.conversation.findFirst({
+          where: and(
+            eq(schema.conversation.id, conversationId),
+            eq(schema.conversation.organizationId, member.organizationId),
+            isNull(schema.conversation.deletedAt),
+          ),
+        });
+        invariant(conversation);
+
+        const memory = memorySchema.parse(conversation.memory);
+        const updatedMemory = {
+          ...memory,
+          workflowIds: [...memory.workflowIds, workflow.id],
+        };
+        await updateAgentConversation({
+          member,
+          conversationId,
+          memory: updatedMemory,
+        });
+
+        return {
+          ok: true,
+          data: { workflow },
+        };
+      } catch (err) {
+        return returnErr(err);
+      }
+    },
+  });
+}
+
+export function createForm({
+  member,
+  conversationId,
+}: {
+  member: Member;
+  conversationId: string;
+}) {
+  return tool({
+    description:
+      "Create a new form. A form is a form template that belongs to a workflow and defines specific data collection fields.",
+    inputSchema: z.object({
+      workflowId: z
+        .string()
+        .describe("The ID of the workflow this form belongs to"),
+      name: z.string().describe("The name of the form"),
+      hint: z
+        .string()
+        .describe("A hint or description of what this form is for"),
+    }),
+    execute: async ({ workflowId, name, hint }) => {
+      try {
+        // Validate that the workflow exists and belongs to the organization
+        const workflow = await db.query.workflow.findFirst({
+          where: and(
+            eq(schema.workflow.organizationId, member.organizationId),
+            eq(schema.workflow.id, workflowId),
+          ),
+        });
+        invariant(workflow);
+
+        // Create a fresh conversation for this form
+        const [newConversation] = await db
+          .insert(schema.conversation)
+          .values({
+            organizationId: member.organizationId,
+            agent: false,
+            model: "openai/gpt-5.2",
+          })
+          .returning();
+        invariant(newConversation);
+
+        const [form] = await db
+          .insert(schema.form)
+          .values({
+            organizationId: member.organizationId,
+            workflowId,
+            conversationId: newConversation.id,
+            name,
+            hint,
+          })
+          .returning();
+        invariant(form);
+
+        const conversation = await db.query.conversation.findFirst({
+          where: and(
+            eq(schema.conversation.id, conversationId),
+            eq(schema.conversation.organizationId, member.organizationId),
+            isNull(schema.conversation.deletedAt),
+          ),
+        });
+        invariant(conversation);
+
+        const memory = memorySchema.parse(conversation.memory);
+
+        const updatedMemory = {
+          ...memory,
+          formIds: [...memory.formIds, form.id],
+        };
+        await updateAgentConversation({
+          member,
+          conversationId,
+          memory: updatedMemory,
+        });
+
+        return {
+          ok: true,
+          data: { form },
+        };
+      } catch (err) {
+        return returnErr(err);
+      }
+    },
+  });
+}
+
+const pipelineStepSchema = z.object({
+  name: z.string().min(1).describe("The display name of this step"),
+  description: z.string().min(1).describe("What this step does"),
+  prompt: z
+    .string()
+    .min(1)
+    .describe("The instructions for the AI model to execute in this step"),
+  outputFormId: z
+    .string()
+    .min(1)
+    .describe("The ID of the form structure for this step's output"),
+  toolsAllowed: z
+    .array(z.string())
+    .default([])
+    .describe(
+      "List of tool names allowed in this step (leave empty for no tools). Available tools will be shown to you.",
+    ),
+});
+
+const createPipelineSchema = z.object({
+  name: z.string().min(1).describe("The name of the pipeline"),
+  description: z
+    .string()
+    .min(1)
+    .describe("A description of what this pipeline does"),
+  inputFormId: z.string().min(1).describe("The ID of the form to use as input"),
+  steps: z
+    .array(pipelineStepSchema)
+    .min(1)
+    .describe(
+      "The steps to execute in order. Each step takes input from the previous step's output (or the pipeline's input form for the first step).",
+    ),
+});
+
+export function createPipelineTool({
+  member,
+  conversationId,
+}: {
+  member: Member;
+  conversationId: string;
+}) {
+  return tool({
+    description: `Create a new pipeline for automated multi-step workflows.
+
+Pipelines allow you to define reusable AI workflows with multiple steps. Each step:
+- Takes input from the previous step's output form (or the pipeline's input form for the first step)
+- Processes data using AI with optional tools
+- Produces output in a structured form
+
+Steps are executed sequentially in order, with each step building on the previous step's output.
+
+Use this when the user asks to:
+- Create a new pipeline with multiple steps
+- Set up an automated workflow with data transformations
+- Build a reusable data processing pipeline`,
+    inputSchema: createPipelineSchema,
+    execute: async ({ name, description, inputFormId, steps }) => {
+      try {
+        // Validate the input form exists
+        const inputForm = await db.query.form.findFirst({
+          where: and(
+            eq(schema.form.id, inputFormId),
+            eq(schema.form.organizationId, member.organizationId),
+            isNull(schema.form.deletedAt),
+          ),
+        });
+        if (!inputForm) {
+          return {
+            ok: false,
+            error: `Form not found: ${inputFormId}`,
+          };
+        }
+
+        // Collect all unique form IDs that need validation (output forms only)
+        const allFormIds = new Set<string>();
+        for (const step of steps) {
+          allFormIds.add(step.outputFormId);
+        }
+
+        // Verify all forms exist and belong to this organization
+        const forms = await db.query.form.findMany({
+          where: and(
+            eq(schema.form.organizationId, member.organizationId),
+            isNull(schema.form.deletedAt),
+          ),
+          columns: {
+            id: true,
+            name: true,
+          },
+        });
+
+        const formIdMap = new Map(forms.map((f) => [f.id, f]));
+        const missingFormIds = Array.from(allFormIds).filter(
+          (id) => !formIdMap.has(id),
+        );
+
+        if (missingFormIds.length > 0) {
+          return {
+            ok: false,
+            error: `The following form IDs were not found: ${missingFormIds.join(", ")}`,
+          };
+        }
+
+        const created = await db.transaction(async (tx) => {
+          const [pipeline] = await tx
+            .insert(schema.pipeline)
+            .values({
+              organizationId: member.organizationId,
+              name,
+              description,
+              isActive: true,
+              version: "1",
+              metadata: { createdBy: "chat" },
+            })
+            .returning();
+          invariant(pipeline);
+
+          // Note: Pipeline-form mappings are no longer used in the new architecture
+          // Pipelines now work with deals and documents directly
+
+          let previousStepId: string | null = null;
+
+          for (let i = 0; i < steps.length; i++) {
+            const step = steps[i];
+            invariant(step);
+            const stepResults: PipelineStep[] = await tx
+              .insert(schema.pipelineStep)
+              .values({
+                pipelineId: pipeline.id,
+                name: step.name,
+                description: step.description,
+                prompt: step.prompt,
+                toolsAllowed: step.toolsAllowed,
+                retryPolicy: {},
+              })
+              .returning();
+            const insertedStep = stepResults[0];
+            if (!insertedStep)
+              throw new Error("Failed to create pipeline step");
+
+            // Create output form mapping if specified
+            if (step.outputFormId) {
+              await tx.insert(schema.pipelineStepOutputForm).values({
+                stepId: insertedStep.id,
+                formId: step.outputFormId,
+              });
+            }
+
+            // Create dependency if there was a previous step
+            if (previousStepId) {
+              await tx.insert(schema.pipelineStepDependency).values({
+                childStepId: insertedStep.id,
+                parentStepId: previousStepId,
+              });
+            }
+
+            previousStepId = insertedStep.id;
+          }
+
+          return pipeline;
+        });
+
+        return {
+          ok: true,
+          data: {
+            id: created.id,
+            name: created.name,
+            description: created.description,
+            stepCount: steps.length,
+            message: `Successfully created pipeline "${name}" with ${steps.length} step(s)`,
+          },
+        };
+      } catch (err) {
+        return returnErr(err);
+      }
+    },
+  });
+}
+
+const modifyPipelineSchema = z.object({
+  pipelineId: z.string().min(1).describe("The ID of the pipeline to modify"),
+  name: z.string().min(1).optional().describe("The new name of the pipeline"),
+  description: z
+    .string()
+    .min(1)
+    .optional()
+    .describe("The new description of the pipeline"),
+  inputFormId: z
+    .string()
+    .min(1)
+    .optional()
+    .describe("The new input form ID to use"),
+  steps: z
+    .array(pipelineStepSchema)
+    .min(1)
+    .optional()
+    .describe(
+      "The updated steps to execute. If provided, this will replace ALL existing steps.",
+    ),
+});
+
+export function modifyPipeline({ member }: { member: Member }) {
+  return tool({
+    description: `Modify an existing pipeline.
+
+Use this when the user asks to:
+- Update the pipeline's name or description
+- Change the input form
+- Modify, add, or remove steps
+- Reorder steps
+- Change step configurations
+
+IMPORTANT: If you modify the steps, you must provide the complete list of steps you want,
+not just the changes. The new steps will replace all existing steps.`,
+    inputSchema: modifyPipelineSchema,
+    execute: async ({ pipelineId, name, description, inputFormId, steps }) => {
+      try {
+        // Verify the pipeline exists and belongs to the organization
+        const existingPipeline = await db.query.pipeline.findFirst({
+          where: and(
+            eq(schema.pipeline.id, pipelineId),
+            eq(schema.pipeline.organizationId, member.organizationId),
+            isNull(schema.pipeline.deletedAt),
+          ),
+          with: {
+            steps: true,
+          },
+        });
+
+        if (!existingPipeline) {
+          return {
+            ok: false,
+            error: `Pipeline not found: ${pipelineId}`,
+          };
+        }
+
+        // Validate the new input form exists if provided
+        if (inputFormId) {
+          const inputForm = await db.query.form.findFirst({
+            where: and(
+              eq(schema.form.id, inputFormId),
+              eq(schema.form.organizationId, member.organizationId),
+              isNull(schema.form.deletedAt),
+            ),
+          });
+          if (!inputForm) {
+            return {
+              ok: false,
+              error: `Form not found: ${inputFormId}`,
+            };
+          }
+        }
+
+        // Validate all output forms exist if steps are provided
+        if (steps) {
+          const allFormIds = new Set<string>();
+          for (const step of steps) {
+            allFormIds.add(step.outputFormId);
+          }
+
+          const forms = await db.query.form.findMany({
+            where: and(
+              eq(schema.form.organizationId, member.organizationId),
+              isNull(schema.form.deletedAt),
+            ),
+            columns: {
+              id: true,
+              name: true,
+            },
+          });
+
+          const formIdMap = new Map(forms.map((f) => [f.id, f]));
+          const missingFormIds = Array.from(allFormIds).filter(
+            (id) => !formIdMap.has(id),
+          );
+
+          if (missingFormIds.length > 0) {
+            return {
+              ok: false,
+              error: `The following form IDs were not found: ${missingFormIds.join(", ")}`,
+            };
+          }
+        }
+
+        const updated = await db.transaction(async (tx) => {
+          // Update the pipeline metadata if provided
+          const updateData: {
+            name?: string;
+            description?: string;
+          } = {};
+          if (name !== undefined) updateData.name = name;
+          if (description !== undefined) updateData.description = description;
+
+          if (Object.keys(updateData).length > 0) {
+            await tx
+              .update(schema.pipeline)
+              .set(updateData)
+              .where(eq(schema.pipeline.id, pipelineId));
+          }
+
+          // Note: Input form mapping removed - no longer used in new architecture
+
+          // Update steps if provided
+          if (steps) {
+            // Delete all existing steps (this cascades to dependencies and output forms)
+            await tx
+              .delete(schema.pipelineStep)
+              .where(eq(schema.pipelineStep.pipelineId, pipelineId));
+
+            // Create new steps
+            let previousStepId: string | null = null;
+
+            for (let i = 0; i < steps.length; i++) {
+              const step = steps[i];
+              invariant(step);
+              const stepResults: PipelineStep[] = await tx
+                .insert(schema.pipelineStep)
+                .values({
+                  pipelineId,
+                  name: step.name,
+                  description: step.description,
+                  prompt: step.prompt,
+                  toolsAllowed: step.toolsAllowed,
+                  retryPolicy: {},
+                })
+                .returning();
+              const insertedStep = stepResults[0];
+              if (!insertedStep)
+                throw new Error("Failed to create pipeline step");
+
+              // Create output form mapping if specified
+              if (step.outputFormId) {
+                await tx.insert(schema.pipelineStepOutputForm).values({
+                  stepId: insertedStep.id,
+                  formId: step.outputFormId,
+                });
+              }
+
+              // Create dependency if there was a previous step
+              if (previousStepId) {
+                await tx.insert(schema.pipelineStepDependency).values({
+                  childStepId: insertedStep.id,
+                  parentStepId: previousStepId,
+                });
+              }
+
+              previousStepId = insertedStep.id;
+            }
+          }
+
+          // Fetch the updated pipeline
+          const updatedPipeline = await tx.query.pipeline.findFirst({
+            where: eq(schema.pipeline.id, pipelineId),
+            with: {
+              steps: true,
+            },
+          });
+
+          return updatedPipeline;
+        });
+
+        invariant(updated);
+
+        return {
+          ok: true,
+          data: {
+            id: updated.id,
+            name: updated.name,
+            description: updated.description,
+            stepCount: updated.steps.length,
+            message: `Successfully modified pipeline "${updated.name}"${steps ? ` with ${steps.length} step(s)` : ""}`,
+          },
+        };
+      } catch (err) {
+        return returnErr(err);
+      }
+    },
+  });
+}
+
+export function listPipelines({ member }: { member: Member }) {
+  return tool({
+    description: `List all available pipelines in the organization.
+
+Use this to:
+- View all pipelines that have been created
+- Find the pipeline ID you want to work with
+- See pipeline names and descriptions`,
+    inputSchema: z.object({}),
+    execute: async () => {
+      try {
+        const pipelines = await db.query.pipeline.findMany({
+          where: and(
+            eq(schema.pipeline.organizationId, member.organizationId),
+            isNull(schema.pipeline.deletedAt),
+            eq(schema.pipeline.isActive, true),
+          ),
+          columns: {
+            id: true,
+            name: true,
+            description: true,
+            createdAt: true,
+            updatedAt: true,
+          },
+          orderBy: desc(schema.pipeline.updatedAt),
+        });
+
+        return {
+          ok: true,
+          data: {
+            pipelines: pipelines.map((p) => ({
+              id: p.id,
+              name: p.name,
+              description: p.description,
+              createdAt: p.createdAt,
+              updatedAt: p.updatedAt,
+            })),
+            count: pipelines.length,
+          },
+        };
+      } catch (err) {
+        return returnErr(err);
+      }
+    },
+  });
+}
+
+const fetchPipelineSchema = z.object({
+  pipelineId: z.string().min(1).describe("The ID of the pipeline to fetch"),
+});
+
+export function fetchPipeline({ member }: { member: Member }) {
+  return tool({
+    description: `Fetch a pipeline's configuration including its name, description, input form, and steps.
+
+Use this to:
+- View the current configuration of a pipeline before modifying it
+- Understand what steps are currently defined
+- See what forms are being used as inputs and outputs`,
+    inputSchema: fetchPipelineSchema,
+    execute: async ({ pipelineId }) => {
+      try {
+        const pipelineResult = await getPipelineWithSteps({
+          member,
+          pipelineId,
+        });
+
+        if (!pipelineResult.ok) {
+          return {
+            ok: false,
+            error: `Pipeline not found: ${pipelineId}`,
+          };
+        }
+
+        const pipeline = pipelineResult.data;
+
+        // Get output forms for each step
+        const stepsWithOutputForms = await Promise.all(
+          pipeline.steps.map(async (step) => {
+            const outputForms = await db.query.pipelineStepOutputForm.findMany({
+              where: eq(schema.pipelineStepOutputForm.stepId, step.id),
+            });
+            return {
+              id: step.id,
+              name: step.name,
+              description: step.description,
+              prompt: step.prompt,
+              toolsAllowed: step.toolsAllowed ?? [],
+              outputFormIds: outputForms.map((of) => of.formId),
+            };
+          }),
+        );
+
+        return {
+          ok: true,
+          data: {
+            id: pipeline.id,
+            name: pipeline.name,
+            description: pipeline.description,
+            steps: stepsWithOutputForms,
+          },
+        };
+      } catch (err) {
+        return returnErr(err);
+      }
+    },
+  });
+}
+
+const listFormsSchema = z.object({});
+
+export function listForms({ member }: { member: Member }) {
+  return tool({
+    description: `List all available forms in the organization.
+
+Use this to discover what forms are available before creating a template.
+Returns form IDs, names, and descriptions.`,
+    inputSchema: listFormsSchema,
+    execute: async () => {
+      try {
+        const forms = await db.query.form.findMany({
+          where: and(
+            eq(schema.form.organizationId, member.organizationId),
+            isNull(schema.form.deletedAt),
+          ),
+          columns: {
+            id: true,
+            name: true,
+            hint: true,
+          },
+          orderBy: [desc(schema.form.updatedAt)],
+        });
+
+        return {
+          ok: true,
+          data: {
+            forms: forms.map((f) => ({
+              id: f.id,
+              name: f.name,
+              description: f.hint,
+            })),
+            count: forms.length,
+          },
+        };
+      } catch (err) {
+        return returnErr(err);
+      }
+    },
+  });
+}

package/libs/core/src/chat/types.ts

@@ -0,0 +1,3 @@
+// Re-export types and schemas from @sea/schemas
+export type { ChatType } from "@sea/schemas/core/chat";
+export { chatTypeSchema } from "@sea/schemas/core/chat";