@tuturuuu/ai 0.0.10

package/src/tools/executors/memory.ts

@@ -0,0 +1,277 @@
+import {
+  forgetAiMemory,
+  listAiMemories,
+  rememberAiMemory,
+  resolveAiMemoryScope,
+  searchAiMemories,
+} from '../../memory';
+import {
+  MIRA_MEMORY_CATEGORIES,
+  type MiraMemoryCategory,
+} from '../definitions/memory';
+import type { MiraToolContext } from '../mira-tools';
+
+function toMemoryCategory(value: unknown): MiraMemoryCategory | undefined {
+  if (typeof value !== 'string') return undefined;
+  return MIRA_MEMORY_CATEGORIES.includes(value as MiraMemoryCategory)
+    ? (value as MiraMemoryCategory)
+    : undefined;
+}
+
+function parseMemoryCategory(
+  categoryInput: unknown,
+  options: { fieldName?: string; required?: boolean } = {}
+): { category: MiraMemoryCategory | null; error: string | null } {
+  const { fieldName = 'category', required = false } = options;
+  const allowed = MIRA_MEMORY_CATEGORIES.join(', ');
+
+  if (categoryInput === undefined || categoryInput === null) {
+    if (!required) return { category: null, error: null };
+    return {
+      category: null,
+      error: `${fieldName} is required. Allowed: ${allowed}`,
+    };
+  }
+
+  const parsedCategory = toMemoryCategory(categoryInput);
+  if (!parsedCategory) {
+    return {
+      category: null,
+      error: `Invalid ${fieldName}. Allowed: ${allowed}`,
+    };
+  }
+
+  return { category: parsedCategory, error: null };
+}
+
+function getMemoryWorkspaceId(ctx: MiraToolContext) {
+  return ctx.workspaceContext?.wsId ?? ctx.wsId;
+}
+
+function resolveMiraMemoryScope(ctx: MiraToolContext) {
+  return resolveAiMemoryScope({
+    customId: ctx.chatId ?? 'mira-chat',
+    product: 'mira',
+    source: 'mira_chat',
+    surface: 'mira_chat',
+    userId: ctx.userId,
+    wsId: getMemoryWorkspaceId(ctx),
+  });
+}
+
+function keyValueMemory(memory: {
+  category?: string | null;
+  key?: string | null;
+  updatedAt?: string | null;
+  value: string;
+}) {
+  return {
+    category: memory.category ?? 'fact',
+    key: memory.key ?? memory.value.slice(0, 80),
+    updatedAt: memory.updatedAt ?? new Date().toISOString(),
+    value: memory.value,
+  };
+}
+
+export async function executeRemember(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  const key = args.key as string;
+  const value = args.value as string;
+  const { category, error: categoryError } = parseMemoryCategory(
+    args.category,
+    {
+      required: true,
+    }
+  );
+
+  if (categoryError || !category) {
+    return {
+      error:
+        categoryError ??
+        'Invalid category. Allowed: preference, fact, conversation_topic, event, person',
+    };
+  }
+
+  const result = await rememberAiMemory({
+    category,
+    key,
+    scope: resolveMiraMemoryScope(ctx),
+    value,
+  });
+
+  if (!result.ok) return { error: result.error };
+  if (result.skipped) {
+    return {
+      action: 'skipped',
+      message: `Memory "${key}" was not saved: ${result.reason}`,
+      success: false,
+    };
+  }
+
+  return {
+    action: 'created',
+    message: `Remembered: "${key}"`,
+    success: true,
+  };
+}
+
+export async function executeRecall(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  const query = (args.query as string | null | undefined) ?? null;
+  const { category, error: categoryError } = parseMemoryCategory(args.category);
+  if (categoryError) return { error: categoryError };
+
+  const maxResults = (args.maxResults as number) || 10;
+  const scope = resolveMiraMemoryScope(ctx);
+
+  const result = query?.trim()
+    ? await searchAiMemories({
+        category,
+        limit: maxResults,
+        query,
+        scope,
+      })
+    : await listAiMemories({
+        category,
+        limit: maxResults,
+        scope,
+      });
+
+  if (!result.ok) return { error: result.error };
+
+  const memories = (result.value ?? []).map((memory) =>
+    keyValueMemory({
+      category:
+        'category' in memory
+          ? memory.category
+          : typeof memory.metadata?.memoryCategory === 'string'
+            ? memory.metadata.memoryCategory
+            : category,
+      key:
+        'key' in memory
+          ? memory.key
+          : typeof memory.metadata?.memoryKey === 'string'
+            ? memory.metadata.memoryKey
+            : null,
+      updatedAt: memory.updatedAt,
+      value:
+        'value' in memory
+          ? memory.value
+          : memory.summary || memory.content || memory.title || '',
+    })
+  );
+
+  return {
+    count: memories.length,
+    memories,
+  };
+}
+
+export async function executeDeleteMemory(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  const key = args.key as string;
+  const result = await forgetAiMemory({
+    key,
+    scope: resolveMiraMemoryScope(ctx),
+  });
+
+  if (!result.ok) return { error: result.error };
+  if (result.skipped) {
+    return {
+      message: `Memory "${key}" was not deleted: ${result.reason}`,
+      success: false,
+    };
+  }
+
+  return { message: `Memory "${key}" deleted`, success: true };
+}
+
+export async function executeListMemories(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  const { category, error: categoryError } = parseMemoryCategory(args.category);
+  if (categoryError) return { error: categoryError };
+
+  const result = await listAiMemories({
+    category,
+    scope: resolveMiraMemoryScope(ctx),
+  });
+
+  if (!result.ok) return { error: result.error };
+
+  const memories = (result.value ?? []).map((memory) =>
+    keyValueMemory({
+      category: memory.category,
+      key: memory.key,
+      updatedAt: memory.updatedAt,
+      value: memory.summary || memory.content || memory.title || '',
+    })
+  );
+
+  return {
+    count: memories.length,
+    memories,
+  };
+}
+
+export async function executeMergeMemories(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  const keysToDelete = args.keysToDelete as string[];
+  const newKey = args.newKey as string;
+  const newValue = args.newValue as string;
+  const { category: newCategory, error: categoryError } = parseMemoryCategory(
+    args.newCategory,
+    {
+      fieldName: 'newCategory',
+      required: true,
+    }
+  );
+
+  if (categoryError || !newCategory) {
+    return {
+      error:
+        categoryError ??
+        'Invalid newCategory. Allowed: preference, fact, conversation_topic, event, person',
+    };
+  }
+
+  if (!keysToDelete || keysToDelete.length === 0) {
+    return { error: 'No keys provided to delete' };
+  }
+
+  const scope = resolveMiraMemoryScope(ctx);
+  const rememberResult = await rememberAiMemory({
+    category: newCategory,
+    key: newKey,
+    scope,
+    value: newValue,
+  });
+
+  if (!rememberResult.ok) return { error: rememberResult.error };
+
+  await Promise.all(
+    keysToDelete
+      .filter((key) => key !== newKey)
+      .map((key) =>
+        forgetAiMemory({
+          key,
+          reason: `Merged into ${newKey}`,
+          scope,
+        })
+      )
+  );
+
+  return {
+    message: `Merged ${keysToDelete.length} memories into "${newKey}"`,
+    success: !rememberResult.skipped,
+  };
+}

