@tulip-systems/create-app 0.11.1

package/dist/templates/code/src/server/agents/sales/instructions.ts

@@ -0,0 +1,162 @@
+export const instructions = `# Sales Agent
+
+Je bent de sales- en CRM-specialist voor de Tulip admin workspace. Je helpt met prospects, leads, contactpersonen, kwalificatie, opvolging en CRM-intake.
+
+Je belangrijkste doel is betrouwbare CRM-acties voorbereiden en uitvoeren zonder duplicaten, onduidelijke aannames of ongewenste mutaties te veroorzaken.
+
+## Kernprincipes
+
+- Werk feitelijk, zorgvuldig en praktisch.
+- Gebruik CRM-tools voor feitelijke claims over bestaande klanten, prospects en contactpersonen.
+- Maak duidelijk onderscheid tussen feiten uit tools, aannames, interpretaties en open vragen.
+- Stel maximaal één gerichte verduidelijkingsvraag wanneer essentiële informatie ontbreekt.
+- Gebruik Nederlands, tenzij de gebruiker of hoofdassistent expliciet in een andere taal werkt.
+- Geef geen ruwe tool-output terug; vat resultaten begrijpelijk samen.
+- Verzin nooit CRM-records, toolresultaten, contactgegevens, websites, statussen of uitgevoerde acties.
+
+## Beschikbare Tools
+
+### \`search_crm_records\`
+
+Gebruik deze tool om bestaande klanten, prospects en contactpersonen te zoeken op naam, e-mail, telefoon, website, domein of andere herkenbare zoektekst.
+
+Gebruik deze tool wanneer:
+
+- de gebruiker vraagt of iets al bestaat in CRM
+- je een prospect, klant of contactpersoon moet identificeren
+- je een \`prospectId\` nodig hebt voor een vervolgactie
+- je context nodig hebt voordat je advies geeft over een lead
+
+### \`find_duplicate_crm_records\`
+
+Gebruik deze tool altijd voordat je een nieuwe prospect aanmaakt. Gebruik hem ook voordat je een contactpersoon aanmaakt als naam, e-mail of telefoon mogelijk al bekend is.
+
+Gebruik de sterkste beschikbare signalen:
+
+- naam
+- e-mail
+- website of domein
+- telefoon
+- btw-nummer
+
+### \`create_prospect\`
+
+Gebruik deze tool alleen wanneer:
+
+- de gebruiker expliciet vraagt om een prospect aan te maken
+- je eerst duplicaten hebt gecontroleerd
+- er geen waarschijnlijke duplicate is, of de gebruiker expliciet kiest om toch door te gaan
+- minimaal de bedrijfsnaam bekend is
+
+### \`create_prospect_contact\`
+
+Gebruik deze tool alleen wanneer:
+
+- de gebruiker expliciet vraagt om een contactpersoon toe te voegen
+- de doelprospect duidelijk is
+- je het juiste \`prospectId\` kent
+- minimaal voornaam, achternaam en e-mailadres bekend zijn
+
+## CRM Lookup Workflow
+
+Voor vragen over bestaande CRM-data:
+
+- Zoek met \`search_crm_records\`.
+- Vat de meest relevante matches samen.
+- Noem type record: klant, prospect of contactpersoon.
+- Benoem wanneer niets gevonden is.
+- Vraag pas om extra informatie als de zoekresultaten te breed of ambigu zijn.
+
+## Prospect Creation Workflow
+
+Volg deze volgorde strikt:
+
+- Verzamel minimaal bedrijfsnaam; verzamel indien beschikbaar website, e-mail, telefoon, btw-nummer, bron en context.
+- Roep \`find_duplicate_crm_records\` aan met de beste beschikbare signalen.
+- Als er waarschijnlijke duplicates zijn, maak niets aan. Vat de matches samen en vraag wat de gebruiker wil doen.
+- Als er geen waarschijnlijke duplicate is en de gebruiker vroeg expliciet om creatie, roep \`create_prospect\` aan.
+- Na creatie: vat kort samen welke prospect is aangemaakt en welke belangrijke velden ontbreken.
+
+Maak nooit een prospect aan zonder duplicate check.
+
+## Prospect Contact Workflow
+
+Volg deze volgorde strikt:
+
+- Bepaal eerst de doelprospect. Zoek met \`search_crm_records\` als de prospect niet eenduidig bekend is.
+- Verzamel minimaal voornaam, achternaam en e-mailadres.
+- Controleer mogelijke duplicaten met \`find_duplicate_crm_records\` wanneer naam, e-mail of telefoon beschikbaar is.
+- Als er een waarschijnlijke bestaande contactpersoon is, maak niets aan en vraag bevestiging.
+- Als de doelprospect en contactgegevens duidelijk zijn en de gebruiker vroeg expliciet om toevoeging, roep \`create_prospect_contact\` aan.
+- Na creatie: vat kort samen welke contactpersoon is toegevoegd en aan welke prospect.
+
+## Lead Qualification
+
+Kwalificeer leads op basis van concrete informatie. Verzamel of benoem ontbrekende velden:
+
+- bedrijf of organisatie
+- website of domein
+- algemeen e-mailadres of telefoonnummer
+- contactpersoon, rol en contactgegevens
+- bron van de lead
+- behoefte of probleem
+- timing of urgentie
+- mogelijke waarde of fit
+- voorgestelde volgende stap
+
+Gebruik een compacte kwalificatiesamenvatting:
+
+- Fit: hoog, gemiddeld, laag of onbekend
+- Reden: maximaal drie concrete punten
+- Ontbreekt: belangrijkste ontbrekende velden
+- Volgende stap: één praktische actie
+
+## Mutatie- en Dataveiligheid
+
+- Maak of wijzig CRM-records alleen wanneer de gebruiker expliciet om die actie vraagt.
+- Beschouw alle creaties en updates als gevoelige business acties.
+- Maak nooit automatisch duplicaten aan.
+- Overschrijf nooit bestaande klant- of prospectdata zonder expliciete instructie.
+- Als een tool faalt, zeg wat niet gelukt is en welke minimale informatie of actie nodig is.
+- Zeg nooit dat iets is aangemaakt, gekoppeld of gewijzigd tenzij de tool dat bevestigt.
+- Als informatie gedeeltelijk ontbreekt, kun je een concept voorstellen maar moet je ontbrekende velden expliciet benoemen.
+
+## Follow-up Advies
+
+Wanneer de gebruiker om opvolging vraagt:
+
+- Baseer het advies op beschikbare feiten en benoem aannames.
+- Kies één duidelijke volgende stap: e-mail, telefoontje, discovery call, extra onderzoek of wachten.
+- Houd conceptmails kort, professioneel en concreet.
+- Vraag om ontbrekende personalisatiegegevens wanneer die nodig zijn voor een goede e-mail.
+
+## Antwoordstijl
+
+- Schrijf professioneel, helder en beknopt.
+- Begin met de uitkomst of aanbeveling.
+- Gebruik bullets wanneer je matches, ontbrekende velden of vervolgstappen opsomt.
+- Vermijd interne toolnamen in het eindantwoord, tenzij de gebruiker technische details vraagt.
+- Benoem onzekerheid expliciet wanneer data ontbreekt of matches niet eenduidig zijn.
+
+## Antwoordpatronen
+
+Voor CRM-zoekvragen:
+
+- Gevonden: korte lijst met relevante matches
+- Interpretatie: wat dit betekent
+- Volgende stap: wat de gebruiker kan doen
+
+Voor prospectcreatie:
+
+- Duplicate check: geen match of relevante matches
+- Actie: aangemaakt of niet aangemaakt
+- Ontbreekt: velden die later aangevuld kunnen worden
+- Volgende stap: aanbevolen salesactie
+
+Voor kwalificatie:
+
+- Fit
+- Feiten
+- Aannames
+- Ontbrekende informatie
+- Volgende stap`;

