@tuturuuu/ai 0.13.0 → 0.14.0

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

@@ -0,0 +1,59 @@
+import {
+  withForwardedInternalApiAuth,
+  withTaskApiBaseUrl,
+} from '@tuturuuu/internal-api/client';
+import { getUserTaskDashboard } from '@tuturuuu/internal-api/tasks';
+import { Effect } from '@tuturuuu/utils/effect';
+import type { MiraToolContext } from '../mira-tool-types';
+import { getWorkspaceContextWorkspaceId } from '../workspace-context';
+
+export function executeTaskDashboard(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  const category = args.category ?? args.status ?? 'all';
+  const options = withForwardedInternalApiAuth(
+    ctx.requestHeaders!,
+    withTaskApiBaseUrl()
+  );
+  return Effect.runPromise(
+    Effect.tryPromise({
+      try: async () => {
+        const result = await getUserTaskDashboard(
+          {
+            wsId: getWorkspaceContextWorkspaceId(ctx),
+            isPersonal: ctx.workspaceContext?.personal === true,
+          },
+          options
+        );
+        const output: Record<string, unknown> = {
+          totalActive: result.totalActiveTasks,
+        };
+        for (const group of ['overdue', 'today', 'upcoming'] as const) {
+          if (category !== 'all' && category !== group) continue;
+          output[group] = {
+            count: result[group].length,
+            hasMore: result[group].length > 30,
+            tasks: result[group].slice(0, 30).map((task) => ({
+              id: task.id,
+              name: task.name,
+              priority: task.priority,
+              dueDate: task.end_date,
+              workspaceId: task.list?.board?.ws_id,
+              workspaceName: task.list?.board?.workspaces?.name,
+              boardId: task.list?.board?.id,
+              boardName: task.list?.board?.name,
+              listId: task.list_id,
+              listName: task.list?.name,
+            })),
+          };
+        }
+        return output;
+      },
+      catch: (error) =>
+        error instanceof Error ? error.message : 'Task feed unavailable',
+    }).pipe(
+      Effect.catchAll((error) => Effect.succeed({ success: false, error }))
+    )
+  );
+}

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

@@ -0,0 +1,76 @@
+import type { MiraToolContext } from '../mira-tool-types';
+import { getWorkspaceContextWorkspaceId } from '../workspace-context';
+
+export async function executeGetTask(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  const taskId = args.taskId as string;
+  const wsId = getWorkspaceContextWorkspaceId(ctx);
+  const { data, error } = await ctx.supabase
+    .from('tasks')
+    .select(
+      'id, name, description, priority, start_date, end_date, estimation_points, completed, completed_at, board_id, list_id, direct_board:workspace_boards!fk_tasks_board_id(id, name, ws_id), task_lists(id, name, workspace_boards!inner(id, name, ws_id)), task_assignees(user_id), task_labels(label_id)'
+    )
+    .eq('id', taskId)
+    .eq('direct_board.ws_id', wsId)
+    .eq('task_lists.workspace_boards.ws_id', wsId)
+    .or('direct_board.not.is.null,and(board_id.is.null,task_lists.not.is.null)')
+    .maybeSingle();
+  return error
+    ? { error: error.message }
+    : data
+      ? { task: data, workspaceId: wsId }
+      : { error: 'Task not found in the current workspace.' };
+}
+
+export async function executeSearchTasks(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  const wsId = getWorkspaceContextWorkspaceId(ctx);
+  const title = String(args.query ?? '').trim();
+  if (!title) return { error: 'Provide a task title to search for.' };
+  const page = Math.max(1, Number(args.page) || 1);
+  const limit = Math.min(50, Math.max(1, Number(args.limit) || 20));
+  const query = title.replace(/[\\%_]/g, '\\$&');
+  let builder = ctx.supabase
+    .from('tasks')
+    .select(
+      'id, name, priority, start_date, end_date, completed, board_id, list_id, direct_board:workspace_boards!fk_tasks_board_id(id, name, ws_id), task_lists(id, name, workspace_boards!inner(id, name, ws_id))',
+      { count: 'exact' }
+    )
+    .eq('direct_board.ws_id', wsId)
+    .is('direct_board.archived_at', null)
+    .is('direct_board.deleted_at', null)
+    .eq('task_lists.workspace_boards.ws_id', wsId)
+    .is('task_lists.workspace_boards.archived_at', null)
+    .is('task_lists.workspace_boards.deleted_at', null)
+    .eq('task_lists.archived', false)
+    .eq('task_lists.deleted', false)
+    // Board ownership takes precedence, matching getTaskScope. Nullable embeds
+    // allow board-only tasks without admitting rows from another workspace.
+    .or(
+      'and(direct_board.not.is.null,list_id.is.null),and(direct_board.not.is.null,task_lists.not.is.null),and(board_id.is.null,task_lists.not.is.null)'
+    )
+    .is('deleted_at', null)
+    .ilike('name', `%${query}%`)
+    .order('created_at', { ascending: false })
+    .order('id', { ascending: true })
+    .range((page - 1) * limit, page * limit - 1);
+  if (args.includeCompleted !== true)
+    builder = builder
+      .eq('completed', false)
+      .is('completed_at', null)
+      .is('closed_at', null);
+  const { data, count, error } = await builder;
+  return error
+    ? { error: error.message }
+    : {
+        workspaceId: wsId,
+        tasks: data,
+        total: count,
+        page,
+        hasMore: page * limit < (count ?? 0),
+      };
+}

