@tuturuuu/ai 0.13.0 → 0.14.0

package/src/tools/executors/calendar-automation.ts

@@ -0,0 +1,207 @@
+import {
+  applyWorkspaceCalendarSchedule,
+  createWorkspaceCalendarEvent,
+  deleteWorkspaceCalendarEvent,
+  getGoogleCalendarAuthUrl,
+  getWorkspaceCalendarSyncStatus,
+  listCalendarConnections,
+  listWorkspaceSchedulableTasks,
+  previewWorkspaceCalendarSchedule,
+  syncWorkspaceCalendar,
+  updateWorkspaceCalendarEvent,
+  type WorkspaceCalendarEventCreatePayload,
+  type WorkspaceCalendarEventUpdatePayload,
+} from '@tuturuuu/internal-api/calendar';
+import { withForwardedInternalApiAuth } from '@tuturuuu/internal-api/client';
+import { resolveInternalAppUrl } from '@tuturuuu/utils/app-url';
+import { Effect } from '@tuturuuu/utils/effect';
+import type { MiraToolContext } from '../mira-tool-types';
+import { getWorkspaceContextWorkspaceId } from '../workspace-context';
+
+type SchedulePreview = {
+  success: boolean;
+  preview?: { summary?: unknown; warnings?: string[]; events?: unknown[] };
+  tasks?: unknown;
+  habits?: unknown;
+  lockedEvents?: unknown[];
+};
+const previews = new WeakMap<object, Set<string>>();
+
+export async function executeCalendarAutomation(
+  name: string,
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  if (!ctx.requestHeaders)
+    return {
+      success: false,
+      error:
+        'Calendar automation is unavailable in this session. Open Calendar settings to manage connections.',
+    };
+  const wsId = getWorkspaceContextWorkspaceId(ctx);
+  const state = ctx.executionState ?? ctx;
+  const baseUrl = resolveInternalAppUrl({
+    appName: 'calendar',
+    candidates: [
+      process.env.CALENDAR_APP_URL,
+      process.env.NEXT_PUBLIC_CALENDAR_APP_URL,
+    ],
+    fallback:
+      process.env.NODE_ENV === 'production'
+        ? 'https://calendar.tuturuuu.com'
+        : 'https://calendar.tuturuuu.localhost',
+  });
+  const target = new URL(baseUrl);
+  const localDevelopment =
+    process.env.NODE_ENV !== 'production' &&
+    (['localhost', '127.0.0.1', '[::1]'].includes(target.hostname) ||
+      target.hostname.endsWith('.localhost'));
+  if (target.protocol !== 'https:' && !localDevelopment)
+    return {
+      success: false,
+      error: 'Calendar requires a secure HTTPS connection.',
+    };
+  const options = withForwardedInternalApiAuth(ctx.requestHeaders, { baseUrl });
+  const windowDays = typeof args.windowDays === 'number' ? args.windowDays : 7;
+  const previewKey = `${wsId}:${windowDays}:${ctx.timezone ?? ''}`;
+  return Effect.runPromise(
+    Effect.tryPromise({
+      try: async () => {
+        switch (name) {
+          case 'create_event': {
+            const event = await createWorkspaceCalendarEvent(
+              wsId,
+              {
+                title: args.title as string,
+                start_at: new Date(args.startAt as string).toISOString(),
+                end_at: new Date(args.endAt as string).toISOString(),
+                description: args.description as string | null | undefined,
+                location: args.location as string | null | undefined,
+                color: args.color as string | undefined,
+                locked: args.locked as boolean | undefined,
+                source:
+                  args.source as WorkspaceCalendarEventCreatePayload['source'],
+              },
+              options
+            );
+            return { success: true, event, workspaceId: wsId };
+          }
+          case 'update_event': {
+            const payload: WorkspaceCalendarEventUpdatePayload = {};
+            for (const [input, output] of [
+              ['title', 'title'],
+              ['startAt', 'start_at'],
+              ['endAt', 'end_at'],
+              ['description', 'description'],
+              ['location', 'location'],
+              ['color', 'color'],
+              ['locked', 'locked'],
+              ['source', 'source'],
+            ] as const) {
+              if (args[input] !== undefined)
+                Object.assign(payload, {
+                  [output]:
+                    input === 'startAt' || input === 'endAt'
+                      ? new Date(args[input] as string).toISOString()
+                      : args[input],
+                });
+            }
+            const event = await updateWorkspaceCalendarEvent(
+              wsId,
+              args.eventId as string,
+              payload,
+              options
+            );
+            return { success: true, event, workspaceId: wsId };
+          }
+          case 'delete_event':
+            return {
+              success: true,
+              ...(await deleteWorkspaceCalendarEvent(
+                wsId,
+                args.eventId as string,
+                options
+              )),
+            };
+          case 'get_calendar_connections': {
+            const [connections, sync] = await Promise.all([
+              listCalendarConnections(wsId, options),
+              getWorkspaceCalendarSyncStatus(wsId, options),
+            ]);
+            return { connections, sync };
+          }
+          case 'connect_google_calendar':
+            return getGoogleCalendarAuthUrl(wsId, options);
+          case 'sync_calendar':
+            return syncWorkspaceCalendar(wsId, options, {
+              direction: args.direction as 'inbound' | 'outbound' | 'both',
+            });
+          case 'set_event_locked':
+            return updateWorkspaceCalendarEvent(
+              wsId,
+              args.eventId as string,
+              { locked: args.locked as boolean },
+              options
+            );
+          case 'get_schedulable_tasks':
+            return listWorkspaceSchedulableTasks(
+              wsId,
+              { q: args.query as string | undefined },
+              options
+            );
+          case 'preview_calendar_schedule': {
+            const preview =
+              await previewWorkspaceCalendarSchedule<SchedulePreview>(
+                wsId,
+                { windowDays, clientTimezone: ctx.timezone },
+                options
+              );
+            if (!preview.success)
+              return {
+                success: false,
+                error: 'Scheduling preview failed. Nothing was applied.',
+              };
+            const keys = previews.get(state) ?? new Set<string>();
+            keys.add(previewKey);
+            previews.set(state, keys);
+            return {
+              success: true,
+              summary: preview.preview?.summary,
+              warnings: preview.preview?.warnings,
+              events: preview.preview?.events?.slice(0, 50),
+              totalEvents: preview.preview?.events?.length ?? 0,
+              lockedEventCount: preview.lockedEvents?.length ?? 0,
+              tasks: preview.tasks,
+              habits: preview.habits,
+            };
+          }
+          case 'apply_calendar_schedule': {
+            if (!previews.get(state)?.has(previewKey))
+              return {
+                success: false,
+                error: 'Preview this workspace and scheduling window first.',
+              };
+            previews.get(state)?.delete(previewKey);
+            return applyWorkspaceCalendarSchedule(
+              wsId,
+              {
+                windowDays,
+                clientTimezone: ctx.timezone,
+                mode: 'safe-apply',
+                scope: 'impacted-only',
+                forceReschedule: false,
+              },
+              options
+            );
+          }
+          default:
+            return { success: false, error: 'Unknown calendar operation' };
+        }
+      },
+      catch: (error) =>
+        error instanceof Error ? error.message : 'Calendar operation failed',
+    }).pipe(
+      Effect.catchAll((error) => Effect.succeed({ success: false, error }))
+    )
+  );
+}