package/dist/templates/code/src/server/agents/sales/skills/review_prospect.md

@@ -0,0 +1,9 @@
+# Review Prospect
+
+Voordat een prospect wordt aangemaakt:
+
+- controleer mogelijke duplicaten in prospects, klanten en contacten
+- overschrijf nooit automatisch bestaande klantdata
+- maak een nieuwe prospect alleen aan na menselijke goedkeuring
+- maak duidelijk onderscheid tussen feiten, interpretaties en open vragen
+- als de contactpersoon onvolledig is, maak de prospect wel voorstelbaar maar meld waarom het contact niet volledig kan worden aangemaakt

package/dist/templates/code/src/server/agents/sales/tools/create_prospect/tool.client.tsx

@@ -0,0 +1,21 @@
+"use client";
+
+import { ToolCallCard } from "@tulip-systems/ai/chat/client";
+import { defineToolClient } from "@tulip-systems/ai/tools/client";
+import { UserPlus } from "lucide-react";
+import type { createProspect } from "./tool.server";
+
+export const createProspectToolClient = defineToolClient<typeof createProspect>({
+  toolName: "create_prospect",
+  render: (part) => (
+    <ToolCallCard
+      part={part}
+      title="Prospect aanmaken"
+      icon={<UserPlus className="size-3.5" />}
+      labels={{
+        output: "Aangemaakte prospect",
+        preliminaryOutput: "Tussentijds resultaat",
+      }}
+    />
+  ),
+});

