sea-dev 1.0.0

package/apps/main/src/routes/_authed/_app/agents/-fns.ts

@@ -0,0 +1,560 @@
+import { getAppConfig } from "@/lib/config";
+import * as zfd from "@/lib/zfd";
+import { membershipMiddleware, requestLogMiddleware } from "@/middleware";
+import { createLanguageModel } from "@sea/ai/models";
+import { HatchetClientMgr } from "@sea/clients";
+import { AzureClient } from "@sea/clients/azure";
+import { GCPClient } from "@sea/clients/gcp";
+import { prepareTools } from "@sea/core/chat/prepare-tools";
+import { ReasoningEffortSchema } from "@sea/core/data-extraction/models";
+import { getExtractionSetup } from "@sea/core/data-extraction/utils";
+import { checkCanExtract } from "@sea/dal/billing";
+import {
+  addToAgentMemory,
+  createAgentConversation,
+  getAgentConversation,
+  getAgentConversations,
+  getRelevantItems,
+  removeFromAgentMemory,
+} from "@sea/dal/conversation";
+import { getCitationsByIds } from "@sea/dal/document";
+import { getSubmission } from "@sea/dal/submission";
+import { getToolsForConversation, upsertToolConfig } from "@sea/dal/tool";
+import { db, schema } from "@sea/db";
+import { memorySchema } from "@sea/db/schema";
+import type { Member } from "@sea/db/types";
+import { nanoid } from "@sea/util/id";
+import { invariant } from "@sea/util/invariant";
+import { notFound, redirect } from "@tanstack/react-router";
+import { createServerFn } from "@tanstack/react-start";
+import { deleteCookie, getCookie, setCookie } from "@tanstack/react-start/server";
+import type { UIMessage } from "ai";
+import { and, desc, eq, isNull, notInArray } from "drizzle-orm";
+import { z } from "zod/v4";
+
+const config = getAppConfig();
+
+async function getAgentToolsConfig({
+  member,
+  conversationId,
+}: {
+  member: Member;
+  conversationId: string;
+}) {
+  const model = createLanguageModel({
+    gatewayApiKey: config.vercel.aiGatewayApiKey,
+    modelId: "openai/gpt-5.2",
+  });
+  const conversation = await db.query.conversation.findFirst({
+    where: and(
+      eq(schema.conversation.id, conversationId),
+      eq(schema.conversation.organizationId, member.organizationId),
+      eq(schema.conversation.agent, true),
+    ),
+  });
+  if (!conversation) return null;
+
+  const { baseTools } = await prepareTools({
+    chatType: "agent",
+    member,
+    conversationId,
+    model,
+  });
+
+  const dbTools = await getToolsForConversation({
+    member,
+    conversationId,
+  });
+  const dbToolsMap = new Map(dbTools.map((t) => [t.toolName, t]));
+
+  return Object.entries(baseTools || {}).map(([toolName, toolInstance]) => {
+    const dbTool = dbToolsMap.get(toolName);
+    try {
+      const inputSchema = JSON.stringify(
+        z.toJSONSchema(toolInstance.inputSchema as z.ZodSchema),
+        null,
+        2,
+      );
+      return {
+        toolName,
+        defaultDescription: toolInstance.description || "",
+        customDescription: dbTool?.description || null,
+        inputSchema,
+        id: dbTool?.id,
+      };
+    } catch {
+      return {
+        toolName,
+        defaultDescription: toolInstance.description || "",
+        customDescription: dbTool?.description || null,
+        inputSchema: "{}",
+        id: dbTool?.id,
+      };
+    }
+  });
+}
+
+export function extractCitationIds(messages: UIMessage[]): string[] {
+  // Match both old [citation:ID] format and new <cite data-id="ID"> format
+  const oldFormatRegex = /\[citation:([^\]]+)\]/g;
+  const newFormatRegex = /<cite\s+data-id=["']([^"']+)["'][^>]*>/g;
+  const citationIds = new Set<string>();
+
+  for (const message of messages) {
+    for (const part of message.parts) {
+      if (part.type === "text") {
+        // Check old format
+        let match: RegExpExecArray | null;
+        while ((match = oldFormatRegex.exec(part.text)) !== null) {
+          if (match[1]) {
+            citationIds.add(match[1]);
+          }
+        }
+
+        // Check new format
+        while ((match = newFormatRegex.exec(part.text)) !== null) {
+          if (match[1]) {
+            citationIds.add(match[1]);
+          }
+        }
+      }
+    }
+  }
+
+  return Array.from(citationIds);
+}
+
+export const createAgentFn = createServerFn()
+  .middleware([membershipMiddleware])
+  .handler(async ({ context: { member } }) => {
+    const newAgent = await createAgentConversation({ member });
+    const { id } = newAgent;
+    setCookie("currentAgent", id, { path: "/", sameSite: "strict", secure: true });
+    throw redirect({
+      to: "/agents/$agentId",
+      params: { agentId: id },
+    });
+  });
+
+export const getAgentConversationsFn = createServerFn()
+  .middleware([membershipMiddleware])
+  .handler(async ({ context: { member } }) => {
+    return await getAgentConversations({ member });
+  });
+
+export const getAgentDataFn = createServerFn()
+  .middleware([membershipMiddleware])
+  .validator((data: { conversationId: string }) => data)
+  .handler(async ({ context: { member }, data: { conversationId } }) => {
+    const [agentResult, agentConversations, itemsResult] = await Promise.all([
+      getAgentConversation({ member, conversationId }),
+      getAgentConversations({ member, limit: 10 }),
+      getRelevantItems({ member, conversationId }),
+    ]);
+
+    const cookieExists = !!getCookie("currentAgent");
+    if (!agentResult.ok || !itemsResult.ok) {
+      // Hopefully this will prevent an infinite loop?
+      if (cookieExists) {
+        deleteCookie("currentAgent");
+        throw redirect({ to: "/agents" });
+      } else {
+        throw notFound();
+      }
+    }
+
+    const { data: conversation } = agentResult;
+    const { id } = conversation;
+    setCookie("currentAgent", id, { path: "/", sameSite: "strict", secure: true });
+
+    const canExtract = await checkCanExtract({ member });
+
+    // Extract citation IDs from messages and fetch citations
+    const messages = conversation.messages as UIMessage[];
+    const citationIds = extractCitationIds(messages);
+    const citations = await getCitationsByIds({ member, citationIds });
+
+    // Transform to ExtractionInfo format
+    const extractionMap = new Map();
+    for (const citation of citations) {
+      const { extraction } = citation;
+      const extractionId = extraction.id;
+
+      if (!extractionMap.has(extractionId)) {
+        extractionMap.set(extractionId, {
+          documentId: extraction.document.id,
+          documentExtractionId: extraction.id,
+          url: extraction.document.blobUrl,
+          urlExpiry: extraction.document.blobUrlExpiry,
+          uploaded: extraction.document.uploaded,
+          name: extraction.document.name,
+          contentType: extraction.document.contentType,
+          status: extraction.status,
+          displayType: extraction.document.displayType,
+          extractionModel: extraction.extractionModel,
+          extractionTrigger: extraction.extractionTrigger,
+          extractedData: extraction.data,
+          citations: [],
+        });
+      }
+
+      const extractionInfo = extractionMap.get(extractionId);
+      extractionInfo.citations.push({
+        id: citation.id,
+        text: citation.text,
+        sourceRef: citation.sourceRef,
+        path: citation.path,
+        boundingRegions: citation.boundingRegions,
+      });
+    }
+
+    const extractionInfo = Array.from(extractionMap.values());
+
+    return {
+      conversation,
+      agentConversations,
+      items: itemsResult.data,
+      canExtract,
+      extractionInfo,
+    };
+  });
+
+export const insertDocumentAgentFn = createServerFn({ method: "POST" })
+  .middleware([membershipMiddleware])
+  .validator(
+    (data: {
+      submissionId: string;
+      model: string;
+      files: { id: string; name: string; type: string }[];
+    }) => data,
+  )
+  .handler(async ({ context: { member }, data: { submissionId, model, files } }) => {
+    const submission = await getSubmission({ member, submissionId });
+    const documents = await Promise.all(
+      files.map(async (file) => {
+        const { name, type: contentType, id } = file;
+        // TODO: remove this nonsense once we merge all the models we use
+        const { storageProvider, displayType } = getExtractionSetup(config);
+        return db.transaction(async (tx) => {
+          const blobKey = nanoid() + "-" + name;
+          const [insertedDocument] = await tx
+            .insert(schema.document)
+            .values({
+              id,
+              dealId: submission.dealId,
+              name,
+              contentType,
+              storageProvider,
+              displayType,
+              blobKey,
+            })
+            .returning();
+
+          invariant(insertedDocument);
+          const { id: documentId } = insertedDocument;
+
+          const [documentExtraction] = await tx
+            .insert(schema.documentExtraction)
+            .values({
+              documentId,
+              submissionId: submission.id,
+              status: "pending",
+              extractionModel: model,
+            })
+            .returning({ id: schema.documentExtraction.id });
+          invariant(documentExtraction);
+
+          return { documentId, extractionId: documentExtraction.id, blobKey };
+        });
+      }),
+    );
+    return documents;
+  });
+
+const uploadDocumentSchema = zfd.formData({
+  documentExtractionId: zfd.text(),
+  conversationId: zfd.text(),
+  userPrompt: zfd.text().optional(),
+  reasoningEffort: ReasoningEffortSchema.optional(),
+  file: zfd.file(),
+});
+
+export const uploadDocumentAgentFn = createServerFn({ method: "POST" })
+  .middleware([membershipMiddleware, requestLogMiddleware])
+  .validator((formData: FormData) => uploadDocumentSchema.parse(formData))
+  .handler(
+    async ({
+      context: { member, reqLogger },
+      data: { file, documentExtractionId, conversationId, userPrompt, reasoningEffort },
+    }) => {
+      const documentExtraction = await db.query.documentExtraction.findFirst({
+        where: eq(schema.documentExtraction.id, documentExtractionId),
+        with: { document: true },
+      });
+      invariant(documentExtraction);
+      invariant(documentExtraction.document);
+
+      const { blobKey, storageProvider } = documentExtraction.document;
+      const client =
+        storageProvider === "azure" ? new AzureClient(config.azure) : new GCPClient(config.gcp);
+
+      const buffer = Buffer.from(await file.arrayBuffer());
+      await client.uploadFile(buffer, blobKey, file.type);
+      const { url, expiry } = await client.getSignedUrl(blobKey);
+
+      await db.transaction(async (tx) => {
+        await tx
+          .update(schema.document)
+          .set({ uploaded: true, blobUrl: url, blobUrlExpiry: expiry })
+          .where(eq(schema.document.id, documentExtraction.documentId));
+      });
+
+      // run extraction
+      reqLogger.info(
+        {
+          memberId: member.id,
+          submissionId: documentExtraction.submissionId,
+          documentId: documentExtraction.documentId,
+        },
+        "extraction: start",
+      );
+
+      const hatchetClient = new HatchetClientMgr(config.hatchet);
+      await hatchetClient.pushDocAgent(
+        documentExtraction.id,
+        conversationId,
+        documentExtraction.extractionModel,
+        userPrompt,
+        reasoningEffort,
+      );
+      reqLogger.info({}, "extraction: pushed to hatchet");
+    },
+  );
+
+export const getRelevantSubmissionsFn = createServerFn()
+  .middleware([membershipMiddleware])
+  .validator((data: { conversationId: string }) => data)
+  .handler(async ({ context: { member }, data: { conversationId } }) => {
+    const itemsResult = await getRelevantItems({ member, conversationId });
+
+    if (!itemsResult.ok) {
+      throw notFound();
+    }
+
+    const {
+      data: { submissions },
+    } = itemsResult;
+
+    return { submissions };
+  });
+
+export const renameAgentFn = createServerFn()
+  .middleware([membershipMiddleware])
+  .validator((data: { conversationId: string; name: string }) => data)
+  .handler(async ({ context: { member }, data: { conversationId, name } }) => {
+    await db
+      .update(schema.conversation)
+      .set({ name })
+      .where(
+        and(
+          eq(schema.conversation.organizationId, member.organizationId),
+          eq(schema.conversation.id, conversationId),
+        ),
+      );
+  });
+
+export const deleteAgentFn = createServerFn()
+  .middleware([membershipMiddleware])
+  .validator((data: { conversationId: string }) => data)
+  .handler(async ({ context: { member }, data: { conversationId } }) => {
+    await db
+      .update(schema.conversation)
+      .set({
+        deletedAt: new Date(),
+      })
+      .where(
+        and(
+          eq(schema.conversation.organizationId, member.organizationId),
+          eq(schema.conversation.id, conversationId),
+        ),
+      );
+  });
+
+export const deleteContextFn = createServerFn()
+  .middleware([membershipMiddleware])
+  .validator(
+    (data: {
+      conversationId: string;
+      itemType: keyof z.infer<typeof memorySchema>;
+      itemId: string;
+    }) => data,
+  )
+  .handler(async ({ context: { member }, data: { conversationId, itemType, itemId } }) => {
+    await removeFromAgentMemory({ member, conversationId, itemType, itemId });
+  });
+
+export const deleteArtifactFn = createServerFn()
+  .middleware([membershipMiddleware])
+  .validator((data: { conversationId: string; artifactId: string }) => data)
+  .handler(async ({ context: { member }, data: { conversationId, artifactId } }) => {
+    await removeFromAgentMemory({
+      member,
+      conversationId,
+      itemType: "artifacts",
+      itemId: artifactId,
+    });
+  });
+
+export const addToContextFn = createServerFn()
+  .middleware([membershipMiddleware])
+  .validator(
+    (data: {
+      conversationId: string;
+      itemType: keyof z.infer<typeof memorySchema>;
+      itemId: string;
+    }) => data,
+  )
+  .handler(async ({ context: { member }, data: { conversationId, itemType, itemId } }) => {
+    await removeFromAgentMemory({ member, conversationId, itemType, itemId });
+    await addToAgentMemory({
+      member,
+      conversationId,
+      memory: { [itemType]: [itemId] },
+    });
+  });
+
+export const getRecentItemsFn = createServerFn()
+  .middleware([membershipMiddleware])
+  .validator((data: { conversationId: string }) => data)
+  .handler(async ({ context: { member }, data: { conversationId } }) => {
+    const conversationResult = await getAgentConversation({ member, conversationId });
+    if (!conversationResult.ok) {
+      throw notFound();
+    }
+    const {
+      data: { memory: memoryRaw },
+    } = conversationResult;
+    const { dealIds, submissionIds, formIds } = memorySchema.parse(memoryRaw);
+
+    const [deals, submissions, forms] = await Promise.all([
+      db.query.deal.findMany({
+        where: and(
+          eq(schema.deal.organizationId, member.organizationId),
+          isNull(schema.deal.deletedAt),
+          notInArray(schema.deal.id, dealIds),
+        ),
+        orderBy: desc(schema.deal.updatedAt),
+        limit: 3,
+      }),
+      db.query.submission.findMany({
+        where: and(
+          eq(schema.submission.organizationId, member.organizationId),
+          eq(schema.submission.type, "extraction"),
+          isNull(schema.submission.deletedAt),
+          notInArray(schema.submission.id, submissionIds),
+        ),
+        orderBy: desc(schema.submission.updatedAt),
+        limit: 3,
+      }),
+      db.query.form.findMany({
+        where: and(
+          eq(schema.form.organizationId, member.organizationId),
+          isNull(schema.form.deletedAt),
+          notInArray(schema.form.id, formIds),
+        ),
+        orderBy: desc(schema.form.updatedAt),
+        limit: 3,
+      }),
+    ]);
+
+    return { deals, submissions, forms };
+  });
+
+export const getAgentToolsFn = createServerFn()
+  .middleware([membershipMiddleware])
+  .validator((data: { conversationId: string }) => data)
+  .handler(async ({ context: { member }, data: { conversationId } }) => {
+    const tools = await getAgentToolsConfig({ member, conversationId });
+    if (!tools) throw notFound();
+    return tools;
+  });
+
+export const updateToolDescriptionFn = createServerFn()
+  .middleware([membershipMiddleware])
+  .validator(
+    (data: { conversationId: string; toolName: string; description: string | null }) => data,
+  )
+  .handler(async ({ context: { member }, data: { conversationId, toolName, description } }) => {
+    const model = createLanguageModel({
+      gatewayApiKey: config.vercel.aiGatewayApiKey,
+      modelId: "openai/gpt-5.2",
+    });
+    // Get the tool schema from prepareTools
+    const { tools } = await prepareTools({
+      chatType: "agent",
+      member,
+      conversationId,
+      model,
+    });
+
+    const toolInstance = tools[toolName];
+    if (!toolInstance) throw notFound();
+
+    const toolSchema = {
+      name: toolName,
+      description: toolInstance.description,
+      toolSchema: toolInstance.inputSchema,
+    };
+
+    // Upsert the tool config
+    const result = await upsertToolConfig({
+      member,
+      conversationId,
+      toolName,
+      toolSchema,
+      description,
+    });
+
+    return result;
+  });
+
+export const getCitations = createServerFn()
+  .middleware([membershipMiddleware])
+  .validator((data: { citationIds: string[] }) => data)
+  .handler(async ({ context: { member }, data: { citationIds } }) => {
+    const citations = await getCitationsByIds({ member, citationIds });
+
+    const extractionMap = new Map();
+    for (const citation of citations) {
+      const { extraction } = citation;
+      const extractionId = extraction.id;
+      if (!extractionMap.has(extractionId)) {
+        extractionMap.set(extractionId, {
+          documentId: extraction.document.id,
+          documentExtractionId: extraction.id,
+          url: extraction.document.blobUrl,
+          urlExpiry: extraction.document.blobUrlExpiry,
+          uploaded: extraction.document.uploaded,
+          name: extraction.document.name,
+          contentType: extraction.document.contentType,
+          status: extraction.status,
+          displayType: extraction.document.displayType,
+          extractionModel: extraction.extractionModel,
+          extractionTrigger: extraction.extractionTrigger,
+          extractedData: extraction.data,
+          citations: [],
+        });
+      }
+
+      const extractionInfo = extractionMap.get(extractionId);
+      extractionInfo.citations.push({
+        id: citation.id,
+        text: citation.text,
+        sourceRef: citation.sourceRef,
+        path: citation.path,
+        boundingRegions: citation.boundingRegions,
+      });
+    }
+
+    return [...extractionMap.values()];
+  });

