@tuturuuu/ai 0.0.10

package/src/tools/executors/scope-helpers.ts

@@ -0,0 +1,192 @@
+import { verifyWorkspaceMembershipType } from '@tuturuuu/utils/workspace-helper';
+import type { MiraToolContext } from '../mira-tools';
+import { getWorkspaceContextWorkspaceId } from '../workspace-context';
+
+function normalizeRelation<T>(value: T | T[] | null | undefined): T | null {
+  if (!value) return null;
+  return Array.isArray(value) ? (value[0] ?? null) : value;
+}
+
+export type TaskScope = {
+  id: string;
+  boardId: string | null;
+  listId: string | null;
+};
+
+export async function hasWorkspaceBoardAccess(
+  ctx: MiraToolContext,
+  boardId: string
+): Promise<boolean> {
+  const { data, error } = await ctx.supabase
+    .from('workspace_boards')
+    .select('id')
+    .eq('id', boardId)
+    .eq('ws_id', getWorkspaceContextWorkspaceId(ctx))
+    .maybeSingle();
+
+  if (error) {
+    throw new Error(error.message);
+  }
+
+  return Boolean(data);
+}
+
+export async function hasTaskListAccess(
+  ctx: MiraToolContext,
+  listId: string
+): Promise<boolean> {
+  const { data, error } = await ctx.supabase
+    .from('task_lists')
+    .select('id, workspace_boards!inner(ws_id)')
+    .eq('id', listId)
+    .maybeSingle();
+
+  if (error) {
+    throw new Error(error.message);
+  }
+
+  const board = normalizeRelation(
+    data?.workspace_boards as { ws_id: string } | { ws_id: string }[] | null
+  );
+
+  return board?.ws_id === getWorkspaceContextWorkspaceId(ctx);
+}
+
+export async function hasTaskAccess(
+  ctx: MiraToolContext,
+  taskId: string
+): Promise<boolean> {
+  return Boolean(await getTaskScope(ctx, taskId));
+}
+
+export async function getTaskScope(
+  ctx: MiraToolContext,
+  taskId: string
+): Promise<TaskScope | null> {
+  const { data, error } = await ctx.supabase
+    .from('tasks')
+    .select('id, board_id, list_id')
+    .eq('id', taskId)
+    .maybeSingle();
+
+  if (error) {
+    throw new Error(error.message);
+  }
+
+  if (!data) {
+    return null;
+  }
+
+  const taskScope: TaskScope = {
+    id: data.id,
+    boardId: data.board_id ?? null,
+    listId: data.list_id ?? null,
+  };
+
+  if (taskScope.boardId) {
+    if (await hasWorkspaceBoardAccess(ctx, taskScope.boardId)) {
+      return taskScope;
+    }
+    return null;
+  }
+
+  if (taskScope.listId) {
+    if (await hasTaskListAccess(ctx, taskScope.listId)) {
+      return taskScope;
+    }
+  }
+
+  return null;
+}
+
+export async function hasProjectAccess(
+  ctx: MiraToolContext,
+  projectId: string
+): Promise<boolean> {
+  const { data, error } = await ctx.supabase
+    .from('task_projects')
+    .select('id')
+    .eq('id', projectId)
+    .eq('ws_id', getWorkspaceContextWorkspaceId(ctx))
+    .maybeSingle();
+
+  if (error) {
+    throw new Error(error.message);
+  }
+
+  return Boolean(data);
+}
+
+export async function hasWalletAccess(
+  ctx: MiraToolContext,
+  walletId: string
+): Promise<boolean> {
+  const { data, error } = await ctx.supabase
+    .schema('private')
+    .from('workspace_wallets')
+    .select('id')
+    .eq('id', walletId)
+    .eq('ws_id', getWorkspaceContextWorkspaceId(ctx))
+    .maybeSingle();
+
+  if (error) {
+    throw new Error(error.message);
+  }
+
+  return Boolean(data);
+}
+
+export async function hasTransactionCategoryAccess(
+  ctx: MiraToolContext,
+  categoryId: string
+): Promise<boolean> {
+  const { data, error } = await ctx.supabase
+    .from('transaction_categories')
+    .select('id')
+    .eq('id', categoryId)
+    .eq('ws_id', getWorkspaceContextWorkspaceId(ctx))
+    .maybeSingle();
+
+  if (error) {
+    throw new Error(error.message);
+  }
+
+  return Boolean(data);
+}
+
+export async function hasTimeTrackingCategoryAccess(
+  ctx: MiraToolContext,
+  categoryId: string
+): Promise<boolean> {
+  const { data, error } = await ctx.supabase
+    .from('time_tracking_categories')
+    .select('id')
+    .eq('id', categoryId)
+    .eq('ws_id', getWorkspaceContextWorkspaceId(ctx))
+    .maybeSingle();
+
+  if (error) {
+    throw new Error(error.message);
+  }
+
+  return Boolean(data);
+}
+
+export async function isWorkspaceMember(
+  ctx: MiraToolContext,
+  userId: string,
+  workspaceId = getWorkspaceContextWorkspaceId(ctx)
+): Promise<boolean> {
+  const result = await verifyWorkspaceMembershipType({
+    wsId: workspaceId,
+    userId,
+    supabase: ctx.supabase,
+    requiredType: 'MEMBER',
+  });
+
+  if (result.error === 'membership_lookup_failed') {
+    throw new Error('Membership lookup failed');
+  }
+
+  return result.ok;
+}

package/src/tools/executors/search.ts