package/dist/templates/code/src/server/agents/sales/tools/create_prospect/tool.server.ts

@@ -0,0 +1,64 @@
+import { ORPCError } from "@orpc/server";
+import { json } from "@tulip-systems/ai/mcp/server";
+import { defineTool, resolveAgentTool, resolveMCPTool } from "@tulip-systems/ai/tools/server";
+import z from "zod";
+import { prospectSchema } from "@/app/admin/prospects/_lib/validators";
+import { db } from "@/server/db/init";
+import { prospects } from "@/server/db/schema";
+
+export const createProspect = defineTool({
+  name: "create_prospect",
+  title: "Create Prospect",
+  description:
+    "Creates a new prospect in the database. This tool should only be used after duplicate checks and explicit user approval.",
+  inputSchema: z.object({
+    prospect: z.object({
+      name: z.string().min(1).describe("The name of the prospect."),
+      tradeName: z.string().min(1).optional().describe("Optional trading name."),
+      vat: z.string().min(1).optional().describe("Optional VAT number."),
+      website: z.string().url().optional().describe("The prospect website."),
+      email: z.string().email().optional().describe("The general prospect email address."),
+      phone: z.string().min(1).optional().describe("The general prospect phone number."),
+      source: z.string().min(1).optional().describe("Where this lead came from."),
+    }),
+  }),
+  outputSchema: z.object({
+    prospect: prospectSchema,
+  }),
+  async execute(input) {
+    const [prospect] = await db.insert(prospects).values(input.prospect).returning();
+
+    if (!prospect) {
+      throw new ORPCError("INTERNAL_SERVER_ERROR", {
+        message: "Prospect kon niet worden aangemaakt",
+      });
+    }
+
+    return {
+      prospect,
+    };
+  },
+});
+
+export const createProspectTool = resolveAgentTool(createProspect, {
+  permissions: ["prospects:create"],
+  confirmation: {
+    required: true,
+    title: "Create prospect?",
+    description: "Review the prospect details before creating a new CRM record.",
+  },
+  audit: {
+    action: "prospect.create",
+    resource: "prospect",
+    severity: "medium",
+  },
+  ui: {
+    label: "Create prospect",
+    icon: "user-plus",
+  },
+});
+
+export const createProspectMCPTool = resolveMCPTool(createProspect, {
+  description: "Create a new prospect in the CRM.",
+  content: ({ output }) => json(output, { label: "Created prospect:" }),
+});

package/dist/templates/code/src/server/agents/sales/tools/create_prospect_contact/tool.client.tsx

@@ -0,0 +1,22 @@
+"use client";
+
+import { ToolCallCard } from "@tulip-systems/ai/chat/client";
+import { defineToolClient } from "@tulip-systems/ai/tools/client";
+import { Contact } from "lucide-react";
+import type { createProspectContact } from "./tool.server";
+
+export const createProspectContactToolClient = defineToolClient<typeof createProspectContact>({
+  toolName: "create_prospect_contact",
+  render: (part) => (
+    <ToolCallCard
+      part={part}
+      title="Prospect contact aanmaken"
+      icon={<Contact className="size-3.5" />}
+      labels={{
+        input: "Contactgegevens",
+        output: "Aangemaakt contact",
+        preliminaryOutput: "Tussentijds resultaat",
+      }}
+    />
+  ),
+});

package/dist/templates/code/src/server/agents/sales/tools/create_prospect_contact/tool.server.ts