package/src/tools/executors/parallel-checks.ts

@@ -0,0 +1,176 @@
+import { google } from '@ai-sdk/google';
+import { stepCountIs, ToolLoopAgent } from 'ai';
+import { z } from 'zod';
+import { withAiMemory } from '../../memory';
+import type { MiraToolContext } from '../mira-tools';
+
+const PARALLEL_CHECKS_MODEL = 'gemini-3.1-flash-lite';
+
+const ParallelChecksArgsSchema = z.object({
+  question: z
+    .string()
+    .transform((value) => value.trim())
+    .refine((value) => value.length > 0, {
+      message: 'Missing required `question`.',
+    })
+    .transform((value) => value.slice(0, 2000)),
+  context: z
+    .string()
+    .transform((value) => value.trim())
+    .optional()
+    .transform((value) => (value ? value.slice(0, 8000) : undefined)),
+  checks: z
+    .array(z.enum(['assumptions', 'factuality', 'risk', 'implementation']))
+    .min(1)
+    .max(4)
+    .optional(),
+});
+
+type CheckKind = z.infer<typeof ParallelChecksArgsSchema>['checks'] extends
+  | Array<infer T>
+  | undefined
+  ? T
+  : never;
+
+type ParallelCheckResult = {
+  label: string;
+  finding: string;
+};
+
+const CHECK_INSTRUCTIONS: Record<CheckKind, string> = {
+  assumptions:
+    'You identify hidden assumptions, missing premises, and unclear decision points. Return concise findings only.',
+  factuality:
+    'You check whether claims need verification, external evidence, or clearer source attribution. Return concise findings only.',
+  implementation:
+    'You review implementation feasibility, sequencing, interfaces, and likely integration risks. Return concise findings only.',
+  risk: 'You review failure modes, user-impact risks, regressions, and test gaps. Return concise findings only.',
+};
+
+const DEFAULT_CHECKS: CheckKind[] = ['assumptions', 'factuality', 'risk'];
+
+function buildPrompt({
+  check,
+  context,
+  question,
+}: {
+  check: CheckKind;
+  context?: string;
+  question: string;
+}) {
+  return `Review this request from the "${check}" perspective.
+
+Question or scenario:
+${question}
+
+${context ? `Relevant context:\n${context}\n\n` : ''}Return:
+- 1 to 3 concise findings
+- Any blocker, if present
+- "No material issues" if this perspective has nothing important`;
+}
+
+async function runCheck({
+  abortSignal,
+  check,
+  context,
+  question,
+  toolContext,
+}: {
+  abortSignal?: AbortSignal;
+  check: CheckKind;
+  context?: string;
+  question: string;
+  toolContext: MiraToolContext;
+}): Promise<ParallelCheckResult> {
+  const agent = new ToolLoopAgent({
+    model: await withAiMemory({
+      addMemory: 'never',
+      customId: toolContext.chatId
+        ? `${toolContext.chatId}-parallel-checks-${check}`
+        : `parallel-checks-${check}`,
+      model: google(PARALLEL_CHECKS_MODEL),
+      product: 'mira',
+      source: 'mira_parallel_checks_tool',
+      surface: 'mira_parallel_checks_tool',
+      userId: toolContext.userId,
+      wsId: toolContext.workspaceContext?.wsId ?? toolContext.wsId,
+    }),
+    instructions: CHECK_INSTRUCTIONS[check],
+    stopWhen: stepCountIs(2),
+    providerOptions: {
+      google: {
+        thinkingConfig: {
+          thinkingBudget: 0,
+          includeThoughts: false,
+        },
+      },
+    },
+  });
+
+  const result = await agent.generate({
+    prompt: buildPrompt({ check, context, question }),
+    abortSignal,
+  });
+
+  return {
+    label: check,
+    finding: result.text.trim() || 'No material issues.',
+  };
+}
+
+export async function executeParallelChecks(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext,
+  options?: { abortSignal?: AbortSignal }
+) {
+  const parsed = ParallelChecksArgsSchema.safeParse(args);
+  if (!parsed.success) {
+    return {
+      ok: false,
+      error: parsed.error.issues[0]?.message ?? 'Invalid parallel check input.',
+    };
+  }
+
+  const { context, question } = parsed.data;
+  const checks = parsed.data.checks ?? DEFAULT_CHECKS;
+
+  try {
+    const results = await Promise.all(
+      checks.map((check) =>
+        runCheck({
+          abortSignal: options?.abortSignal,
+          check,
+          context,
+          question,
+          toolContext: ctx,
+        })
+      )
+    );
+
+    const issueCount = results.filter(
+      (result) => !/no material issues/i.test(result.finding)
+    ).length;
+
+    return {
+      ok: true,
+      summary:
+        issueCount > 0
+          ? `Parallel checks found ${issueCount} perspective(s) with material notes.`
+          : 'Parallel checks found no material issues.',
+      checks: results,
+    };
+  } catch (error) {
+    if (error instanceof DOMException && error.name === 'AbortError') {
+      return {
+        ok: false,
+        error: 'Parallel checks were cancelled.',
+      };
+    }
+
+    console.error('executeParallelChecks provider error:', error);
+    return {
+      ok: false,
+      error: 'Parallel checks failed. Please try again.',
+    };
+  }
+}