package/src/tools/executors/calendar.ts

@@ -4,6 +4,7 @@ import timezone from 'dayjs/plugin/timezone';
 import utc from 'dayjs/plugin/utc';
 import type { MiraToolContext } from '../mira-tools';
 import { getWorkspaceContextWorkspaceId } from '../workspace-context';
+import { executeCalendarAutomation } from './calendar-automation';
 import {
   decryptEventsForTools,
   encryptEventFieldsForTools,
@@ -42,7 +43,9 @@ export async function executeGetUpcomingEvents(
 
   const { data: events, error } = await ctx.supabase
     .from('workspace_calendar_events')
-    .select('id, title, description, start_at, end_at, location, is_encrypted')
+    .select(
+      'id, title, description, start_at, end_at, location, is_encrypted, locked'
+    )
     .eq('ws_id', workspaceId)
     .gte('start_at', rangeStart.toISOString())
     .lte('start_at', rangeEnd.toISOString())
@@ -75,6 +78,7 @@ export async function executeGetUpcomingEvents(
         start_at: string;
         end_at: string;
         location: string | null;
+        locked?: boolean | null;
       }) => ({
         id: e.id,
         title: e.title,
@@ -82,6 +86,7 @@ export async function executeGetUpcomingEvents(
         start: formatInTz(e.start_at),
         end: formatInTz(e.end_at),
         location: e.location,
+        locked: e.locked === true,
       })
     ),
   };