@@ -0,0 +1,107 @@
+import "server-cli-only";
+
+import { ORPCError } from "@orpc/server";
+import { defineTool, resolveAgentTool } from "@tulip-systems/ai/tools/server";
+import { eq } from "drizzle-orm";
+import z from "zod";
+import { contacts } from "@/app/admin/contacts/_lib/schema";
+import { prospects, prospectsContacts } from "@/app/admin/prospects/_lib/schema";
+import { db } from "@/server/db/init";
+
+const prospectContactSchema = z.object({
+  id: z.string(),
+  prospectId: z.string(),
+  contact: z.object({
+    id: z.string(),
+    name: z.string(),
+    firstName: z.string(),
+    lastName: z.string(),
+    email: z.string(),
+    phone: z.string().nullable(),
+    position: z.string().nullable(),
+  }),
+});
+
+export const createProspectContact = defineTool({
+  name: "create_prospect_contact",
+  title: "Create Prospect Contact",
+  description:
+    "Create a contact person and link it to an existing prospect. Use only after the user approves adding the contact.",
+  inputSchema: z.object({
+    prospectId: z.string().uuid().describe("The prospect to attach the contact to."),
+    firstName: z.string().trim().min(1),
+    lastName: z.string().trim().min(1),
+    email: z.string().trim().email(),
+    phone: z.string().trim().min(1).optional(),
+    position: z.string().trim().min(1).optional(),
+  }),
+  outputSchema: prospectContactSchema,
+  async execute(input) {
+    const [prospect] = await db
+      .select({ id: prospects.id })
+      .from(prospects)
+      .where(eq(prospects.id, input.prospectId));
+
+    if (!prospect) {
+      throw new ORPCError("NOT_FOUND", {
+        message: "Prospect niet gevonden",
+      });
+    }
+
+    const result = await db.transaction(async (tx) => {
+      const [contact] = await tx
+        .insert(contacts)
+        .values({
+          firstName: input.firstName,
+          lastName: input.lastName,
+          email: input.email,
+          phone: input.phone,
+          position: input.position,
+        })
+        .returning();
+
+      if (!contact) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Contact kon niet worden aangemaakt",
+        });
+      }
+
+      const [link] = await tx
+        .insert(prospectsContacts)
+        .values({ prospectId: input.prospectId, contactId: contact.id })
+        .returning();
+
+      if (!link) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Contact kon niet aan prospect gekoppeld worden",
+        });
+      }
+
+      return { link, contact };
+    });
+
+    return {
+      id: result.link.id,
+      prospectId: input.prospectId,
+      contact: result.contact,
+    };
+  },
+});
+
+export const createProspectContactTool = resolveAgentTool(createProspectContact, {
+  permissions: ["prospect:update"],
+  confirmation: {
+    required: true,
+    title: "Create prospect contact?",
+    description: "Review the contact details before linking them to this prospect.",
+  },
+  audit: {
+    action: "prospect.contact.create",
+    resource: "prospect",
+    severity: "medium",
+  },
+  ui: {
+    label: "Create prospect contact",
+    icon: "contact",
+  },
+});

package/dist/templates/code/src/server/agents/sales/tools/find_duplicate_crm_records/tool.client.tsx

@@ -0,0 +1,22 @@
+"use client";
+
+import { ToolCallCard } from "@tulip-systems/ai/chat/client";
+import { defineToolClient } from "@tulip-systems/ai/tools/client";
+import { CopyCheck } from "lucide-react";
+import type { findDuplicateCrmRecords } from "./tool.server";
+
+export const findDuplicateCrmRecordsToolClient = defineToolClient<typeof findDuplicateCrmRecords>({
+  toolName: "find_duplicate_crm_records",
+  render: (part) => (
+    <ToolCallCard
+      part={part}
+      title="Duplicaten controleren"
+      icon={<CopyCheck className="size-3.5" />}
+      labels={{
+        input: "Controle",
+        output: "Mogelijke duplicaten",
+        preliminaryOutput: "Tussentijds resultaat",
+      }}
+    />
+  ),
+});

package/dist/templates/code/src/server/agents/sales/tools/find_duplicate_crm_records/tool.server.ts

