@tulip-systems/create-app 0.11.1

package/dist/templates/code/src/app/admin/addresses/_components/create-command.tsx

@@ -0,0 +1,202 @@
+"use client";
+
+import { standardSchemaResolver } from "@hookform/resolvers/standard-schema";
+import type { DefaultError, MutationOptions } from "@tanstack/react-query";
+import {
+  CommandFormDialog,
+  CommandFormDialogCancel,
+  CommandFormDialogContent,
+  CommandFormDialogFields,
+  CommandFormDialogFooter,
+  CommandFormDialogHeader,
+  CommandFormDialogSubmit,
+  CommandFormDialogTitle,
+  CommandFormDialogTrigger,
+} from "@tulip-systems/commands/client";
+import { ComboboxDropdown } from "@tulip-systems/ui/combobox-dropdown";
+import { Input } from "@tulip-systems/ui/input";
+import {
+  Form,
+  FormControl,
+  FormField,
+  FormItem,
+  FormLabel,
+  FormMessage,
+} from "@tulip-systems/ui/react-hook-form";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@tulip-systems/ui/select";
+import type React from "react";
+import { useForm } from "react-hook-form";
+import {
+  ADDRESS_TYPES,
+  countriesComboboxOptions,
+  DEFAULT_ADDRESS_TYPE,
+  DEFAULT_COUNTRY_CODE,
+} from "../_lib/constants";
+import {
+  type CreateAddressInput,
+  type CreateAddressSchema,
+  createAddressSchema,
+} from "../_lib/validators";
+
+export type AddressCreateCommandProps<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = undefined,
+  TOnMutateResult = unknown,
+> = {
+  variables: (values: CreateAddressSchema) => TVariables;
+  mutation: MutationOptions<TData, TError, TVariables, TOnMutateResult>;
+  defaultValues?: Partial<CreateAddressSchema>;
+  children?: React.ReactNode;
+};
+
+export function AddressCreateCommand<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = undefined,
+  TOnMutateResult = unknown,
+>({
+  variables,
+  mutation,
+  defaultValues,
+  children,
+}: AddressCreateCommandProps<TData, TError, TVariables, TOnMutateResult>) {
+  const form = useForm<CreateAddressInput>({
+    resolver: standardSchemaResolver(createAddressSchema),
+    defaultValues: {
+      countryCode: DEFAULT_COUNTRY_CODE,
+      type: DEFAULT_ADDRESS_TYPE,
+      ...defaultValues,
+    },
+  });
+
+  return (
+    <CommandFormDialog>
+      {children}
+
+      <Form {...form}>
+        <CommandFormDialogContent variables={variables} mutation={mutation}>
+          <CommandFormDialogHeader>
+            <CommandFormDialogTitle>Address Toevoegen</CommandFormDialogTitle>
+          </CommandFormDialogHeader>
+
+          <CommandFormDialogFields>
+            <FormField
+              control={form.control}
+              name="type"
+              render={({ field }) => (
+                <FormItem>
+                  <FormLabel>Type</FormLabel>
+                  <Select onValueChange={field.onChange} defaultValue={field.value}>
+                    <FormControl>
+                      <SelectTrigger className="w-full">
+                        <SelectValue placeholder="Kies een type" />
+                      </SelectTrigger>
+                    </FormControl>
+                    <SelectContent>
+                      {ADDRESS_TYPES.map((type) => (
+                        <SelectItem key={type.id} value={type.id}>
+                          {type.value}
+                        </SelectItem>
+                      ))}
+                    </SelectContent>
+                  </Select>
+                  <FormMessage />
+                </FormItem>
+              )}
+            />
+
+            <FormField
+              control={form.control}
+              name="street"
+              render={({ field }) => (
+                <FormItem>
+                  <FormLabel>Straat</FormLabel>
+                  <FormControl>
+                    <Input {...field} />
+                  </FormControl>
+                  <FormMessage />
+                </FormItem>
+              )}
+            />
+
+            <div className="grid grid-cols-1 gap-4 md:grid-cols-2">
+              <FormField
+                control={form.control}
+                name="city"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>Stad</FormLabel>
+                    <FormControl>
+                      <Input {...field} />
+                    </FormControl>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+
+              <FormField
+                control={form.control}
+                name="postalCode"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>Postcode</FormLabel>
+                    <FormControl>
+                      <Input {...field} />
+                    </FormControl>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+            </div>
+
+            <FormField
+              control={form.control}
+              name="countryCode"
+              render={({ field }) => (
+                <FormItem>
+                  <FormLabel>Land</FormLabel>
+                  <FormControl>
+                    <ComboboxDropdown
+                      selectedItem={countriesComboboxOptions.find(({ id }) => id === field.value)}
+                      onSelect={(item) => field.onChange(item.id)}
+                      items={countriesComboboxOptions}
+                    />
+                  </FormControl>
+                  <FormMessage />
+                </FormItem>
+              )}
+            />
+
+            <FormField
+              control={form.control}
+              name="name"
+              render={({ field }) => (
+                <FormItem>
+                  <FormLabel>Naam</FormLabel>
+                  <FormControl>
+                    <Input {...field} value={field.value ?? ""} />
+                  </FormControl>
+                  <FormMessage />
+                </FormItem>
+              )}
+            />
+          </CommandFormDialogFields>
+
+          <CommandFormDialogFooter>
+            <CommandFormDialogCancel>Annuleren</CommandFormDialogCancel>
+            <CommandFormDialogSubmit>Opslaan</CommandFormDialogSubmit>
+          </CommandFormDialogFooter>
+        </CommandFormDialogContent>
+      </Form>
+    </CommandFormDialog>
+  );
+}
+
+export const AddressCreateCommandTrigger = CommandFormDialogTrigger;