package/src/tools/executors/qr.ts

@@ -0,0 +1,170 @@
+import { createAdminClient } from '@tuturuuu/supabase/next/server';
+import QRCode from 'qrcode';
+import type { MiraToolContext } from '../mira-tools';
+import { getWorkspaceContextWorkspaceId } from '../workspace-context';
+
+const DEFAULT_SIZE = 512;
+const DEFAULT_FOREGROUND = '#000000';
+const DEFAULT_BACKGROUND = '#FFFFFF';
+const DRIVE_QR_PREFIX = 'drive/mira/qr';
+
+function normalizeHexColor(value: unknown, fallback: string): string {
+  if (typeof value !== 'string') return fallback;
+  const normalized = value.trim();
+  if (!/^#(?:[0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/.test(normalized)) {
+    return fallback;
+  }
+  return normalized.toUpperCase();
+}
+
+function normalizeSize(value: unknown): number {
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    return DEFAULT_SIZE;
+  }
+  const rounded = Math.round(value);
+  return Math.min(2048, Math.max(128, rounded));
+}
+
+function sanitizeFileName(value: unknown): string {
+  if (typeof value !== 'string') {
+    return `qr-${Date.now()}.png`;
+  }
+
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return `qr-${Date.now()}.png`;
+  }
+
+  const withoutExt = trimmed.replace(/\.[A-Za-z0-9]+$/, '');
+  const safeBase = withoutExt
+    .replace(/[^A-Za-z0-9-_ ]/g, '')
+    .replace(/\s+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+    .slice(0, 64);
+
+  const finalBase = safeBase || `qr-${Date.now()}`;
+  return `${finalBase}.png`;
+}
+
+function toPngBytes(dataUrl: string): Uint8Array {
+  if (!dataUrl.startsWith('data:')) {
+    throw new Error("Malformed data URL: expected 'data:[mime];base64,<data>'");
+  }
+
+  const commaIndex = dataUrl.indexOf(',');
+  if (commaIndex < 0) {
+    throw new Error("Malformed data URL: expected 'data:[mime];base64,<data>'");
+  }
+
+  const metadata = dataUrl.slice(5, commaIndex);
+  if (!/^[^,]*;base64$/i.test(metadata)) {
+    throw new Error("Malformed data URL: expected 'data:[mime];base64,<data>'");
+  }
+
+  const mime = metadata.slice(0, -';base64'.length).toLowerCase();
+  if (mime && mime !== 'image/png') {
+    throw new Error("Malformed data URL: expected 'data:[mime];base64,<data>'");
+  }
+
+  const base64 = dataUrl.slice(commaIndex + 1).trim();
+  if (!base64) {
+    throw new Error("Malformed data URL: expected 'data:[mime];base64,<data>'");
+  }
+
+  return Uint8Array.from(Buffer.from(base64, 'base64'));
+}
+
+function readQrValue(args: Record<string, unknown>): string {
+  for (const key of ['value', 'text', 'url', 'content', 'payload']) {
+    const value = args[key];
+    if (typeof value === 'string' && value.trim()) {
+      return value.trim();
+    }
+  }
+
+  return '';
+}
+
+export async function executeCreateQrCode(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+): Promise<unknown> {
+  const rawValue = readQrValue(args);
+  if (!rawValue) {
+    return {
+      success: false,
+      error: 'QR value is required.',
+    };
+  }
+
+  const size = normalizeSize(args.size);
+  const foregroundColor = normalizeHexColor(
+    args.foregroundColor,
+    DEFAULT_FOREGROUND
+  );
+  const backgroundColor = normalizeHexColor(
+    args.backgroundColor,
+    DEFAULT_BACKGROUND
+  );
+  const fileName = sanitizeFileName(args.fileName);
+
+  const fileId = crypto.randomUUID();
+  const wsId = getWorkspaceContextWorkspaceId(ctx);
+  const storagePath = `${wsId}/${DRIVE_QR_PREFIX}/${fileId}-${fileName}`;
+
+  try {
+    const qrDataUrl = await QRCode.toDataURL(rawValue, {
+      type: 'image/png',
+      width: size,
+      margin: 2,
+      color: {
+        dark: foregroundColor,
+        light: backgroundColor,
+      },
+      errorCorrectionLevel: 'M',
+    });
+
+    const sbAdmin = await createAdminClient();
+    const pngBytes = toPngBytes(qrDataUrl);
+
+    const { error: uploadError } = await sbAdmin.storage
+      .from('workspaces')
+      .upload(storagePath, pngBytes, {
+        contentType: 'image/png',
+        upsert: false,
+      });
+
+    if (uploadError) {
+      throw new Error(`Upload failed: ${uploadError.message}`);
+    }
+
+    const { data: urlData, error: signedUrlError } = await sbAdmin.storage
+      .from('workspaces')
+      .createSignedUrl(storagePath, 60 * 60 * 24 * 30);
+
+    if (signedUrlError || !urlData?.signedUrl) {
+      throw new Error(
+        `Signed URL failed: ${signedUrlError?.message ?? 'No signed URL returned'}`
+      );
+    }
+
+    return {
+      success: true,
+      qrCodeUrl: urlData.signedUrl,
+      downloadUrl: urlData.signedUrl,
+      storagePath,
+      drivePath: storagePath.replace(`${wsId}/`, ''),
+      fileName,
+      size,
+      foregroundColor,
+      backgroundColor,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error:
+        error instanceof Error ? error.message : 'Failed to generate QR code.',
+    };
+  }
+}