@tuturuuu/ai 0.0.10

package/src/tools/mira-tools.ts

@@ -0,0 +1,167 @@
+import type { PermissionId } from '@tuturuuu/types';
+import { DEV_MODE } from '@tuturuuu/utils/constants';
+import type { Tool, ToolSet } from 'ai';
+import { createStreamRenderUiTool } from './definitions/render-ui';
+import { miraToolDefinitions } from './mira-tool-definitions';
+import { executeMiraTool } from './mira-tool-dispatcher';
+import {
+  MIRA_TOOL_DIRECTORY,
+  MIRA_TOOL_PERMISSIONS,
+} from './mira-tool-metadata';
+import type { MiraToolName } from './mira-tool-names';
+import {
+  buildRenderUiFailsafeSpec,
+  isRenderableRenderUiSpec,
+} from './mira-tool-render-ui';
+import type { MiraToolContext } from './mira-tool-types';
+
+export type { MiraToolContext } from './mira-tool-types';
+export type { MiraToolName };
+export {
+  executeMiraTool,
+  MIRA_TOOL_DIRECTORY,
+  MIRA_TOOL_PERMISSIONS,
+  miraToolDefinitions,
+};
+
+export function createMiraStreamTools(
+  ctx: MiraToolContext,
+  withoutPermission?: (p: PermissionId) => boolean,
+  getSteps?: () => unknown[]
+): ToolSet {
+  const tools: ToolSet = {};
+  let renderUiInvalidAttempts = 0;
+
+  // Create a per-stream render_ui tool with stateful preprocessor.
+  // The preprocessor auto-populates a context-aware fallback on the first
+  // empty-elements call using data tools found in previous steps.
+  const { toolDef: streamRenderUiDef, wasAutoPopulated } =
+    createStreamRenderUiTool(getSteps);
+
+  const definitionEntries = Object.entries(miraToolDefinitions) as Array<
+    [
+      keyof typeof miraToolDefinitions,
+      (typeof miraToolDefinitions)[keyof typeof miraToolDefinitions],
+    ]
+  >;
+
+  for (const [name, def] of definitionEntries) {
+    const requiredPerm = MIRA_TOOL_PERMISSIONS[name];
+    let isMissingPermission = false;
+    let missingPermissionsStr = '';
+
+    if (requiredPerm && withoutPermission) {
+      if (Array.isArray(requiredPerm)) {
+        const missing = requiredPerm.filter((p) => withoutPermission(p));
+        if (missing.length > 0) {
+          isMissingPermission = true;
+          missingPermissionsStr = missing.join(', ');
+        }
+      } else if (withoutPermission(requiredPerm)) {
+        isMissingPermission = true;
+        missingPermissionsStr = requiredPerm;
+      }
+    }
+
+    if (isMissingPermission) {
+      tools[name] = {
+        ...def,
+        execute: async () => ({
+          ok: false,
+          error: `You do not have the required permissions to use this tool. Missing permission(s): ${missingPermissionsStr}. Please inform the user.`,
+        }),
+      } as Tool;
+      continue;
+    }
+
+    if (name === 'render_ui') {
+      if (!DEV_MODE) {
+        continue; // Skip adding render_ui in non-DEV_MODE
+      }
+
+      tools[name] = {
+        // Use the per-stream definition (stateful preprocessor + refinement)
+        // instead of the shared singleton definition.
+        ...streamRenderUiDef,
+        execute: async (args: Record<string, unknown>) => {
+          // Check if the preprocessor auto-populated this spec (the model
+          // sent empty elements repeatedly and we injected a placeholder).
+          if (wasAutoPopulated()) {
+            return {
+              spec: args,
+              autoPopulatedFallback: true,
+              autoRecoveredFromInvalidSpec: true,
+              forcedFromRecoveryLoop: true,
+              warning:
+                'render_ui was auto-recovered from empty elements. A context-aware fallback was injected based on previously-called data tools.',
+            };
+          }
+
+          if (isRenderableRenderUiSpec(args)) {
+            renderUiInvalidAttempts = 0;
+            return { spec: args };
+          }
+
+          // If we reach here, the spec passed Zod validation but still
+          // fails our stricter isRenderableRenderUiSpec check (e.g. root key
+          // not matching an element, or root element is not an object).
+          renderUiInvalidAttempts += 1;
+          const isRepeatedInvalidAttempt = renderUiInvalidAttempts > 1;
+
+          // Build a targeted diagnosis of what went wrong.
+          const diagnosisParts: string[] = [];
+          if (typeof args.root !== 'string' || args.root.length === 0) {
+            diagnosisParts.push('`root` is missing or not a string');
+          }
+          const elements = args.elements;
+          if (
+            !elements ||
+            typeof elements !== 'object' ||
+            Array.isArray(elements)
+          ) {
+            diagnosisParts.push('`elements` is missing or not an object');
+          } else if (Object.keys(elements as object).length === 0) {
+            diagnosisParts.push(
+              '`elements` is empty — you must define at least elements[root]'
+            );
+          } else if (
+            typeof args.root === 'string' &&
+            !(args.root in (elements as Record<string, unknown>))
+          ) {
+            diagnosisParts.push(
+              `elements["${args.root}"] does not exist — the root element ID must be a key in elements`
+            );
+          }
+          const diagnosis =
+            diagnosisParts.length > 0
+              ? ` Diagnosis: ${diagnosisParts.join('; ')}.`
+              : '';
+
+          const stopMessage = isRepeatedInvalidAttempt
+            ? ' STOP retrying render_ui. Respond with plain text/markdown instead.'
+            : ` Fix: elements MUST contain the root element. Minimal working example: { "root": "r", "elements": { "r": { "type": "Card", "props": { "title": "Result" }, "children": ["t"] }, "t": { "type": "Text", "props": { "content": "Your content here" }, "children": [] } } }. Retry ONE more time with populated elements.`;
+
+          return {
+            spec: buildRenderUiFailsafeSpec(args),
+            autoRecoveredFromInvalidSpec: true,
+            ...(isRepeatedInvalidAttempt
+              ? { forcedFromRecoveryLoop: true }
+              : {}),
+            warning: `Invalid render_ui spec.${diagnosis}${stopMessage}`,
+          };
+        },
+      } as Tool;
+      continue;
+    }
+
+    tools[name] = {
+      ...def,
+      execute: async (
+        args: Record<string, unknown>,
+        options?: { abortSignal?: AbortSignal }
+      ) => executeMiraTool(name, args, ctx, options),
+    } as Tool;
+  }
+
+  return tools;
+}

