@tuturuuu/ai 0.0.10

package/src/tools/definitions/image.ts

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+import { tool } from '../core';
+
+const hexColorSchema = z
+  .string()
+  .trim()
+  .regex(/^#(?:[0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/)
+  .optional();
+const qrPayloadSchema = z.string().trim().min(1).max(4096);
+
+export const imageToolDefinitions = {
+  create_image: tool({
+    description: 'Generate an image from a text description.',
+    inputSchema: z.object({
+      prompt: z.string().describe('Detailed image description'),
+      aspectRatio: z
+        .enum(['1:1', '3:4', '4:3', '9:16', '16:9'])
+        .optional()
+        .describe('Aspect ratio (default 1:1)'),
+      model: z
+        .enum([
+          'google/imagen-4.0-fast-generate-001',
+          'google/imagen-4.0-generate-001',
+          'google/gemini-2.5-flash-image',
+        ])
+        .optional()
+        .describe('Image model (auto-selected by plan if omitted)'),
+    }),
+  }),
+  create_qr_code: tool({
+    description:
+      'Generate a QR code image from any text payload and save it to workspace Drive storage.',
+    inputSchema: z
+      .object({
+        value: qrPayloadSchema
+          .optional()
+          .describe('Text content to encode into the QR code'),
+        text: qrPayloadSchema
+          .optional()
+          .describe('Alias for value when the user provides plain text'),
+        url: qrPayloadSchema
+          .optional()
+          .describe('Alias for value when the user provides a URL'),
+        foregroundColor: hexColorSchema.describe(
+          'QR foreground color in hex, e.g. #000000'
+        ),
+        backgroundColor: hexColorSchema.describe(
+          'QR background color in hex, e.g. #FFFFFF'
+        ),
+        size: z
+          .number()
+          .int()
+          .min(128)
+          .max(2048)
+          .optional()
+          .describe('Image width/height in pixels (default 512)'),
+        fileName: z
+          .string()
+          .trim()
+          .min(1)
+          .max(120)
+          .regex(
+            /^[A-Za-z0-9._ -]+$/,
+            'Filename may only include letters, numbers, spaces, dot, underscore, and hyphen.'
+          )
+          .optional()
+          .describe('Optional desired filename for download and storage'),
+      })
+      .refine((input) => input.value || input.text || input.url, {
+        message: 'Provide value, text, or url to encode into the QR code.',
+        path: ['value'],
+      }),
+  }),
+} as const;

package/src/tools/definitions/memory.ts

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+import { tool } from '../core';
+
+export const MIRA_MEMORY_CATEGORIES = [
+  'preference',
+  'fact',
+  'conversation_topic',
+  'event',
+  'person',
+] as const;
+
+export type MiraMemoryCategory = (typeof MIRA_MEMORY_CATEGORIES)[number];
+
+export const MEMORY_CATEGORY = z.enum(MIRA_MEMORY_CATEGORIES);
+
+export const memoryToolDefinitions = {
+  remember: tool({
+    description:
+      'Save a memory or fact about the user. Store rich, contextual values. For people use key format person_<name>.',
+    inputSchema: z.object({
+      key: z
+        .string()
+        .describe('Short label (e.g. "user_birthday", "person_quoc")'),
+      value: z.string().describe('Detailed contextual content to remember'),
+      category: MEMORY_CATEGORY.describe('Memory category'),
+    }),
+  }),
+
+  recall: tool({
+    description:
+      'Search saved memories. Pass null query with high maxResults for "everything" requests.',
+    inputSchema: z.object({
+      query: z
+        .string()
+        .nullish()
+        .describe('Search keywords, or null/omit for all'),
+      category: MEMORY_CATEGORY.nullish().describe(
+        'Filter by category, or null/omit'
+      ),
+      maxResults: z
+        .number()
+        .int()
+        .min(1)
+        .max(50)
+        .optional()
+        .describe(
+          'Max results (default: 10, use 20-50 for broad queries, 5-10 for specific)'
+        ),
+    }),
+  }),
+
+  delete_memory: tool({
+    description: 'Delete a single memory by its exact key.',
+    inputSchema: z.object({
+      key: z.string().describe('The exact key of the memory to delete'),
+    }),
+  }),
+
+  list_memories: tool({
+    description:
+      'List all stored memories, optionally filtered by category. Used for memory hygiene and review.',
+    inputSchema: z.object({
+      category: MEMORY_CATEGORY.nullish().describe(
+        'Category to filter memories by'
+      ),
+    }),
+  }),
+
+  merge_memories: tool({
+    description:
+      'Consolidate multiple existing memories into a single new memory. The old memories will be deleted.',
+    inputSchema: z.object({
+      keysToDelete: z
+        .array(z.string())
+        .describe('Array of exact keys to delete'),
+      newKey: z.string().describe('The key for the new consolidated memory'),
+      newValue: z
+        .string()
+        .describe('The value for the new consolidated memory'),
+      newCategory: MEMORY_CATEGORY.describe('Category for the new memory'),
+    }),
+  }),
+} as const;

package/src/tools/definitions/meta.ts

@@ -0,0 +1,154 @@
+import { z } from 'zod';
+import { tool } from '../core';
+import { MIRA_TOOL_NAMES } from '../mira-tool-names';
+
+const validToolSet = new Set<string>(MIRA_TOOL_NAMES);
+
+const requiredTrimmedString = (max: number, field: string) =>
+  z.preprocess(
+    (value) => (typeof value === 'string' ? value.trim() : value),
+    z.string().min(1, `${field} cannot be blank`).max(max)
+  );
+
+const optionalTrimmedString = (max: number, field: string) =>
+  z.preprocess(
+    (value) => (typeof value === 'string' ? value.trim() : value),
+    z.string().min(1, `${field} cannot be blank`).max(max).optional()
+  );
+
+export const metaToolDefinitions = {
+  select_tools: tool({
+    description:
+      'Pick which tools you need for this request. You may stream a short text acknowledgement first when useful, then call this before using other Mira tools. Choose from the available tool names listed in the system prompt. Use no_action_needed ONLY for truly conversational turns with no durable info to save and no real-world lookup needed.',
+    inputSchema: z.object({
+      tools: z
+        .array(z.string())
+        .min(1)
+        .refine(
+          (tools) => tools.every((toolName) => validToolSet.has(toolName)),
+          {
+            message: 'Invalid tool name(s)',
+          }
+        )
+        .refine((tools) => new Set(tools).size === tools.length, {
+          message: 'Duplicate tools are not allowed',
+        })
+        .refine(
+          (tools) => !tools.includes('no_action_needed') || tools.length === 1,
+          {
+            message: 'no_action_needed must be selected by itself',
+          }
+        )
+        .describe(
+          'Array of tool names to activate (e.g. ["get_my_tasks", "create_task"]). Include all tools you expect to call.'
+        ),
+    }),
+  }),
+
+  no_action_needed: tool({
+    description:
+      'Call only when the message is purely conversational and requires NO real action (no settings/memory updates, no search, no data/tool operation).',
+    inputSchema: z.object({
+      reason: z
+        .string()
+        .trim()
+        .min(1, 'reason cannot be blank')
+        .describe('Brief reason (e.g. "user said thanks")'),
+    }),
+  }),
+
+  google_search: tool({
+    description:
+      'Search the public web for current, real-time information such as news, pricing, weather, and up-to-date facts.',
+    inputSchema: z.object({
+      query: requiredTrimmedString(500, 'query').describe(
+        'Search query for web lookup'
+      ),
+    }),
+  }),
+
+  run_parallel_checks: tool({
+    description:
+      'Run lightweight parallel subagents for complex verification, planning, risk review, or conflicting-assumption checks. Use this for explicit deep verification requests instead of enabling main-assistant reasoning by default.',
+    inputSchema: z.object({
+      question: requiredTrimmedString(2000, 'question').describe(
+        'The exact question, plan, claim, or scenario to verify.'
+      ),
+      context: z
+        .string()
+        .trim()
+        .max(8000)
+        .optional()
+        .describe(
+          'Optional relevant context from the conversation or tool results.'
+        ),
+      checks: z
+        .array(z.enum(['assumptions', 'factuality', 'risk', 'implementation']))
+        .min(1)
+        .max(4)
+        .optional()
+        .describe(
+          'Optional focused checks to run in parallel. Defaults to assumptions, factuality, and risk.'
+        ),
+    }),
+    toModelOutput: ({ output }) => {
+      if (!output || typeof output !== 'object') {
+        return { type: 'text', value: 'Parallel checks completed.' };
+      }
+
+      const result = output as {
+        ok?: boolean;
+        summary?: string;
+        checks?: Array<{ label?: string; finding?: string }>;
+        error?: string;
+      };
+
+      if (result.ok === false) {
+        return {
+          type: 'text',
+          value: result.error ?? 'Parallel checks failed.',
+        };
+      }
+
+      const checkLines =
+        result.checks
+          ?.map((check) =>
+            check.label && check.finding
+              ? `- ${check.label}: ${check.finding}`
+              : null
+          )
+          .filter((line): line is string => line !== null)
+          .join('\n') ?? '';
+
+      return {
+        type: 'text',
+        value: [result.summary, checkLines].filter(Boolean).join('\n'),
+      };
+    },
+  }),
+
+  convert_file_to_markdown: tool({
+    description:
+      'Convert an attached chat file (Excel, Word, PowerPoint, PDF, etc.) to markdown via MarkItDown. Do not use this for YouTube links; Google/Gemini models receive YouTube URLs as native video input.',
+    inputSchema: z.object({
+      url: optionalTrimmedString(2048, 'url').describe(
+        'Deprecated. Do not use for YouTube summaries; the chat request pipeline attaches YouTube URLs directly to Google/Gemini models as video input.'
+      ),
+      storagePath: optionalTrimmedString(1024, 'storagePath').describe(
+        'Optional full storage path. If omitted, the latest file from the current chat is converted.'
+      ),
+      fileName: optionalTrimmedString(255, 'fileName').describe(
+        'Optional filename from current chat attachments (for example: "report.xlsx"). Used when storagePath is not provided.'
+      ),
+      maxCharacters: z
+        .number()
+        .int()
+        .min(2000)
+        .max(300000)
+        .optional()
+        .describe(
+          'Optional markdown output cap for token safety. Default is 120000.'
+        ),
+    }),
+  }),
+} as const;

package/src/tools/definitions/render-ui.ts

@@ -0,0 +1,81 @@
+import type { FlexibleSchema } from 'ai';
+import { z } from 'zod';
+import { tool } from '../core';
+import { dashboardCatalog } from '../json-render-catalog';
+import {
+  createRenderUiPreprocessor,
+  normalizeRenderUiInputForTool,
+} from '../normalize-render-ui-input';
+
+const RENDER_UI_DESCRIPTION =
+  'Render interactive UI. CRITICAL: `elements` must contain at least one entry keyed by the `root` ID. ' +
+  'Example: { "root": "r", "elements": { "r": { "type": "Card", "props": { "title": "Hello" }, "children": [] } } }. ' +
+  'NEVER pass empty elements ({}). Every element needs type, props, children.';
+
+/** Base catalog Zod schema with a refinement that rejects empty `elements`. */
+const baseSchemaWithRefinement = dashboardCatalog.zodSchema().refine(
+  (spec) => {
+    if (
+      spec &&
+      typeof spec === 'object' &&
+      'elements' in spec &&
+      spec.elements &&
+      typeof spec.elements === 'object'
+    ) {
+      return Object.keys(spec.elements as Record<string, unknown>).length > 0;
+    }
+    return true; // Let other validators handle non-object elements.
+  },
+  {
+    message:
+      'elements must not be empty. Define at least one element keyed by the root ID. ' +
+      'Example: { "root": "r", "elements": { "r": { "type": "Card", "props": { "title": "Hello" }, "children": [] } } }',
+    path: ['elements'],
+  }
+);
+
+// AI SDK and @json-render currently expose nominal Zod minor types.
+const toToolInputSchema = (schema: unknown) =>
+  schema as FlexibleSchema<unknown>;
+
+/**
+ * Static tool definitions used for the shared tool registry.
+ * Uses the basic normalizer (no per-stream state).
+ */
+export const renderUiToolDefinitions = {
+  render_ui: tool({
+    description: RENDER_UI_DESCRIPTION,
+    inputSchema: toToolInputSchema(
+      z.preprocess(
+        (val: unknown) => normalizeRenderUiInputForTool(val),
+        baseSchemaWithRefinement
+      )
+    ),
+  }),
+} as const;
+
+/**
+ * Create a render_ui tool definition with a per-stream stateful preprocessor.
+ *
+ * On the first empty-elements call, the preprocessor auto-populates a
+ * context-aware fallback (using data tools found in previous steps) so
+ * validation passes and the user sees something rather than a failure loop.
+ *
+ * @param getSteps – Optional callback returning the current steps array for
+ *   context-aware fallback selection.
+ *
+ * Returns the tool definition and a `wasAutoPopulated()` check for the execute
+ * handler to detect auto-populated specs.
+ */
+export function createStreamRenderUiTool(getSteps?: () => unknown[]) {
+  const { preprocess, wasAutoPopulated } = createRenderUiPreprocessor(getSteps);
+
+  const toolDef = tool({
+    description: RENDER_UI_DESCRIPTION,
+    inputSchema: toToolInputSchema(
+      z.preprocess((val: unknown) => preprocess(val), baseSchemaWithRefinement)
+    ),
+  });
+
+  return { toolDef, wasAutoPopulated };
+}