sea-dev 1.0.0

package/libs/core/src/chat/tools/deep-dive-agent.ts

@@ -0,0 +1,100 @@
+/**
+ * Deep Dive Agent
+ * Specializes in sandbox code execution and exploratory analysis
+ */
+
+import type { VercelConfig } from "@sea/config/vercel";
+import type { Member } from "@sea/db/types";
+import { Sandbox } from "@vercel/sandbox";
+import { tool, ToolLoopAgent, type LanguageModel } from "ai";
+import { z } from "zod/v4";
+import { createArtifact, updateAgentMemory } from "./agent";
+import { fetchSubmissionAgent } from "./submission";
+
+export interface DeepDiveAgentConfig {
+  model: LanguageModel;
+  member: Member;
+  conversationId: string;
+  vercelConfig: VercelConfig;
+}
+
+export async function createDeepDiveAgent(config: DeepDiveAgentConfig) {
+  const { model, member, conversationId, vercelConfig } = config;
+
+  const sandbox = await Sandbox.create({
+    token: vercelConfig.token,
+    projectId: vercelConfig.projectId,
+    teamId: vercelConfig.teamId,
+    runtime: "python3.13",
+  });
+
+  const agent = new ToolLoopAgent({
+    model,
+    instructions: `You are a deep dive specialist agent with access to an isolated sandbox environment.
+
+Use bash for file operations (cat, echo >, ls, find, etc), Python for data analysis, and Node.js for JavaScript execution.
+
+Create artifacts to present findings and update progress for long-running tasks.
+
+IMPORTANT: When referencing specific data from submissions, include citation references using the format [citation:CITATION_ID] where CITATION_ID is the citationId field from the submission data. This allows users to click and view the source document.`,
+
+    tools: {
+      bash: tool({
+        description:
+          "Run bash commands in the sandbox. Use for file operations (cat, echo >), exploration (ls, find), and shell scripting.",
+        inputSchema: z.object({ command: z.string() }),
+        execute: async ({ command }) => {
+          const result = await sandbox.runCommand({
+            cmd: "bash",
+            args: ["-c", command],
+          });
+          const stdout = await result.stdout();
+          const stderr = await result.stderr();
+          return stdout || stderr;
+        },
+      }),
+      python: tool({
+        description:
+          "Run Python code in the sandbox for data analysis, computation, and scripting.",
+        inputSchema: z.object({ code: z.string() }),
+        execute: async ({ code }) => {
+          const result = await sandbox.runCommand({
+            cmd: "python3",
+            args: ["-c", code],
+          });
+          const stdout = await result.stdout();
+          const stderr = await result.stderr();
+          return stdout || stderr;
+        },
+      }),
+      node: tool({
+        description:
+          "Run Node.js code in the sandbox for JavaScript execution and scripting.",
+        inputSchema: z.object({ code: z.string() }),
+        execute: async ({ code }) => {
+          const result = await sandbox.runCommand({
+            cmd: "node",
+            args: ["-e", code],
+          });
+          const stdout = await result.stdout();
+          const stderr = await result.stderr();
+          return stdout || stderr;
+        },
+      }),
+      fetchSubmission: fetchSubmissionAgent({ member }),
+      createArtifact: createArtifact({ member, conversationId }),
+      updateAgentMemory: updateAgentMemory({ member, conversationId }),
+    },
+  });
+
+  return {
+    agent,
+    cleanup: async () => {
+      try {
+        await sandbox.stop();
+      } catch (err) {
+        console.error(`Failed to stop sandbox ${sandbox.sandboxId}:`, err);
+      }
+    },
+  };
+}

package/libs/core/src/chat/tools/deep-dive.ts

