diff --git a/apps/web/__tests__/ai-choose-args.test.ts b/apps/web/__tests__/ai-choose-args.test.ts
new file mode 100644
index 0000000000..0afce1c620
--- /dev/null
+++ b/apps/web/__tests__/ai-choose-args.test.ts
@@ -0,0 +1,212 @@
+import { describe, expect, test, vi } from "vitest";
+import { getActionItemsWithAiArgs } from "@/utils/ai/choose-rule/ai-choose-args";
+import { type Action, ActionType, RuleType } from "@prisma/client";
+
+vi.mock("server-only", () => ({}));
+
+describe("getActionItemsWithAiArgs", () => {
+  test("should return actions unchanged when no AI args needed", async () => {
+    const actions = [getAction({})];
+    const rule = getRule("Test rule", actions);
+
+    const result = await getActionItemsWithAiArgs({
+      email: getEmail(),
+      user: getUser(),
+      selectedRule: rule,
+    });
+
+    expect(result).toEqual(actions);
+  });
+
+  test("should return actions unchanged when no variables to fill", async () => {
+    const actions = [
+      getAction({
+        type: ActionType.REPLY,
+        content: "You can set a meeting with me here: https://cal.com/alice",
+      }),
+    ];
+    const rule = getRule("Choose this rule for meeting requests", actions);
+
+    const result = await getActionItemsWithAiArgs({
+      email: getEmail({
+        subject: "Quick question",
+        content: "When is the meeting tomorrow?",
+      }),
+      user: getUser(),
+      selectedRule: rule,
+    });
+
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject(actions[0]);
+  });
+
+  test("should generate AI content for actions that need it", async () => {
+    const actions = [
+      getAction({
+        type: ActionType.REPLY,
+        content:
+          "The price of pears is: {{the price with the dollar sign - pears are $1.99, apples are $2.99}}",
+      }),
+    ];
+    const rule = getRule(
+      "Choose this when the price of an items is asked for",
+      actions,
+    );
+
+    const result = await getActionItemsWithAiArgs({
+      email: getEmail({
+        subject: "Quick question",
+        content: "How much are pears?",
+      }),
+      user: getUser(),
+      selectedRule: rule,
+    });
+
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({
+      ...actions[0],
+      content: "The price of pears is: $1.99",
+    });
+    console.debug("Generated content:\n", result[0].content);
+  });
+
+  test("should handle multiple actions with mixed AI needs", async () => {
+    const actions = [
+      getAction({
+        content: "Write a professional response",
+      }),
+      getAction({}),
+    ];
+    const rule = getRule("Test rule", actions);
+
+    const result = await getActionItemsWithAiArgs({
+      email: getEmail({
+        subject: "Project status",
+        content: "Can you update me on the project status?",
+      }),
+      user: getUser(),
+      selectedRule: rule,
+    });
+
+    expect(result).toHaveLength(2);
+    expect(result[0].content).toBeTruthy();
+    expect(result[1]).toEqual(actions[1]);
+  });
+
+  test("should handle multiple variables with specific formatting", async () => {
+    const actions = [
+      getAction({
+        type: ActionType.LABEL,
+        label: "{{fruit}}",
+      }),
+      getAction({
+        type: ActionType.REPLY,
+        content: `Hey {{name}},
+
+{{$10 for apples, $20 for pears}}
+
+Best,
+Matt`,
+      }),
+    ];
+    const rule = getRule(
+      "Use this when someone asks about the price of fruits",
+      actions,
+    );
+
+    const result = await getActionItemsWithAiArgs({
+      email: getEmail({
+        from: "jill@example.com",
+        subject: "fruits",
+        content: "how much do apples cost?",
+      }),
+      user: getUser(),
+      selectedRule: rule,
+    });
+
+    expect(result).toHaveLength(2);
+
+    // Check label action
+    expect(result[0].label).toBeTruthy();
+    expect(result[0].label).not.toContain("{{");
+    expect(result[0].label).toMatch(/apple(s)?/i);
+
+    // Check reply action
+    expect(result[1].content).toMatch(/^Hey [Jj]ill,/); // Match "Hey Jill," or "Hey jill,"
+    expect(result[1].content).toContain("$10");
+    expect(result[1].content).toContain("Best,\nMatt");
+    expect(result[1].content).not.toContain("{{");
+    expect(result[1].content).not.toContain("}}");
+
+    console.debug("Generated label:\n", result[0].label);
+    console.debug("Generated content:\n", result[1].content);
+  });
+});
+
+// helpers
+function getAction(action: Partial<Action> = {}): Action {
+  return {
+    id: "a123",
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    type: ActionType.REPLY,
+    ruleId: "ruleId",
+    label: null,
+    subject: null,
+    content: null,
+    to: null,
+    cc: null,
+    bcc: null,
+    labelPrompt: null,
+    subjectPrompt: null,
+    contentPrompt: null,
+    toPrompt: null,
+    ccPrompt: null,
+    bccPrompt: null,
+    ...action,
+  };
+}
+
+function getRule(instructions: string, actions: Action[] = []) {
+  return {
+    instructions,
+    name: "Test Rule",
+    actions,
+    id: "r123",
+    userId: "userId",
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    automate: false,
+    runOnThreads: false,
+    groupId: null,
+    from: null,
+    subject: null,
+    body: null,
+    to: null,
+    type: RuleType.AI,
+    enabled: true,
+    categoryFilterType: null,
+  };
+}
+
+function getEmail({
+  from = "from@test.com",
+  subject = "subject",
+  content = "content",
+}: { from?: string; subject?: string; content?: string } = {}) {
+  return {
+    from,
+    subject,
+    content,
+  };
+}
+
+function getUser() {
+  return {
+    aiModel: null,
+    aiProvider: null,
+    email: "user@test.com",
+    aiApiKey: null,
+    about: null,
+  };
+}
diff --git a/apps/web/__tests__/ai-choose-rule.test.ts b/apps/web/__tests__/ai-choose-rule.test.ts
index 288899e46f..c5c62cc106 100644
--- a/apps/web/__tests__/ai-choose-rule.test.ts
+++ b/apps/web/__tests__/ai-choose-rule.test.ts
@@ -62,14 +62,14 @@ test("Should generate action arguments", async () => {
       ruleId: "ruleId",
       label: null,
       subject: null,
-      content: null,
+      content: "{{Write a joke}}",
       to: null,
       cc: null,
       bcc: null,
 
       labelPrompt: null,
       subjectPrompt: null,
-      contentPrompt: "Write a joke",
+      contentPrompt: null,
       toPrompt: null,
       ccPrompt: null,
       bccPrompt: null,
@@ -96,6 +96,17 @@ test("Should generate action arguments", async () => {
         subject: null,
         to: null,
         type: "REPLY",
+
+        labelPrompt: null,
+        subjectPrompt: null,
+        contentPrompt: null,
+        toPrompt: null,
+        ccPrompt: null,
+        bccPrompt: null,
+        createdAt: expect.any(Date),
+        updatedAt: expect.any(Date),
+        id: "id",
+        ruleId: "ruleId",
       },
     ],
   });
@@ -120,6 +131,7 @@ function getRule(instructions: string, actions: Action[] = []) {
     to: null,
     type: RuleType.AI,
     enabled: true,
+    categoryFilterType: null,
   };
 }
 