package/apps/main/src/routes/_authed/_app/agents/index.tsx

@@ -0,0 +1,65 @@
+import { Container } from "@/components/header/container";
+import { RelDate } from "@sea/ui/components/misc/rel-date";
+import { Button } from "@sea/ui/components/ui/button";
+import { H1, H3 } from "@sea/ui/components/ui/typography";
+import { createFileRoute, Link, useNavigate } from "@tanstack/react-router";
+import { useServerFn } from "@tanstack/react-start";
+import { PlusIcon, TrashIcon } from "lucide-react";
+import { createAgentFn, getAgentConversationsFn } from "./-fns";
+
+export const Route = createFileRoute("/_authed/_app/agents/")({
+  component: AgentsIndex,
+  loader: () => getAgentConversationsFn(),
+});
+
+function AgentsIndex() {
+  const agentConversations = Route.useLoaderData();
+  const crumbs = [{ href: "/agents", label: "Agents" }];
+
+  const navigate = useNavigate();
+  const createAgent = useServerFn(createAgentFn);
+
+  return (
+    <Container crumbs={crumbs} className="overflow-hidden">
+      <div className="flex h-full min-h-0 flex-col">
+        <div className="flex flex-shrink-0 items-center justify-between gap-2 pb-4">
+          <H1>Agents</H1>
+          <div className="flex flex-row gap-2">
+            <Button variant="secondary" onClick={async () => await createAgent()}>
+              <PlusIcon className="mr-2 h-4 w-4" />
+              New Agent
+            </Button>
+          </div>
+        </div>
+        <div className="min-h-0 flex-1">
+          <H3>Recent Conversations</H3>
+          <div className="mt-2 h-full min-h-0 space-y-2 overflow-y-auto">
+            {agentConversations.map((conv) => (
+              <div
+                key={conv.id}
+                className="group/item hover:bg-muted/50 relative cursor-pointer rounded-lg border p-2 transition-colors"
+              >
+                <Link to="/agents/$agentId" params={{ agentId: conv.id }} className="block pr-8">
+                  <p className="mb-1 truncate text-sm font-medium">{conv.name || "New Agent"}</p>
+                  <p className="text-muted-foreground text-xs">
+                    <RelDate date={conv.updatedAt} />
+                  </p>
+                </Link>
+                <Button
+                  variant="ghost"
+                  size="icon"
+                  className="absolute top-1/2 right-1 -translate-y-1/2 opacity-0 transition-opacity group-hover/item:opacity-100"
+                  onClick={async () => {
+                    navigate({ to: "/agents/$agentId", params: { agentId: conv.id } });
+                  }}
+                >
+                  <TrashIcon className="text-destructive" />
+                </Button>
+              </div>
+            ))}
+          </div>
+        </div>
+      </div>
+    </Container>
+  );
+}