@@ -0,0 +1,141 @@
+import { createDeepDiveAgent } from "./deep-dive-agent";
+import type { VercelConfig } from "@sea/config/vercel";
+import type { Member } from "@sea/db/types";
+import { Sandbox } from "@vercel/sandbox";
+import type { LanguageModel, UIMessageStreamWriter } from "ai";
+import { tool } from "ai";
+import * as z from "zod/v4";
+
+export function codeSandboxTool({
+  member,
+  conversationId,
+  vercelConfig,
+}: {
+  member: Member;
+  conversationId: string;
+  vercelConfig: VercelConfig;
+}) {
+  return tool({
+    description:
+      "Executes Node.js or Python code in a secure, isolated sandbox.",
+    inputSchema: z.object({
+      language: z.enum(["node", "python"]),
+      code: z.string().describe("The code snippet to execute."),
+      packages: z
+        .array(z.string())
+        .optional()
+        .describe('Libraries to install (e.g., ["axios", "pandas"])'),
+    }),
+    execute: async ({ language, code, packages }) => {
+      // 1. Initialize the Sandbox
+      const sb = await Sandbox.create({
+        token: vercelConfig.token,
+        projectId: vercelConfig.projectId,
+        teamId: vercelConfig.teamId,
+        runtime: language === "node" ? "node24" : "python3.13",
+      });
+
+      try {
+        // 2. Install packages if requested
+        if (packages?.length) {
+          const pkgManager = language === "node" ? "npm" : "pip";
+          await sb.runCommand({
+            cmd: pkgManager,
+            args: ["install", ...packages],
+          });
+        }
+
+        // 3. Execute the code
+        const cmd = language === "node" ? "node" : "python3";
+        const args = language === "node" ? ["-e", code] : ["-c", code];
+
+        console.log("Executing code", { cmd, args });
+
+        const result = await sb.runCommand({ cmd, args });
+        const output = await result.stdout();
+        const error = await result.stderr();
+        const exitCode = result.exitCode;
+
+        console.log("stdout:", output);
+        console.log("stderr:", error);
+        console.log("exitCode:", exitCode);
+
+        return {
+          output,
+          error,
+          success: exitCode === 0,
+          sandboxId: sb.sandboxId,
+        };
+      } catch (err) {
+        console.error("Error executing code sandbox", err);
+        return {
+          ok: false,
+          error: err instanceof Error ? err.message : String(err),
+        };
+      } finally {
+        // If you want it to be purely ephemeral, destroy it.
+        // If you want the agent to "remember" files, omit this and let it timeout (default 5m).
+        // await sb.destroy();
+      }
+    },
+  });
+}
+
+/**
+ * Deep Dive Agent Tool - Delegates to a specialized agent with sandbox capabilities
+ */
+export function deepDiveAgent({
+  member,
+  conversationId,
+  vercelConfig,
+  model,
+  writer,
+}: {
+  member: Member;
+  conversationId: string;
+  vercelConfig: VercelConfig;
+  model: LanguageModel;
+  writer?: UIMessageStreamWriter;
+}) {
+  return tool({
+    description: `Delegate to a deep dive specialist agent with isolated sandbox environment.
+Use for: data exploration, running Python/Node.js/bash code, complex computations, data analysis,
+file processing, generating visualizations. The agent has bash, python, and node execution capabilities
+in an isolated environment. DO NOT use for credit scoring, there's a separate credit agent for that.`,
+    inputSchema: z.object({
+      task: z
+        .string()
+        .describe(
+          "Clear description of the task for the deep dive agent. Be specific about what analysis, computation, or exploration is needed.",
+        ),
+    }),
+    execute: async ({ task }) => {
+      let agent: Awaited<ReturnType<typeof createDeepDiveAgent>> | null = null;
+
+      try {
+        agent = await createDeepDiveAgent({
+          model,
+          member,
+          conversationId,
+          vercelConfig,
+        });
+
+        const result = await agent.agent.generate({ prompt: task });
+        return {
+          ok: true,
+          result: result.text,
+        };
+      } catch (err) {
+        console.error("Deep dive agent error:", err);
+        return {
+          ok: false,
+          error: err instanceof Error ? err.message : String(err),
+        };
+      } finally {
+        if (agent) {
+          await agent.cleanup();
+        }
+      }
+    },
+  });
+}

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

