diff --git a/apps/web/app/(app)/automation/Rules.tsx b/apps/web/app/(app)/automation/Rules.tsx
index 6050abea37..242b86353f 100644
--- a/apps/web/app/(app)/automation/Rules.tsx
+++ b/apps/web/app/(app)/automation/Rules.tsx
@@ -245,7 +245,7 @@ export function Rules() {
           <Button asChild variant="outline">
             <Link href="/automation?tab=prompt">
               <PenIcon className="mr-2 hidden h-4 w-4 md:block" />
-              Add Rule via Prompt File
+              Add Rule via Prompt Tab
             </Link>
           </Button>
           <Button asChild variant="outline">
diff --git a/apps/web/app/api/google/webhook/group-rule.ts b/apps/web/app/api/google/webhook/group-rule.ts
index df99732017..d9c6aca756 100644
--- a/apps/web/app/api/google/webhook/group-rule.ts
+++ b/apps/web/app/api/google/webhook/group-rule.ts
@@ -2,11 +2,7 @@ import type { gmail_v1 } from "@googleapis/gmail";
 import type { ParsedMessage } from "@/utils/types";
 import type { User } from "@prisma/client";
 import { emailToContent } from "@/utils/mail";
-import {
-  getActionItemsFromAiArgsResponse,
-  getActionsWithParameters,
-  getArgsAiResponse,
-} from "@/utils/ai/choose-rule/ai-choose-args";
+import { getActionItemsWithAiArgs } from "@/utils/ai/choose-rule/ai-choose-args";
 import {
   findMatchingGroup,
   getGroups,
@@ -60,20 +56,12 @@ export async function handleGroupRule({
     }),
   };
 
-  // generate args
-  const aiArgsResponse =
-    getActionsWithParameters(match.rule.actions).length > 0
-      ? await getArgsAiResponse({
-          email,
-          selectedRule: match.rule,
-          user,
-        })
-      : undefined;
-
-  const actionItems = getActionItemsFromAiArgsResponse(
-    aiArgsResponse,
-    match.rule.actions,
-  );
+  // get action items with args
+  const actionItems = await getActionItemsWithAiArgs({
+    email,
+    user,
+    selectedRule: match.rule,
+  });
 
   // handle action
   // TODO isThread check to skip
diff --git a/apps/web/app/api/google/webhook/process-history.ts b/apps/web/app/api/google/webhook/process-history.ts
index 45aac8993f..94ab84f6db 100644
--- a/apps/web/app/api/google/webhook/process-history.ts
+++ b/apps/web/app/api/google/webhook/process-history.ts
@@ -24,6 +24,9 @@ import { runRulesOnMessage } from "@/utils/ai/choose-rule/run-rules";
 import { blockUnsubscribedEmails } from "@/app/api/google/webhook/block-unsubscribed-emails";
 import { categorizeSender } from "@/utils/actions/categorize";
 import { unwatchEmails } from "@/app/api/google/watch/controller";
+import { createScopedLogger } from "@/utils/logger";
+
+const logger = createScopedLogger("Process History");
 
 export async function processHistoryForUser(
   decodedData: {
@@ -70,7 +73,7 @@ export async function processHistoryForUser(
   });
 
   if (!account) {
-    console.error(`Google webhook: Account not found. email: ${email}`);
+    logger.error(`Account not found. email: ${email}`);
     return NextResponse.json({ ok: true });
   }
 
@@ -79,7 +82,7 @@ export async function processHistoryForUser(
     : undefined;
 
   if (!premium) {
-    console.log(`Google webhook: Account not premium. email: ${email}`);
+    logger.log(`Account not premium. email: ${email}`);
     await unwatchEmails(account);
     return NextResponse.json({ ok: true });
   }
@@ -94,9 +97,7 @@ export async function processHistoryForUser(
   );
 
   if (!userHasAiAccess && !userHasColdEmailAccess) {
-    console.debug(
-      `Google webhook: does not have hasAiOrColdEmailAccess. email: ${email}`,
-    );
+    console.debug(`does not have hasAiOrColdEmailAccess. email: ${email}`);
     await unwatchEmails(account);
     return NextResponse.json({ ok: true });
   }
@@ -107,13 +108,13 @@ export async function processHistoryForUser(
     account.user.coldEmailBlocker !== ColdEmailSetting.DISABLED;
   if (!hasAutomationRules && !shouldBlockColdEmails) {
     console.debug(
-      `Google webhook: has no rules set and cold email blocker disabled. email: ${email}`,
+      `has no rules set and cold email blocker disabled. email: ${email}`,
     );
     return NextResponse.json({ ok: true });
   }
 
   if (!account.access_token || !account.refresh_token) {
-    console.error(
+    logger.error(
       `Missing access or refresh token. User needs to re-authenticate. email: ${email}`,
     );
     return NextResponse.json({ ok: true });
@@ -121,7 +122,7 @@ export async function processHistoryForUser(
 
   if (!account.user.email) {
     // shouldn't ever happen
-    console.error("Missing user email.", email);
+    logger.error(`Missing user email: ${email}`);
     return NextResponse.json({ ok: true });
   }
 
@@ -145,8 +146,8 @@ export async function processHistoryForUser(
         historyId - 500, // avoid going too far back
       ).toString();
 
-    console.log(
-      `Webhook: Listing history... Start: ${startHistoryId} lastSyncedHistoryId: ${account.user.lastSyncedHistoryId} gmailHistoryId: ${startHistoryId} email: ${email}`,
+    logger.log(
+      `Listing history... Start: ${startHistoryId} lastSyncedHistoryId: ${account.user.lastSyncedHistoryId} gmailHistoryId: ${startHistoryId} email: ${email}`,
     );
 
     const history = await gmail.users.history.list({
@@ -160,8 +161,8 @@ export async function processHistoryForUser(
     });
 
     if (history.data.history) {
-      console.log(
-        `Webhook: Processing... email: ${email} startHistoryId: ${startHistoryId} historyId: ${history.data.historyId}`,
+      logger.log(
+        `Processing... email: ${email} startHistoryId: ${startHistoryId} historyId: ${history.data.historyId}`,
       );
 
       await processHistory({
@@ -186,8 +187,8 @@ export async function processHistoryForUser(
         },
       });
     } else {
-      console.log(
-        `Webhook: No history. startHistoryId: ${startHistoryId}. ${JSON.stringify(decodedData)}`,
+      logger.log(
+        `No history. startHistoryId: ${startHistoryId}. ${JSON.stringify(decodedData)}`,
       );
 
       // important to save this or we can get into a loop with never receiving history
@@ -197,12 +198,12 @@ export async function processHistoryForUser(
       });
     }
 
-    console.log(`Webhook: Completed. ${JSON.stringify(decodedData)}`);
+    logger.log(`Completed. ${JSON.stringify(decodedData)}`);
 
     return NextResponse.json({ ok: true });
   } catch (error) {
     captureException(error, { extra: { decodedData } }, email);
-    console.error("Error processing webhook", error, decodedData);
+    logger.error("Error processing webhook", 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();
@@ -260,7 +261,7 @@ async function processHistory(options: ProcessHistoryOptions) {
           { extra: { email, messageId: m.message?.id } },
           email,
         );
-        console.error(`Error processing history item. email: ${email}`, error);
+        logger.error(`Error processing history item. email: ${email}`, error);
       }
     }
   }
@@ -292,7 +293,7 @@ async function processHistoryItem(
   if (!messageId) return;
   if (!threadId) return;
 
-  console.log(
+  logger.log(
     `Getting message... email: ${user.email} messageId: ${messageId} threadId: ${threadId}`,
   );
 
@@ -309,7 +310,7 @@ async function processHistoryItem(
 
     // if the rule has already been executed, skip
     if (hasExistingRule) {
-      console.log("Skipping. Rule already exists.");
+      logger.log("Skipping. Rule already exists.");
       return;
     }
 
@@ -326,7 +327,7 @@ async function processHistoryItem(
     });
 
     if (blocked) {
-      console.log(
+      logger.log(
         `Skipping. Blocked unsubscribed email. email: ${user.email} messageId: ${messageId} threadId: ${threadId}`,
       );
       return;
@@ -341,7 +342,7 @@ async function processHistoryItem(
     );
 
     if (shouldRunBlocker) {
-      console.log("Running cold email blocker...");
+      logger.log("Running cold email blocker...");
 
       const hasPreviousEmail = await hasPreviousEmailsFromSenderOrDomain(
         gmail,
@@ -386,7 +387,7 @@ async function processHistoryItem(
     }
 
     if (hasAutomationRules && hasAiAutomationAccess) {
-      console.log("Running rules...");
+      logger.log("Running rules...");
 
       await runRulesOnMessage({
         gmail,
@@ -399,7 +400,7 @@ async function processHistoryItem(
   } catch (error: any) {
     // gmail bug or snoozed email: https://stackoverflow.com/questions/65290987/gmail-api-getmessage-method-returns-404-for-message-gotten-from-listhistory-meth
     if (error.message === "Requested entity was not found.") {
-      console.log(
+      logger.log(
         `Message not found. email: ${user.email} messageId: ${messageId} threadId: ${threadId}`,
       );
       return;
diff --git a/apps/web/app/api/google/webhook/static-rule.ts b/apps/web/app/api/google/webhook/static-rule.ts
index f0772c811e..15cfe203a9 100644
--- a/apps/web/app/api/google/webhook/static-rule.ts
+++ b/apps/web/app/api/google/webhook/static-rule.ts
@@ -1,11 +1,7 @@
 import type { gmail_v1 } from "@googleapis/gmail";
 import type { ParsedMessage, RuleWithActions } from "@/utils/types";
 import { RuleType, type User } from "@prisma/client";
-import {
-  getActionItemsFromAiArgsResponse,
-  getActionsWithParameters,
-  getArgsAiResponse,
-} from "@/utils/ai/choose-rule/ai-choose-args";
+import { getActionItemsWithAiArgs } from "@/utils/ai/choose-rule/ai-choose-args";
 import { emailToContent } from "@/utils/mail";
 import { saveExecutedRule } from "@/utils/ai/choose-rule/choose-and-execute";
 import { executeAct } from "@/utils/ai/choose-rule/execute";
@@ -52,20 +48,12 @@ export async function handleStaticRule({
     }),
   };
 
-  // generate args
-  const aiArgsResponse =
-    getActionsWithParameters(staticRule.actions).length > 0
-      ? await getArgsAiResponse({
-          email,
-          selectedRule: staticRule,
-          user,
-        })
-      : undefined;
-
-  const actionItems = getActionItemsFromAiArgsResponse(
-    aiArgsResponse,
-    staticRule.actions,
-  );
+  // get action items with args
+  const actionItems = await getActionItemsWithAiArgs({
+    email,
+    user,
+    selectedRule: staticRule,
+  });
 
   // handle action
   // TODO isThread check to skip
diff --git a/apps/web/utils/ai/actions.ts b/apps/web/utils/ai/actions.ts
index 698d760813..8bf7c5ced9 100644
--- a/apps/web/utils/ai/actions.ts
+++ b/apps/web/utils/ai/actions.ts
@@ -9,6 +9,9 @@ import {
 } from "@/utils/gmail/label";
 import { markSpam } from "@/utils/gmail/spam";
 import type { Attachment } from "@/utils/types/mail";
+import { createScopedLogger } from "@/utils/logger";
+
+const logger = createScopedLogger("ai-actions");
 
 export type EmailForAction = {
   threadId: string;
@@ -369,7 +372,8 @@ export const runActionFunction = async (
   action: ActionItem,
   userEmail: string,
 ) => {
-  console.log("Running action", { actionType: action.type, userEmail });
+  logger.log("Running action", { actionType: action.type, userEmail });
+  logger.trace("Running action:", action);
 
   const { type, ...args } = action;
   switch (type) {
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 814ec571a2..174062fc47 100644
--- a/apps/web/utils/ai/choose-rule/ai-choose-args.ts
+++ b/apps/web/utils/ai/choose-rule/ai-choose-args.ts
@@ -1,101 +1,86 @@
 import { z } from "zod";
 import type { UserAIFields } from "@/utils/llms/types";
 import type { ActionItem } from "@/utils/ai/actions";
-import type { Action, ActionType, User } from "@prisma/client";
+import type { Action, User } from "@prisma/client";
 import { chatCompletionTools } from "@/utils/llms";
 import {
   type EmailForLLM,
   stringifyEmail,
 } from "@/utils/ai/choose-rule/stringify-email";
 import { type RuleWithActions, isDefined } from "@/utils/types";
+import { createScopedLogger } from "@/utils/logger";
 
-type AIGeneratedArgs = Record<
-  ActionType,
-  Record<keyof Omit<ActionItem, "type">, string>
->;
+const logger = createScopedLogger("AI Choose Args");
 
-// Returns parameters for a zod.object for the rule that must be AI generated
-function getToolParametersForRule(actions: Action[]) {
-  const actionsWithParameters = getActionsWithParameters(actions);
+export type ActionRequiringAi = {
+  actionId: string;
+  type: string;
+  zodParameters: z.ZodObject<Record<string, z.ZodString>>;
+};
 
-  // 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, z.ZodObject<any>> = {};
+export type ActionWithAiArgs = ActionRequiringAi & {
+  args: Record<string, string>;
+};
 
-  for (const action of actionsWithParameters) {
-    // count how many times we have already had this type
-    typeCount[action.type] = (typeCount[action.type] || 0) + 1;
-    parameters[
-      typeCount[action.type] === 1
-        ? action.type
-        : `${action.type}_${typeCount[action.type]}`
-    ] = action.parameters;
+// Returns the action items with the ai-generated args where needed
+export async function getActionItemsWithAiArgs({
+  email,
+  user,
+  selectedRule,
+}: {
+  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,
+    });
   }
 
-  return parameters;
-}
-
-export function getActionsWithParameters(actions: Action[]) {
-  return actions
-    .map((action) => {
-      const fields = getParameterFieldsForAction(action);
-
-      if (!Object.keys(fields).length) return;
-
-      const parameters = z.object(fields);
-
-      return {
-        type: action.type,
-        parameters,
-      };
-    })
-    .filter(isDefined);
-}
-
-function getParameterFieldsForAction({
-  labelPrompt,
-  subjectPrompt,
-  contentPrompt,
-  toPrompt,
-  ccPrompt,
-  bccPrompt,
-}: Action) {
-  const fields: Record<string, z.ZodString> = {};
+  // 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 (typeof labelPrompt === "string")
-    fields.label = z.string().describe("The email label");
-  if (typeof subjectPrompt === "string")
-    fields.subject = z.string().describe("The email subject");
-  if (typeof contentPrompt === "string")
-    fields.content = z.string().describe("The email content");
-  if (typeof toPrompt === "string")
-    fields.to = z.string().describe("The email recipient(s)");
-  if (typeof ccPrompt === "string")
-    fields.cc = z.string().describe("The cc recipient(s)");
-  if (typeof bccPrompt === "string")
-    fields.bcc = z.string().describe("The bcc recipient(s)");
+  logger.trace(
+    `getActionItemsWithAiArgs. Results: ${JSON.stringify(results, null, 2)}`,
+  );
 
-  return fields;
+  return results;
 }
 
-export async function getArgsAiResponse({
+async function getArgsAiResponse({
   email,
   user,
   selectedRule,
+  actionsRequiringAi,
 }: {
   email: EmailForLLM;
   user: Pick<User, "email" | "about"> & UserAIFields;
   selectedRule: RuleWithActions;
-}) {
-  console.log(
+  actionsRequiringAi: ActionRequiringAi[];
+}): Promise<ActionWithAiArgs[] | undefined> {
+  logger.log(
     `Generating args for rule ${selectedRule.name} (${selectedRule.id})`,
   );
 
-  const parameters = getToolParametersForRule(selectedRule.actions);
-
-  if (!Object.keys(parameters).length) {
-    console.log(
+  if (!actionsRequiringAi.length) {
+    logger.log(
       `Skipping. No parameters for rule ${selectedRule.name} (${selectedRule.id})`,
     );
     return;
@@ -121,7 +106,20 @@ ${stringifyEmail(email, 3000)}
 </email>
 `;
 
-  console.log("Calling chat completion tools");
+  const parameters = getToolParametersForRule(actionsRequiringAi);
+  const zodParameters = z.object(
+    Object.fromEntries(
+      Object.entries(parameters).map(([key, { zodParameters }]) => [
+        key,
+        zodParameters,
+      ]),
+    ),
+  );
+
+  logger.log("Calling chat completion tools");
+  logger.trace(`System: ${system}`);
+  logger.trace(`Prompt: ${prompt}`);
+  // logger.trace("Zod parameters:", zodToJsonSchema(zodParameters));
 
   const aiResponse = await chatCompletionTools({
     userAi: user,
@@ -130,7 +128,7 @@ ${stringifyEmail(email, 3000)}
     tools: {
       apply_rule: {
         description: "Apply the rule with the given arguments",
-        parameters: z.object(parameters),
+        parameters: zodParameters,
       },
     },
     label: "Args for rule",
@@ -141,25 +139,99 @@ ${stringifyEmail(email, 3000)}
 
   if (!toolCall?.toolName) return;
 
-  return toolCall.args;
-}
+  const toolCallArgs = toolCall.args;
 
-export function getActionItemsFromAiArgsResponse(
-  response: AIGeneratedArgs | undefined,
-  ruleActions: Action[],
-) {
-  return ruleActions.map((ra) => {
-    // use prefilled values where we have them
-    const a = response?.[ra.type] || ({} as any);
+  logger.trace(`Tool call args: ${JSON.stringify(toolCallArgs, null, 2)}`);
 
-    return {
-      type: ra.type,
-      label: ra.labelPrompt ? a.label : ra.label,
-      subject: ra.subjectPrompt ? a.subject : ra.subject,
-      content: ra.contentPrompt ? a.content : ra.content,
-      to: ra.toPrompt ? a.to : ra.to,
-      cc: ra.ccPrompt ? a.cc : ra.cc,
-      bcc: ra.bccPrompt ? a.bcc : ra.bcc,
-    };
+  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 results;
+}
+
+// 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,
+    };
+  }
+
+  return parameters;
+}
+
+// Returns the actions with the args that require ai-generation
+function getActionsWithZodParameters(actions: Action[]) {
+  return actions
+    .map((action) => {
+      const fields = getParameterFieldsForAction(action);
+
+      if (!Object.keys(fields).length) return;
+
+      const zodParameters = z.object(fields);
+
+      return {
+        actionId: action.id,
+        type: action.type,
+        zodParameters,
+      };
+    })
+    .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)");
+
+  return fields;
 }
diff --git a/apps/web/utils/ai/choose-rule/choose-and-execute.ts b/apps/web/utils/ai/choose-rule/choose-and-execute.ts
index a61718c8e3..6bf090c614 100644
--- a/apps/web/utils/ai/choose-rule/choose-and-execute.ts
+++ b/apps/web/utils/ai/choose-rule/choose-and-execute.ts
@@ -87,7 +87,20 @@ export async function saveExecutedRule(
   plannedAct: Awaited<ReturnType<typeof chooseRule>>,
 ) {
   const data: Prisma.ExecutedRuleCreateInput = {
-    actionItems: { createMany: { data: plannedAct.actionItems || [] } },
+    actionItems: {
+      createMany: {
+        data:
+          plannedAct.actionItems?.map((a) => ({
+            type: a.type,
+            label: a.label,
+            subject: a.subject,
+            content: a.content,
+            to: a.to,
+            cc: a.cc,
+            bcc: a.bcc,
+          })) || [],
+      },
+    },
     messageId,
     threadId,
     automated: !!plannedAct.rule?.automate,
diff --git a/apps/web/utils/ai/choose-rule/choose.ts b/apps/web/utils/ai/choose-rule/choose.ts
index 908ef38403..1744fc865e 100644
--- a/apps/web/utils/ai/choose-rule/choose.ts
+++ b/apps/web/utils/ai/choose-rule/choose.ts
@@ -1,9 +1,5 @@
 import type { ActionItem } from "@/utils/ai/actions";
-import {
-  getArgsAiResponse,
-  getActionItemsFromAiArgsResponse,
-  getActionsWithParameters,
-} from "@/utils/ai/choose-rule/ai-choose-args";
+import { getActionItemsWithAiArgs } from "@/utils/ai/choose-rule/ai-choose-args";
 import { getAiResponse } from "@/utils/ai/choose-rule/ai-choose-rule";
 import type { UserAIFields } from "@/utils/llms/types";
 import type { RuleWithActions } from "@/utils/types";
@@ -43,21 +39,11 @@ export async function chooseRule(options: ChooseRuleOptions): Promise<
 
   if (!selectedRule) return { reason: aiResponse?.reason };
 
-  const shouldAiGenerateArgs =
-    getActionsWithParameters(selectedRule.actions).length > 0;
-
-  const aiArgsResponse = shouldAiGenerateArgs
-    ? await getArgsAiResponse({
-        ...options,
-        email,
-        selectedRule,
-      })
-    : undefined;
-
-  const actionItems = getActionItemsFromAiArgsResponse(
-    aiArgsResponse,
-    selectedRule.actions,
-  );
+  const actionItems = await getActionItemsWithAiArgs({
+    email,
+    user,
+    selectedRule,
+  });
 
   return {
     rule: selectedRule,
diff --git a/apps/web/utils/logger.ts b/apps/web/utils/logger.ts
new file mode 100644
index 0000000000..09ecf97a57
--- /dev/null
+++ b/apps/web/utils/logger.ts
@@ -0,0 +1,43 @@
+type LogLevel = "log" | "error" | "warn" | "trace";
+type LogMessage = string | Record<string, unknown>;
+
+const colors = {
+  log: "\x1b[0m", // white
+  error: "\x1b[31m", // red
+  warn: "\x1b[33m", // yellow
+  trace: "\x1b[36m", // cyan
+  reset: "\x1b[0m",
+} as const;
+
+export function createScopedLogger(scope: string) {
+  const formatMessage = (level: LogLevel, message: LogMessage) => {
+    const prefix = `[${scope}]: `;
+
+    if (process.env.NODE_ENV === "development") {
+      return `${colors[level]}${prefix} ${
+        typeof message === "string" ? message : JSON.stringify(message, null, 2)
+      }${colors.reset}`;
+    }
+
+    return `${prefix} ${
+      typeof message === "string" ? message : JSON.stringify(message)
+    }`;
+  };
+
+  return {
+    log: (message: LogMessage, ...args: unknown[]) =>
+      console.log(formatMessage("log", message), ...args),
+
+    error: (message: LogMessage, ...args: unknown[]) =>
+      console.error(formatMessage("error", message), ...args),
+
+    warn: (message: LogMessage, ...args: unknown[]) =>
+      console.warn(formatMessage("warn", message), ...args),
+
+    trace: (message: LogMessage, ...args: unknown[]) => {
+      if (process.env.NODE_ENV === "development") {
+        console.log(formatMessage("trace", message), ...args);
+      }
+    },
+  };
+}