@@ -0,0 +1,248 @@
+import "server-cli-only";
+
+import { defineTool, resolveAgentTool } from "@tulip-systems/ai/tools/server";
+import { asc, ilike, or, type SQL } from "drizzle-orm";
+import z from "zod";
+import { contacts } from "@/app/admin/contacts/_lib/schema";
+import { customers } from "@/app/admin/customers/_lib/schema";
+import { prospects } from "@/app/admin/prospects/_lib/schema";
+import { db } from "@/server/db/init";
+
+type TextColumn = Parameters<typeof ilike>[0];
+
+const duplicateRecordSchema = z.object({
+  id: z.string(),
+  type: z.enum(["customer", "prospect", "contact"]),
+  name: z.string(),
+  email: z.string().nullable(),
+  phone: z.string().nullable(),
+  website: z.string().nullable(),
+  confidence: z.enum(["high", "medium", "low"]),
+  reason: z.string(),
+});
+
+const duplicateInputSchema = z
+  .object({
+    name: z.string().trim().min(1).optional(),
+    email: z.string().trim().email().optional(),
+    website: z.string().trim().url().optional(),
+    phone: z.string().trim().min(1).optional(),
+    vat: z.string().trim().min(1).optional(),
+    limit: z.number().int().min(1).max(10).default(5),
+  })
+  .refine(
+    ({ name, email, website, phone, vat }) => Boolean(name || email || website || phone || vat),
+    {
+      message: "Provide at least one duplicate signal: name, email, website, phone, or VAT.",
+    },
+  );
+
+export const findDuplicateCrmRecords = defineTool({
+  name: "find_duplicate_crm_records",
+  title: "Find Duplicate CRM Records",
+  description:
+    "Check customers, prospects, and contacts for likely duplicates before creating a new CRM record.",
+  inputSchema: duplicateInputSchema,
+  outputSchema: z.object({
+    hasLikelyDuplicate: z.boolean(),
+    matches: z.array(duplicateRecordSchema),
+  }),
+  async execute(input) {
+    const websiteDomain = input.website ? getHostname(input.website) : null;
+    const customerWhere = or(
+      ...getCompanyDuplicateConditions({
+        name: customers.name,
+        tradeName: customers.tradeName,
+        email: customers.email,
+        phone: customers.phone,
+        website: customers.website,
+        vat: customers.vat,
+        input,
+        websiteDomain,
+      }),
+    );
+    const prospectWhere = or(
+      ...getCompanyDuplicateConditions({
+        name: prospects.name,
+        tradeName: prospects.tradeName,
+        email: prospects.email,
+        phone: prospects.phone,
+        website: prospects.website,
+        vat: prospects.vat,
+        input,
+        websiteDomain,
+      }),
+    );
+    const contactConditions = [
+      input.name ? ilike(contacts.name, `%${input.name}%`) : undefined,
+      input.email ? ilike(contacts.email, input.email) : undefined,
+      input.phone ? ilike(contacts.phone, `%${input.phone}%`) : undefined,
+    ].filter((condition): condition is SQL => Boolean(condition));
+
+    const [customerRows, prospectRows, contactRows] = await Promise.all([
+      db
+        .select({
+          id: customers.id,
+          name: customers.name,
+          email: customers.email,
+          phone: customers.phone,
+          website: customers.website,
+        })
+        .from(customers)
+        .where(customerWhere)
+        .orderBy(asc(customers.name))
+        .limit(input.limit),
+      db
+        .select({
+          id: prospects.id,
+          name: prospects.name,
+          email: prospects.email,
+          phone: prospects.phone,
+          website: prospects.website,
+        })
+        .from(prospects)
+        .where(prospectWhere)
+        .orderBy(asc(prospects.name))
+        .limit(input.limit),
+      contactConditions.length > 0
+        ? db
+            .select({
+              id: contacts.id,
+              name: contacts.name,
+              email: contacts.email,
+              phone: contacts.phone,
+            })
+            .from(contacts)
+            .where(or(...contactConditions))
+            .orderBy(asc(contacts.name))
+            .limit(input.limit)
+        : Promise.resolve([]),
+    ]);
+
+    const matches = [
+      ...customerRows.map((record) => ({
+        ...record,
+        type: "customer" as const,
+        confidence: getConfidence(input, record),
+        reason: getMatchReason(input, record),
+      })),
+      ...prospectRows.map((record) => ({
+        ...record,
+        type: "prospect" as const,
+        confidence: getConfidence(input, record),
+        reason: getMatchReason(input, record),
+      })),
+      ...contactRows.map((record) => ({
+        ...record,
+        type: "contact" as const,
+        website: null,
+        confidence: getConfidence(input, record),
+        reason: getMatchReason(input, record),
+      })),
+    ];
+
+    return {
+      hasLikelyDuplicate: matches.some((match) => match.confidence !== "low"),
+      matches,
+    };
+  },
+});
+
+export const findDuplicateCrmRecordsTool = resolveAgentTool(findDuplicateCrmRecords, {
+  permissions: ["customer:view", "prospect:view", "contact:view"],
+  ui: {
+    label: "Find duplicate CRM records",
+    icon: "copy-check",
+  },
+});
+
+function getCompanyDuplicateConditions({
+  name,
+  tradeName,
+  email,
+  phone,
+  website,
+  vat,
+  input,
+  websiteDomain,
+}: {
+  name: TextColumn;
+  tradeName: TextColumn;
+  email: TextColumn;
+  phone: TextColumn;
+  website: TextColumn;
+  vat: TextColumn;
+  input: z.infer<typeof duplicateInputSchema>;
+  websiteDomain: string | null;
+}) {
+  return [
+    input.name ? ilike(name, `%${input.name}%`) : undefined,
+    input.name ? ilike(tradeName, `%${input.name}%`) : undefined,
+    input.email ? ilike(email, input.email) : undefined,
+    input.phone ? ilike(phone, `%${input.phone}%`) : undefined,
+    input.vat ? ilike(vat, input.vat) : undefined,
+    websiteDomain ? ilike(website, `%${websiteDomain}%`) : undefined,
+  ].filter((condition): condition is SQL => Boolean(condition));
+}
+
+function getConfidence(
+  input: z.infer<typeof duplicateInputSchema>,
+  record: { name: string; email: string | null; phone: string | null; website?: string | null },
+) {
+  const normalizedEmail = input.email?.toLowerCase();
+  const normalizedRecordEmail = record.email?.toLowerCase();
+  const inputDomain = input.website ? getHostname(input.website) : null;
+  const recordDomain = record.website ? getHostname(record.website) : null;
+
+  if (normalizedEmail && normalizedRecordEmail === normalizedEmail) {
+    return "high" as const;
+  }
+  if (inputDomain && recordDomain === inputDomain) {
+    return "high" as const;
+  }
+  if (input.phone && record.phone?.includes(input.phone)) {
+    return "medium" as const;
+  }
+  if (input.name && record.name.toLowerCase().includes(input.name.toLowerCase())) {
+    return "medium" as const;
+  }
+  return "low" as const;
+}
+
+function getMatchReason(
+  input: z.infer<typeof duplicateInputSchema>,
+  record: { name: string; email: string | null; phone: string | null; website?: string | null },
+) {
+  const reasons = [];
+  const inputDomain = input.website ? getHostname(input.website) : null;
+  const recordDomain = record.website ? getHostname(record.website) : null;
+
+  if (input.email && record.email?.toLowerCase() === input.email.toLowerCase()) {
+    reasons.push("same email");
+  }
+  if (inputDomain && recordDomain === inputDomain) {
+    reasons.push("same website domain");
+  }
+  if (input.phone && record.phone?.includes(input.phone)) {
+    reasons.push("similar phone");
+  }
+  if (input.name && record.name.toLowerCase().includes(input.name.toLowerCase())) {
+    reasons.push("similar name");
+  }
+
+  return reasons.join(", ") || "possible CRM match";
+}
+
+function getHostname(value: string) {
+  try {
+    return new URL(value).hostname.replace(/^www\./, "").toLowerCase();
+  } catch {
+    return (
+      value
+        .replace(/^https?:\/\//, "")
+        .replace(/^www\./, "")
+        .split("/")[0]
+        ?.toLowerCase() ?? value
+    );
+  }
+}

package/dist/templates/code/src/server/agents/sales/tools/search_crm_records/tool.client.tsx

@@ -0,0 +1,22 @@
+"use client";
+
+import { ToolCallCard } from "@tulip-systems/ai/chat/client";
+import { defineToolClient } from "@tulip-systems/ai/tools/client";
+import { Search } from "lucide-react";
+import type { searchCrmRecords } from "./tool.server";
+
+export const searchCrmRecordsToolClient = defineToolClient<typeof searchCrmRecords>({
+  toolName: "search_crm_records",
+  render: (part) => (
+    <ToolCallCard
+      part={part}
+      title="CRM records zoeken"
+      icon={<Search className="size-3.5" />}
+      labels={{
+        input: "Zoekopdracht",
+        output: "Gevonden records",
+        preliminaryOutput: "Tussentijds resultaat",
+      }}
+    />
+  ),
+});