package/dist/templates/code/src/app/admin/addresses/_components/grid.tsx

@@ -0,0 +1,67 @@
+import type { CommandFor } from "@tulip-systems/commands";
+import {
+  ContextCommandMenu,
+  ContextCommandMenuContent,
+  ContextCommandMenuTrigger,
+  DropdownCommandMenu,
+} from "@tulip-systems/commands/client";
+import { Badge } from "@tulip-systems/ui/badge";
+import { Card, CardContent, CardHeader, CardTitle } from "@tulip-systems/ui/card";
+import { cn } from "@tulip-systems/ui/cn";
+import { EmptyPage, EmptyPageTitle } from "@tulip-systems/ui/empty";
+import type { ComponentProps } from "react";
+import { COUNTRIES } from "../_lib/constants";
+import type { Address } from "../_lib/validators";
+
+type AddressGridProps = ComponentProps<"div"> & {
+  addresses: Address[];
+  commands?: CommandFor<Address>[];
+};
+
+export function AddressGrid({ commands = [], addresses, className, ...props }: AddressGridProps) {
+  if (!addresses.length) {
+    return (
+      <EmptyPage className="min-h-52">
+        <EmptyPageTitle>Geen adressen aangemaakt</EmptyPageTitle>
+      </EmptyPage>
+    );
+  }
+
+  return (
+    <div
+      {...props}
+      className={cn(
+        "grid @5xl/admin:grid-cols-[repeat(auto-fill,minmax(30rem,1fr))] grid-cols-1 gap-5",
+        className,
+      )}
+    >
+      {addresses.map((address, index) => (
+        <ContextCommandMenu key={address.id}>
+          <ContextCommandMenuTrigger asChild>
+            <Card>
+              <CardHeader>
+                <CardTitle className="flex items-center justify-between gap-2 text-lg">
+                  <span className="flex items-center gap-2">
+                    {address.name || `Adres ${index + 1}`}
+                    <Badge variant="outline">{address.type}</Badge>
+                  </span>
+                  <DropdownCommandMenu data={address} commands={commands} />
+                </CardTitle>
+              </CardHeader>
+
+              <CardContent className="space-y-2 text-sm">
+                <div>{address.street}</div>
+                <div>
+                  {address.postalCode}, {address.city}
+                </div>
+                <div>{COUNTRIES.find((country) => country.code === address.countryCode)?.name}</div>
+              </CardContent>
+            </Card>
+          </ContextCommandMenuTrigger>
+
+          <ContextCommandMenuContent data={address} commands={commands} className="w-[300px]" />
+        </ContextCommandMenu>
+      ))}
+    </div>
+  );
+}

package/dist/templates/code/src/app/admin/addresses/_lib/constants.ts