@@ -91,6 +96,17 @@ export async function executeCreateEvent(
   args: Record<string, unknown>,
   ctx: MiraToolContext
 ) {
+  if (ctx.requestHeaders)
+    return executeCalendarAutomation('create_event', args, ctx);
+  if (
+    args.source !== undefined ||
+    args.locked !== undefined ||
+    args.color !== undefined
+  )
+    return {
+      error:
+        'Provider destinations, colors and locks require an authenticated Chat or Calendar session. No event changes were saved.',
+    };
   const workspaceId = getWorkspaceContextWorkspaceId(ctx);
   const title = args.title as string;
   const description = (args.description as string) ?? '';
@@ -161,6 +177,17 @@ export async function executeUpdateEvent(
   args: Record<string, unknown>,
   ctx: MiraToolContext
 ) {
+  if (ctx.requestHeaders)
+    return executeCalendarAutomation('update_event', args, ctx);
+  if (
+    args.source !== undefined ||
+    args.locked !== undefined ||
+    args.color !== undefined
+  )
+    return {
+      error:
+        'Provider destinations, colors and locks require an authenticated Chat or Calendar session. No event changes were saved.',
+    };
   const workspaceId = getWorkspaceContextWorkspaceId(ctx);
   const eventId = args.eventId as string;
   const title = args.title as string | undefined;
@@ -257,6 +284,8 @@ export async function executeDeleteEvent(
   args: Record<string, unknown>,
   ctx: MiraToolContext
 ) {
+  if (ctx.requestHeaders)
+    return executeCalendarAutomation('delete_event', args, ctx);
   const workspaceId = getWorkspaceContextWorkspaceId(ctx);
   const eventId = args.eventId as string;
 

package/src/tools/executors/helpers/encryption.ts

@@ -17,22 +17,22 @@ type CalendarEventRow = {
 
 /**
  * Retrieve the workspace encryption key (read-only).
- * Returns `null` when E2EE is not configured for the workspace.
+ * Strict mode throws on key/configuration failures; null means no workspace key.
  */
 export async function getWorkspaceKeyForTools(
-  wsId: string
+  wsId: string,
+  strict = false
 ): Promise<Buffer | null> {
   try {
     const { isEncryptionEnabled, getMasterKey, decryptWorkspaceKey } =
       await import('@tuturuuu/utils/encryption');
 
-    if (!isEncryptionEnabled()) return null;
+    if (!strict && !isEncryptionEnabled()) return null;
 
     const { createAdminClient } = await import(
       '@tuturuuu/supabase/next/server'
     );
     const sbAdmin = await createAdminClient();
-    const masterKey = getMasterKey();
 
     const { data, error } = await sbAdmin
       .from('workspace_encryption_keys')
@@ -40,13 +40,15 @@ export async function getWorkspaceKeyForTools(
       .eq('ws_id', wsId)
       .maybeSingle();
 
-    if (error || !data) return null;
+    if (error) throw error;
+    if (!data) return null;
 
     return await decryptWorkspaceKey(
       (data as { encrypted_key: string }).encrypted_key,
-      masterKey
+      getMasterKey()
     );
-  } catch {
+  } catch (error) {
+    if (strict) throw error;
     return null;
   }
 }
@@ -74,14 +76,15 @@ export async function decryptEventsForTools<T extends CalendarEventRow>(
  */
 export async function encryptEventFieldsForTools(
   fields: { title: string; description: string; location: string | null },
-  wsId: string
+  wsId: string,
+  strict = false
 ): Promise<{
   title: string;
   description: string;
   location: string | null;
   is_encrypted: boolean;
 }> {
-  const key = await getWorkspaceKeyForTools(wsId);
+  const key = await getWorkspaceKeyForTools(wsId, strict);
   if (!key) {
     return { ...fields, is_encrypted: false };
   }

package/src/tools/executors/search.ts

@@ -2,10 +2,11 @@ import { google } from '@ai-sdk/google';
 import { generateText, stepCountIs } from 'ai';
 import { z } from 'zod';
 import { withAiMemory } from '../../memory';
+import { isGoogleSearchToolName } from '../google-search-events';
 import { createGoogleSearchToolSet } from '../google-search-tool';
 import type { MiraToolContext } from '../mira-tools';
 
-const SEARCH_WRAPPER_MODEL = 'gemini-3.1-flash-lite';
+const SEARCH_WRAPPER_MODEL = 'gemini-3.5-flash-lite';
 
 type SearchSource = {
   sourceId?: string;
@@ -34,16 +35,35 @@ function hasGoogleSearchCallInSteps(steps: unknown): boolean {
   return steps.some((step) => {
     if (!step || typeof step !== 'object') return false;
     const typedStep = step as ToolStepLike;
-    const called = (typedStep.toolCalls ?? []).some(
-      (toolCall) => toolCall.toolName === 'google_search'
+    const called = (typedStep.toolCalls ?? []).some((toolCall) =>
+      isGoogleSearchToolName(toolCall.toolName)
     );
-    const hasResult = (typedStep.toolResults ?? []).some(
-      (toolResult) => toolResult.toolName === 'google_search'
+    const hasResult = (typedStep.toolResults ?? []).some((toolResult) =>
+      isGoogleSearchToolName(toolResult.toolName)
     );
     return called || hasResult;
   });
 }
 
+function hasGroundingQueries(value: unknown): boolean {
+  if (!value || typeof value !== 'object') return false;
+  const result = value as {
+    providerMetadata?: {
+      google?: { groundingMetadata?: { webSearchQueries?: unknown } };
+    };
+    steps?: unknown[];
+  };
+  const queries =
+    result.providerMetadata?.google?.groundingMetadata?.webSearchQueries;
+  return (
+    (Array.isArray(queries) &&
+      queries.some(
+        (query) => typeof query === 'string' && query.trim().length > 0
+      )) ||
+    (result.steps?.some(hasGroundingQueries) ?? false)
+  );
+}
+
 function normalizeSources(value: unknown): SearchSource[] {
   if (!Array.isArray(value)) return [];
 
@@ -88,8 +108,11 @@ async function runGoogleSearchWrapper(
     }),
     tools: createGoogleSearchToolSet(),
     prompt,
-    stopWhen: stepCountIs(4),
-    ...(forceTool ? { toolChoice: 'required' as const } : {}),
+    stopWhen: stepCountIs(1),
+    maxRetries: 0,
+    maxOutputTokens: 2048,
+    abortSignal: AbortSignal.timeout(30_000),
+    toolChoice: 'auto',
   });
 }
 
@@ -114,7 +137,7 @@ export async function executeGoogleSearch(
       (result as { steps?: unknown }).steps
     );
 
-    if (!wasToolCalled) {
+    if (!wasToolCalled && !hasGroundingQueries(result)) {
       result = await runGoogleSearchWrapper(query, true, ctx);
       sources = normalizeSources((result as { sources?: unknown }).sources);
       wasToolCalled = hasGoogleSearchCallInSteps(
@@ -122,7 +145,7 @@ export async function executeGoogleSearch(
       );
     }
 
-    if (!wasToolCalled && sources.length === 0) {
+    if (!wasToolCalled && !hasGroundingQueries(result)) {
       return {
         ok: false,
         query,
@@ -130,6 +153,14 @@ export async function executeGoogleSearch(
       };
     }
 
+    if (!result.text.trim())
+      return {
+        ok: false,
+        query,
+        error:
+          'Search completed without a final answer. Try a more specific query.',
+      };
+
     return {
       ok: true,
       query,

package/src/tools/executors/task-create.ts

@@ -0,0 +1,232 @@
+import type { Enums } from '@tuturuuu/types';
+import { parseTaskDateToUTCISO } from '@tuturuuu/utils/task-date-timezone';
+import type { MiraToolContext } from '../mira-tool-types';
+import { getWorkspaceContextWorkspaceId } from '../workspace-context';
+
+export async function executeCreateTask(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  const { supabase } = ctx;
+  const wsId = getWorkspaceContextWorkspaceId(ctx);
+  const boardIdArg = args.boardId as string | undefined;
+  const listIdArg = args.listId as string | undefined;
+
+  // If listId is provided directly, validate it exists and use it
+  if (listIdArg) {
+    const { data: targetList, error: listError } = await supabase
+      .from('task_lists')
+      .select('id, board_id, workspace_boards!inner(ws_id)')
+      .eq('id', listIdArg)
+      .not('status', 'in', '(done,closed)')
+      .is('workspace_boards.archived_at', null)
+      .is('workspace_boards.deleted_at', null)
+      .eq('archived', false)
+      .eq('deleted', false)
+      .maybeSingle();
+    if (listError) return { created: false, error: listError.message };
+
+    if (!targetList) {
+      return {
+        created: false,
+        error: `Task list "${listIdArg}" not found or archived. Use list_task_lists to discover valid lists.`,
+      };
+    }
+
+    const relation = targetList.workspace_boards as unknown as
+      | { ws_id: string }
+      | { ws_id: string }[];
+    const listWsId = (Array.isArray(relation) ? relation[0] : relation)?.ws_id;
+    if (listWsId !== wsId) {
+      return {
+        created: false,
+        error: `Task list does not belong to the current workspace context. Switch workspace first with set_workspace_context.`,
+      };
+    }
+
+    if (boardIdArg && targetList.board_id !== boardIdArg) {
+      return {
+        created: false,
+        error: 'The list does not belong to the specified board.',
+      };
+    }
+    return persistTask(args, ctx, listIdArg);
+  }
+
+  // Resolve board: use provided boardId or fall back to first workspace board
+  let board: { id: string } | null = null;
+
+  if (boardIdArg) {
+    const { data: targetBoard, error: boardError } = await supabase
+      .from('workspace_boards')
+      .select('id')
+      .eq('id', boardIdArg)
+      .eq('ws_id', wsId)
+      .is('deleted_at', null)
+      .is('archived_at', null)
+      .maybeSingle();
+    if (boardError) return { created: false, error: boardError.message };
+
+    if (!targetBoard) {
+      return {
+        created: false,
+        error: `Board "${boardIdArg}" not found in this workspace. Use list_boards to discover valid boards.`,
+      };
+    }
+    board = targetBoard;
+  } else {
+    const { data: firstBoard, error: lookupError } = await supabase
+      .from('workspace_boards')
+      .select('id')
+      .eq('ws_id', wsId)
+      .is('deleted_at', null)
+      .is('archived_at', null)
+      .order('created_at', { ascending: true })
+      .limit(1)
+      .maybeSingle();
+    if (lookupError) return { created: false, error: lookupError.message };
+    board = firstBoard;
+  }
+
+  if (!board) {
+    const { data: newBoard, error: boardErr } = await supabase
+      .from('workspace_boards')
+      .insert({ name: 'Tasks', ws_id: wsId })
+      .select('id')
+      .single();
+    if (boardErr || !newBoard)
+      return {
+        created: false,
+        writeUncertain: true,
+        error: `Failed to create board: ${boardErr?.message ?? 'Unknown error'}`,
+      };
+    board = newBoard;
+  }
+
+  const { data: existingList, error: lookupError } = await supabase
+    .from('task_lists')
+    .select('id')
+    .eq('board_id', board.id)
+    .not('status', 'in', '(done,closed)')
+    .eq('archived', false)
+    .eq('deleted', false)
+    .order('created_at', { ascending: true })
+    .limit(1)
+    .maybeSingle();
+  if (lookupError) return { created: false, error: lookupError.message };
+
+  let list = existingList;
+  if (!list) {
+    const { data: newList, error: listErr } = await supabase
+      .from('task_lists')
+      .insert({ name: 'To Do', board_id: board.id })
+      .select('id')
+      .single();
+    if (listErr || !newList)
+      return {
+        created: false,
+        writeUncertain: true,
+        error: `Failed to create list: ${listErr?.message ?? 'Unknown error'}`,
+      };
+    list = newList;
+  }
+
+  return persistTask(args, ctx, list.id);
+}
+
+async function persistTask(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext,
+  listId: string
+) {
+  const { userId, supabase } = ctx;
+  const name = args.name as string;
+  const description = args.description as string | null;
+  const priority = (args.priority as Enums<'task_priority'> | null) ?? null;
+  const assignToSelf = args.assignToSelf !== false;
+  const date = (value: unknown, end: boolean) =>
+    typeof value === 'string'
+      ? ctx.timezone
+        ? parseTaskDateToUTCISO(value, ctx.timezone, end)
+        : value
+      : null;
+  const { data: task, error } = await supabase
+    .from('tasks')
+    .insert({
+      creator_id: userId,
+      name,
+      description: description
+        ? JSON.stringify({
+            type: 'doc',
+            content: [
+              {
+                type: 'paragraph',
+                content: [{ type: 'text', text: description }],
+              },
+            ],
+          })
+        : null,
+      list_id: listId,
+      priority,
+      start_date: date(args.startDate, false),
+      end_date: date(args.endDate ?? args.dueDate, true),
+      estimation_points: (args.estimationPoints as number | null) ?? null,
+      completed: false,
+    })
+    .select('id')
+    .single();
+  if (error || !task) {
+    // PostgreSQL data/constraint/permission errors reject the insert statement.
+    // Unknown or transport errors can lose the response after a committed write.
+    const rejected =
+      /^(22|23)/.test(error?.code ?? '') || error?.code === '42501';
+    return {
+      success: false,
+      ...(rejected ? { created: false } : { writeUncertain: true }),
+      error: error?.message ?? 'Task creation returned no saved task.',
+      instruction: rejected
+        ? 'The database rejected the insert. Correct the reported problem before retrying.'
+        : 'The insert could not be verified. Check existing tasks before attempting creation again.',
+    };
+  }
+
+  let assignmentError: string | undefined;
+  if (assignToSelf) {
+    const { error } = await supabase
+      .from('task_assignees')
+      .insert({ task_id: task.id, user_id: userId });
+    assignmentError = error?.message;
+  }
+  // Read the saved row and its location before claiming completion. Never retry
+  // a write when this read fails: the ID is returned for recovery instead.
+  const { data: saved, error: readError } = await supabase
+    .from('tasks')
+    .select(
+      'id, name, priority, start_date, end_date, estimation_points, created_at, task_lists!inner(id, name, workspace_boards!inner(id, name, ws_id))'
+    )
+    .eq('id', task.id)
+    .single();
+  if (readError || !saved)
+    return {
+      success: false,
+      created: true,
+      taskId: task.id,
+      error:
+        'Task was inserted but its saved details could not be verified. Do not create it again; retrieve this task ID.',
+      ...(assignmentError ? { assignmentError } : {}),
+    };
+  return {
+    success: !assignmentError,
+    created: true,
+    task: saved,
+    workspaceId: getWorkspaceContextWorkspaceId(ctx),
+    assignedToSelf: assignToSelf && !assignmentError,
+    ...(assignmentError
+      ? {
+          error: `Task was created, but assignment failed: ${assignmentError}. Retry assignment only, never creation.`,
+        }
+      : {}),
+    message:
+      'Use the saved task ID, location and due date in your confirmation. Do not claim any fields absent from this result.',
+  };
+}