@@ -0,0 +1,149 @@
+import { google } from '@ai-sdk/google';
+import { generateText, stepCountIs } from 'ai';
+import { z } from 'zod';
+import { withAiMemory } from '../../memory';
+import type { MiraToolContext } from '../mira-tools';
+
+const SEARCH_WRAPPER_MODEL = 'gemini-3.1-flash-lite';
+
+type SearchSource = {
+  sourceId?: string;
+  title?: string;
+  url?: string;
+};
+
+type ToolStepLike = {
+  toolCalls?: Array<{ toolName?: string }>;
+  toolResults?: Array<{ toolName?: string }>;
+};
+
+const SearchArgsSchema = z.object({
+  query: z
+    .string()
+    .transform((value) => value.trim())
+    .refine((value) => value.length > 0, {
+      message: 'Missing required `query`.',
+    })
+    .transform((value) => value.slice(0, 500)),
+});
+
+function hasGoogleSearchCallInSteps(steps: unknown): boolean {
+  if (!Array.isArray(steps)) return false;
+
+  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 hasResult = (typedStep.toolResults ?? []).some(
+      (toolResult) => toolResult.toolName === 'google_search'
+    );
+    return called || hasResult;
+  });
+}
+
+function normalizeSources(value: unknown): SearchSource[] {
+  if (!Array.isArray(value)) return [];
+
+  const normalized: SearchSource[] = [];
+
+  for (const item of value) {
+    if (!item || typeof item !== 'object') continue;
+
+    const source = item as Record<string, unknown>;
+    const sourceId =
+      typeof source.sourceId === 'string' ? source.sourceId : undefined;
+    const title = typeof source.title === 'string' ? source.title : undefined;
+    const url = typeof source.url === 'string' ? source.url : undefined;
+
+    if (!sourceId && !title && !url) continue;
+
+    normalized.push({ sourceId, title, url });
+  }
+
+  return normalized;
+}
+
+async function runGoogleSearchWrapper(
+  query: string,
+  forceTool: boolean,
+  ctx: MiraToolContext
+) {
+  const prompt = forceTool
+    ? `You must call the google_search tool before producing the final answer.\nSearch the web for the query below and provide an accurate, concise answer with key points and cited sources.\n\nQuery: ${query}`
+    : `Search the web for the query below and provide an accurate, concise answer with key points and cited sources.\n\nQuery: ${query}`;
+
+  return generateText({
+    model: await withAiMemory({
+      addMemory: 'never',
+      customId: ctx.chatId ? `${ctx.chatId}-google-search` : query,
+      model: google(SEARCH_WRAPPER_MODEL),
+      product: 'mira',
+      source: 'mira_google_search_tool',
+      surface: 'mira_google_search_tool',
+      userId: ctx.userId,
+      wsId: ctx.workspaceContext?.wsId ?? ctx.wsId,
+    }),
+    tools: {
+      google_search: google.tools.googleSearch({}),
+    },
+    prompt,
+    stopWhen: stepCountIs(4),
+    ...(forceTool ? { toolChoice: 'required' as const } : {}),
+  });
+}
+
+export async function executeGoogleSearch(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  const parsed = SearchArgsSchema.safeParse(args);
+  if (!parsed.success) {
+    return {
+      ok: false,
+      error: parsed.error.issues[0]?.message ?? 'Invalid `query`.',
+    };
+  }
+
+  const { query } = parsed.data;
+
+  try {
+    let result = await runGoogleSearchWrapper(query, false, ctx);
+    let sources = normalizeSources((result as { sources?: unknown }).sources);
+    let wasToolCalled = hasGoogleSearchCallInSteps(
+      (result as { steps?: unknown }).steps
+    );
+
+    if (!wasToolCalled) {
+      result = await runGoogleSearchWrapper(query, true, ctx);
+      sources = normalizeSources((result as { sources?: unknown }).sources);
+      wasToolCalled = hasGoogleSearchCallInSteps(
+        (result as { steps?: unknown }).steps
+      );
+    }
+
+    if (!wasToolCalled && sources.length === 0) {
+      return {
+        ok: false,
+        query,
+        error: 'Failed to invoke google_search tool for web-grounded results.',
+      };
+    }
+
+    return {
+      ok: true,
+      query,
+      answer: result.text,
+      sources,
+      sourceCount: sources.length,
+    };
+  } catch (error) {
+    console.error('executeGoogleSearch provider error:', error);
+    return {
+      ok: false,
+      query,
+      error: 'Search provider error. Please try again.',
+    };
+  }
+}

package/src/tools/executors/settings.ts

@@ -0,0 +1,40 @@
+import type { MiraToolContext } from '../mira-tools';
+
+export async function executeUpdateMySettings(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  const updates: Record<string, string> = {};
+  const fields = [
+    'name',
+    'tone',
+    'personality',
+    'boundaries',
+    'vibe',
+    'chat_tone',
+  ] as const;
+
+  for (const field of fields) {
+    const value = args[field];
+    if (typeof value === 'string') {
+      updates[field] = value;
+    }
+  }
+
+  if (Object.keys(updates).length === 0) {
+    return { success: true, message: 'No settings to update' };
+  }
+
+  const { error } = await ctx.supabase
+    .from('mira_soul')
+    .upsert({ user_id: ctx.userId, ...updates }, { onConflict: 'user_id' });
+
+  if (error) return { error: error.message };
+
+  const changedFields = Object.keys(updates).join(', ');
+  return {
+    success: true,
+    message: `Settings updated: ${changedFields}`,
+    updated: updates,
+  };
+}