@@ -0,0 +1,36 @@
+/**
+ * Countries
+ */
+export const COUNTRIES = [
+  { name: "België", code: "BE" },
+  { name: "Nederland", code: "NL" },
+  { name: "Frankrijk", code: "FR" },
+  { name: "Duitsland", code: "DE" },
+  { name: "Luxemburg", code: "LU" },
+];
+
+export const DEFAULT_COUNTRY_CODE = "BE";
+
+export const COUNTRY_CODES = COUNTRIES.flatMap((country) => country.code);
+
+export const countriesComboboxOptions = COUNTRIES.map((country) => ({
+  id: country.code,
+  value: country.name,
+}));
+
+/**
+ * Address types
+ */
+
+export const ADDRESS_TYPES = [
+  { value: "Standaard", id: "default" },
+  { value: "Facturatie", id: "billing" },
+  { value: "Verzending", id: "shipping" },
+  { value: "Overig", id: "other" },
+] as const;
+
+export const DEFAULT_ADDRESS_TYPE = "default";
+
+export type AddressType = (typeof ADDRESS_TYPES)[number];
+
+export const addressTypesComboboxOptions = ADDRESS_TYPES;

package/dist/templates/code/src/app/admin/addresses/_lib/helpers.ts

@@ -0,0 +1,38 @@
+import { ORPCError } from "@orpc/server";
+import type { ExtractTablesWithRelations } from "drizzle-orm";
+import type { NodePgDatabase, NodePgQueryResultHKT } from "drizzle-orm/node-postgres";
+import type { PgTransaction } from "drizzle-orm/pg-core";
+import { addresses } from "./schema";
+import type { Address, CreateAddressSchema } from "./validators";
+
+/**
+ * Create contact
+ */
+export async function createAddress<TSchema extends Record<string, unknown>>(
+  opts: { context: { db: NodePgDatabase<TSchema> }; input: CreateAddressSchema },
+  afterUpdate?: (params: {
+    data: Address;
+    tx: PgTransaction<NodePgQueryResultHKT, TSchema, ExtractTablesWithRelations<TSchema>>;
+  }) => Promise<void>,
+) {
+  return await opts.context.db.transaction(async (tx) => {
+    const [data] = await tx.insert(addresses).values(opts.input).returning();
+
+    if (!data) {
+      throw new ORPCError("INTERNAL_SERVER_ERROR", {
+        message: "Contact kon niet worden toegevoegd",
+      });
+    }
+
+    await afterUpdate?.({ tx, data });
+
+    return data;
+  });
+}
+
+/**
+ * Format address
+ */
+export function formatAddress(address: Address) {
+  return `${address.street}, ${address.postalCode} ${address.city}`;
+}

package/dist/templates/code/src/app/admin/addresses/_lib/router.ts

@@ -0,0 +1,34 @@
+import "server-cli-only";
+
+import { ORPCError } from "@orpc/server";
+import { bulkActionSchema } from "@tulip-systems/query";
+import { eq, inArray } from "drizzle-orm";
+import z from "zod";
+import { addresses } from "@/server/db/schema";
+import { protectedProcedure } from "@/server/router/procedures";
+import { createAddressSchema, updateAddressSchema } from "./validators";
+
+export const addressesRouter = {
+  getAll: protectedProcedure.handler(async ({ context }) => context.db.query.addresses.findMany()),
+  create: protectedProcedure.input(createAddressSchema).handler(async ({ context, input }) => {
+    const [result] = await context.db.insert(addresses).values(input).returning();
+
+    if (!result) {
+      throw new ORPCError("INTERNAL_SERVER_ERROR", {
+        message: "Adres kon niet worden aangemaakt",
+      });
+    }
+
+    return result;
+  }),
+  update: protectedProcedure
+    .input(z.object({ id: z.string(), data: updateAddressSchema.partial() }))
+    .handler(async ({ context, input: { id, data } }) => {
+      await context.db.update(addresses).set(data).where(eq(addresses.id, id));
+    }),
+  delete: protectedProcedure
+    .input(bulkActionSchema)
+    .handler(async ({ context, input: { ids } }) => {
+      await context.db.delete(addresses).where(inArray(addresses.id, ids));
+    }),
+};

package/dist/templates/code/src/app/admin/addresses/_lib/schema.ts