@@ -137,8 +149,8 @@ function getEmail({
 
 function getUser() {
   return {
-    aiModel: "gpt-4o-mini",
-    aiProvider: "openai",
+    aiModel: null,
+    aiProvider: null,
     email: "user@test.com",
     aiApiKey: null,
     about: null,
diff --git a/apps/web/app/(app)/automation/RuleForm.tsx b/apps/web/app/(app)/automation/RuleForm.tsx
index 861e91e8af..948966dea3 100644
--- a/apps/web/app/(app)/automation/RuleForm.tsx
+++ b/apps/web/app/(app)/automation/RuleForm.tsx
@@ -54,6 +54,7 @@ import type { LabelsResponse } from "@/app/api/google/labels/route";
 import { MultiSelectFilter } from "@/components/MultiSelectFilter";
 import { useCategories } from "@/hooks/useCategories";
 import { useSmartCategoriesEnabled } from "@/hooks/useFeatureFlags";
+import { hasVariables } from "@/utils/template";
 
 export function RuleForm({ rule }: { rule: CreateRuleBody & { id?: string } }) {
   const {
@@ -90,7 +91,7 @@ export function RuleForm({ rule }: { rule: CreateRuleBody & { id?: string } }) {
           const hasLabel = gmailLabelsData?.labels?.some(
             (label) => label.name === action.label,
           );
-          if (!hasLabel && action.label?.value) {
+          if (!hasLabel && action.label?.value && !action.label?.ai) {
             await createLabelAction({ name: action.label.value });
           }
         }
@@ -328,29 +329,33 @@ export function RuleForm({ rule }: { rule: CreateRuleBody & { id?: string } }) {
                   {actionInputs[action.type].fields.map((field) => {
                     const isAiGenerated = action[field.name]?.ai;
 
+                    const value = watch(`actions.${i}.${field.name}.value`);
+
                     return (
                       <div key={field.label}>
                         <div className="flex items-center justify-between">
                           <Label name={field.name} label={field.label} />
-                          <div className="flex items-center space-x-2">
-                            <TooltipExplanation text="Enable for AI-generated values unique to each email. Disable to use a fixed value you set here." />
-                            <Toggle
-                              name={`actions.${i}.${field.name}.ai`}
-                              label="AI generated"
-                              enabled={isAiGenerated || false}
-                              onChange={(enabled) => {
-                                setValue(
-                                  `actions.${i}.${field.name}`,
-                                  enabled
-                                    ? { value: "", ai: true }
-                                    : { value: "", ai: false },
-                                );
-                              }}
-                            />
-                          </div>
+                          {field.name === "label" && (
+                            <div className="flex items-center space-x-2">
+                              <TooltipExplanation text="Enable for AI-generated values unique to each email. Put the prompt inside braces {{your prompt here}}. Disable to use a fixed value." />
+                              <Toggle
+                                name={`actions.${i}.${field.name}.ai`}
+                                label="AI generated"
+                                enabled={isAiGenerated || false}
+                                onChange={(enabled) => {
+                                  setValue(
+                                    `actions.${i}.${field.name}`,
+                                    enabled
+                                      ? { value: "", ai: true }
+                                      : { value: "", ai: false },
+                                  );
+                                }}
+                              />
+                            </div>
+                          )}
                         </div>
 
-                        {field.name === "label" ? (
+                        {field.name === "label" && !isAiGenerated ? (
                           <div className="mt-2">
                             <LabelCombobox
                               userLabels={userLabels}
@@ -366,23 +371,44 @@ export function RuleForm({ rule }: { rule: CreateRuleBody & { id?: string } }) {
                             />
                           </div>
                         ) : field.textArea ? (
-                          <textarea
-                            className="mt-2 block w-full flex-1 whitespace-pre-wrap rounded-md border-gray-300 shadow-sm focus:border-black focus:ring-black sm:text-sm"
-                            rows={3}
-                            placeholder={
-                              isAiGenerated ? "AI prompt (optional)" : ""
-                            }
-                            {...register(`actions.${i}.${field.name}.value`)}
-                          />
+                          <div className="mt-2">
+                            <textarea
+                              className="block w-full flex-1 whitespace-pre-wrap rounded-md border-gray-300 shadow-sm focus:border-black focus:ring-black sm:text-sm"
+                              rows={4}
+                              placeholder="Add text or use {{AI prompts}}. e.g. Hi {{write greeting}}"
+                              value={value || ""}
+                              {...register(`actions.${i}.${field.name}.value`)}
+                            />
+                          </div>
                         ) : (
-                          <input
-                            className="mt-2 block w-full flex-1 rounded-md border-gray-300 shadow-sm focus:border-black focus:ring-black sm:text-sm"
-                            type="text"
-                            placeholder={
-                              isAiGenerated ? "AI prompt (optional)" : ""
-                            }
-                            {...register(`actions.${i}.${field.name}.value`)}
-                          />
+                          <div className="mt-2">
+                            <input
+                              className="block w-full flex-1 rounded-md border-gray-300 shadow-sm focus:border-black focus:ring-black sm:text-sm"
+                              type="text"
+                              placeholder="Add text or use {{AI prompts}}. e.g. Hi {{write greeting}}"
+                              {...register(`actions.${i}.${field.name}.value`)}
+                            />
+                          </div>
+                        )}
+
+                        {hasVariables(value) && (
+                          <div className="mt-2 whitespace-pre-wrap rounded-md bg-gray-50 p-2 font-mono text-sm text-gray-900">
+                            {(value || "")
+                              .split(/(\{\{.*?\}\})/g)
+                              .map((part, i) =>
+                                part.startsWith("{{") ? (
+                                  <span
+                                    key={i}
+                                    className="rounded bg-blue-100 px-1 text-blue-500"
+                                  >
+                                    <sub className="font-sans">AI</sub>
+                                    {part}
+                                  </span>
+                                ) : (
+                                  <span key={i}>{part}</span>
+                                ),
+                              )}
+                          </div>
                         )}
 
                         {errors.actions?.[i]?.[field.name]?.message ? (
diff --git a/apps/web/app/(app)/automation/TestRules.tsx b/apps/web/app/(app)/automation/TestRules.tsx
index bf87cdbb93..e6d74ba83f 100644
--- a/apps/web/app/(app)/automation/TestRules.tsx
+++ b/apps/web/app/(app)/automation/TestRules.tsx
@@ -227,32 +227,27 @@ function TestResultDisplay({ result }: { result: TestResult }) {
   if (result.actionItems) {
     const MAX_LENGTH = 280;
 
-    const aiGeneratedContent = result.actionItems.map((action, i) => {
-      return (
-        <div key={i}>
-          <strong>{capitalCase(action.type)}</strong>
-          {Object.entries(action)
-            .filter(
-              ([key, value]) =>
-                value &&
-                (key === "label" ||
-                  key === "subject" ||
-                  key === "content" ||
-                  key === "to" ||
-                  key === "cc" ||
-                  key === "bcc"),
-            )
-            .map(([key, value]) => {
-              return (
-                <div key={key}>
-                  <strong>{capitalCase(key)}: </strong>
-                  {value}
-                </div>
-              );
-            })}
+    const aiGeneratedContent = result.actionItems.map((action, i) => (
+      <div key={i} className="rounded-md border border-gray-200 bg-gray-50 p-3">
+        <div className="mb-2 text-xs font-semibold uppercase tracking-wide text-gray-900">
+          {capitalCase(action.type)}
         </div>
-      );
-    });
+        {Object.entries(action)
+          .filter(
+            ([key, value]) =>
+              value &&
+              ["label", "subject", "content", "to", "cc", "bcc"].includes(key),
+          )
+          .map(([key, value]) => (
+            <div key={key} className="flex text-sm text-gray-800">
+              <span className="min-w-20 font-medium text-gray-600">
+                {capitalCase(key)}:
+              </span>
+              <span className="ml-2 flex-1">{value}</span>
+            </div>
+          ))}
+      </div>
+    ));
 
     return (
       <AlertBasic
@@ -261,22 +256,19 @@ function TestResultDisplay({ result }: { result: TestResult }) {
         description={
           <div className="mt-4 space-y-4">
             {!!aiGeneratedContent.length && (
-              <div>
-                <strong>Content: </strong>
-                {aiGeneratedContent}
-              </div>
+              <div className="space-y-3">{aiGeneratedContent}</div>
             )}
             {!!result.reason && (
-              <div>
-                <strong>AI reason: </strong>
+              <div className="border-l-2 border-blue-200 pl-3 text-sm">
+                <span className="font-medium">AI Reasoning: </span>
                 {result.reason}
               </div>
             )}
             {result.rule.type === RuleType.AI && (
-              <div>
-                <strong>Instructions: </strong>
-                {result.rule.instructions.substring(0, MAX_LENGTH) +
-                  (result.rule.instructions.length < MAX_LENGTH ? "" : "...")}
+              <div className="border-t border-blue-100 pt-3 text-sm">
+                <span className="font-medium">Rule Instructions: </span>
+                {result.rule.instructions.substring(0, MAX_LENGTH)}
+                {result.rule.instructions.length >= MAX_LENGTH && "..."}
               </div>
             )}
           </div>
diff --git a/apps/web/app/(app)/automation/rule/[ruleId]/page.tsx b/apps/web/app/(app)/automation/rule/[ruleId]/page.tsx
index 9f4cff6dba..6f5c90e96a 100644
--- a/apps/web/app/(app)/automation/rule/[ruleId]/page.tsx
+++ b/apps/web/app/(app)/automation/rule/[ruleId]/page.tsx
@@ -3,6 +3,7 @@ import prisma from "@/utils/prisma";
 import { auth } from "@/app/api/auth/[...nextauth]/auth";
 import { RuleForm } from "@/app/(app)/automation/RuleForm";
 import { TopSection } from "@/components/TopSection";
+import { hasVariables } from "@/utils/template";
 
 export default async function RulePage({
   params,
@@ -28,30 +29,15 @@ export default async function RulePage({
     ...rule,
     actions: rule.actions.map((action) => ({
       ...action,
-      label:
-        typeof action.labelPrompt === "string"
-          ? { value: action.labelPrompt, ai: true }
-          : { value: action.label, ai: false },
-      subject:
-        typeof action.subjectPrompt === "string"
-          ? { value: action.subjectPrompt, ai: true }
-          : { value: action.subject, ai: false },
-      content:
-        typeof action.contentPrompt === "string"
-          ? { value: action.contentPrompt, ai: true }
-          : { value: action.content, ai: false },
-      to:
-        typeof action.toPrompt === "string"
-          ? { value: action.toPrompt, ai: true }
-          : { value: action.to, ai: false },
-      cc:
-        typeof action.ccPrompt === "string"
-          ? { value: action.ccPrompt, ai: true }
-          : { value: action.cc, ai: false },
-      bcc:
-        typeof action.bccPrompt === "string"
-          ? { value: action.bccPrompt, ai: true }
-          : { value: action.bcc, ai: false },
+      label: {
+        value: action.label,
+        ai: hasVariables(action.label),
+      },
+      subject: { value: action.subject },
+      content: { value: action.content },
+      to: { value: action.to },
+      cc: { value: action.cc },
+      bcc: { value: action.bcc },
     })),
     categoryFilters: rule.categoryFilters.map((category) => category.id),
   };
diff --git a/apps/web/app/api/ai/cold-email/controller.ts b/apps/web/app/api/ai/cold-email/controller.ts
index de3d22b442..0ccbc45a34 100644
--- a/apps/web/app/api/ai/cold-email/controller.ts
+++ b/apps/web/app/api/ai/cold-email/controller.ts
@@ -79,18 +79,18 @@ async function aiIsColdEmail(
 ${user.coldEmailPrompt || DEFAULT_COLD_EMAIL_PROMPT}
 </instructions>
 
-<outputFormat>
+<output_format>
 Return a JSON object with a "reason" and "coldEmail" field.
 The "reason" should be a concise explanation that explains why the email is or isn't considered a cold email.
 The "coldEmail" should be a boolean that is true if the email is a cold email and false otherwise.
-</outputFormat>
+</output_format>
 
-<exampleResponse>
+<example_response>
 {
   "reason": "This is someone trying to sell you services.",
   "coldEmail": true
 }
-</exampleResponse>
+</example_response>
 
 <email>
 ${stringifyEmail(email, 500)}
diff --git a/apps/web/app/api/google/webhook/process-history.ts b/apps/web/app/api/google/webhook/process-history.ts
index 05768d5469..513227b87c 100644
--- a/apps/web/app/api/google/webhook/process-history.ts
+++ b/apps/web/app/api/google/webhook/process-history.ts
@@ -204,7 +204,13 @@ export async function processHistoryForUser(
     return NextResponse.json({ ok: true });
   } catch (error) {
     captureException(error, { extra: { decodedData } }, email);
-    logger.error("Error processing webhook", error, decodedData);
+    logger.error(
+      "Error processing webhook",
+      error instanceof Error
+        ? { message: error.message, stack: error.stack, name: error.name }
+        : String(error),
+      decodedData,
+    );
     return NextResponse.json({ error: true });
     // be careful about calling an error here with the wrong settings, as otherwise PubSub will call the webhook over and over
     // return NextResponse.error();
diff --git a/apps/web/package.json b/apps/web/package.json
index ff4642fb12..f7b8dad9e3 100644
--- a/apps/web/package.json
+++ b/apps/web/package.json
@@ -66,7 +66,6 @@
     "@upstash/qstash": "^2.7.16",
     "@upstash/redis": "^1.34.3",
     "@vercel/analytics": "^1.3.2",
-    "@vercel/speed-insights": "^1.0.14",
     "ai": "^3.4.31",
     "capital-case": "^2.0.0",
     "cheerio": "1.0.0",
diff --git a/apps/web/utils/actions/ai-rule.ts b/apps/web/utils/actions/ai-rule.ts
index 93eba6cacb..e481ace3c3 100644
--- a/apps/web/utils/actions/ai-rule.ts
+++ b/apps/web/utils/actions/ai-rule.ts
@@ -38,6 +38,9 @@ import { aiFindExistingRules } from "@/utils/ai/rule/find-existing-rules";
 import { aiGenerateRulesPrompt } from "@/utils/ai/rule/generate-rules-prompt";
 import { getLabels } from "@/utils/gmail/label";
 import { withActionInstrumentation } from "@/utils/actions/middleware";
+import { createScopedLogger } from "@/utils/logger";
+
+const logger = createScopedLogger("ai-rule");
 
 export const runRulesAction = withActionInstrumentation(
   "runRules",
@@ -81,7 +84,7 @@ export const runRulesAction = withActionInstrumentation(
     const gmailThread = await getThread(email.threadId, gmail);
 
     if (hasExistingRule && !force) {
-      console.log("Skipping. Rule already exists.");
+      logger.info("Skipping. Rule already exists.");
       return;
     }
 
@@ -296,7 +299,12 @@ async function safeCreateRule(
       return { id: rule.id };
     }
 
-    console.log(`Error creating rule. ${error}`);
+    logger.info("Error creating rule", {
+      error:
+        error instanceof Error
+          ? { message: error.message, stack: error.stack, name: error.name }
+          : error,
+    });
 
     return { error: "Error creating rule." };
   }
@@ -322,7 +330,12 @@ async function safeUpdateRule(
       return { id: rule.id };
     }
 
-    console.log(`Error updating rule. ${error}`);
+    logger.info("Error updating rule", {
+      error:
+        error instanceof Error
+          ? { message: error.message, stack: error.stack, name: error.name }
+          : error,
+    });
 
     return { error: "Error updating rule." };
   }
@@ -508,7 +521,7 @@ export const saveRulesPromptAction = withActionInstrumentation(
     if (!session?.user.email) return { error: "Not logged in" };
     setUser({ email: session.user.email });
 
-    console.log(
+    logger.info(
       `Starting saveRulesPromptAction for user ${session.user.email}`,
     );
 
@@ -539,13 +552,13 @@ export const saveRulesPromptAction = withActionInstrumentation(
     }
 
     const oldPromptFile = user.rulesPrompt;
-    console.log(
+    logger.info(
       "Old prompt file:",
       oldPromptFile ? "exists" : "does not exist",
     );
 
     if (oldPromptFile === data.rulesPrompt) {
-      console.log("No changes in rules prompt, returning early");
+      logger.info("No changes in rules prompt, returning early");
       return { createdRules: 0, editedRules: 0, removedRules: 0 };
     }
 
@@ -555,14 +568,14 @@ export const saveRulesPromptAction = withActionInstrumentation(
 
     // check how the prompts have changed, and make changes to the rules accordingly
     if (oldPromptFile) {
-      console.log("Comparing old and new prompts");
+      logger.info("Comparing old and new prompts");
       const diff = await aiDiffRules({
         user: { ...user, email: user.email },
         oldPromptFile,
         newPromptFile: data.rulesPrompt,
       });
 
-      console.log(
+      logger.info(
         `Diff results: Added rules: ${diff.addedRules.length}, Edited rules: ${diff.editedRules.length}, Removed rules: ${diff.removedRules.length}`,
       );
 
@@ -571,18 +584,18 @@ export const saveRulesPromptAction = withActionInstrumentation(
         !diff.editedRules.length &&
         !diff.removedRules.length
       ) {
-        console.log("No changes detected in rules, returning early");
+        logger.info("No changes detected in rules, returning early");
         return { createdRules: 0, editedRules: 0, removedRules: 0 };
       }
 
       if (diff.addedRules.length) {
-        console.log("Processing added rules");
+        logger.info("Processing added rules");
         addedRules = await aiPromptToRules({
           user: { ...user, email: user.email },
           promptFile: diff.addedRules.join("\n\n"),
           isEditing: false,
         });
-        console.log(`${addedRules?.length || 0} rules to be added`);
+        logger.info(`${addedRules?.length || 0} rules to be added`);
       }
 
       // find existing rules
@@ -590,7 +603,7 @@ export const saveRulesPromptAction = withActionInstrumentation(
         where: { userId: session.user.id, enabled: true },
         include: { actions: true },
       });
-      console.log(`Found ${userRules.length} existing user rules`);
+      logger.info(`Found ${userRules.length} existing user rules`);
 
       const existingRules = await aiFindExistingRules({
         user: { ...user, email: user.email },
@@ -600,7 +613,7 @@ export const saveRulesPromptAction = withActionInstrumentation(
       });
 
       // remove rules
-      console.log(
+      logger.info(
         `Processing ${existingRules.removedRules.length} rules for removal`,
       );
       for (const rule of existingRules.removedRules) {
@@ -608,7 +621,7 @@ export const saveRulesPromptAction = withActionInstrumentation(
           where: { userId: session.user.id, ruleId: rule.rule?.id },
         });
 
-        console.log(
+        logger.info(
           `Removing rule. Prompt: ${rule.promptRule}. Rule: ${rule.rule?.name}`,
         );
 
@@ -644,7 +657,7 @@ export const saveRulesPromptAction = withActionInstrumentation(
             continue;
           }
 
-          console.log(`Editing rule. Prompt: ${rule.name}`);
+          logger.info(`Editing rule. Prompt: ${rule.name}`);
 
           const groupIdResult = await getGroupId(rule, session.user.id);
           if (isActionError(groupIdResult)) {
@@ -665,18 +678,18 @@ export const saveRulesPromptAction = withActionInstrumentation(
         }
       }
     } else {
-      console.log("Processing new rules prompt with AI");
+      logger.info("Processing new rules prompt with AI");
       addedRules = await aiPromptToRules({
         user: { ...user, email: user.email },
         promptFile: data.rulesPrompt,
         isEditing: false,
       });
-      console.log(`${addedRules?.length || 0} rules to be added`);
+      logger.info(`${addedRules?.length || 0} rules to be added`);
     }
 
     // add new rules
     for (const rule of addedRules || []) {
-      console.log(`Creating rule. Prompt: ${rule.name}`);
+      logger.info(`Creating rule. Prompt: ${rule.name}`);
 
       const groupIdResult = await getGroupId(rule, session.user.id);
       if (isActionError(groupIdResult)) {
@@ -693,7 +706,7 @@ export const saveRulesPromptAction = withActionInstrumentation(
       data: { rulesPrompt: data.rulesPrompt },
     });
 
-    console.log(
+    logger.info(
       `saveRulesPromptAction completed. Created rules: ${addedRules?.length || 0}, Edited rules: ${editRulesCount}, Removed rules: ${removeRulesCount}`,
     );
 
diff --git a/apps/web/utils/actions/rule.ts b/apps/web/utils/actions/rule.ts
index 0fc9e7c62f..e9e3cead01 100644
--- a/apps/web/utils/actions/rule.ts
+++ b/apps/web/utils/actions/rule.ts
@@ -41,24 +41,12 @@ export const createRuleAction = withActionInstrumentation(
                     ({ type, label, subject, content, to, cc, bcc }) => {
                       return {
                         type,
-                        ...(label?.ai
-                          ? { label: null, labelPrompt: label?.value }
-                          : { label: label?.value, labelPrompt: null }),
-                        ...(subject?.ai
-                          ? { subject: null, subjectPrompt: subject?.value }
-                          : { subject: subject?.value, subjectPrompt: null }),
-                        ...(content?.ai
-                          ? { content: null, contentPrompt: content?.value }
-                          : { content: content?.value, contentPrompt: null }),
-                        ...(to?.ai
-                          ? { to: null, toPrompt: to?.value }
-                          : { to: to?.value, toPrompt: null }),
-                        ...(cc?.ai
-                          ? { cc: null, ccPrompt: cc?.value }
-                          : { cc: cc?.value, ccPrompt: null }),
-                        ...(bcc?.ai
-                          ? { bcc: null, bccPrompt: bcc?.value }
-                          : { bcc: bcc?.value, bccPrompt: null }),
+                        label: label?.value,
+                        subject: subject?.value,
+                        content: content?.value,
+                        to: to?.value,
+                        cc: cc?.value,
+                        bcc: bcc?.value,
                       };
                     },
                   ),
@@ -161,24 +149,12 @@ export const updateRuleAction = withActionInstrumentation(
             where: { id: a.id },
             data: {
               type: a.type,
-              ...(a.label?.ai
-                ? { label: null, labelPrompt: a.label?.value }
-                : { label: a.label?.value, labelPrompt: null }),
-              ...(a.subject?.ai
-                ? { subject: null, subjectPrompt: a.subject?.value }
-                : { subject: a.subject?.value, subjectPrompt: null }),
-              ...(a.content?.ai
-                ? { content: null, contentPrompt: a.content?.value }
-                : { content: a.content?.value, contentPrompt: null }),
-              ...(a.to?.ai
-                ? { to: null, toPrompt: a.to?.value }
-                : { to: a.to?.value, toPrompt: null }),
-              ...(a.cc?.ai
-                ? { cc: null, ccPrompt: a.cc?.value }
-                : { cc: a.cc?.value, ccPrompt: null }),
-              ...(a.bcc?.ai
-                ? { bcc: null, bccPrompt: a.bcc?.value }
-                : { bcc: a.bcc?.value, bccPrompt: null }),
+              label: a.label?.value,
+              subject: a.subject?.value,
+              content: a.content?.value,
+              to: a.to?.value,
+              cc: a.cc?.value,
+              bcc: a.bcc?.value,
             },
           });
         }),
@@ -189,24 +165,12 @@ export const updateRuleAction = withActionInstrumentation(
                 data: actionsToCreate.map((a) => ({
                   ruleId: body.id,
                   type: a.type,
-                  ...(a.label?.ai
-                    ? { label: null, labelPrompt: a.label?.value }
-                    : { label: a.label?.value, labelPrompt: null }),
-                  ...(a.subject?.ai
-                    ? { subject: null, subjectPrompt: a.subject?.value }
-                    : { subject: a.subject?.value, subjectPrompt: null }),
-                  ...(a.content?.ai
-                    ? { content: null, contentPrompt: a.content?.value }
-                    : { content: a.content?.value, contentPrompt: null }),
-                  ...(a.to?.ai
-                    ? { to: null, toPrompt: a.to?.value }
-                    : { to: a.to?.value, toPrompt: null }),
-                  ...(a.cc?.ai
-                    ? { cc: null, ccPrompt: a.cc?.value }
-                    : { cc: a.cc?.value, ccPrompt: null }),
-                  ...(a.bcc?.ai
-                    ? { bcc: null, bccPrompt: a.bcc?.value }
-                    : { bcc: a.bcc?.value, bccPrompt: null }),
+                  label: a.label?.value,
+                  subject: a.subject?.value,
+                  content: a.content?.value,
+                  to: a.to?.value,
+                  cc: a.cc?.value,
+                  bcc: a.bcc?.value,
                 })),
               }),
             ]
diff --git a/apps/web/utils/ai/choose-rule/ ai-choose-args.test.ts b/apps/web/utils/ai/choose-rule/ ai-choose-args.test.ts
new file mode 100644
index 0000000000..48641d8bf7
--- /dev/null
+++ b/apps/web/utils/ai/choose-rule/ ai-choose-args.test.ts	
@@ -0,0 +1,125 @@
+import { describe, it, expect, vi } from "vitest";
+import { getParameterFieldsForAction, parseTemplate } from "./ai-choose-args";
+import { z } from "zod";
+
+// Run with:
+// pnpm test ai-choose-args.test.ts
+
+vi.mock("server-only", () => ({}));
+
+describe("getParameterFieldsForAction", () => {
+  it("creates schema for simple field", () => {
+    const action = {
+      label: "{{write label}}",
+      subject: "",
+      content: "",
+      to: "",
+      cc: "",
+      bcc: "",
+    };
+
+    const result = getParameterFieldsForAction(action);
+
+    expect(result.label?.shape).toEqual({
+      var1: expect.any(z.ZodString),
+    });
+    expect(result.label?._def.description).toBe(
+      "Generate this template: {{var1: write label}}",
+    );
+  });
+
+  it("creates schema for field with multiple variables", () => {
+    const action = {
+      label: "",
+      content: "Dear {{write greeting}},\n\n{{draft response}}\n\nBest",
+      subject: "",
+      to: "",
+      cc: "",
+      bcc: "",
+    };
+
+    const result = getParameterFieldsForAction(action);
+
+    expect(result.content?.shape).toEqual({
+      var1: expect.any(z.ZodString),
+      var2: expect.any(z.ZodString),
+    });
+    expect(result.content?._def.description).toBe(
+      "Generate this template: Dear {{var1: write greeting}},\n\n{{var2: draft response}}\n\nBest\nMake sure to maintain the exact formatting.",
+    );
+  });
+
+  it("ignores fields without template variables", () => {
+    const action = {
+      label: "Simple label",
+      subject: "",
+      content: "",
+      to: "",
+      cc: "",
+      bcc: "",
+    };
+
+    const result = getParameterFieldsForAction(action);
+
+    expect(result.label).toBeUndefined();
+  });
+
+  it("handles multiple fields with template variables", () => {
+    const action = {
+      label: "{{write label}}",
+      subject: "Re: {{write subject}}",
+      content: "{{write content}}",
+      to: "{{recipient}}",
+      cc: "",
+      bcc: "",
+    };
+
+    const result = getParameterFieldsForAction(action);
+
+    expect(Object.keys(result)).toHaveLength(4);
+    expect(result.label?._def.description).toBe(
+      "Generate this template: {{var1: write label}}",
+    );
+    expect(result.subject?._def.description).toBe(
+      "Generate this template: Re: {{var1: write subject}}",
+    );
+    expect(result.to?._def.description).toBe(
+      "Generate this template: {{var1: recipient}}",
+    );
+  });
+});
+
+describe("parseTemplate", () => {
+  it("handles adjacent template variables with no gap", () => {
+    const template = "start{{x}}{{y}}end";
+    const result = parseTemplate(template);
+
+    expect(result).toEqual({
+      aiPrompts: ["x", "y"],
+      fixedParts: ["start", "", "end"],
+    });
+  });
+
+  it("handles multiple edge cases", () => {
+    const cases = [
+      {
+        template: "{{x}}{{y}}", // No gaps, at start
+        expected: {
+          aiPrompts: ["x", "y"],
+          fixedParts: ["", "", ""],
+        },
+      },
+      {
+        template: "{{x}}text{{y}}{{z}}", // Mixed gaps
+        expected: {
+          aiPrompts: ["x", "y", "z"],
+          fixedParts: ["", "text", "", ""],
+        },
+      },
+    ];
+
+    cases.forEach(({ template, expected }) => {
+      expect(parseTemplate(template)).toEqual(expected);
+    });
+  });
+});
diff --git a/apps/web/utils/ai/choose-rule/ai-choose-args.ts b/apps/web/utils/ai/choose-rule/ai-choose-args.ts
index 5956fb68f5..214f2dbac9 100644
--- a/apps/web/utils/ai/choose-rule/ai-choose-args.ts
+++ b/apps/web/utils/ai/choose-rule/ai-choose-args.ts
@@ -1,6 +1,5 @@
 import { z } from "zod";
 import type { UserAIFields } from "@/utils/llms/types";
-import type { ActionItem } from "@/utils/ai/actions";
 import type { Action, User } from "@prisma/client";
 import { chatCompletionTools, withRetry } from "@/utils/llms";
 import {
@@ -11,19 +10,45 @@ import { type RuleWithActions, isDefined } from "@/utils/types";
 import { createScopedLogger } from "@/utils/logger";
 import { InvalidToolArgumentsError } from "ai";
 
+/**
+ * AI Argument Generator for Email Actions
+ *
+ * This module handles the second stage of the AI email processing pipeline:
+ * generating specific arguments for a selected rule's actions.
+ *
+ * Process:
+ * 1. Receives a selected rule and email context
+ * 2. Analyzes action fields (label, subject, content, to, cc, bcc)
+ * 3. Extracts variables from template strings using {{handlebars}} syntax
+ * 4. Generates Zod schemas for validation
+ * 5. Uses AI function calling to fill in variables
+ * 6. Returns completed templates with filled variables
+ *
+ * Example:
+ * Template: "Dear {{name}}, \n{{draft response to investment inquiry}}"
+ * Variables are numbered (var1, var2) and passed to AI with full context
+ *
+ * The AI generates content for each variable while preserving static template parts
+ * and returns a fully formed response ready for email sending.
+ *
+ * Note: This is specifically for argument generation AFTER rule selection,
+ * not for choosing which rule to apply.
+ */
+
 const logger = createScopedLogger("AI Choose Args");
 
-export type ActionRequiringAi = {
-  actionId: string;
-  type: string;
-  zodParameters: z.ZodObject<Record<string, z.ZodString>>;
-};
+type ActionRequiringAi = ReturnType<
+  typeof extractActionsNeedingAiGeneration
+>[number];
 
-export type ActionWithAiArgs = ActionRequiringAi & {
-  args: Record<string, string>;
+type ActionArgResponse = {
+  [key: `${string}-${string}`]: {
+    [field: string]: {
+      [key: `var${number}`]: string;
+    };
+  };
 };
 
-// Returns the action items with the ai-generated args where needed
 export async function getActionItemsWithAiArgs({
   email,
   user,
@@ -32,98 +57,82 @@ export async function getActionItemsWithAiArgs({
   email: EmailForLLM;
   user: Pick<User, "email" | "about"> & UserAIFields;
   selectedRule: RuleWithActions;
-}): Promise<ActionItem[]> {
-  // Get the actions that require ai-generated args
-  const actionsRequiringAi = getActionsWithZodParameters(selectedRule.actions);
-
-  // Get the ai-generated args
-  let aiGeneratedActionItems: ActionWithAiArgs[] | undefined;
-  if (actionsRequiringAi.length) {
-    aiGeneratedActionItems = await getArgsAiResponse({
-      email,
-      user,
-      selectedRule,
-      actionsRequiringAi,
-    });
-  }
+}): Promise<Action[]> {
+  const parameters = extractActionsNeedingAiGeneration(selectedRule.actions);
 
-  // Combine static args with ai-generated args
-  const results = selectedRule.actions.map((action) => {
-    const aiGeneratedActionItem = aiGeneratedActionItems?.find(
-      (item) => item.actionId === action.id,
-    );
-    return {
-      ...action,
-      ...aiGeneratedActionItem?.args,
-    };
+  if (parameters.length === 0) return selectedRule.actions;
+
+  const result = await getArgsAiResponse({
+    email,
+    user,
+    selectedRule,
+    parameters,
   });
 
-  logger.trace(
-    `getActionItemsWithAiArgs. Results: ${JSON.stringify(results, null, 2)}`,
-  );
+  // Combine the result with the original action items
+  const combinedActions = selectedRule.actions.map((action) => {
+    const aiAction = result?.[`${action.type}-${action.id}`];
+    if (!aiAction) return action;
+
+    const updatedAction = { ...action };
+
+    // Merge variables for each field that has AI-generated content
+    for (const [field, vars] of Object.entries(aiAction)) {
+      // Only process fields that we know can contain template strings
+      if (
+        field === "label" ||
+        field === "subject" ||
+        field === "content" ||
+        field === "to" ||
+        field === "cc" ||
+        field === "bcc"
+      ) {
+        const originalValue = action[field];
+        if (typeof originalValue === "string") {
+          (updatedAction[field] as string) = mergeTemplateWithVars(
+            originalValue,
+            vars as Record<`var${number}`, string>,
+          );
+        }
+      }
+    }
+
+    return updatedAction;
+  });
 
-  return results;
+  return combinedActions;
 }
 
 async function getArgsAiResponse({
   email,
   user,
   selectedRule,
-  actionsRequiringAi,
+  parameters,
 }: {
   email: EmailForLLM;
   user: Pick<User, "email" | "about"> & UserAIFields;
   selectedRule: RuleWithActions;
-  actionsRequiringAi: ActionRequiringAi[];
-}): Promise<ActionWithAiArgs[] | undefined> {
+  parameters: ActionRequiringAi[];
+}): Promise<ActionArgResponse | undefined> {
   logger.info(
     `Generating args for rule ${selectedRule.name} (${selectedRule.id})`,
   );
 
-  if (!actionsRequiringAi.length) {
+  // If no parameters, skip
+  if (parameters.length === 0) {
     logger.info(
       `Skipping. No parameters for rule ${selectedRule.name} (${selectedRule.id})`,
     );
     return;
   }
 
-  const system = `You are an AI assistant that helps people manage their emails.
-Never put placeholders in your email responses.
-Do not mention you are an AI assistant when responding to people.
-${
-  user.about
-    ? `\nSome additional information the user has provided about themselves:\n\n${user.about}`
-    : ""
-}
-
-IMPORTANT: When responding, always provide a complete object with all required fields.
-`;
-
-  const prompt = `An email was received for processing and the following rule was selected to process it. Handle the email.
-
-<selectedRule>
-${selectedRule.instructions}
-</selectedRule>
-
-<email>
-${stringifyEmail(email, 3000)}
-</email>
-`;
-
-  const parameters = getToolParametersForRule(actionsRequiringAi);
-  const zodParameters = z.object(
-    Object.fromEntries(
-      Object.entries(parameters).map(([key, { zodParameters }]) => [
-        key,
-        zodParameters,
-      ]),
-    ),
-  );
+  const system = getSystemPrompt({ user });
+  const prompt = getPrompt({ email, selectedRule });
 
   logger.info("Calling chat completion tools");
   logger.trace(`System: ${system}`);
   logger.trace(`Prompt: ${prompt}`);
-  // logger.trace("Zod parameters:", zodToJsonSchema(zodParameters));
+  // logger.trace("Parameters:", zodToJsonSchema(parameters));
 
   const aiResponse = await withRetry(
     () =>
@@ -133,9 +142,15 @@ ${stringifyEmail(email, 3000)}
         system,
         tools: {
           apply_rule: {
-            description:
-              "Apply the rule with the given arguments. Each field must be provided as an object with the required properties.",
-            parameters: zodParameters,
+            description: "Apply the rule with the given arguments.",
+            parameters: z.object(
+              Object.fromEntries(
+                parameters.map((p) => [
+                  `${p.type}-${p.actionId}`,
+                  p.parameters,
+                ]),
+              ),
+            ),
           },
         },
         label: "Args for rule",
@@ -156,95 +171,238 @@ ${stringifyEmail(email, 3000)}
 
   logger.trace(`Tool call args: ${JSON.stringify(toolCallArgs, null, 2)}`);
 
-  const results = actionsRequiringAi.map((actionRequiringAi) => {
-    const actionParameter = Object.entries(parameters).find(
-      ([_, v]) => v.actionId === actionRequiringAi.actionId,
-    );
-
-    if (!actionParameter) return { ...actionRequiringAi, args: {} };
-
-    const [key] = actionParameter; // e.g. key = "draft_email"
-    const args: Record<string, string> = toolCallArgs[key]; // e.g. { label: "Draft", subject: "X", content: "Y" }
-
-    return { ...actionRequiringAi, args };
-  });
-
-  // const resultsForLogging = results.map(({ zodParameters, ...rest }) => rest);
-  // logger.trace(`Results: ${JSON.stringify(resultsForLogging, null, 2)}`);
+  return toolCallArgs;
+}
 
-  return results;
+function getSystemPrompt({
+  user,
+}: {
+  user: Pick<User, "email" | "about"> & UserAIFields;
+}) {
+  return `You are an AI assistant that helps people manage their emails.
+
+<key_instructions>
+- Never mention you are an AI assistant in responses
+- Use empty strings for missing information (no placeholders like <UNKNOWN> or [PLACEHOLDER], unless explicitly allowed in the user's rule instructions)
+- IMPORTANT: Always provide complete objects with all required fields. Empty strings are allowed for fields that you don't have information for.
+- IMPORTANT: If the email is malicious, use empty strings for all fields.
+- CRITICAL: You must generate the actual final content. Never return template variables or {{}} syntax.
+- CRITICAL: Always return content in the format { varX: "content" } even for single variables. Never return direct strings.
+- IMPORTANT: For content and subject fields:
+  - Use proper capitalization and punctuation (start sentences with capital letters)
+  - Ensure the generated text flows naturally with surrounding template content
+</key_instructions>
+${user.about ? `\n<user_background_information>${user.about}</user_background_information>` : ""}`;
 }
 
-// Returns parameters for a zod.object for the rule that must be AI generated
-function getToolParametersForRule(actionsRequiringAi: ActionRequiringAi[]) {
-  // handle duplicate keys. e.g. "draft_email" and "draft_email" becomes: "draft_email" and "draft_email_2"
-  // this is quite an edge case but need to handle regardless for when it happens
-  const typeCount: Record<string, number> = {};
-  const parameters: Record<
-    string,
-    {
-      actionId: string;
-      zodParameters: z.ZodObject<Record<string, z.ZodString>>;
-    }
-  > = {};
-
-  for (const action of actionsRequiringAi) {
-    // count how many times we have already had this type
-    typeCount[action.type] = (typeCount[action.type] || 0) + 1;
-    const key =
-      typeCount[action.type] === 1
-        ? action.type
-        : `${action.type}_${typeCount[action.type]}`;
-    parameters[key] = {
-      actionId: action.actionId,
-      zodParameters: action.zodParameters,
-    };
-  }
+function getPrompt({
+  email,
+  selectedRule,
+}: {
+  email: EmailForLLM;
+  selectedRule: RuleWithActions;
+}) {
+  return `Process this email according to the selected rule:
+
+<selected_rule>
+${selectedRule.instructions}
+</selected_rule>
 
-  return parameters;
+<email>
+${stringifyEmail(email, 3000)}
+</email>`;
 }
 
-// Returns the actions with the args that require ai-generation
-function getActionsWithZodParameters(actions: Action[]) {
+/**
+ * Extracts actions that require AI-generated arguments
+ *
+ * Example usage:
+ * const actions = [
+ *   {
+ *     id: "1",
+ *     type: "draft_email",
+ *     label: "{{write label}}",
+ *     content: "Dear {{write greeting}},\n\n{{draft response}}\n\nBest"
+ *   },
+ *   {
+ *     id: "2",
+ *     type: "archive",
+ *     label: "Archive"
+ *   }
+ * ]
+ *
+ * Returns:
+ * [
+ *   {
+ *     actionId: "1",
+ *     type: "draft_email",
+ *     parameters: z.object({
+ *       label: z.object({ var1: z.string() })
+ *         .describe("Generate this template: {{var1: write label}}"),
+ *       content: z.object({ var1: z.string(), var2: z.string() })
+ *         .describe("Generate this template: Dear {{var1: write greeting}},\n\n{{var2: draft response}}\n\nBest")
+ *     })
+ *   }
+ * ]
+ *
+ * Note: Only returns actions that have fields containing {{template variables}}
+ */
+function extractActionsNeedingAiGeneration(actions: Action[]) {
   return actions
     .map((action) => {
       const fields = getParameterFieldsForAction(action);
 
-      if (!Object.keys(fields).length) return;
-
-      const zodParameters = z.object(fields);
+      // Skip if no AI-generated fields are needed
+      if (Object.keys(fields).length === 0) return;
 
       return {
         actionId: action.id,
         type: action.type,
-        zodParameters,
+        parameters: z.object(fields),
       };
     })
     .filter(isDefined);
 }
 
-function getParameterFieldsForAction({
-  labelPrompt,
-  subjectPrompt,
-  contentPrompt,
-  toPrompt,
-  ccPrompt,
-  bccPrompt,
-}: Action) {
-  const fields: Record<string, z.ZodString> = {};
-
-  if (typeof labelPrompt === "string")
-    fields.label = z.string().describe(labelPrompt || "The email label");
-  if (typeof subjectPrompt === "string")
-    fields.subject = z.string().describe(subjectPrompt || "The email subject");
-  if (typeof contentPrompt === "string")
-    fields.content = z.string().describe(contentPrompt || "The email content");
-  if (typeof toPrompt === "string")
-    fields.to = z.string().describe(toPrompt || "The email recipient(s)");
-  if (typeof ccPrompt === "string")
-    fields.cc = z.string().describe(ccPrompt || "The cc recipient(s)");
-  if (typeof bccPrompt === "string")
-    fields.bcc = z.string().describe(bccPrompt || "The bcc recipient(s)");
+/**
+ * Extracts fields from an action that need AI-generated content
+ *
+ * Example usage:
+ * const action = {
+ *   label: "{{write label}}",
+ *   subject: "Re: {{write subject}}",
+ *   content: "Dear {{write greeting}},\n\n{{draft response}}\n\nBest",
+ *   to: "{{recipient}}",
+ *   cc: "john@example.com",
+ *   bcc: null
+ * }
+ * const fields = getParameterFieldsForAction(action)
+ *
+ * Returns:
+ * {
+ *   label: z.object({ var1: z.string() })
+ *     .describe("Generate this template: {{var1: write label}}"),
+ *   subject: z.object({ var1: z.string() })
+ *     .describe("Generate this template: Re: {{var1: write subject}}"),
+ *   content: z
+ *     .object({
+ *       var1: z.string(),
+ *       var2: z.string(),
+ *     })
+ *     .describe(
+ *       "Generate this template: Dear {{var1: write greeting}},\n\n{{var2: draft response}}\n\nBest\nMake sure to maintain the exact formatting.",
+ *     ),
+ *   to: z.object({ var1: z.string() }).describe("Generate this template: {{var1: recipient}}"),
+ * }
+ *
+ * Note: Only processes string fields that contain {{template variables}}
+ */
+export function getParameterFieldsForAction(
+  action: Pick<Action, "label" | "subject" | "content" | "to" | "cc" | "bcc">,
+) {
+  const fields: Record<string, z.ZodObject<Record<string, z.ZodString>>> = {};
+  const fieldNames = [
+    "label",
+    "subject",
+    "content",
+    "to",
+    "cc",
+    "bcc",
+  ] as const;
+
+  for (const field of fieldNames) {
+    const value = action[field];
+    if (typeof value === "string") {
+      const { aiPrompts } = parseTemplate(value);
+      if (aiPrompts.length > 0) {
+        const schemaFields: Record<string, z.ZodString> = {};
+        aiPrompts.forEach((prompt, index) => {
+          schemaFields[`var${index + 1}`] = z.string();
+        });
+
+        // Transform original template to use var1, var2, etc
+        let template = value;
+        aiPrompts.forEach((prompt, index) => {
+          template = template.replace(
+            `{{${prompt}}}`,
+            `{{var${index + 1}: ${prompt}}}`,
+          );
+        });
+
+        const description = `Generate this template: ${template}${
+          field === "content"
+            ? "\nMake sure to maintain the exact formatting."
+            : ""
+        }`;
+
+        fields[field] = z.object(schemaFields).describe(description);
+      }
+    }
+  }
 
   return fields;
 }
+
+/**
+ * Extracts AI prompts and static text from a template string
+ *
+ * Example usage:
+ * const template = "Hello {{write greeting}},\n\n{{draft response}}\n\nBest"
+ * const result = parseTemplate(template)
+ *
+ * Returns:
+ * {
+ *   aiPrompts: ["write greeting", "draft response"],
+ *   fixedParts: ["Hello ", ",\n\n", "\n\nBest"]
+ * }
+ *
+ * This allows us to:
+ * 1. Extract AI prompts for generation
+ * 2. Preserve static parts of the template
+ * 3. Reconstruct the full text by combining AI responses with fixed parts
+ */
+export function parseTemplate(template: string): {
+  aiPrompts: string[];
+  fixedParts: string[];
+} {
+  const regex = /\{\{(.*?)\}\}/g;
+  const aiPrompts: string[] = [];
+  const fixedParts: string[] = [];
+  let lastIndex = 0;
+
+  let match = regex.exec(template);
+  while (match !== null) {
+    fixedParts.push(template.slice(lastIndex, match.index));
+    aiPrompts.push(match[1].trim());
+    lastIndex = match.index + match[0].length;
+    match = regex.exec(template);
+  }
+  fixedParts.push(template.slice(lastIndex));
+
+  return { aiPrompts, fixedParts };
+}
+
+/**
+ * Merges AI-generated variables back into a template string
+ *
+ * Example usage:
+ * const template = "Price: {{price}}, Message: {{message}}"
+ * const vars = { var1: "$1.99", var2: "Hello!" }
+ * const result = mergeTemplateWithVars(template, vars)
+ * // Returns: "Price: $1.99, Message: Hello!"
+ */
+export function mergeTemplateWithVars(
+  template: string,
+  vars: Record<`var${number}`, string>,
+): string {
+  const { aiPrompts, fixedParts } = parseTemplate(template);
+
+  let result = fixedParts[0];
+  for (let i = 0; i < aiPrompts.length; i++) {
+    const varKey = `var${i + 1}` as const;
+    const varValue = vars[varKey] || "";
+    result += varValue + fixedParts[i + 1];
+  }
+
+  return result;
+}
diff --git a/apps/web/utils/ai/rule/create-rule-schema.ts b/apps/web/utils/ai/rule/create-rule-schema.ts
index f68eb182a5..bf288e9c39 100644
--- a/apps/web/utils/ai/rule/create-rule-schema.ts
+++ b/apps/web/utils/ai/rule/create-rule-schema.ts
@@ -44,7 +44,7 @@ export const createRuleSchema = z.object({
     .array(
       z.object({
         type: z.nativeEnum(ActionType).describe("The type of the action"),
-        static: z
+        fields: z
           .object({
             label: z
               .string()
@@ -78,43 +78,8 @@ export const createRuleSchema = z.object({
               .describe("The content of the email"),
           })
           .optional()
-          .describe("The static fields to use for the action"),
-        aiPrompts: z
-          .object({
-            label: z
-              .string()
-              .nullish()
-              .transform((v) => v ?? null)
-              .describe("The prompt to generate the label"),
-            to: z
-              .string()
-              .nullish()
-              .transform((v) => v ?? null)
-              .describe("The prompt to generate the to email address"),
-            cc: z
-              .string()
-              .nullish()
-              .transform((v) => v ?? null)
-              .describe("The prompt to generate the cc email address"),
-            bcc: z
-              .string()
-              .nullish()
-              .transform((v) => v ?? null)
-              .describe("The prompt to generate the bcc email address"),
-            subject: z
-              .string()
-              .nullish()
-              .transform((v) => v ?? null)
-              .describe("The prompt to generate the subject"),
-            content: z
-              .string()
-              .nullish()
-              .transform((v) => v ?? null)
-              .describe("The prompt to generate the content"),
-          })
-          .optional()
           .describe(
-            "If any of the fields are AI generated in real time based on the email being processed, the prompts to generate the fields",
+            "The fields to use for the action. Static text can be combined with dynamic values using double braces {{}}. For example: 'Hi {{sender's name}}' or 'Re: {{subject}}' or '{{when I'm available for a meeting}}'. Dynamic values will be replaced with actual email data when the rule is executed. Dynamic values are generated in real time by the AI. Only use dynamic values where absolutely necessary. Otherwise, use plain static text. A field can be also be fully static or fully dynamic.",
           ),
       }),
     )
diff --git a/apps/web/utils/ai/rule/create-rule.ts b/apps/web/utils/ai/rule/create-rule.ts
index ad0f255422..acc78355ff 100644
--- a/apps/web/utils/ai/rule/create-rule.ts
+++ b/apps/web/utils/ai/rule/create-rule.ts
@@ -34,20 +34,12 @@ export async function aiCreateRule(
     ...result,
     actions: result.actions.map((action) => ({
       type: action.type,
-      // static
-      label: action.static?.label ?? undefined,
-      to: action.static?.to ?? undefined,
-      cc: action.static?.cc ?? undefined,
-      bcc: action.static?.bcc ?? undefined,
-      subject: action.static?.subject ?? undefined,
-      content: action.static?.content ?? undefined,
-      // ai
-      labelPrompt: action.aiPrompts?.label ?? undefined,
-      toPrompt: action.aiPrompts?.to ?? undefined,
-      ccPrompt: action.aiPrompts?.cc ?? undefined,
-      bccPrompt: action.aiPrompts?.bcc ?? undefined,
-      subjectPrompt: action.aiPrompts?.subject ?? undefined,
-      contentPrompt: action.aiPrompts?.content ?? undefined,
+      label: action.fields?.label ?? undefined,
+      to: action.fields?.to ?? undefined,
+      cc: action.fields?.cc ?? undefined,
+      bcc: action.fields?.bcc ?? undefined,
+      subject: action.fields?.subject ?? undefined,
+      content: action.fields?.content ?? undefined,
     })),
   };
 }
diff --git a/apps/web/utils/ai/rule/prompt-to-rules.ts b/apps/web/utils/ai/rule/prompt-to-rules.ts
index fe56b32dab..f1cd349f31 100644
--- a/apps/web/utils/ai/rule/prompt-to-rules.ts
+++ b/apps/web/utils/ai/rule/prompt-to-rules.ts
@@ -50,20 +50,12 @@ export async function aiPromptToRules({
     ...rule,
     actions: rule.actions.map((action) => ({
       type: action.type,
-      // static
-      label: action.static?.label ?? undefined,
-      to: action.static?.to ?? undefined,
-      cc: action.static?.cc ?? undefined,
-      bcc: action.static?.bcc ?? undefined,
-      subject: action.static?.subject ?? undefined,
-      content: action.static?.content ?? undefined,
-      // ai
-      labelPrompt: action.aiPrompts?.label ?? undefined,
-      toPrompt: action.aiPrompts?.to ?? undefined,
-      ccPrompt: action.aiPrompts?.cc ?? undefined,
-      bccPrompt: action.aiPrompts?.bcc ?? undefined,
-      subjectPrompt: action.aiPrompts?.subject ?? undefined,
-      contentPrompt: action.aiPrompts?.content ?? undefined,
+      label: action.fields?.label ?? undefined,
+      to: action.fields?.to ?? undefined,
+      cc: action.fields?.cc ?? undefined,
+      bcc: action.fields?.bcc ?? undefined,
+      subject: action.fields?.subject ?? undefined,
+      content: action.fields?.content ?? undefined,
     })),
   }));
 }
diff --git a/apps/web/utils/risk.test.ts b/apps/web/utils/risk.test.ts
new file mode 100644
index 0000000000..0e5bd47e4d
--- /dev/null
+++ b/apps/web/utils/risk.test.ts
@@ -0,0 +1,205 @@
+import { describe, it, expect, vi } from "vitest";
+import { getRiskLevel, getActionRiskLevel } from "./risk";
+import { RuleType } from "@prisma/client";
+import type { RulesResponse } from "@/app/api/user/rules/route";
+
+// Run with:
+// pnpm test risk.test.ts
+
+vi.mock("server-only", () => ({}));
+
+describe("getActionRiskLevel", () => {
+  const testCases = [
+    {
+      name: "returns very-high risk for fully dynamic content and recipient with automation",
+      action: {
+        subject: "{{dynamic}}",
+        content: "{{dynamic}}",
+        to: "{{dynamic}}",
+        cc: "",
+        bcc: "",
+      },
+      hasAutomation: true,
+      ruleType: RuleType.AI,
+      expectedLevel: "very-high",
+      expectedMessageContains: "Very High Risk",
+    },
+    {
+      name: "returns high risk for fully dynamic recipient with automation",
+      action: {
+        subject: "",
+        content: "",
+        to: "{{dynamic}}",
+        cc: "",
+        bcc: "",
+      },
+      hasAutomation: true,
+      ruleType: RuleType.AI,
+      expectedLevel: "high",
+      expectedMessageContains: "High Risk",
+    },
+    {
+      name: "returns medium risk for partially dynamic content with automation",
+      action: {
+        subject: "Hello {{name}}",
+        content: "How are you {{name}}?",
+        to: "static@example.com",
+        cc: "",
+        bcc: "",
+      },
+      hasAutomation: true,
+      ruleType: RuleType.AI,
+      expectedLevel: "medium",
+      expectedMessageContains: "Medium Risk",
+    },
+    {
+      name: "returns low risk for static content and recipient",
+      action: {
+        subject: "Static Subject",
+        content: "Static Content",
+        to: "static@example.com",
+        cc: "",
+        bcc: "",
+      },
+      hasAutomation: false,
+      ruleType: RuleType.AI,
+      expectedLevel: "low",
+      expectedMessageContains: "Low Risk",
+    },
+    {
+      name: "returns medium risk for dynamic recipient without automation",
+      action: {
+        subject: "Static Subject",
+        content: "Static Content",
+        to: "{{dynamic}}",
+        cc: "",
+        bcc: "",
+      },
+      hasAutomation: false,
+      ruleType: RuleType.AI,
+      expectedLevel: "medium",
+      expectedMessageContains: "Medium Risk",
+    },
+    {
+      name: "returns medium risk for dynamic cc/bcc without automation",
+      action: {
+        subject: "Static Subject",
+        content: "Static Content",
+        to: "static@example.com",
+        cc: "{{dynamic}}",
+        bcc: "",
+      },
+      hasAutomation: false,
+      ruleType: RuleType.AI,
+      expectedLevel: "medium",
+      expectedMessageContains: "Medium Risk",
+    },
+  ];
+
+  testCases.forEach(
+    ({
+      name,
+      action,
+      hasAutomation,
+      ruleType,
+      expectedLevel,
+      expectedMessageContains,
+    }) => {
+      it(name, () => {
+        const result = getActionRiskLevel(action, hasAutomation, ruleType);
+        expect(result.level).toBe(expectedLevel);
+        expect(result.message).toContain(expectedMessageContains);
+      });
+    },
+  );
+});
+
+describe("getRiskLevel", () => {
+  const getRiskLevelTests = [
+    {
+      name: "returns the highest risk level among actions",
+      rule: {
+        actions: [
+          {
+            subject: "{{dynamic}}",
+            content: "Static Content",
+            to: "static@example.com",
+            cc: "",
+            bcc: "",
+          },
+          {
+            subject: "Static Subject",
+            content: "Static Content",
+            to: "{{dynamic}}",
+            cc: "",
+            bcc: "",
+          },
+        ],
+        automate: true,
+        type: RuleType.AI,
+      } as RulesResponse[number],
+      expectedLevel: "high",
+      expectedMessageContains: "High Risk",
+    },
+    {
+      name: "returns medium risk when one action is medium and another is low",
+      rule: {
+        actions: [
+          {
+            subject: "{{dynamic}}",
+            content: "Static Content",
+            to: "static@example.com",
+            cc: "",
+            bcc: "",
+          },
+          {
+            subject: "Static Subject",
+            content: "Static Content",
+            to: "static@example.com",
+            cc: "",
+            bcc: "",
+          },
+        ],
+        automate: false,
+        type: RuleType.AI,
+      } as RulesResponse[number],
+      expectedLevel: "medium",
+      expectedMessageContains: "Medium Risk",
+    },
+    {
+      name: "returns low risk when all actions are low risk",
+      rule: {
+        actions: [
+          {
+            subject: "Static Subject",
+            content: "Static Content",
+            to: "static@example.com",
+            cc: "",
+            bcc: "",
+          },
+          {
+            subject: "Another Static Subject",
+            content: "Another Static Content",
+            to: "another@example.com",
+            cc: "",
+            bcc: "",
+          },
+        ],
+        automate: false,
+        type: RuleType.AI,
+      } as RulesResponse[number],
+      expectedLevel: "low",
+      expectedMessageContains: "Low Risk",
+    },
+  ];
+
+  getRiskLevelTests.forEach(
+    ({ name, rule, expectedLevel, expectedMessageContains }) => {
+      it(name, () => {
+        const result = getRiskLevel(rule);
+        expect(result.level).toBe(expectedLevel);
+        expect(result.message).toContain(expectedMessageContains);
+      });
+    },
+  );
+});
diff --git a/apps/web/utils/risk.ts b/apps/web/utils/risk.ts
index 87702245fb..1d4e6910aa 100644
--- a/apps/web/utils/risk.ts
+++ b/apps/web/utils/risk.ts
@@ -1,76 +1,173 @@
 import type { RulesResponse } from "@/app/api/user/rules/route";
 import { RuleType } from "@prisma/client";
 
-export type RiskLevel = "low" | "medium" | "high" | "very-high";
+const RISK_LEVELS = {
+  VERY_HIGH: "very-high",
+  HIGH: "high",
+  MEDIUM: "medium",
+  LOW: "low",
+} as const;
 
-export function getRiskLevel(
-  rule: Pick<RulesResponse[number], "actions" | "automate" | "type">,
+export type RiskLevel = (typeof RISK_LEVELS)[keyof typeof RISK_LEVELS];
+
+export function getActionRiskLevel(
+  action: Pick<
+    RulesResponse[number]["actions"][number],
+    "subject" | "content" | "to" | "cc" | "bcc"
+  >,
+  isAutomated: boolean,
+  ruleType: RuleType,
 ): {
   level: RiskLevel;
   message: string;
 } {
-  const hasAiGeneratedContent = rule.actions.some(isAiGeneratedContent);
-  const hasAiGeneratedTo = rule.actions.some(isAiGeneratedTo);
+  const fieldStatus = getFieldsDynamicStatus(action);
 
-  if (hasAiGeneratedContent && hasAiGeneratedTo && rule.automate) {
-    const level = rule.type === RuleType.AI ? "very-high" : "high";
+  const contentFields = [fieldStatus.subject, fieldStatus.content];
+  const recipientFields = [fieldStatus.to, fieldStatus.cc, fieldStatus.bcc];
 
-    return {
-      level,
-      message: `${
-        level === "very-high" ? "Very High Risk" : "High Risk"
-      }: The AI can generate content and send it to any address. A malicious actor could trick the AI to send spam or other unwanted emails on your behalf. Note: for any given email, the AI only has information to your rules and the content of the email it is replying to.`,
-    };
-  }
+  const hasFullyDynamicContent = hasAnyFieldWithStatus(
+    contentFields,
+    "fully-dynamic",
+  );
+  const hasPartiallyDynamicContent = hasAnyFieldWithStatus(
+    contentFields,
+    "partially-dynamic",
+  );
+  const hasAnyDynamicContent =
+    hasFullyDynamicContent || hasPartiallyDynamicContent;
 
-  if (hasAiGeneratedTo && rule.automate) {
-    return {
-      level: "high",
-      message:
-        "High Risk: The AI can send emails to any address. A malicious actor could use this to send spam or other unwanted emails on your behalf.",
-    };
-  }
+  const hasFullyDynamicRecipient = hasAnyFieldWithStatus(
+    recipientFields,
+    "fully-dynamic",
+  );
+  const hasPartiallyDynamicRecipient = hasAnyFieldWithStatus(
+    recipientFields,
+    "partially-dynamic",
+  );
+  const hasAnyDynamicRecipient =
+    hasFullyDynamicRecipient || hasPartiallyDynamicRecipient;
 
-  if (hasAiGeneratedContent && rule.automate) {
-    return {
-      level: "medium",
-      message:
-        "Medium Risk: The AI can automatically generate and send email content. A malicious actor could potentially trick the AI into generating unwanted or inappropriate content in your emails.",
-    };
+  // Handle automated cases first
+  if (isAutomated) {
+    if (hasFullyDynamicContent && hasFullyDynamicRecipient) {
+      const level =
+        ruleType === RuleType.AI ? RISK_LEVELS.VERY_HIGH : RISK_LEVELS.HIGH;
+      return {
+        level,
+        message: `${level === RISK_LEVELS.VERY_HIGH ? "Very High" : "High"} Risk: The AI can generate any content and send it to any address. A malicious actor could trick the AI to send spam or other unwanted emails on your behalf.`,
+      };
+    }
+
+    if (hasFullyDynamicRecipient) {
+      return {
+        level: RISK_LEVELS.HIGH,
+        message:
+          "High Risk: The AI can send emails to any address. A malicious actor could use this to send spam or other unwanted emails on your behalf.",
+      };
+    }
+
+    if (hasFullyDynamicContent) {
+      return {
+        level: RISK_LEVELS.HIGH,
+        message:
+          "High Risk: The AI can automatically generate and send any email content. A malicious actor could potentially trick the AI into generating unwanted or inappropriate content.",
+      };
+    }
+
+    if (hasPartiallyDynamicContent || hasPartiallyDynamicRecipient) {
+      return {
+        level: RISK_LEVELS.MEDIUM,
+        message:
+          "Medium Risk: The AI can generate content or recipients using templates. While more constrained than fully dynamic content, review the templates carefully.",
+      };
+    }
   }
 
-  if ((hasAiGeneratedContent || hasAiGeneratedTo) && !rule.automate) {
+  // Non-automated cases
+  if (hasAnyDynamicContent || hasAnyDynamicRecipient) {
     return {
-      level: "medium",
+      level: RISK_LEVELS.MEDIUM,
       message:
         "Medium Risk: The AI can generate content or recipients, but requires manual approval. Review the AI's suggestions carefully before approving.",
     };
   }
 
-  return { level: "low", message: "" };
+  return {
+    level: RISK_LEVELS.LOW,
+    message: "Low Risk: All content and recipients are static.",
+  };
 }
 
-function isAiGeneratedContent(
-  action: Pick<
-    RulesResponse[number]["actions"][number],
-    "subjectPrompt" | "contentPrompt"
-  >,
+function hasAnyFieldWithStatus(
+  fields: (string | null)[],
+  status: "fully-dynamic" | "partially-dynamic",
 ) {
-  return (
-    typeof action.subjectPrompt === "string" ||
-    typeof action.contentPrompt === "string"
+  return fields.some((field) => field === status);
+}
+
+function compareRiskLevels(a: RiskLevel, b: RiskLevel): RiskLevel {
+  const riskOrder: Record<RiskLevel, number> = {
+    [RISK_LEVELS.VERY_HIGH]: 4,
+    [RISK_LEVELS.HIGH]: 3,
+    [RISK_LEVELS.MEDIUM]: 2,
+    [RISK_LEVELS.LOW]: 1,
+  };
+  return riskOrder[a] >= riskOrder[b] ? a : b;
+}
+
+export function getRiskLevel(
+  rule: Pick<RulesResponse[number], "actions" | "automate" | "type">,
+): {
+  level: RiskLevel;
+  message: string;
+} {
+  // Get risk level for each action and return the highest risk
+  return rule.actions.reduce<{ level: RiskLevel; message: string }>(
+    (highestRisk, action) => {
+      const actionRisk = getActionRiskLevel(action, rule.automate, rule.type);
+      if (
+        compareRiskLevels(actionRisk.level, highestRisk.level) ===
+        actionRisk.level
+      ) {
+        return actionRisk;
+      }
+      return highestRisk;
+    },
+    {
+      level: RISK_LEVELS.LOW,
+      message: "Low Risk: All content and recipients are static.",
+    },
   );
 }
 
-function isAiGeneratedTo(
+function getFieldsDynamicStatus(
   action: Pick<
     RulesResponse[number]["actions"][number],
-    "toPrompt" | "ccPrompt" | "bccPrompt"
+    "subject" | "content" | "to" | "cc" | "bcc"
   >,
 ) {
-  return (
-    typeof action.toPrompt === "string" ||
-    typeof action.ccPrompt === "string" ||
-    typeof action.bccPrompt === "string"
-  );
+  const checkFieldStatus = (field: string | null) => {
+    if (!field) return null;
+    if (isFullyDynamicField(field)) return "fully-dynamic";
+    if (isPartiallyDynamicField(field)) return "partially-dynamic";
+    return "static";
+  };
+
+  return {
+    subject: checkFieldStatus(action.subject),
+    content: checkFieldStatus(action.content),
+    to: checkFieldStatus(action.to),
+    cc: checkFieldStatus(action.cc),
+    bcc: checkFieldStatus(action.bcc),
+  };
+}
+
+// Helper functions
+function isFullyDynamicField(field: string) {
+  return /^\{\{.*?\}\}$/.test(field);
+}
+
+function isPartiallyDynamicField(field: string) {
+  return /\{\{.*?\}\}/.test(field);
 }
diff --git a/apps/web/utils/template.ts b/apps/web/utils/template.ts
new file mode 100644
index 0000000000..c7b4966c3e
--- /dev/null
+++ b/apps/web/utils/template.ts
@@ -0,0 +1,3 @@
+// Returns true if contains "{{" and "}}".
+export const hasVariables = (text: string | undefined | null) =>
+  text ? /\{\{.*?\}\}/g.test(text) : false;
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 1f4124cc1a..db97f3acae 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -251,9 +251,6 @@ importers:
       '@vercel/analytics':
         specifier: ^1.3.2
         version: 1.3.2(next@14.2.15(@babel/core@7.24.7)(@opentelemetry/api@1.9.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1))(react@18.3.1)
-      '@vercel/speed-insights':
-        specifier: ^1.0.14
-        version: 1.0.14(next@14.2.15(@babel/core@7.24.7)(@opentelemetry/api@1.9.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1))(react@18.3.1)(svelte@4.2.12)(vue@3.4.19(typescript@5.6.3))
       ai:
         specifier: ^3.4.31
         version: 3.4.31(openai@4.70.2(encoding@0.1.13)(zod@3.23.8))(react@18.3.1)(solid-js@1.8.15)(sswr@2.1.0(svelte@4.2.12))(svelte@4.2.12)(vue@3.4.19(typescript@5.6.3))(zod@3.23.8)
@@ -5186,29 +5183,6 @@ packages:
       react:
         optional: true
 
-  '@vercel/speed-insights@1.0.14':
-    resolution: {integrity: sha512-env1BkPddz1UaEZwBL4GmfRksMi2LbiYaKuoxMQjfLk83aEh7kkWMukkUhpQVs717NE6nnD+1+KO85GZHOZ4nQ==}
-    peerDependencies:
-      '@sveltejs/kit': ^1 || ^2
-      next: '>= 13'
-      react: ^18 || ^19 || ^19.0.0-rc
-      svelte: '>= 4'
-      vue: ^3
-      vue-router: ^4
-    peerDependenciesMeta:
-      '@sveltejs/kit':
-        optional: true
-      next:
-        optional: true
-      react:
-        optional: true
-      svelte:
-        optional: true
-      vue:
-        optional: true
-      vue-router:
-        optional: true
-
   '@vercel/stega@0.1.2':
     resolution: {integrity: sha512-P7mafQXjkrsoyTRppnt0N21udKS9wUmLXHRyP9saLXLHw32j/FgUJ3FscSWgvSqRs4cj7wKZtwqJEvWJ2jbGmA==}
 
@@ -16873,13 +16847,6 @@ snapshots:
       next: 14.2.15(@babel/core@7.24.7)(@opentelemetry/api@1.9.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       react: 18.3.1
 
-  '@vercel/speed-insights@1.0.14(next@14.2.15(@babel/core@7.24.7)(@opentelemetry/api@1.9.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1))(react@18.3.1)(svelte@4.2.12)(vue@3.4.19(typescript@5.6.3))':
-    optionalDependencies:
-      next: 14.2.15(@babel/core@7.24.7)(@opentelemetry/api@1.9.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      react: 18.3.1
-      svelte: 4.2.12
-      vue: 3.4.19(typescript@5.6.3)
-
   '@vercel/stega@0.1.2': {}
 
   '@vercel/style-guide@6.0.0(@next/eslint-plugin-next@14.2.15)(eslint@9.10.0(jiti@2.4.0))(prettier@3.3.3)(typescript@5.6.3)(vitest@2.1.4(@types/node@22.8.6)(jsdom@25.0.1)(terser@5.26.0))':
@@ -18547,8 +18514,8 @@ snapshots:
       '@typescript-eslint/parser': 8.8.1(eslint@8.57.1)(typescript@5.6.3)
       eslint: 8.57.1
       eslint-import-resolver-node: 0.3.9
-      eslint-import-resolver-typescript: 3.6.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.29.1)(eslint@8.57.1)
-      eslint-plugin-import: 2.29.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-typescript@3.6.1)(eslint@8.57.1)
+      eslint-import-resolver-typescript: 3.6.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.29.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1))(eslint@8.57.1)
+      eslint-plugin-import: 2.29.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.29.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1))(eslint@8.57.1))(eslint@8.57.1)
       eslint-plugin-jsx-a11y: 6.8.0(eslint@8.57.1)
       eslint-plugin-react: 7.35.0(eslint@8.57.1)
       eslint-plugin-react-hooks: 4.6.0(eslint@8.57.1)
@@ -18596,13 +18563,13 @@ snapshots:
       - eslint-import-resolver-webpack
       - supports-color
 
-  eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.29.1)(eslint@8.57.1):
+  eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.29.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1))(eslint@8.57.1):
     dependencies:
       debug: 4.3.6
       enhanced-resolve: 5.15.0
       eslint: 8.57.1
-      eslint-module-utils: 2.8.0(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1)(eslint@8.57.1)
-      eslint-plugin-import: 2.29.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-typescript@3.6.1)(eslint@8.57.1)
+      eslint-module-utils: 2.8.0(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.29.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1))(eslint@8.57.1))(eslint@8.57.1)
+      eslint-plugin-import: 2.29.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.29.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1))(eslint@8.57.1))(eslint@8.57.1)
       fast-glob: 3.3.2
       get-tsconfig: 4.7.5
       is-core-module: 2.13.1
@@ -18624,14 +18591,14 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  eslint-module-utils@2.8.0(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1)(eslint@8.57.1):
+  eslint-module-utils@2.8.0(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.29.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1))(eslint@8.57.1))(eslint@8.57.1):
     dependencies:
       debug: 3.2.7
     optionalDependencies:
       '@typescript-eslint/parser': 8.8.1(eslint@8.57.1)(typescript@5.6.3)
       eslint: 8.57.1
       eslint-import-resolver-node: 0.3.9
-      eslint-import-resolver-typescript: 3.6.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.29.1)(eslint@8.57.1)
+      eslint-import-resolver-typescript: 3.6.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.29.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1))(eslint@8.57.1)
     transitivePeerDependencies:
       - supports-color
 
@@ -18651,7 +18618,7 @@ snapshots:
       eslint: 9.10.0(jiti@2.4.0)
       ignore: 5.3.1
 
-  eslint-plugin-import@2.29.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-typescript@3.6.1)(eslint@8.57.1):
+  eslint-plugin-import@2.29.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.29.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1))(eslint@8.57.1))(eslint@8.57.1):
     dependencies:
       array-includes: 3.1.8
       array.prototype.findlastindex: 1.2.3
@@ -18661,7 +18628,7 @@ snapshots:
       doctrine: 2.1.0
       eslint: 8.57.1
       eslint-import-resolver-node: 0.3.9
-      eslint-module-utils: 2.8.0(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1)(eslint@8.57.1)
+      eslint-module-utils: 2.8.0(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.29.1(@typescript-eslint/parser@8.8.1(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1))(eslint@8.57.1))(eslint@8.57.1)
       hasown: 2.0.2
       is-core-module: 2.13.1
       is-glob: 4.0.3