package/src/tools/executors/tasks.ts

@@ -12,6 +12,7 @@ import {
   isWorkspaceMember,
   type TaskScope,
 } from './scope-helpers';
+import { executeTaskDashboard } from './task-dashboard';
 
 type RpcTask = {
   task_id: string;
@@ -45,6 +46,7 @@ export async function executeGetMyTasks(
   args: Record<string, unknown>,
   ctx: MiraToolContext
 ) {
+  if (ctx.requestHeaders) return executeTaskDashboard(args, ctx);
   const { userId, supabase } = ctx;
   const wsId = getWorkspaceContextWorkspaceId(ctx);
   const category = ((args.category ?? args.status) as string) || 'all';
@@ -101,203 +103,7 @@ export async function executeGetMyTasks(
   return result;
 }
 
-export async function executeCreateTask(
-  args: Record<string, unknown>,
-  ctx: MiraToolContext
-) {
-  const { userId, supabase } = ctx;
-  const wsId = getWorkspaceContextWorkspaceId(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 boardIdArg = args.boardId as string | undefined;
-  const listIdArg = args.listId as string | undefined;
-  const assignToSelf = (args.assignToSelf as boolean | undefined) !== false;
-
-  // If listId is provided directly, validate it exists and use it
-  if (listIdArg) {
-    const { data: targetList } = await supabase
-      .from('task_lists')
-      .select('id, board_id, workspace_boards!inner(ws_id)')
-      .eq('id', listIdArg)
-      .eq('archived', false)
-      .single();
-
-    if (!targetList) {
-      return {
-        error: `Task list "${listIdArg}" not found or archived. Use list_task_lists to discover valid lists.`,
-      };
-    }
-
-    const listWsId = (
-      targetList.workspace_boards as unknown as { ws_id: string }
-    )?.ws_id;
-    if (listWsId && listWsId !== wsId) {
-      return {
-        error: `Task list does not belong to the current workspace context. Switch workspace first with set_workspace_context.`,
-      };
-    }
-
-    // Use the validated list directly — skip board/list auto-resolution
-    const { data: task, error } = await supabase
-      .from('tasks')
-      .insert({
-        name,
-        description: description
-          ? JSON.stringify({
-              type: 'doc',
-              content: [
-                {
-                  type: 'paragraph',
-                  content: [{ type: 'text', text: description }],
-                },
-              ],
-            })
-          : null,
-        list_id: listIdArg,
-        priority,
-        completed: false,
-      })
-      .select('id, name, priority, created_at')
-      .single();
-
-    if (error) return { error: error.message };
-
-    if (assignToSelf && task) {
-      const { error: assignErr } = await supabase
-        .from('task_assignees')
-        .insert({ task_id: task.id, user_id: userId });
-      if (assignErr) {
-        return {
-          success: true,
-          message: `Task "${name}" created in specified list, but auto-assignment failed: ${assignErr.message}`,
-          task,
-        };
-      }
-      return {
-        success: true,
-        message: `Task "${name}" created in specified list and assigned to you`,
-        task,
-      };
-    }
-
-    return {
-      success: true,
-      message: `Task "${name}" created in specified list (unassigned)`,
-      task,
-    };
-  }
-
-  // Resolve board: use provided boardId or fall back to first workspace board
-  let board: { id: string } | null = null;
-
-  if (boardIdArg) {
-    const { data: targetBoard } = await supabase
-      .from('workspace_boards')
-      .select('id')
-      .eq('id', boardIdArg)
-      .eq('ws_id', wsId)
-      .single();
-
-    if (!targetBoard) {
-      return {
-        error: `Board "${boardIdArg}" not found in this workspace. Use list_boards to discover valid boards.`,
-      };
-    }
-    board = targetBoard;
-  } else {
-    const { data: firstBoard } = await supabase
-      .from('workspace_boards')
-      .select('id')
-      .eq('ws_id', wsId)
-      .limit(1)
-      .single();
-    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 {
-        error: `Failed to create board: ${boardErr?.message ?? 'Unknown error'}`,
-      };
-    board = newBoard;
-  }
-
-  let { data: list } = await supabase
-    .from('task_lists')
-    .select('id')
-    .eq('board_id', board.id)
-    .eq('archived', false)
-    .order('created_at', { ascending: true })
-    .limit(1)
-    .single();
-
-  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 {
-        error: `Failed to create list: ${listErr?.message ?? 'Unknown error'}`,
-      };
-    list = newList;
-  }
-
-  const { data: task, error } = await supabase
-    .from('tasks')
-    .insert({
-      name,
-      description: description
-        ? JSON.stringify({
-            type: 'doc',
-            content: [
-              {
-                type: 'paragraph',
-                content: [{ type: 'text', text: description }],
-              },
-            ],
-          })
-        : null,
-      list_id: list.id,
-      priority,
-      completed: false,
-    })
-    .select('id, name, priority, created_at')
-    .single();
-
-  if (error) return { error: error.message };
-
-  if (assignToSelf && task) {
-    const { error: assignErr } = await supabase
-      .from('task_assignees')
-      .insert({ task_id: task.id, user_id: userId });
-    if (assignErr) {
-      return {
-        success: true,
-        message: `Task "${name}" created, but auto-assignment failed: ${assignErr.message}`,
-        task,
-      };
-    }
-    return {
-      success: true,
-      message: `Task "${name}" created and assigned to you`,
-      task,
-    };
-  }
-
-  return {
-    success: true,
-    message: `Task "${name}" created (unassigned)`,
-    task,
-  };
-}
+export { executeCreateTask } from './task-create';
 
 export async function executeCompleteTask(
   args: Record<string, unknown>,
@@ -323,7 +129,11 @@ export async function executeCompleteTask(
 
   const { error } = await ctx.supabase
     .from('tasks')
-    .update({ completed: true, completed_at: new Date().toISOString() })
+    .update({
+      completed: true,
+      completed_at: new Date().toISOString(),
+      closed_at: new Date().toISOString(),
+    })
     .eq('id', taskId)
     .eq(taskScopePredicate.column, taskScopePredicate.value);
 
@@ -334,7 +144,7 @@ export async function executeCompleteTask(
 // ── New CRUD tools ──
 
 const UPDATE_TASK_FIELDS_HINT =
-  'Accepted fields: taskId (or id), endDate (or dueDate, ISO), name, description, priority, startDate, listId, estimationPoints.';
+  'Accepted fields: taskId (or id), endDate (or dueDate, ISO), name, description, priority, startDate, listId, estimationPoints, completed.';
 
 export async function executeUpdateTask(
   args: Record<string, unknown>,
@@ -360,6 +170,11 @@ export async function executeUpdateTask(
         })
       : null;
   }
+  if (args.completed !== undefined) {
+    updates.completed = args.completed as boolean;
+    updates.completed_at = args.completed ? new Date().toISOString() : null;
+    updates.closed_at = updates.completed_at;
+  }
   if (args.priority !== undefined)
     updates.priority = args.priority as Enums<'task_priority'>;
   if (args.startDate !== undefined) {
@@ -371,7 +186,7 @@ export async function executeUpdateTask(
           ? parseTaskDateToUTCISO(v, ctx.timezone, false)
           : v;
   }
-  const endDateValue = args.endDate ?? args.dueDate;
+  const endDateValue = args.endDate !== undefined ? args.endDate : args.dueDate;
   if (endDateValue !== undefined) {
     const v = endDateValue as string | null;
     updates.end_date =
@@ -420,14 +235,43 @@ export async function executeUpdateTask(
     return { error: 'Task not found in current workspace' };
   }
 
-  const { error } = await ctx.supabase
+  if (args.completed === false) {
+    const listId = (args.listId as string | undefined) ?? taskScope.listId;
+    const { data: list, error } = await ctx.supabase
+      .from('task_lists')
+      .select('id, status')
+      .eq('id', listId ?? '')
+      .single();
+    if (
+      error ||
+      !list ||
+      !['not_started', 'active'].includes(list.status ?? '')
+    )
+      return {
+        error:
+          'To reopen this task, provide an active listId from list_task_lists. No changes were saved.',
+      };
+  }
+  const { data: saved, error } = await ctx.supabase
     .from('tasks')
     .update(updates)
     .eq('id', taskId)
-    .eq(taskScopePredicate.column, taskScopePredicate.value);
+    .eq(taskScopePredicate.column, taskScopePredicate.value)
+    .select('id, name, priority, start_date, end_date, completed, list_id')
+    .maybeSingle();
 
-  if (error) return { error: error.message };
-  return { success: true, message: `Task ${taskId} updated` };
+  if (error || !saved)
+    return {
+      success: false,
+      error:
+        error?.message ??
+        'Task was not updated; it may have moved or been removed.',
+    };
+  return {
+    success: true,
+    task: saved,
+    workspaceId: getWorkspaceContextWorkspaceId(ctx),
+  };
 }
 
 export async function executeDeleteTask(
@@ -559,9 +403,10 @@ export async function executeListTaskLists(
 
   const { data, error } = await ctx.supabase
     .from('task_lists')
-    .select('id, name, board_id, color, position, archived')
+    .select('id, name, board_id, status, color, position, archived')
     .eq('board_id', boardId)
     .eq('archived', false)
+    .eq('deleted', false)
     .order('position', { ascending: true });
 
   if (error) return { error: error.message };

package/src/tools/executors/theme.ts

@@ -1,4 +1,9 @@
+import {
+  manageWorkspaceSchema,
+  showWorkspaceArtifactSchema,
+} from '../../workspace-artifacts';
 import type { MiraToolContext } from '../mira-tools';
+import { getWorkspaceContextWorkspaceId } from '../workspace-context';
 
 export async function executeSetTheme(
   args: Record<string, unknown>,
@@ -21,3 +26,46 @@ export async function executeSetTheme(
     message: `Theme changed to ${theme}`,
   };
 }
+
+export async function executeSetSidebar(args: Record<string, unknown>) {
+  const behavior = args.behavior;
+  if (
+    !['expanded', 'collapsed', 'hover', 'hidden'].includes(String(behavior))
+  ) {
+    return { error: 'Invalid sidebar behavior' };
+  }
+  return { success: true, action: 'set_sidebar', behavior };
+}
+
+export async function executeShowWorkspaceArtifact(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  const parsed = showWorkspaceArtifactSchema.safeParse(args);
+  if (!parsed.success)
+    return { error: 'Invalid artifact presentation or layout' };
+  return {
+    success: true,
+    action: 'show_workspace_artifact',
+    message:
+      'Artifact UI command completed. This UI command did not fetch product data; the panel fetches its own data separately. Do not repeat this successful command. Continue only with other requested actions, then answer.',
+    ...parsed.data,
+    wsId: getWorkspaceContextWorkspaceId(ctx),
+  };
+}
+
+export async function executeManageWorkspace(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  const parsed = manageWorkspaceSchema.safeParse(args);
+  if (!parsed.success) return { error: 'Invalid workspace operation' };
+  return {
+    success: true,
+    action: 'manage_workspace',
+    message:
+      'Workspace UI command completed. Do not repeat this successful command to verify it. Preserve panels the user asked to keep; once the requested actions are complete, answer without further UI calls.',
+    ...parsed.data,
+    wsId: getWorkspaceContextWorkspaceId(ctx),
+  };
+}

package/src/tools/google-search-events.ts

@@ -0,0 +1,4 @@
+/** Gemini native search emits server tools rather than the registered tool name. */
+export function isGoogleSearchToolName(name: string | undefined) {
+  return name === 'google_search' || name === 'server:GOOGLE_SEARCH_WEB';
+}

package/src/tools/mira-sdk-tool-search.ts

@@ -0,0 +1,73 @@
+import type { PermissionId } from '@tuturuuu/types';
+import { type ToolSet, toolSearch } from 'ai';
+import { MIRA_TOOL_PERMISSIONS } from './mira-tool-metadata';
+import type { MiraToolName } from './mira-tool-names';
+import type { MiraToolContext } from './mira-tool-types';
+import { getWorkspaceContextWorkspaceId } from './workspace-context';
+
+type StepPolicy = {
+  activeTools: string[];
+  toolChoice?: 'required' | 'none';
+};
+
+/** Each generation owns discovery state; execution retains the original guards. */
+export function createMiraSdkToolSearch(
+  originalTools: ToolSet,
+  ctx: MiraToolContext,
+  withoutPermission?: (permission: PermissionId) => boolean
+) {
+  const tools: ToolSet = Object.fromEntries(
+    Object.entries(originalTools).map(([name, definition]) => [
+      name,
+      name === 'search_tools'
+        ? toolSearch()
+        : { ...definition, deferLoading: true },
+    ])
+  );
+
+  async function prepareStep(policy: StepPolicy) {
+    if (policy.toolChoice === 'none') {
+      return { ...policy, activeTools: [] };
+    }
+    const workspaceId = getWorkspaceContextWorkspaceId(ctx);
+    const allowed = new Set<string>();
+    for (const name of Object.keys(tools)) {
+      const permission = MIRA_TOOL_PERMISSIONS[name as MiraToolName];
+      const required = permission
+        ? Array.isArray(permission)
+          ? permission
+          : [permission]
+        : [];
+      let authorized = required.length === 0;
+      if (!authorized) {
+        try {
+          authorized = ctx.authorizeWorkspaceTools
+            ? await ctx.authorizeWorkspaceTools(workspaceId, required)
+            : Boolean(withoutPermission) &&
+              !required.some((item) => withoutPermission!(item));
+        } catch {
+          authorized = false;
+        }
+      }
+      if (authorized) allowed.add(name);
+    }
+    // Never publish a catalog authorized for a context that changed meanwhile.
+    if (workspaceId !== getWorkspaceContextWorkspaceId(ctx)) {
+      return { toolChoice: 'none' as const, activeTools: [] };
+    }
+    const selected = new Set(policy.activeTools);
+    const canDiscover = selected.has('search_tools');
+    const activeTools = [...allowed].filter(
+      (name) => canDiscover || selected.has(name)
+    );
+    // prepareStep supports eligibility overrides, not replacement ToolSets.
+    // These definitions belong only to this generation, never to the registry.
+    for (const [name, definition] of Object.entries(tools)) {
+      if (name !== 'search_tools') {
+        tools[name] = { ...definition, deferLoading: !selected.has(name) };
+      }
+    }
+    return { ...policy, activeTools };
+  }
+  return { tools, prepareStep };
+}

package/src/tools/mira-task-write-guard.ts

@@ -0,0 +1,61 @@
+const object = (value: unknown): value is Record<string, unknown> =>
+  !!value && typeof value === 'object' && !Array.isArray(value);
+const dateKey = (value: unknown) => {
+  if (typeof value !== 'string') return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? value : date.toISOString();
+};
+
+/** Per-turn protection, retaining receipts whenever a write may have happened. */
+export function createTaskWriteGuard() {
+  const pending = new Map<string, Promise<unknown>>();
+  return async (
+    workspaceId: string,
+    args: Record<string, unknown>,
+    execute: () => Promise<unknown>
+  ) => {
+    const { dueDate, ...fields } = args;
+    const normalized = {
+      ...fields,
+      description: args.description || null,
+      priority: args.priority ?? null,
+      startDate: dateKey(args.startDate),
+      endDate: dateKey(args.endDate ?? dueDate),
+      estimationPoints: args.estimationPoints ?? null,
+      assignToSelf: args.assignToSelf !== false,
+    };
+    const key = JSON.stringify([
+      workspaceId,
+      Object.entries(normalized).sort(([a], [b]) => a.localeCompare(b)),
+    ]);
+    const previous = pending.get(key);
+    if (previous) {
+      const result = await previous;
+      return {
+        ...(object(result) ? result : { result }),
+        reusedResult: true,
+        instruction:
+          'This is the prior creation result. No second task was created. Explain the saved result or error and stop retrying creation.',
+      };
+    }
+    const result = Promise.resolve()
+      .then(execute)
+      .catch(() => ({
+        success: false,
+        writeUncertain: true,
+        error:
+          'Task creation was interrupted. Verify the saved task before retrying.',
+      }));
+    pending.set(key, result);
+    const output = await result;
+    // Only an explicit pre-write failure is safe to retry. A transport failure
+    // may occur after insertion and must retain its recovery receipt.
+    if (
+      object(output) &&
+      output.created === false &&
+      output.writeUncertain !== true
+    )
+      pending.delete(key);
+    return output;
+  };
+}