@@ -0,0 +1,13 @@
+import { pgTable } from "drizzle-orm/pg-core";
+import { baseColumns } from "@/server/db/helpers";
+import { DEFAULT_ADDRESS_TYPE } from "./constants";
+
+export const addresses = pgTable("addresses", (t) => ({
+  ...baseColumns,
+  type: t.varchar().default(DEFAULT_ADDRESS_TYPE).notNull(),
+  name: t.varchar(),
+  street: t.varchar().notNull(),
+  city: t.varchar().notNull(),
+  postalCode: t.varchar({ length: 10 }).notNull(),
+  countryCode: t.varchar({ length: 2 }).notNull(),
+}));

package/dist/templates/code/src/app/admin/addresses/_lib/validators.ts

@@ -0,0 +1,26 @@
+import { createInsertSchema } from "drizzle-zod";
+import { z } from "zod";
+import { ADDRESS_TYPES, COUNTRY_CODES } from "./constants";
+import { addresses } from "./schema";
+
+/**
+ * Address type
+ */
+export type Address = typeof addresses.$inferSelect;
+
+/**
+ * Schema
+ */
+export const createAddressSchema = createInsertSchema(addresses).extend({
+  type: z.enum(ADDRESS_TYPES.map((type) => type.id) as [string, ...string[]]),
+  countryCode: z.enum(COUNTRY_CODES as [string, ...string[]]),
+});
+export const updateAddressSchema = createAddressSchema.partial();
+
+/**
+ * Create Address schema
+ */
+export type CreateAddressInput = z.input<typeof createAddressSchema>;
+export type CreateAddressSchema = z.infer<typeof createAddressSchema>;
+export type UpdateAddressInput = z.input<typeof updateAddressSchema>;
+export type UpdateAddressSchema = z.infer<typeof updateAddressSchema>;

package/dist/templates/code/src/app/admin/assistant/(chats)/layout.tsx

@@ -0,0 +1,16 @@
+import { Header, Topbar, TopbarTitle } from "@tulip-systems/app/components/client";
+import type { PropsWithChildren } from "react";
+
+export default function AssistantLayout(props: PropsWithChildren) {
+  return (
+    <>
+      <Header>
+        <Topbar>
+          <TopbarTitle breadcrumbs={[{ label: "Assistant", href: "/admin/assistant" }]} />
+        </Topbar>
+      </Header>
+
+      {props.children}
+    </>
+  );
+}

package/dist/templates/code/src/app/admin/assistant/(chats)/page.tsx