@@ -0,0 +1,449 @@
+import { getForm } from "@sea/dal/form";
+import { db, schema } from "@sea/db";
+import type { InsertFormDerived, InsertFormField, Member } from "@sea/db/types";
+import { invariant } from "@sea/util/invariant";
+import { tool } from "ai";
+import { and, eq, inArray, isNull, sql } from "drizzle-orm";
+import * as z from "zod/v4";
+import { returnErr, type Group, groupsSchema } from "./helpers";
+
+export function fetchCurrentForm({
+  member,
+  formId,
+}: {
+  member: Member;
+  formId: string;
+}) {
+  return tool({
+    description: "Fetch the current form and data",
+    inputSchema: z.object({}),
+    execute: async () => {
+      try {
+        const form = await getForm({ member, formId });
+        const { groups } = form;
+        return {
+          ok: true,
+          data: { groups },
+        };
+      } catch (err) {
+        return returnErr(err);
+      }
+    },
+  });
+}
+
+export function fetchFormAgent({ member }: { member: Member }) {
+  return tool({
+    description: "Fetch the current form and data",
+    inputSchema: z.object({ formId: z.string() }),
+    execute: async ({ formId }) => {
+      try {
+        const form = await getForm({ member, formId });
+        const { groups } = form;
+        return {
+          ok: true,
+          data: { groups },
+        };
+      } catch (err) {
+        return returnErr(err);
+      }
+    },
+  });
+}
+
+export function fetchFormEditability({
+  member,
+  formId,
+}: {
+  member: Member;
+  formId: string;
+}) {
+  return tool({
+    description: `Check what edits are allowed on this form. MUST be called before any form modifications
+to understand if the form has submissions that restrict certain changes.`,
+    inputSchema: z.object({}),
+    execute: async () => {
+      try {
+        // Count submissions for this form
+        const [result] = await db
+          .select({ count: sql<number>`count(*)::int` })
+          .from(schema.submission)
+          .where(
+            and(
+              eq(schema.submission.formId, formId),
+              eq(schema.submission.organizationId, member.organizationId),
+              isNull(schema.submission.deletedAt),
+            ),
+          );
+
+        const submissionCount = result?.count ?? 0;
+        const hasSubmissions = submissionCount > 0;
+
+        return {
+          ok: true,
+          data: {
+            hasSubmissions,
+            submissionCount,
+            restrictions: {
+              canDeleteFields: !hasSubmissions,
+              canDeleteGroups: !hasSubmissions,
+              canChangeFieldTypes: !hasSubmissions,
+              canRenameFields: true,
+              canUpdateHints: true,
+              canAddFields: true,
+              canAddGroups: true,
+              canAddDerivedFields: true,
+              canReorderFields: true,
+            },
+            message: hasSubmissions
+              ? `This form has ${submissionCount} submission(s) with data. ` +
+                `You CAN: add fields, rename fields, update hints, add derived fields, reorder fields. ` +
+                `You CANNOT: delete fields, delete groups, or change field types (would break existing data).`
+              : "This form has no submissions. All edits are allowed.",
+          },
+        };
+      } catch (err) {
+        return returnErr(err);
+      }
+    },
+  });
+}
+
+export function fetchFormEditabilityAgent({ member }: { member: Member }) {
+  return tool({
+    description: `Check what edits are allowed on a form. MUST be called before any form modifications
+to understand if the form has submissions that restrict certain changes.`,
+    inputSchema: z.object({
+      formId: z
+        .string()
+        .describe("The ID of the form to check editability for"),
+    }),
+    execute: async ({ formId }) => {
+      try {
+        // Count submissions for this form
+        const [result] = await db
+          .select({ count: sql<number>`count(*)::int` })
+          .from(schema.submission)
+          .where(
+            and(
+              eq(schema.submission.formId, formId),
+              eq(schema.submission.organizationId, member.organizationId),
+              isNull(schema.submission.deletedAt),
+            ),
+          );
+
+        const submissionCount = result?.count ?? 0;
+        const hasSubmissions = submissionCount > 0;
+
+        return {
+          ok: true,
+          data: {
+            hasSubmissions,
+            submissionCount,
+            restrictions: {
+              canDeleteFields: !hasSubmissions,
+              canDeleteGroups: !hasSubmissions,
+              canChangeFieldTypes: !hasSubmissions,
+              canRenameFields: true,
+              canUpdateHints: true,
+              canAddFields: true,
+              canAddGroups: true,
+              canAddDerivedFields: true,
+              canReorderFields: true,
+            },
+            message: hasSubmissions
+              ? `This form has ${submissionCount} submission(s) with data. ` +
+                `You CAN: add fields, rename fields, update hints, add derived fields, reorder fields. ` +
+                `You CANNOT: delete fields, delete groups, or change field types (would break existing data).`
+              : "This form has no submissions. All edits are allowed.",
+          },
+        };
+      } catch (err) {
+        return returnErr(err);
+      }
+    },
+  });
+}
+
+export function persistForm({
+  member,
+  formId,
+}: {
+  member: Member;
+  formId: string;
+}) {
+  return tool({
+    description: "[DESTRUCTIVE] Persist the updated form to the database",
+    inputSchema: z.object({ groups: groupsSchema }),
+    execute: async ({ groups }: { groups: Group[] }) => {
+      try {
+        await persistFormInternal({ member, formId, groups });
+        return {
+          ok: true,
+          data: undefined,
+        };
+      } catch (err) {
+        return returnErr(err);
+      }
+    },
+  });
+}
+
+export function persistFormAgent({ member }: { member: Member }) {
+  return tool({
+    description: "Persist the updated form to the database",
+    inputSchema: z.object({
+      groups: groupsSchema,
+      formId: z.string(),
+    }),
+    execute: async ({
+      groups,
+      formId,
+    }: {
+      groups: Group[];
+      formId: string;
+    }) => {
+      try {
+        await persistFormInternal({ member, formId, groups });
+        return {
+          ok: true,
+          data: undefined,
+        };
+      } catch (err) {
+        return returnErr(err);
+      }
+    },
+  });
+}
+
+async function persistFormInternal({
+  member,
+  formId,
+  groups,
+}: {
+  member: Member;
+  formId: string;
+  groups: Group[];
+}) {
+  const form = await db.query.form.findFirst({
+    where: and(
+      eq(schema.form.organizationId, member.organizationId),
+      eq(schema.form.id, formId),
+    ),
+    with: {
+      groups: { with: { fields: true, derived: true } },
+      submissions: {
+        where: and(
+          eq(schema.submission.organizationId, member.organizationId),
+          isNull(schema.submission.deletedAt),
+        ),
+      },
+    },
+  });
+  invariant(form);
+
+  // Validate no destructive changes if form has submissions
+  if (form.submissions.length > 0) {
+    const existingFieldIds = new Set(
+      form.groups.flatMap((g) => g.fields.map((f) => f.id)),
+    );
+    const existingGroupIds = new Set(form.groups.map((g) => g.id));
+
+    const newFieldIds = new Set(
+      groups.flatMap((g) => g.fields.filter((f) => f.id).map((f) => f.id)),
+    );
+    const newGroupIds = new Set(groups.filter((g) => g.id).map((g) => g.id));
+
+    // Check for deleted fields
+    for (const existingId of existingFieldIds) {
+      if (!newFieldIds.has(existingId)) {
+        throw new Error(
+          `Cannot delete field because this form has ${form.submissions.length} existing submission(s). ` +
+            `Deleting fields would break data integrity. ` +
+            `To delete fields, first remove all submissions or clone the form.`,
+        );
+      }
+    }
+
+    // Check for deleted groups
+    for (const existingId of existingGroupIds) {
+      if (!newGroupIds.has(existingId)) {
+        throw new Error(
+          `Cannot delete group because this form has ${form.submissions.length} existing submission(s). ` +
+            `Deleting groups would break data integrity. ` +
+            `To delete groups, first remove all submissions or clone the form.`,
+        );
+      }
+    }
+  }
+
+  // Check which of the new groups exist update them, delete the rest
+  const groupsIdsToDelete = form.groups
+    .filter((eg) => !groups.some((g) => g.id === eg.id))
+    .map((g) => g.id);
+
+  if (groupsIdsToDelete.length > 0) {
+    await db
+      .delete(schema.formGroup)
+      .where(inArray(schema.formGroup.id, groupsIdsToDelete));
+  }
+
+  // First pass: Set temporary negative orders for existing groups to avoid constraint conflicts
+  // This allows us to safely reorder groups even when swapping positions
+  const existingGroupsToUpdate = groups
+    .map((group, index) => ({ group, index }))
+    .filter(({ group }) => form.groups.find((g) => g.id === group.id))
+    .map(({ group, index }) => ({
+      id: form.groups.find((g) => g.id === group.id)!.id,
+      tempOrder: -(index + 1000), // Large negative to avoid conflicts
+    }));
+
+  for (const { id, tempOrder } of existingGroupsToUpdate) {
+    await db
+      .update(schema.formGroup)
+      .set({ order: tempOrder })
+      .where(eq(schema.formGroup.id, id));
+  }
+
+  // Create / update the rest of the groups
+  for (const [groupOrder, group] of groups.entries()) {
+    // Check if this is an existing group (has an ID and that ID exists in the database)
+    const existingGroup = form.groups.find((g) => g.id === group.id);
+
+    if (existingGroup) {
+      const formGroupId = existingGroup.id;
+      await db
+        .update(schema.formGroup)
+        .set({
+          name: group.name,
+          multi: group.multi,
+          hint: group.hint,
+          order: groupOrder,
+        })
+        .where(
+          and(
+            eq(schema.formGroup.formId, form.id),
+            eq(schema.formGroup.id, formGroupId),
+          ),
+        );
+
+      const existingFieldIds = new Set(existingGroup.fields.map((f) => f.id));
+      const existingDerivedIds = new Set(
+        existingGroup.derived.map((d) => d.id),
+      );
+
+      // Build new field/derived lists with IDs
+      const fields: InsertFormField[] = group.fields.map((f, order) => {
+        const { id, ...rest } = f;
+        return {
+          formGroupId,
+          ...(id && id !== "" ? { id } : {}),
+          ...rest,
+          order,
+        };
+      });
+      const derived: InsertFormDerived[] =
+        group.derived?.map((d) => {
+          const { id, ...rest } = d;
+          return {
+            formGroupId,
+            ...(id && id !== "" ? { id } : {}),
+            ...rest,
+          };
+        }) ?? [];
+
+      const newFieldIds = new Set(fields.filter((f) => f.id).map((f) => f.id!));
+      const newDerivedIds = new Set(
+        derived.filter((d) => d.id).map((d) => d.id!),
+      );
+
+      // Delete fields/derived that were removed
+      const fieldIdsToDelete = [...existingFieldIds].filter(
+        (id) => !newFieldIds.has(id),
+      );
+      const derivedIdsToDelete = [...existingDerivedIds].filter(
+        (id) => !newDerivedIds.has(id),
+      );
+
+      if (fieldIdsToDelete.length) {
+        await db
+          .delete(schema.formField)
+          .where(inArray(schema.formField.id, fieldIdsToDelete));
+      }
+      if (derivedIdsToDelete.length) {
+        await db
+          .delete(schema.formDerived)
+          .where(inArray(schema.formDerived.id, derivedIdsToDelete));
+      }
+
+      // Upsert fields and derived fields
+      if (fields.length) {
+        await db
+          .insert(schema.formField)
+          .values(fields)
+          .onConflictDoUpdate({
+            target: schema.formField.id,
+            set: {
+              name: sql.raw(`excluded.${schema.formField.name.name}`),
+              type: sql.raw(`excluded.${schema.formField.type.name}`),
+              hint: sql.raw(`excluded.${schema.formField.hint.name}`),
+              order: sql.raw(`excluded.${schema.formField.order.name}`),
+            },
+          });
+      }
+      if (derived.length) {
+        await db
+          .insert(schema.formDerived)
+          .values(derived)
+          .onConflictDoUpdate({
+            target: schema.formDerived.id,
+            set: {
+              name: sql.raw(`excluded.${schema.formDerived.name.name}`),
+              prompt: sql.raw(`excluded.${schema.formDerived.prompt.name}`),
+            },
+          });
+      }
+    } else {
+      // CREATE path: New group (no ID or ID doesn't exist in database)
+      const [newGroup] = await db
+        .insert(schema.formGroup)
+        .values({
+          name: group.name,
+          hint: group.hint,
+          multi: group.multi,
+          formId: form.id,
+          order: groupOrder,
+        })
+        .returning();
+      invariant(newGroup);
+
+      const formGroupId = newGroup.id;
+
+      // For new groups, don't include IDs in fields/derived (let DB generate them)
+      const fields = group.fields.map((item, order) => {
+        const { id, ...rest } = item;
+        return {
+          ...rest,
+          formGroupId,
+          order,
+        };
+      });
+
+      const derived =
+        group.derived?.map((d) => {
+          const { id, ...rest } = d;
+          return {
+            ...rest,
+            formGroupId,
+          };
+        }) ?? [];
+
+      if (fields.length) {
+        await db.insert(schema.formField).values(fields);
+      }
+      if (derived.length) {
+        await db.insert(schema.formDerived).values(derived);
+      }
+    }
+  }
+}