iris-chatbot 5.2.0 → 5.3.1

package/template/src/app/api/chat/route.ts

@@ -44,6 +44,8 @@ const LOCAL_TOOL_SYSTEM_INSTRUCTIONS = [
   "Calendar: You have direct access to the user's Apple Calendar via calendar_list_events and related tools. You CAN see their events—call the tools; do not say you cannot access or see their calendar. Never ask the user to paste their calendar, export it, or send a screenshot; you already have access. When they ask what's on the calendar, what's happening this/next weekend/month, or say 'check' or 'you can see', call calendar_list_events immediately with from/to for the range (e.g. next month → from: 'today', to: 'end of next month'; specific day → YYYY-MM-DD for both). Always pass calendar: 'all'. from/to support 'today', 'tomorrow', 'next week', 'end of next week', 'next month', 'end of next month'. Report the exact queried range from the tool result. For move/delete/reschedule: call calendar_list_events first to get uids. For rescheduling to a new time on the same calendar use calendar_update_event (preserves recurrence); for delete use calendar_delete_event; use calendar_move_event only when update is not sufficient (e.g. user says move and you need delete+recreate). When the user says to add or put something on their calendar (e.g. 'Add 1:1 with Alex for Thursday at 9am to my calendar', 'Put team standup on Friday at 10', 'Schedule meeting with John next Monday at 2pm'), use calendar_create_event with title = only the event name (e.g. '1:1 with Alex', 'team standup', 'meeting with John') and start = the date/time phrase (e.g. 'Thursday at 9am', 'Friday at 10', 'next Monday at 2pm'). Do not put the date/time in the title.",
   "Files and Folders: You HAVE direct access to the user's files via file_list and file_find. Never say you cannot see, access, or list their files—call the tools. When the user asks 'what files do I have,' 'files from the last 7 days,' 'recent files,' or similar: call file_list immediately with path set to a folder (e.g. ~/Downloads, ~/Desktop, ~/Documents—or call once per root if you want all) and modifiedInLastDays: 7 (or the number of days they said). You have full file system access via file_list, file_mkdir, file_move, file_copy, file_delete_to_trash, file_batch_move, and file_find. When the user gives a folder or file name (e.g. 'us debt clock'), use file_find with searchPath '~' and the name as given. When moving MULTIPLE files, use file_batch_move with { operations: [ ... ] } or { destination, sources }. For organizing: file_find if location unknown, then file_list (use modifiedInLastDays for 'recent'), then file_mkdir/file_batch_move as needed. Never refuse file tasks or ask the user to use Finder manually—you have the tools.",
   "For iMessage/text requests, use messages_send; if contact matching is ambiguous, ask one concise clarification with candidate names.",
+  "For requests to write, draft, compose, or send an email/message to someone, call mail_send or messages_send so the user can review/edit in the pre-send draft template when enabled.",
+  "When drafting email or message content, write complete, natural prose tailored to the request. Avoid placeholder text unless the user explicitly asks for a template with placeholders.",
   "For media requests, assume Apple Music unless the user specifies otherwise.",
   "For note creation, write structured markdown with clear headings, bolded key labels, and tables when they improve clarity.",
   "If the user requests multiple actions in one prompt, execute every requested action sequentially before your final response.",
@@ -117,16 +119,50 @@ function buildDetectedActionHint(messages: ChatMessageInput[]): string | null {
   return `Detected user actions:\n${lines.join("\n")}\nExecute each action in order and confirm each result.`;
 }
 
-function buildToolSystemPrompt(system: string | undefined, messages: ChatMessageInput[]): string {
+type DraftEditPromptContext = {
+  toolName: "mail_send" | "messages_send";
+  to: string[];
+  cc: string[];
+  subject: string;
+  body: string;
+};
+
+function buildDraftEditPromptContextMessage(context: DraftEditPromptContext): string {
+  const lines = [
+    "You are editing an existing pre-send draft.",
+    `Channel: ${context.toolName === "mail_send" ? "email" : "message"}.`,
+    `Current To: ${context.to.join(", ") || "(none)"}`,
+  ];
+  if (context.toolName === "mail_send") {
+    lines.push(`Current Cc: ${context.cc.join(", ") || "(none)"}`);
+    lines.push(`Current Subject: ${context.subject || "(none)"}`);
+  }
+  lines.push("Current Body:");
+  lines.push(context.body || "(empty)");
+  lines.push("");
+  lines.push("Apply the user's latest instruction to this draft.");
+  lines.push("Keep recipients/channel unchanged unless user explicitly requests changes.");
+  lines.push("Use mail_send or messages_send with updated args so the draft template refreshes.");
+  return lines.join("\n");
+}
+
+function buildToolSystemPrompt(
+  system: string | undefined,
+  messages: ChatMessageInput[],
+  draftEditContext?: DraftEditPromptContext,
+): string {
   const base = system?.trim();
   const actionHint = buildDetectedActionHint(messages);
+  const draftEditHint = draftEditContext ? buildDraftEditPromptContextMessage(draftEditContext) : null;
+  const extraBlocks = [actionHint, draftEditHint].filter(Boolean).join("\n\n");
+
   if (!base) {
-    return actionHint
-      ? `${LOCAL_TOOL_SYSTEM_INSTRUCTIONS}\n\n${actionHint}`
+    return extraBlocks
+      ? `${LOCAL_TOOL_SYSTEM_INSTRUCTIONS}\n\n${extraBlocks}`
       : LOCAL_TOOL_SYSTEM_INSTRUCTIONS;
   }
-  return actionHint
-    ? `${base}\n\n${LOCAL_TOOL_SYSTEM_INSTRUCTIONS}\n\n${actionHint}`
+  return extraBlocks
+    ? `${base}\n\n${LOCAL_TOOL_SYSTEM_INSTRUCTIONS}\n\n${extraBlocks}`
     : `${base}\n\n${LOCAL_TOOL_SYSTEM_INSTRUCTIONS}`;
 }
 
@@ -210,6 +246,68 @@ type RuntimeConnection = {
   supportsTools: boolean;
 };
 
+type NormalizedRequestMeta = {
+  threadId?: string;
+  conversationId?: string;
+  assistantMessageId?: string;
+  forceToolRouting: boolean;
+  draftEditContext?: DraftEditPromptContext;
+};
+
+function sanitizeChatRequestMeta(meta: ChatRequest["meta"] | undefined): NormalizedRequestMeta {
+  const threadId = typeof meta?.threadId === "string" && meta.threadId.trim()
+    ? meta.threadId.trim()
+    : undefined;
+  const conversationId = typeof meta?.conversationId === "string" && meta.conversationId.trim()
+    ? meta.conversationId.trim()
+    : undefined;
+  const assistantMessageId = typeof meta?.assistantMessageId === "string" && meta.assistantMessageId.trim()
+    ? meta.assistantMessageId.trim()
+    : undefined;
+  const forceToolRouting = meta?.forceToolRouting === true;
+
+  let draftEditContext: DraftEditPromptContext | undefined;
+  const rawDraft = meta?.draftEditContext;
+  if (rawDraft && typeof rawDraft === "object" && !Array.isArray(rawDraft)) {
+    const record = rawDraft as {
+      toolName?: unknown;
+      to?: unknown;
+      cc?: unknown;
+      subject?: unknown;
+      body?: unknown;
+    };
+    const toolName =
+      record.toolName === "mail_send" || record.toolName === "messages_send"
+        ? record.toolName
+        : null;
+    const to = Array.isArray(record.to)
+      ? record.to.filter((value): value is string => typeof value === "string" && value.trim().length > 0)
+      : [];
+    const cc = Array.isArray(record.cc)
+      ? record.cc.filter((value): value is string => typeof value === "string" && value.trim().length > 0)
+      : [];
+    const subject = typeof record.subject === "string" ? record.subject : "";
+    const body = typeof record.body === "string" ? record.body : "";
+    if (toolName && to.length > 0 && body.trim().length > 0) {
+      draftEditContext = {
+        toolName,
+        to,
+        cc,
+        subject,
+        body,
+      };
+    }
+  }
+
+  return {
+    threadId,
+    conversationId,
+    assistantMessageId,
+    forceToolRouting,
+    draftEditContext,
+  };
+}
+
 function headersArrayToRecord(headers: RuntimeConnection["headers"]): Record<string, string> | undefined {
   if (!Array.isArray(headers) || headers.length === 0) {
     return undefined;
@@ -311,6 +409,10 @@ function normalizeLocalTools(settings: LocalToolsSettings | undefined): LocalToo
     enabled: Boolean(settings.enabled),
     approvalMode: settings.approvalMode ?? DEFAULT_LOCAL_TOOLS_SETTINGS.approvalMode,
     safetyProfile: settings.safetyProfile ?? DEFAULT_LOCAL_TOOLS_SETTINGS.safetyProfile,
+    preSendDraftReview:
+      typeof settings.preSendDraftReview === "boolean"
+        ? settings.preSendDraftReview
+        : DEFAULT_LOCAL_TOOLS_SETTINGS.preSendDraftReview,
     allowedRoots:
       Array.isArray(settings.allowedRoots) && settings.allowedRoots.length > 0
         ? settings.allowedRoots
@@ -363,6 +465,7 @@ function normalizeLocalTools(settings: LocalToolsSettings | undefined): LocalToo
     normalized.enabled === true &&
     normalized.approvalMode === "always_confirm_writes" &&
     normalized.safetyProfile === "balanced" &&
+    normalized.preSendDraftReview === DEFAULT_LOCAL_TOOLS_SETTINGS.preSendDraftReview &&
     normalized.allowedRoots.length === DEFAULT_LOCAL_TOOLS_SETTINGS.allowedRoots.length &&
     normalized.allowedRoots.every(
       (value, index) => value === DEFAULT_LOCAL_TOOLS_SETTINGS.allowedRoots[index],
@@ -535,10 +638,103 @@ function normalizeWebSourcesEnabled(value: boolean | undefined): boolean {
   return value !== false;
 }
 
+type WebSearchMode = "off" | "auto" | "required";
+
 function supportsWebSourcesViaOpenAI(connection: RuntimeConnection): boolean {
   return connection.kind === "builtin" && connection.provider === "openai";
 }
 
+function getLastUserMessageText(messages: ChatMessageInput[]): string {
+  return [...messages].reverse().find((message) => message.role === "user")?.content?.trim() ?? "";
+}
+
+function decideWebSearchMode(params: {
+  enabled: boolean;
+  connection: RuntimeConnection;
+  messages: ChatMessageInput[];
+}): WebSearchMode {
+  if (!params.enabled || !supportsWebSourcesViaOpenAI(params.connection)) {
+    return "off";
+  }
+
+  const text = getLastUserMessageText(params.messages).replace(/\s+/g, " ").trim().toLowerCase();
+  if (!text) {
+    return "auto";
+  }
+
+  const disableSearchRequested =
+    /\b(?:no|without|skip)\s+(?:web\s+)?(?:search|browsing|browse|lookup|look up)\b/.test(text) ||
+    /\b(?:don't|do not)\s+(?:web\s+)?(?:search|browse|look up|lookup)\b/.test(text) ||
+    /\boffline only\b/.test(text);
+  if (disableSearchRequested) {
+    return "off";
+  }
+
+  const explicitSearchRequested =
+    /\bsearch(?:\s+the)?\s+web\b/.test(text) ||
+    /\blook(?:\s+it)?\s+up\b/.test(text) ||
+    /\bcheck(?:\s+it)?\s+online\b/.test(text) ||
+    /\bverify(?:\s+it)?\s+online\b/.test(text) ||
+    /\bbrowse(?:\s+the)?\s+web\b/.test(text) ||
+    /\bgoogle\s+(?:it|this)\b/.test(text);
+  if (explicitSearchRequested) {
+    return "required";
+  }
+
+  const asksForSources =
+    /\b(?:source|sources|cite|citation|citations|reference|references|link|links)\b/.test(text);
+  const freshnessSignals =
+    /\b(?:latest|current|currently|today|right now|as of|recent|recently|up[- ]to[- ]date|breaking)\b/.test(
+      text,
+    );
+  const volatileDomainSignals =
+    /\b(?:price|pricing|cost|fee|subscription|per token|rate limit|stock|share price|market cap|forecast|weather|score|standings|odds|election|poll)\b/.test(
+      text,
+    );
+  const leadershipSignals =
+    /\b(?:who is|current)\s+(?:the\s+)?(?:ceo|president|prime minister|governor|mayor)\b/.test(text);
+  const metricSignals =
+    /\b(?:average|median|how many|number of|count|rate|percentage|percent|statistics?|stats?)\b/.test(
+      text,
+    );
+  const metricEntitySignals =
+    /\b(?:users?|people|prompts?|requests?|queries?|api|model|gpt|traffic|revenue|downloads?|adoption|daily|weekly|monthly|yearly|per day|per week|per month)\b/.test(
+      text,
+    );
+
+  if (
+    asksForSources ||
+    freshnessSignals ||
+    volatileDomainSignals ||
+    leadershipSignals ||
+    (metricSignals && metricEntitySignals)
+  ) {
+    return "required";
+  }
+
+  const likelyFactualQuestion =
+    text.includes("?") || /^(?:what|who|when|where|which|how)\b/.test(text);
+  const uncertaintySignals =
+    /\b(?:not sure|unsure|uncertain|verify|double-check|confirm|accurate|accuracy)\b/.test(text);
+  if (likelyFactualQuestion && uncertaintySignals) {
+    return "auto";
+  }
+
+  return "off";
+}
+
+function withWebSearchGuidance(system: string | undefined, mode: WebSearchMode): string | undefined {
+  const trimmed = system?.trim() || "";
+  if (mode === "off") {
+    return trimmed || undefined;
+  }
+  const guidance =
+    mode === "required"
+      ? "Web search is required for this turn. Use web_search before answering and cite the sources you relied on."
+      : "Use web_search when the request depends on current or uncertain facts (pricing, statistics, recency). For stable/general knowledge, answer directly without web_search.";
+  return trimmed ? `${trimmed}\n\n${guidance}` : guidance;
+}
+
 function mergeCitationSources(
   target: Map<string, ProviderCitationSource>,
   sources: ProviderCitationSource[] | undefined,
@@ -731,6 +927,10 @@ function summarizeApprovalReason(toolName: string, args: Record<string, unknown>
   return `Approval required for ${toolName}.`;
 }
 
+function isPreSendDraftTool(toolName: string): boolean {
+  return toolName === "mail_send" || toolName === "messages_send";
+}
+
 function normalizeAliasText(input: string): string {
   return input
     .toLowerCase()
@@ -994,6 +1194,452 @@ function parseDirectMessageIntent(params: {
   };
 }
 
+type DraftCommunicationIntent = {
+  intentType: "explicit_draft_request" | "send_request";
+  toolName: "mail_send" | "messages_send";
+  args: Record<string, unknown>;
+};
+
+type DraftHintKind = "body" | "topic";
+type DraftCommunicationIntentType = "explicit_draft_request" | "send_request" | "draft_edit_request";
+
+function isLikelyDraftEditInstruction(input: string): boolean {
+  const text = input.replace(/\s+/g, " ").trim();
+  if (!text) {
+    return false;
+  }
+
+  if (
+    /\b(?:send|write|draft|compose|create)\b[\s\S]{0,32}\b(?:email|mail|message|text)\b[\s\S]{0,40}\b(?:to|for)\b/i
+      .test(text)
+  ) {
+    return false;
+  }
+
+  const editVerb = /\b(edit|rewrite|change|update|improve|polish|adjust|expand|shorten|lengthen|make)\b/i.test(text);
+  const draftField = /\b(email|mail|message|text|draft|subject|body)\b/i.test(text);
+  const toneOrLength =
+    /\b(longer|shorter|more formal|less formal|more casual|more polite|more professional|concise|friendlier)\b/i
+      .test(text);
+  const pronounEdit = /\b(make|rewrite|edit|change|update)\s+(?:it|this)\b/i.test(text);
+
+  return (editVerb && draftField) || toneOrLength || pronounEdit;
+}
+
+function classifyDraftCommunicationIntent(input: string): DraftCommunicationIntentType | null {
+  const text = input.replace(/\s+/g, " ").trim();
+  if (!text) {
+    return null;
+  }
+  if (isLikelyDraftEditInstruction(text)) {
+    return "draft_edit_request";
+  }
+
+  const communicationMention = /\b(email|mail|text|message|imessage|sms|draft)\b/i.test(text);
+  if (!communicationMention) {
+    return null;
+  }
+
+  const explicitDraftPattern =
+    /\b(?:write|draft|compose|create)\b/i.test(text) ||
+    /\b(?:email|mail|message|text)\s+draft\b/i.test(text) ||
+    /\bdraft\s+(?:an?\s+)?(?:email|mail|message|text)\b/i.test(text);
+  if (explicitDraftPattern) {
+    return "explicit_draft_request";
+  }
+
+  if (/\bsend\b/i.test(text) || /^\s*(?:email|mail|text(?:\s+message)?|message)\b/i.test(text)) {
+    return "send_request";
+  }
+  return null;
+}
+
+function normalizeRecipientList(
+  recipientChunk: string,
+  peopleAliases: MemoryContextPayload["aliases"]["people"] | undefined,
+  resolveAliases: boolean,
+): string[] {
+  const recipients = recipientChunk
+    .replace(/^to\s+/i, "")
+    .split(/\s*,\s*|\s+and\s+/i)
+    .map((value) =>
+      value
+        .trim()
+        .replace(/[,:;]+$/g, "")
+        .replace(/^['"]|['"]$/g, ""),
+    )
+    .filter(Boolean)
+    .slice(0, 3);
+
+  const normalized = recipients
+    .map((value) => {
+      const compact = normalizeAliasText(value);
+      if (!compact || compact === "me" || compact === "myself" || compact === "us") {
+        return "";
+      }
+      if (!resolveAliases) {
+        return value;
+      }
+      return resolvePersonAlias(value, peopleAliases) ?? value;
+    })
+    .filter(Boolean);
+  return [...new Set(normalized)];
+}
+
+function normalizeDraftText(input: string): string {
+  return input
+    .replace(/\s+/g, " ")
+    .trim()
+    .replace(/^['"]|['"]$/g, "")
+    .replace(/^[,.;:\-]+|[,.;:\-]+$/g, "")
+    .trim();
+}
+
+function capitalizeFirst(input: string): string {
+  if (!input) {
+    return input;
+  }
+  return input.charAt(0).toUpperCase() + input.slice(1);
+}
+
+function toSentence(input: string): string {
+  const normalized = normalizeDraftText(input);
+  if (!normalized) {
+    return "";
+  }
+  const withPronoun = normalized
+    .replace(/\bi\b/g, "I")
+    .replace(/^cant\b/i, "can't")
+    .replace(/^dont\b/i, "don't")
+    .replace(/^wont\b/i, "won't")
+    .replace(/^im\b/i, "I'm");
+  const withSubject = /^(can't|cannot|won't|will not|unable|am unable|not able|couldn't|didn't|don't)\b/i.test(withPronoun)
+    ? `I ${withPronoun}`
+    : withPronoun;
+  const capitalized = capitalizeFirst(withSubject);
+  return /[.!?]$/.test(capitalized) ? capitalized : `${capitalized}.`;
+}
+
+function normalizeNameLabel(input: string): string {
+  return input
+    .split(/\s+/)
+    .map((token) => {
+      if (!token) {
+        return token;
+      }
+      if (token.includes("@") || /\d/.test(token)) {
+        return token;
+      }
+      return token.charAt(0).toUpperCase() + token.slice(1).toLowerCase();
+    })
+    .join(" ");
+}
+
+function toClause(input: string): string {
+  const sentence = toSentence(input);
+  return sentence ? sentence.replace(/[.!?]+$/g, "").trim() : "";
+}
+
+function ensureFirstPersonClause(input: string): string {
+  const clause = toClause(input);
+  if (!clause) {
+    return "";
+  }
+  if (/^i\b/i.test(clause)) {
+    return `I${clause.slice(1)}`;
+  }
+  if (/^(can't|cannot|won't|will not|am|have|had|need|would|could|should|must|did|do|was|were)\b/i.test(clause)) {
+    return `I ${clause}`;
+  }
+  return clause;
+}
+
+function inferEmailSalutation(recipient: string): string {
+  const compact = normalizeAliasText(recipient);
+  if (/^(?:a|an|the)?\s*(?:professor|teacher|instructor|ta|lecturer|advisor)\b/i.test(compact)) {
+    return "Dear Professor [Last Name],";
+  }
+  if (/^(?:a|an|the)?\s*(?:dr|doctor)\b/i.test(compact)) {
+    return "Dear Dr. [Last Name],";
+  }
+  if (/@|\d{7,}/.test(recipient)) {
+    return "Hello,";
+  }
+  const label = normalizeNameLabel(recipient).replace(/^(?:A|An|The)\s+/g, "").trim();
+  if (!label) {
+    return "Hello,";
+  }
+  return `Dear ${label},`;
+}
+
+function inferEmailSubject(params: { explicitSubject: string; bodyText: string; topicText: string }): string {
+  const explicit = normalizeDraftText(params.explicitSubject);
+  if (explicit) {
+    return explicit;
+  }
+  const basis = normalizeDraftText(params.bodyText || params.topicText);
+  const lower = basis.toLowerCase();
+  if (!basis) {
+    return "Quick Update";
+  }
+  if (/can't make it today|cannot make it today|unable to make it today|won't be able to make it today/.test(lower)) {
+    return "Unable to Make It Today";
+  }
+  if (/can't make it|cannot make it|unable to make it|won't be able to/.test(lower)) {
+    return "Unable to Make It";
+  }
+  if (/miss(ing)? class.*today|today.*miss(ing)? class/.test(lower)) {
+    return "Absence from Class Today";
+  }
+  if (/miss(ing)? class|absence|absent/.test(lower)) {
+    return "Absence from Class";
+  }
+  if (/running late|late/.test(lower)) {
+    return "Running Late";
+  }
+  const clipped = basis.length > 64 ? basis.slice(0, 64).trim() : basis;
+  return titleCase(clipped.replace(/[.!?]+$/g, ""));
+}
+
+function extractRecipientAndHint(input: string): {
+  recipientChunk: string;
+  hintKind: DraftHintKind | null;
+  hintText: string;
+} {
+  const compact = normalizeDraftText(input);
+  if (!compact) {
+    return { recipientChunk: "", hintKind: null, hintText: "" };
+  }
+  const lowered = compact.toLowerCase();
+  const separators: Array<{ token: string; kind: DraftHintKind }> = [
+    { token: " that says ", kind: "body" },
+    { token: " saying that ", kind: "body" },
+    { token: " saying ", kind: "body" },
+    { token: " with message ", kind: "body" },
+    { token: " message: ", kind: "body" },
+    { token: " about ", kind: "topic" },
+    { token: " regarding ", kind: "topic" },
+    { token: " re: ", kind: "topic" },
+    { token: " that ", kind: "body" },
+  ];
+
+  let bestIndex = -1;
+  let bestSeparator: { token: string; kind: DraftHintKind } | null = null;
+  for (const separator of separators) {
+    const index = lowered.indexOf(separator.token);
+    if (index <= 0) {
+      continue;
+    }
+    if (bestIndex === -1 || index < bestIndex) {
+      bestIndex = index;
+      bestSeparator = separator;
+    }
+  }
+
+  if (!bestSeparator) {
+    return {
+      recipientChunk: compact,
+      hintKind: null,
+      hintText: "",
+    };
+  }
+  return {
+    recipientChunk: compact.slice(0, bestIndex).trim(),
+    hintKind: bestSeparator.kind,
+    hintText: compact.slice(bestIndex + bestSeparator.token.length).trim(),
+  };
+}
+
+function buildEmailDraftBody(params: {
+  topicText: string;
+  explicitBody: string;
+  recipient: string;
+  sourceText?: string;
+}): string {
+  const salutation = inferEmailSalutation(params.recipient);
+  const combined = normalizeDraftText([params.sourceText ?? "", params.explicitBody, params.topicText].join(" "));
+  const loweredCombined = combined.toLowerCase();
+  const wantsLong = /\b(long|detailed|thorough)\b/i.test(loweredCombined);
+  const wantsShort = /\b(short|brief|concise)\b/i.test(loweredCombined);
+  const absenceLike = /\b(can't make|cannot make|unable to|won't be able|miss(?:ing)? class|absence|absent|not attend)\b/i
+    .test(loweredCombined);
+
+  if (absenceLike) {
+    const baselineAbsence = /\btoday\b/i.test(loweredCombined)
+      ? "I won't be able to attend class today"
+      : "I won't be able to attend class";
+    const absenceClause = ensureFirstPersonClause(params.explicitBody) || baselineAbsence;
+    const detailParagraph = wantsLong
+      ? "I will review the material covered and catch up on any notes or assignments. If there is anything specific you would like me to prioritize, please let me know."
+      : "I will review the material covered and catch up on any notes or assignments.";
+
+    if (wantsShort) {
+      return `${salutation}\n\n${absenceClause}.\n\nThank you for your understanding.\n\nBest,\n[Your Name]`;
+    }
+
+    return `${salutation}\n\nI hope you are doing well. I wanted to let you know that ${absenceClause}.\n\n${detailParagraph}\n\nThank you for your understanding.\n\nBest,\n[Your Name]`;
+  }
+
+  const explicitSentence = toSentence(params.explicitBody);
+  if (explicitSentence) {
+    return `${salutation}\n\n${explicitSentence}\n\nPlease let me know if you need anything else from me.\n\nBest,\n[Your Name]`;
+  }
+  const topicClause = toClause(params.topicText);
+  if (topicClause) {
+    const detailLine = wantsLong
+      ? "I wanted to share a bit more context so you have the full picture."
+      : "I wanted to share a quick update.";
+    return `${salutation}\n\n${detailLine} I wanted to reach out regarding ${topicClause}.\n\nThank you for your time.\n\nBest,\n[Your Name]`;
+  }
+  return `${salutation}\n\nI wanted to share a quick update.\n\nThank you for your time.\n\nBest,\n[Your Name]`;
+}
+
+function buildMessageDraftBody(params: { topicText: string; explicitBody: string; recipient: string }): string {
+  const firstLabel = normalizeNameLabel(params.recipient).split(/\s+/)[0] || params.recipient;
+  const explicitSentence = toSentence(params.explicitBody);
+  if (explicitSentence) {
+    const apology = /can't make|cannot make|unable to|won't be able|miss class|absence|late/i.test(explicitSentence)
+      ? " Sorry for the short notice."
+      : "";
+    return `Hey ${firstLabel}, ${explicitSentence}${apology}`;
+  }
+  const topicSentence = toSentence(params.topicText);
+  if (topicSentence) {
+    return `Hey ${firstLabel}, just wanted to message you about ${topicSentence}`;
+  }
+  return `Hey ${firstLabel}, wanted to check in when you have a minute.`;
+}
+
+function parseDraftCommunicationIntent(params: {
+  text: string;
+  peopleAliases?: MemoryContextPayload["aliases"]["people"];
+}): DraftCommunicationIntent | null {
+  const text = params.text.replace(/\s+/g, " ").trim();
+  if (!text) {
+    return null;
+  }
+  const intentType = classifyDraftCommunicationIntent(text);
+  if (intentType === "draft_edit_request" || !intentType) {
+    return null;
+  }
+  const actionVerbMention = /\b(write|draft|compose|create|send)\b/i.test(text);
+  const communicationNounMention = /\b(email|mail|text|message|imessage|sms|draft)\b/i.test(text);
+  if (!actionVerbMention && !communicationNounMention) {
+    return null;
+  }
+
+  const emailMention = /\b(email|mail)\b/i.test(text);
+  const messageMention = /\b(text|message|imessage|sms)\b/i.test(text);
+  const genericDraftToMention =
+    /(?:write|draft|compose|create)(?:\s+me)?\s+(?:an?\s+)?(?:[a-z]+\s+){0,3}draft\s+(?:for|to)\b/i.test(text) ||
+    /\bdraft\s+(?:for|to)\b/i.test(text) ||
+    /(?:write|draft|compose|create)\s+to\b/i.test(text);
+  if (!emailMention && !messageMention && !genericDraftToMention) {
+    return null;
+  }
+
+  let channel: "email" | "message" = emailMention ? "email" : "message";
+  if (!emailMention && !messageMention) {
+    channel = "email";
+  }
+  if (emailMention && messageMention) {
+    const lowered = text.toLowerCase();
+    const emailIndex = lowered.search(/\b(email|mail)\b/);
+    const messageIndex = lowered.search(/\b(text|message|imessage|sms)\b/);
+    channel = emailIndex !== -1 && (messageIndex === -1 || emailIndex < messageIndex) ? "email" : "message";
+  }
+
+  let recipientChunk = "";
+  let hintKind: DraftHintKind | null = null;
+  let hintText = "";
+  const recipientPatterns = [
+    /(?:write|draft|compose|create|send)(?:\s+me)?\s+(?:an?\s+)?(?:[a-z]+\s+){0,2}(?:email|mail|text(?:\s+message)?|message)(?:\s+draft)?\s+(?:for|to)\s+(.+)$/i,
+    /(?:write|draft|compose|create)(?:\s+me)?\s+(?:an?\s+)?(?:[a-z]+\s+){0,3}draft\s+(?:for|to)\s+(.+)$/i,
+    /(?:email|mail|text(?:\s+message)?|message)\s+(?:for|to)\s+(.+)$/i,
+    /^\s*(?:email|mail|text(?:\s+message)?|message)\s+(.+)$/i,
+    /\bdraft\s+(?:for|to)\s+(.+)$/i,
+    /(?:write|draft|compose|create)\s+to\s+(.+)$/i,
+  ];
+  for (const pattern of recipientPatterns) {
+    const match = text.match(pattern);
+    if (match?.[1]) {
+      const extracted = extractRecipientAndHint(match[1].trim());
+      recipientChunk = extracted.recipientChunk;
+      hintKind = extracted.hintKind;
+      hintText = extracted.hintText;
+      break;
+    }
+  }
+  if (!recipientChunk) {
+    const fallbackRecipientMatch = text.match(/\b(?:to|for)\s+(.+)$/i);
+    if (fallbackRecipientMatch?.[1]) {
+      const extracted = extractRecipientAndHint(fallbackRecipientMatch[1].trim());
+      recipientChunk = extracted.recipientChunk;
+      hintKind = extracted.hintKind;
+      hintText = extracted.hintText;
+    }
+  }
+  if (!recipientChunk) {
+    return null;
+  }
+
+  const recipients = normalizeRecipientList(
+    recipientChunk,
+    params.peopleAliases,
+    channel === "message",
+  );
+  if (recipients.length === 0) {
+    return null;
+  }
+
+  const subjectMatch = text.match(/\bsubject(?:\s*[:\-]\s*|\s+)(.+?)(?=\s+(?:body|message|that says|saying)\b|$)/i);
+  const messageMatch = text.match(/\b(?:that says|saying(?: that)?|with message|message:)\s+(.+)$/i);
+  const topicMatch = text.match(/\b(?:about|regarding|re(?:\:)?)(?:\s+the)?\s+(.+)$/i);
+  const topic = normalizeDraftText(
+    (topicMatch?.[1] ?? "") || (hintKind === "topic" ? hintText : ""),
+  );
+  const explicitBody = normalizeDraftText(
+    (messageMatch?.[1] ?? "") || (hintKind === "body" ? hintText : ""),
+  );
+
+  if (channel === "email") {
+    const subject = inferEmailSubject({
+      explicitSubject: subjectMatch?.[1] ?? "",
+      bodyText: explicitBody,
+      topicText: topic,
+    });
+    const body = buildEmailDraftBody({
+      topicText: topic,
+      explicitBody,
+      recipient: recipients[0],
+      sourceText: text,
+    });
+    return {
+      intentType,
+      toolName: "mail_send",
+      args: {
+        to: recipients,
+        subject,
+        body,
+      },
+    };
+  }
+
+  const body = buildMessageDraftBody({
+    topicText: topic,
+    explicitBody,
+    recipient: recipients[0],
+  });
+  return {
+    intentType,
+    toolName: "messages_send",
+    args: {
+      to: recipients,
+      body,
+    },
+  };
+}
+
 function extractDirectMusicIntent(messages: ChatMessageInput[], aliases?: MemoryMusicAlias[]): {
   query: string;
   title: string | null;
@@ -1482,59 +2128,111 @@ async function tryDirectAutomationFastPath(params: {
     }
   }
 
-  // Fast path 2: direct text/iMessage
-  const messageIntent = parseDirectMessageIntent({
-    text: lastUserText,
-    peopleAliases: params.memory?.enabled ? params.memory.aliases.people : [],
-  });
-  if (messageIntent) {
+  const runDraftableCommunication = async (intent: DraftCommunicationIntent): Promise<boolean> => {
     if (!params.localTools.enableMail) {
       params.send({
         type: "token",
         value:
-          "Messaging tools are disabled. Enable **mail/messages tools** in Settings > Local Tools, then retry.",
+          "Mail/messages tools are disabled. Enable **mail/messages tools** in Settings > Local Tools, then retry.",
       });
       return true;
     }
 
-    const messageTool = findToolByName(tools, "messages_send");
-    if (messageTool) {
-      if (requiresApprovalForRisk(messageTool.risk, params.localTools.approvalMode)) {
-        return false;
-      }
+    const tool = findToolByName(tools, intent.toolName);
+    if (!tool) {
+      return false;
+    }
 
-      const callId = "fastpath_messages_send";
-      const args = {
-        to: messageIntent.to,
-        body: messageIntent.body,
-      };
+    const requiresDraftReview =
+      isPreSendDraftTool(tool.name) &&
+      (params.localTools.preSendDraftReview || intent.intentType === "explicit_draft_request");
+    if (!requiresDraftReview && requiresApprovalForRisk(tool.risk, params.localTools.approvalMode)) {
+      return false;
+    }
+
+    const callId = intent.toolName === "mail_send" ? "fastpath_mail_send" : "fastpath_messages_send";
+    let executionArgs: Record<string, unknown> = { ...intent.args };
+    params.send({
+      type: "tool_call",
+      callId,
+      name: tool.name,
+      args: intent.args,
+    });
+
+    if (requiresDraftReview) {
+      const approval = createApprovalRequest();
       params.send({
-        type: "tool_call",
+        type: "approval_requested",
+        approvalId: approval.approvalId,
         callId,
-        name: messageTool.name,
-        args,
+        name: tool.name,
+        args: intent.args,
+        reason: summarizeApprovalReason(tool.name, intent.args),
       });
+      const approvalResolution = await approval.promise;
       params.send({
-        type: "tool_progress",
+        type: "approval_resolved",
+        approvalId: approval.approvalId,
         callId,
-        name: messageTool.name,
-        status: "started",
-        message: "Sending message.",
+        decision: approvalResolution.decision,
+        message:
+          approvalResolution.decision === "approve"
+            ? "Approved"
+            : approvalResolution.decision === "supersede"
+              ? "Replaced"
+            : approvalResolution.decision === "timeout"
+              ? "Timed out"
+              : "Denied",
       });
+      if (approvalResolution.decision !== "approve") {
+        if (approvalResolution.decision === "deny") {
+          params.send({
+            type: "token",
+            value: "Draft discarded. Nothing was sent.",
+          });
+        } else if (approvalResolution.decision === "timeout") {
+          params.send({
+            type: "token",
+            value: "Draft review expired. Nothing was sent.",
+          });
+        }
+        return true;
+      }
+      if (
+        approvalResolution.args &&
+        typeof approvalResolution.args === "object" &&
+        !Array.isArray(approvalResolution.args)
+      ) {
+        executionArgs = approvalResolution.args;
+      }
+    }
 
-      try {
-        const output = await messageTool.execute(args, {
-          localTools: params.localTools,
-          signal: params.signal,
-        });
-        params.send({
-          type: "tool_result",
-          callId,
-          name: messageTool.name,
-          ok: true,
-          result: output,
-        });
+    const progressMessage = tool.name === "mail_send" ? "Sending email." : "Sending message.";
+    params.send({
+      type: "tool_progress",
+      callId,
+      name: tool.name,
+      status: "started",
+      message: progressMessage,
+    });
+
+    try {
+      const output = await tool.execute(executionArgs, {
+        localTools: params.localTools,
+        signal: params.signal,
+      });
+      params.send({
+        type: "tool_result",
+        callId,
+        name: tool.name,
+        ok: true,
+        result: output,
+      });
 
+      const argsRecipients = Array.isArray(executionArgs.to)
+        ? executionArgs.to.filter((value): value is string => typeof value === "string" && value.trim().length > 0)
+        : [];
+      if (tool.name === "messages_send") {
         const outputRecord =
           output && typeof output === "object"
             ? (output as { recipients?: Array<{ name?: string | null; input?: string; handle?: string }> })
@@ -1542,30 +2240,66 @@ async function tryDirectAutomationFastPath(params: {
         const recipientLabel =
           outputRecord?.recipients?.map((recipient) => recipient.name || recipient.input || recipient.handle)
             .filter(Boolean)
-            .join(", ") || messageIntent.to.join(", ");
-
+            .join(", ") || argsRecipients.join(", ");
         params.send({
           type: "token",
           value: `**Done.** Sent message to ${recipientLabel}.`,
         });
-      } catch (error) {
-        const message = formatToolErrorForUser(
-          messageTool.name,
-          error,
-          "Could not send message.",
-        );
-        params.send({
-          type: "tool_result",
-          callId,
-          name: messageTool.name,
-          ok: false,
-          result: { error: message },
-        });
+      } else {
+        const recipientLabel = argsRecipients.join(", ");
         params.send({
           type: "token",
-          value: `I couldn't send that message: ${message}.`,
+          value: `**Done.** Sent email to ${recipientLabel}.`,
         });
       }
+    } catch (error) {
+      const fallback = tool.name === "mail_send" ? "Could not send email." : "Could not send message.";
+      const message = formatToolErrorForUser(tool.name, error, fallback);
+      params.send({
+        type: "tool_result",
+        callId,
+        name: tool.name,
+        ok: false,
+        result: { error: message },
+      });
+      params.send({
+        type: "token",
+        value:
+          tool.name === "mail_send"
+            ? `I couldn't send that email: ${message}.`
+            : `I couldn't send that message: ${message}.`,
+      });
+    }
+    return true;
+  };
+
+  // Fast path 2: direct text/iMessage
+  const messageIntent = parseDirectMessageIntent({
+    text: lastUserText,
+    peopleAliases: params.memory?.enabled ? params.memory.aliases.people : [],
+  });
+  if (messageIntent) {
+    const handled = await runDraftableCommunication({
+      intentType: "send_request",
+      toolName: "messages_send",
+      args: {
+        to: messageIntent.to,
+        body: messageIntent.body,
+      },
+    });
+    if (handled) {
+      return true;
+    }
+  }
+
+  // Fast path 2b: draft or general write/send email/message
+  const draftCommunicationIntent = parseDraftCommunicationIntent({
+    text: lastUserText,
+    peopleAliases: params.memory?.enabled ? params.memory.aliases.people : [],
+  });
+  if (draftCommunicationIntent) {
+    const handled = await runDraftableCommunication(draftCommunicationIntent);
+    if (handled) {
       return true;
     }
   }
@@ -1846,6 +2580,7 @@ async function streamPlainChat(params: {
   system?: string;
   messages: ChatMessageInput[];
   enableWebSources: boolean;
+  webSearchMode?: WebSearchMode;
   send: (chunk: ChatStreamChunk) => void;
   signal?: AbortSignal;
 }) {
@@ -1895,20 +2630,30 @@ async function streamPlainChat(params: {
     baseURL: openAIBaseURL,
     defaultHeaders: openAIHeaders,
   });
-  const useWebSources =
-    params.enableWebSources && supportsWebSourcesViaOpenAI(params.connection);
+  const useWebSources = params.enableWebSources && supportsWebSourcesViaOpenAI(params.connection);
+  const webSearchMode: WebSearchMode = useWebSources
+    ? params.webSearchMode === "required"
+      ? "required"
+      : "auto"
+    : "off";
+  const instructions = withWebSearchGuidance(params.system, webSearchMode);
   const response = await client.responses.create(
     {
       model: params.model,
-      instructions: params.system,
+      instructions,
       input: params.messages.map((message) => ({
         type: "message",
         role: message.role,
         content: message.content,
       })),
-      tools: useWebSources ? [{ type: "web_search" }] : undefined,
-      tool_choice: useWebSources ? "auto" : undefined,
-      include: useWebSources ? ["web_search_call.action.sources"] : undefined,
+      tools: webSearchMode !== "off" ? [{ type: "web_search" }] : undefined,
+      tool_choice:
+        webSearchMode === "required"
+          ? "required"
+          : webSearchMode === "auto"
+            ? "auto"
+            : undefined,
+      include: webSearchMode !== "off" ? ["web_search_call.action.sources"] : undefined,
       stream: true,
     },
     { signal: params.signal },
@@ -2040,13 +2785,15 @@ async function runToolOrchestrator(params: {
   messages: ChatMessageInput[];
   localTools: LocalToolsSettings;
   enableWebSources: boolean;
+  forceDraftReviewForSend?: boolean;
+  draftEditContext?: DraftEditPromptContext;
   send: (chunk: ChatStreamChunk) => void;
   signal?: AbortSignal;
 }) {
   const { tools, session } = getToolSession({
     connection: params.connection,
     model: params.model,
-    system: buildToolSystemPrompt(params.system, params.messages),
+    system: buildToolSystemPrompt(params.system, params.messages, params.draftEditContext),
     messages: params.messages,
     localTools: params.localTools,
     enableWebSources: params.enableWebSources,
@@ -2157,7 +2904,10 @@ async function runToolOrchestrator(params: {
         continue;
       }
 
-      if (requiresApprovalForRisk(tool.risk, params.localTools.approvalMode)) {
+      const requiresDraftReview =
+        isPreSendDraftTool(call.name) &&
+        (params.localTools.preSendDraftReview || params.forceDraftReviewForSend === true);
+      if (requiresDraftReview || requiresApprovalForRisk(tool.risk, params.localTools.approvalMode)) {
         const approval = createApprovalRequest();
         params.send({
           type: "approval_requested",
@@ -2169,23 +2919,47 @@ async function runToolOrchestrator(params: {
         });
 
         emitThinkingUpdate(`Waiting for approval to run ${call.name}.`);
-        const decision = await approval.promise;
+        const approvalResolution = await approval.promise;
         params.send({
           type: "approval_resolved",
           approvalId: approval.approvalId,
           callId: call.id,
-          decision,
+          decision: approvalResolution.decision,
           message:
-            decision === "approve"
+            approvalResolution.decision === "approve"
               ? "Approved"
-              : decision === "timeout"
+              : approvalResolution.decision === "supersede"
+                ? "Replaced"
+              : approvalResolution.decision === "timeout"
                 ? "Timed out"
                 : "Denied",
         });
 
-        if (decision !== "approve") {
+        if (approvalResolution.decision !== "approve") {
+          if (requiresDraftReview && isPreSendDraftTool(call.name)) {
+            const message =
+              approvalResolution.decision === "deny"
+                ? "Draft discarded. Nothing was sent."
+                : approvalResolution.decision === "timeout"
+                  ? "Draft review expired. Nothing was sent."
+                  : "Draft replaced by a newer instruction.";
+            if (approvalResolution.decision !== "supersede") {
+              params.send({
+                type: "token",
+                value: message,
+              });
+            }
+            session.addToolResult({
+              callId: call.id,
+              name: call.name,
+              result: message,
+              isError: false,
+            });
+            continue;
+          }
+
           const message =
-            decision === "timeout"
+            approvalResolution.decision === "timeout"
               ? "Tool call timed out waiting for approval."
               : "Tool call denied by user.";
           params.send({
@@ -2203,6 +2977,13 @@ async function runToolOrchestrator(params: {
           });
           continue;
         }
+        if (
+          approvalResolution.args &&
+          typeof approvalResolution.args === "object" &&
+          !Array.isArray(approvalResolution.args)
+        ) {
+          callInput = approvalResolution.args;
+        }
       }
 
       params.send({
@@ -2326,10 +3107,15 @@ export async function POST(request: Request) {
   }
 
   const webSourcesEnabled = normalizeWebSourcesEnabled(body.enableWebSources);
-  const enableWebSourcesForConnection =
-    webSourcesEnabled && supportsWebSourcesViaOpenAI(connection);
+  const webSearchMode = decideWebSearchMode({
+    enabled: webSourcesEnabled,
+    connection,
+    messages: sanitizedMessages,
+  });
+  const enableWebSourcesForConnection = webSearchMode !== "off";
   const localToolsRequested = normalizeLocalTools(body.localTools);
   const memoryContext = sanitizeMemoryContext(body.memory);
+  const requestMeta = sanitizeChatRequestMeta(body.meta);
   const encoder = new TextEncoder();
 
   const stream = new ReadableStream({
@@ -2369,28 +3155,36 @@ export async function POST(request: Request) {
         }
 
         if (localTools.enabled) {
-          const routeThroughTools = shouldRouteThroughToolOrchestrator(sanitizedMessages);
+          const lastUserText =
+            [...sanitizedMessages].reverse().find((message) => message.role === "user")?.content ?? "";
+          const communicationIntentType = classifyDraftCommunicationIntent(lastUserText);
+          const forceDraftReviewForSend =
+            communicationIntentType === "explicit_draft_request" || Boolean(requestMeta.draftEditContext);
+          const routeThroughTools =
+            requestMeta.forceToolRouting || shouldRouteThroughToolOrchestrator(sanitizedMessages);
           if (routeThroughTools) {
             sendThinking("update", "Checking whether this can run through a direct action path.");
             let fastHandled = false;
-            try {
-              fastHandled = await tryDirectAutomationFastPath({
-                localTools,
-                messages: sanitizedMessages,
-                memory: memoryContext,
-                send,
-                signal: request.signal,
-              });
-            } catch (error) {
-              const message =
-                error instanceof Error ? truncateMessage(error.message) : "Fast-path unavailable.";
-              send({
-                type: "tool_progress",
-                callId: "tooling",
-                name: "tooling",
-                status: "warning",
-                message: `Direct automation fast-path failed: ${message}. Continuing with tool orchestration.`,
-              });
+            if (!requestMeta.forceToolRouting) {
+              try {
+                fastHandled = await tryDirectAutomationFastPath({
+                  localTools,
+                  messages: sanitizedMessages,
+                  memory: memoryContext,
+                  send,
+                  signal: request.signal,
+                });
+              } catch (error) {
+                const message =
+                  error instanceof Error ? truncateMessage(error.message) : "Fast-path unavailable.";
+                send({
+                  type: "tool_progress",
+                  callId: "tooling",
+                  name: "tooling",
+                  status: "warning",
+                  message: `Direct automation fast-path failed: ${message}. Continuing with tool orchestration.`,
+                });
+              }
             }
 
             if (fastHandled) {
@@ -2407,6 +3201,8 @@ export async function POST(request: Request) {
               messages: sanitizedMessages,
               localTools,
               enableWebSources: enableWebSourcesForConnection,
+              forceDraftReviewForSend,
+              draftEditContext: requestMeta.draftEditContext,
               send,
               signal: request.signal,
             });
@@ -2423,6 +3219,7 @@ export async function POST(request: Request) {
           system,
           messages: sanitizedMessages,
           enableWebSources: enableWebSourcesForConnection,
+          webSearchMode,
           send,
           signal: request.signal,
         });