@@ -0,0 +1,122 @@
+"use client";
+
+import { useChat } from "@ai-sdk/react";
+import { eventIteratorToUnproxiedDataStream } from "@orpc/client";
+import {
+  ChatComposer,
+  ChatComposerActions,
+  ChatComposerAttachmentButton,
+  ChatComposerInput,
+  ChatComposerSubmit,
+  ChatComposerToolbar,
+  ChatThread,
+  ChatThreadActivity,
+  ChatThreadContent,
+  ChatThreadMessage,
+  StarterPrompts,
+} from "@tulip-systems/ai/chat/client";
+import type { ChatTransport, UIDataTypes, UIMessage, UITools } from "ai";
+import { useMemo, useState } from "react";
+import { orpc } from "@/server/router/client";
+import { ASSISTANT_STARTER_PROMPTS } from "../_config/starter-prompts";
+import { ASSISTANT_TOOL_CLIENTS } from "../_config/tools.client";
+
+export default function ChatPage() {
+  const transport = useMemo(
+    () =>
+      ({
+        async sendMessages(options) {
+          return eventIteratorToUnproxiedDataStream(
+            await orpc.assistant.chat.call(
+              {
+                chatId: options.chatId,
+                messages: options.messages,
+              },
+              { signal: options.abortSignal },
+            ),
+          );
+        },
+        reconnectToStream: async () => null,
+      }) satisfies ChatTransport<UIMessage<unknown, UIDataTypes, UITools>>,
+    [],
+  );
+
+  const { messages, sendMessage, status } = useChat({ transport });
+  const [input, setInput] = useState("");
+
+  function submitPrompt(prompt: string) {
+    const value = prompt.trim();
+    if (!value || status !== "ready") {
+      return;
+    }
+
+    sendMessage({ text: value });
+    setInput("");
+  }
+
+  return (
+    <div className="relative flex h-[calc(100dvh-var(--header-top-bar-height))] flex-col overflow-hidden bg-background">
+      <ChatThread status={status} className="h-full flex-1">
+        {messages.length === 0 && (
+          <div className="flex h-full flex-1 items-center justify-center py-20">
+            <div className="flex w-full max-w-2xl flex-col items-center gap-8 text-center">
+              <div className="space-y-4">
+                <div className="space-y-3">
+                  <h1 className="text-balance font-semibold text-3xl tracking-tight md:text-4xl">
+                    Waarmee kan ik je vandaag helpen?
+                  </h1>
+                  <p className="mx-auto max-w-xl text-pretty text-muted-foreground text-sm leading-6 md:text-base">
+                    Stel een vraag, laat iets online opzoeken of stuur een sales-gerelateerde taak
+                    door naar de specialistische agent.
+                  </p>
+                </div>
+              </div>
+            </div>
+          </div>
+        )}
+
+        {messages.length > 0 && (
+          <ChatThreadContent>
+            {messages.map((message) => (
+              <ChatThreadMessage
+                key={message.id}
+                message={message}
+                toolRenderers={ASSISTANT_TOOL_CLIENTS}
+              />
+            ))}
+
+            <ChatThreadActivity />
+          </ChatThreadContent>
+        )}
+      </ChatThread>
+
+      <div className="pointer-events-none z-10 flex shrink-0 flex-col gap-8 px-1 pt-6 pb-4 md:pb-6">
+        {messages.length === 0 && (
+          <StarterPrompts
+            prompts={ASSISTANT_STARTER_PROMPTS}
+            disabled={status !== "ready"}
+            onSelect={submitPrompt}
+            className="pointer-events-auto mx-auto max-w-3xl"
+          />
+        )}
+
+        <ChatComposer
+          value={input}
+          onValueChange={setInput}
+          onSubmit={submitPrompt}
+          status={status}
+        >
+          <ChatComposerInput placeholder="Vraag iets, laat online zoeken of schakel de sales agent in..." />
+
+          <ChatComposerToolbar>
+            <ChatComposerActions>
+              <ChatComposerAttachmentButton onClick={() => undefined} />
+            </ChatComposerActions>
+
+            <ChatComposerSubmit />
+          </ChatComposerToolbar>
+        </ChatComposer>
+      </div>
+    </div>
+  );
+}

package/dist/templates/code/src/app/admin/assistant/_config/starter-prompts.ts

@@ -0,0 +1,16 @@
+export const ASSISTANT_STARTER_PROMPTS = [
+  "Controleer of Linear al in CRM bestaat. Als er geen match is, kwalificeer Linear als potentiële prospect en benoem ontbrekende informatie.",
+  "Maak een projectvoorstel voor een klantportaal: project, eerste initiatief en een takenplan. Maak nog niets aan zonder mijn akkoord.",
+  "Welke projecten hebben deze maand de meeste tijd gekost? Geef de top 5 met korte interpretatie.",
+  "Zoek in Drive naar documentatie voor een klantportaal en vat de relevante folders of bestanden samen.",
+];
+
+export const ASSISTANT_SIDEPANEL_STARTER_PROMPTS = [
+  "Controleer of een bedrijf of e-mailadres al in CRM bestaat.",
+  "Kwalificeer een nieuwe lead en benoem welke CRM-info nog ontbreekt.",
+  "Zoek een project en vat de delivery-context samen.",
+  "Welke projecten of klanten vragen deze maand de meeste tijd?",
+  "Analyseer de gezondheid van een initiatief op basis van tijd en story points.",
+  "Zoek relevante Drive-documentatie voor deze klant of dit project.",
+  "Controleer of er al een Drive-folder bestaat voordat je er één aanmaakt.",
+];

package/dist/templates/code/src/app/admin/assistant/_config/tools.client.tsx