package/src/tools/normalize-render-ui-input.ts

@@ -0,0 +1,321 @@
+import { hasToolCallInSteps } from '../chat/mira-render-ui-policy';
+
+type AnyRecord = Record<string, unknown>;
+
+function isRecord(value: unknown): value is AnyRecord {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function safeParseJson(value: string): unknown {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+
+function normalizeElement(raw: unknown): unknown {
+  if (!isRecord(raw)) return raw;
+
+  const element: AnyRecord = { ...raw };
+  const rawProps = element.props;
+  const props = isRecord(rawProps) ? { ...rawProps } : {};
+
+  // Common model mistake: put bindings under props.bindings instead of element.bindings.
+  if (!element.bindings && isRecord(props.bindings)) {
+    element.bindings = props.bindings;
+    delete props.bindings;
+  }
+
+  element.props = props;
+  element.children = Array.isArray(element.children) ? element.children : [];
+
+  return element;
+}
+
+function normalizeSpecLike(raw: unknown): unknown {
+  if (!isRecord(raw)) return raw;
+  if (typeof raw.root !== 'string' || !isRecord(raw.elements)) return raw;
+
+  const normalizedElements: AnyRecord = {};
+  for (const [id, element] of Object.entries(raw.elements)) {
+    normalizedElements[id] = normalizeElement(element);
+  }
+
+  return {
+    ...raw,
+    elements: normalizedElements,
+  };
+}
+
+function getCandidates(value: AnyRecord): unknown[] {
+  const candidates: unknown[] = [];
+  const keys = [
+    'json_schema',
+    'spec',
+    'schema',
+    'output',
+    'result',
+    'data',
+    'payload',
+  ];
+
+  for (const key of keys) {
+    if (key in value) candidates.push(value[key]);
+  }
+
+  if (typeof value.json === 'string') {
+    const parsed = safeParseJson(value.json);
+    if (parsed !== null) candidates.push(parsed);
+  } else if (value.json !== undefined) {
+    candidates.push(value.json);
+  }
+
+  return candidates;
+}
+
+/**
+ * Detect whether a normalized spec-like value has an empty `elements` record.
+ */
+function hasEmptyElements(value: unknown): boolean {
+  if (!isRecord(value)) return false;
+  if (typeof value.root !== 'string') return false;
+  if (!isRecord(value.elements)) return false;
+  return Object.keys(value.elements).length === 0;
+}
+
+/**
+ * Mapping from data-fetching tool names to smart fallback UI specs.
+ * Each entry returns `{ root, elements }` that can be merged onto the spec.
+ */
+function buildContextAwareFallback(
+  steps: unknown[]
+): { root: string; elements: AnyRecord } | null {
+  // Priority order: tasks > time-tracking > calendar > finance
+  const taskTools = ['get_my_tasks', 'create_task', 'update_task'];
+  const timeTools = [
+    'start_timer',
+    'stop_timer',
+    'list_time_tracking_sessions',
+    'list_time_tracking_categories',
+    'create_time_tracking_category',
+    'update_time_tracking_category',
+    'delete_time_tracking_category',
+    'get_time_tracking_session',
+    'get_time_tracker_stats',
+    'get_time_tracker_goals',
+    'create_time_tracker_goal',
+    'update_time_tracker_goal',
+    'delete_time_tracker_goal',
+    'create_time_tracking_entry',
+  ];
+  const calendarTools = [
+    'get_upcoming_events',
+    'create_calendar_event',
+    'update_calendar_event',
+  ];
+  const financeTools = [
+    'get_spending_summary',
+    'list_transactions',
+    'create_transaction',
+  ];
+
+  const hasAnyToolCall = (toolNames: string[]) =>
+    toolNames.some((name) => hasToolCallInSteps(steps, name));
+
+  if (hasAnyToolCall(taskTools)) {
+    return {
+      root: 'auto_tasks',
+      elements: {
+        auto_tasks: {
+          type: 'MyTasks',
+          props: { showSummary: true, showFilters: true },
+          children: [],
+        },
+      },
+    };
+  }
+
+  if (hasAnyToolCall(timeTools)) {
+    return {
+      root: 'auto_time',
+      elements: {
+        auto_time: {
+          type: 'TimeTrackingStats',
+          props: { period: 'last_7_days' },
+          children: [],
+        },
+      },
+    };
+  }
+
+  if (hasAnyToolCall(calendarTools)) {
+    return {
+      root: 'auto_calendar',
+      elements: {
+        auto_calendar: {
+          type: 'Card',
+          props: { title: 'Upcoming Events' },
+          children: ['auto_calendar_text'],
+        },
+        auto_calendar_text: {
+          type: 'Text',
+          props: {
+            content:
+              'Your upcoming events are shown above. Ask me to create, update, or check specific events.',
+          },
+          children: [],
+        },
+      },
+    };
+  }
+
+  if (hasAnyToolCall(financeTools)) {
+    return {
+      root: 'auto_finance',
+      elements: {
+        auto_finance: {
+          type: 'Card',
+          props: { title: 'Finance Summary' },
+          children: ['auto_finance_text'],
+        },
+        auto_finance_text: {
+          type: 'Text',
+          props: {
+            content:
+              'Your finance data is shown above. Ask me for more details or to manage transactions.',
+          },
+          children: [],
+        },
+      },
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Build a minimal valid spec so the model output passes Zod validation.
+ * Uses context from previous tool calls when available, otherwise falls back
+ * to a generic Callout.
+ */
+function autoPopulateEmptyElements(
+  value: AnyRecord,
+  steps: unknown[]
+): AnyRecord {
+  const contextFallback = buildContextAwareFallback(steps);
+  if (contextFallback) {
+    return {
+      ...value,
+      root: contextFallback.root,
+      elements: contextFallback.elements,
+    };
+  }
+
+  // Generic fallback when no data tools were called.
+  const root =
+    typeof value.root === 'string' && value.root.trim().length > 0
+      ? value.root.trim()
+      : 'auto_root';
+
+  return {
+    ...value,
+    root,
+    elements: {
+      [root]: {
+        type: 'Callout',
+        props: {
+          title: 'UI unavailable',
+          variant: 'warning',
+          content:
+            'The assistant attempted to render interactive UI but the specification was incomplete. Please try your request again.',
+        },
+        children: [],
+      },
+    },
+  };
+}
+
+/**
+ * Normalize model-generated render_ui inputs before zod validation.
+ * Handles common wrappers and structural mistakes while preserving unknown fields.
+ */
+export function normalizeRenderUiInputForTool(input: unknown): unknown {
+  const queue: unknown[] = [input];
+  const visited = new WeakSet<object>();
+
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === null || current === undefined) continue;
+
+    if (typeof current === 'string') {
+      const parsed = safeParseJson(current);
+      if (parsed !== null) {
+        queue.push(parsed);
+      }
+      continue;
+    }
+
+    if (!isRecord(current)) continue;
+    if (visited.has(current)) continue;
+    visited.add(current);
+
+    const normalized = normalizeSpecLike(current);
+    if (normalized !== current) return normalized;
+
+    queue.push(...getCandidates(current));
+  }
+
+  return input;
+}
+
+/**
+ * Create a stateful preprocessor for render_ui that tracks empty-elements
+ * attempts per stream.
+ *
+ * When the model sends empty `elements`, the preprocessor immediately
+ * auto-populates a context-aware fallback (using data tools found in
+ * previous steps) on the **first** empty-elements call. Waiting for a
+ * Zod rejection first is proven to be wasteful — the model never
+ * self-corrects after rejection.
+ *
+ * @param getSteps – Optional callback returning the current steps array.
+ *   When provided, the auto-populated fallback is context-aware (e.g.
+ *   MyTasks when get_my_tasks was called). When omitted, falls back to a
+ *   generic Callout.
+ *
+ * Returns an object with the preprocessor function and a `wasAutoPopulated()`
+ * check that the execute handler can call to detect auto-populated specs.
+ */
+export function createRenderUiPreprocessor(getSteps?: () => unknown[]): {
+  preprocess: (val: unknown) => unknown;
+  wasAutoPopulated: () => boolean;
+} {
+  let emptyElementsAttempts = 0;
+  let lastCallAutoPopulated = false;
+
+  return {
+    preprocess(val: unknown): unknown {
+      lastCallAutoPopulated = false;
+      const normalized = normalizeRenderUiInputForTool(val);
+
+      if (hasEmptyElements(normalized)) {
+        emptyElementsAttempts += 1;
+
+        // Auto-populate on the first empty-elements call. The model never
+        // self-corrects after Zod rejection, so the first rejection just
+        // wastes a step and tokens.
+        if (emptyElementsAttempts === 1) {
+          lastCallAutoPopulated = true;
+          const steps = getSteps?.() ?? [];
+          return autoPopulateEmptyElements(normalized as AnyRecord, steps);
+        }
+      }
+
+      return normalized;
+    },
+    wasAutoPopulated(): boolean {
+      return lastCallAutoPopulated;
+    },
+  };
+}

package/src/tools/workspace-context.ts

@@ -0,0 +1,233 @@
+import type { TypedSupabaseClient } from '@tuturuuu/supabase/next/client';
+import {
+  normalizeWorkspaceContextId,
+  PERSONAL_WORKSPACE_SLUG,
+} from '@tuturuuu/utils/constants';
+import type { MiraToolContext } from './mira-tool-types';
+
+type WorkspaceMembershipRow = {
+  ws_id: string | null;
+  workspaces:
+    | {
+        id: string;
+        name: string | null;
+        personal: boolean | null;
+      }
+    | Array<{
+        id: string;
+        name: string | null;
+        personal: boolean | null;
+      }>
+    | null;
+};
+
+type WorkspaceMemberRow = {
+  ws_id: string | null;
+};
+
+export type MiraWorkspaceSummary = {
+  id: string;
+  name: string;
+  personal: boolean;
+  memberCount: number;
+};
+
+export type MiraWorkspaceContextState = {
+  workspaceContextId: string;
+  wsId: string;
+  name: string;
+  personal: boolean;
+  memberCount: number;
+};
+
+export function getWorkspaceContextWorkspaceId(ctx: MiraToolContext): string {
+  return ctx.workspaceContext?.wsId ?? ctx.wsId;
+}
+
+function toWorkspaceContextState(
+  workspace: MiraWorkspaceSummary,
+  workspaceContextId: string
+): MiraWorkspaceContextState {
+  return {
+    workspaceContextId,
+    wsId: workspace.id,
+    name: workspace.name,
+    personal: workspace.personal,
+    memberCount: workspace.memberCount,
+  };
+}
+
+export async function listAccessibleWorkspaceSummaries(
+  supabase: TypedSupabaseClient,
+  userId: string
+): Promise<MiraWorkspaceSummary[]> {
+  const { data: membershipData, error: membershipError } = await supabase
+    .from('workspace_members')
+    .select(
+      `
+        ws_id,
+        workspaces!inner (
+          id,
+          name,
+          personal
+        )
+      `
+    )
+    .eq('user_id', userId);
+
+  if (membershipError) {
+    throw new Error(membershipError.message);
+  }
+
+  const memberships = (membershipData ?? []) as WorkspaceMembershipRow[];
+  const workspaceMap = new Map<
+    string,
+    Omit<MiraWorkspaceSummary, 'memberCount'>
+  >();
+
+  for (const membership of memberships) {
+    const workspace = Array.isArray(membership.workspaces)
+      ? (membership.workspaces[0] ?? null)
+      : membership.workspaces;
+
+    if (!membership.ws_id || !workspace?.id) continue;
+
+    workspaceMap.set(workspace.id, {
+      id: workspace.id,
+      name: workspace.name?.trim() || 'Untitled workspace',
+      personal: workspace.personal === true,
+    });
+  }
+
+  const workspaceIds = [...workspaceMap.keys()];
+  if (workspaceIds.length === 0) {
+    return [];
+  }
+
+  const { data: memberRows, error: memberError } = await supabase
+    .from('workspace_members')
+    .select('ws_id')
+    .in('ws_id', workspaceIds);
+
+  if (memberError) {
+    throw new Error(memberError.message);
+  }
+
+  const memberCounts = new Map<string, number>();
+  for (const row of (memberRows ?? []) as WorkspaceMemberRow[]) {
+    if (!row.ws_id) continue;
+    memberCounts.set(row.ws_id, (memberCounts.get(row.ws_id) ?? 0) + 1);
+  }
+
+  return workspaceIds
+    .map((id) => {
+      const workspace = workspaceMap.get(id)!;
+      return {
+        ...workspace,
+        memberCount: memberCounts.get(id) ?? 0,
+      };
+    })
+    .sort((a, b) => {
+      if (a.personal !== b.personal) {
+        return a.personal ? -1 : 1;
+      }
+      return a.name.localeCompare(b.name);
+    });
+}
+
+type ResolveWorkspaceContextParams = {
+  supabase: TypedSupabaseClient;
+  userId: string;
+  requestedWorkspaceContextId?: string;
+  fallbackWorkspaceId?: string;
+  strict?: boolean;
+};
+
+export async function resolveWorkspaceContextState({
+  supabase,
+  userId,
+  requestedWorkspaceContextId,
+  fallbackWorkspaceId,
+  strict = false,
+}: ResolveWorkspaceContextParams): Promise<MiraWorkspaceContextState> {
+  const accessibleWorkspaces = await listAccessibleWorkspaceSummaries(
+    supabase,
+    userId
+  );
+
+  if (accessibleWorkspaces.length === 0) {
+    throw new Error('No accessible workspaces found for current user.');
+  }
+
+  const personalWorkspace =
+    accessibleWorkspaces.find((workspace) => workspace.personal) ?? null;
+  const fallbackWorkspace =
+    (fallbackWorkspaceId
+      ? accessibleWorkspaces.find(
+          (workspace) => workspace.id === fallbackWorkspaceId
+        )
+      : null) ??
+    personalWorkspace ??
+    accessibleWorkspaces[0]!;
+
+  const requested = normalizeWorkspaceContextId(requestedWorkspaceContextId);
+  const requestedRaw = requestedWorkspaceContextId?.trim();
+  if (!requestedRaw) {
+    return toWorkspaceContextState(
+      fallbackWorkspace,
+      fallbackWorkspace.personal
+        ? PERSONAL_WORKSPACE_SLUG
+        : fallbackWorkspace.id
+    );
+  }
+
+  if (requested === PERSONAL_WORKSPACE_SLUG) {
+    if (!personalWorkspace) {
+      if (strict) {
+        throw new Error('Personal workspace is not available for this user.');
+      }
+      return toWorkspaceContextState(
+        fallbackWorkspace,
+        fallbackWorkspace.personal
+          ? PERSONAL_WORKSPACE_SLUG
+          : fallbackWorkspace.id
+      );
+    }
+
+    return toWorkspaceContextState(personalWorkspace, PERSONAL_WORKSPACE_SLUG);
+  }
+
+  const directMatch = accessibleWorkspaces.find(
+    (workspace) => workspace.id === requested
+  );
+  if (directMatch) {
+    return toWorkspaceContextState(
+      directMatch,
+      directMatch.personal ? PERSONAL_WORKSPACE_SLUG : directMatch.id
+    );
+  }
+
+  const nameMatches = accessibleWorkspaces.filter(
+    (workspace) =>
+      workspace.name.toLowerCase() === (requestedRaw ?? '').toLowerCase()
+  );
+  if (nameMatches.length === 1) {
+    return toWorkspaceContextState(
+      nameMatches[0]!,
+      nameMatches[0]!.personal ? PERSONAL_WORKSPACE_SLUG : nameMatches[0]!.id
+    );
+  }
+
+  if (strict) {
+    throw new Error(
+      nameMatches.length > 1
+        ? `Workspace name "${requested}" is ambiguous. Use the workspace ID instead.`
+        : `Workspace "${requestedRaw}" is not accessible for this user.`
+    );
+  }
+
+  return toWorkspaceContextState(
+    fallbackWorkspace,
+    fallbackWorkspace.personal ? PERSONAL_WORKSPACE_SLUG : fallbackWorkspace.id
+  );
+}