@@ -0,0 +1,43 @@
+"use client";
+
+import { delegateToDeliveryToolClient } from "@/server/agents/assistant/tools/delegate_to_delivery/tool.client";
+import { delegateToKnowledgeToolClient } from "@/server/agents/assistant/tools/delegate_to_knowledge/tool.client";
+import { delegateToOperationsToolClient } from "@/server/agents/assistant/tools/delegate_to_operations/tool.client";
+import { delegateToSalesToolClient } from "@/server/agents/assistant/tools/delegate_to_sales/tool.client";
+import { bulkCreateTasksToolClient } from "@/server/agents/delivery/tools/bulk_create_tasks/tool.client";
+import { createInitiativeToolClient } from "@/server/agents/delivery/tools/create_initiative/tool.client";
+import { createProjectToolClient } from "@/server/agents/delivery/tools/create_project/tool.client";
+import { getProjectContextToolClient } from "@/server/agents/delivery/tools/get_project_context/tool.client";
+import { searchDeliveryRecordsToolClient } from "@/server/agents/delivery/tools/search_delivery_records/tool.client";
+import { createDriveFolderToolClient } from "@/server/agents/knowledge/tools/create_drive_folder/tool.client";
+import { getDriveFolderContextToolClient } from "@/server/agents/knowledge/tools/get_drive_folder_context/tool.client";
+import { searchDriveNodesToolClient } from "@/server/agents/knowledge/tools/search_drive_nodes/tool.client";
+import { getInitiativeHealthToolClient } from "@/server/agents/operations/tools/get_initiative_health/tool.client";
+import { summarizeTimeEntriesToolClient } from "@/server/agents/operations/tools/summarize_time_entries/tool.client";
+import { createProspectToolClient } from "@/server/agents/sales/tools/create_prospect/tool.client";
+import { createProspectContactToolClient } from "@/server/agents/sales/tools/create_prospect_contact/tool.client";
+import { findDuplicateCrmRecordsToolClient } from "@/server/agents/sales/tools/find_duplicate_crm_records/tool.client";
+import { searchCrmRecordsToolClient } from "@/server/agents/sales/tools/search_crm_records/tool.client";
+import { webSearchToolClient } from "@/server/agents/tools/web_search/tool.client";
+
+export const ASSISTANT_TOOL_CLIENTS = [
+  webSearchToolClient,
+  delegateToDeliveryToolClient,
+  delegateToKnowledgeToolClient,
+  delegateToOperationsToolClient,
+  delegateToSalesToolClient,
+  searchDeliveryRecordsToolClient,
+  getProjectContextToolClient,
+  createProjectToolClient,
+  createInitiativeToolClient,
+  bulkCreateTasksToolClient,
+  searchDriveNodesToolClient,
+  getDriveFolderContextToolClient,
+  createDriveFolderToolClient,
+  summarizeTimeEntriesToolClient,
+  getInitiativeHealthToolClient,
+  searchCrmRecordsToolClient,
+  findDuplicateCrmRecordsToolClient,
+  createProspectToolClient,
+  createProspectContactToolClient,
+];

package/dist/templates/code/src/app/admin/assistant/_lib/providers.ts

@@ -0,0 +1,10 @@
+import { createOpenRouter } from "@openrouter/ai-sdk-provider";
+import { env } from "@/env";
+
+/**
+ * OpenRouter provider for Eve. This provider allows you to use OpenRouter models in your Eve agents.
+ */
+export const openrouter = createOpenRouter({
+  apiKey: env.OPENROUTER_API_KEY,
+  compatibility: "strict",
+});

package/dist/templates/code/src/app/admin/assistant/_lib/router.ts

@@ -0,0 +1,33 @@
+import { type } from "@orpc/server";
+import {
+  type AgentContextSnapshot,
+  streamAgentChatEventIterator,
+} from "@tulip-systems/ai/chat/server";
+import type { UIMessage } from "ai";
+import { assistantAgent } from "@/server/agents/assistant/agent";
+import { publicProcedure } from "@/server/router/procedures";
+
+export const assistantRouter = {
+  chat: publicProcedure
+    .input(type<{ chatId: string; messages: UIMessage[] }>())
+    .handler(({ input, signal }) =>
+      streamAgentChatEventIterator({
+        agent: assistantAgent,
+        messages: input.messages,
+        options: {},
+        abortSignal: signal,
+      }),
+    ),
+  sidepanel: publicProcedure
+    .input(type<{ chatId: string; messages: UIMessage[]; context: AgentContextSnapshot }>())
+    .handler(({ input, signal }) => {
+      return streamAgentChatEventIterator({
+        agent: assistantAgent,
+        messages: input.messages,
+        options: {
+          context: input.context,
+        },
+        abortSignal: signal,
+      });
+    }),
+};