@tuturuuu/ai 0.0.10

package/README.md

@@ -0,0 +1,76 @@
+# @tuturuuu/ai
+
+AI utilities and helpers for Tuturuuu Platform.
+
+## Chat SDK
+
+`@tuturuuu/ai/chat-sdk` exposes the Vercel Chat SDK core, `chat/ai`
+tool helpers, and a Tuturuuu adapter registry for omni-channel agentic
+presence workflows.
+
+The registry covers every adapter currently listed at
+https://chat-sdk.dev/adapters:
+
+- Official platform adapters: Slack, Microsoft Teams, Google Chat, Discord,
+  GitHub, Linear, Telegram, WhatsApp Business Cloud, Messenger, and Web.
+- Vendor-official platform adapters: Beeper Matrix, Photon iMessage, Resend,
+  Zernio, and Liveblocks.
+- Community platform adapters: Webex, Baileys WhatsApp, Sendblue, Blooio, Zalo,
+  and Mattermost.
+- State adapters: Memory, Redis, ioredis, PostgreSQL, Cloudflare Durable
+  Objects, and MySQL.
+
+```ts
+import {
+  createChatSdkRuntime,
+  createChatTools,
+} from '@tuturuuu/ai/chat-sdk';
+
+const chat = await createChatSdkRuntime({
+  userName: 'mira',
+  adapters: {
+    slack: true,
+    zalo: {
+      botToken: process.env.ZALO_BOT_TOKEN,
+      webhookSecret: process.env.ZALO_WEBHOOK_SECRET,
+    },
+  },
+  state: {
+    id: 'redis',
+    config: { url: process.env.REDIS_URL },
+  },
+});
+
+const tools = createChatTools({
+  chat,
+  preset: 'messenger',
+});
+```
+
+Use a production state adapter for deployed bots so subscriptions,
+deduplication, and distributed webhook locks survive restarts. The memory state
+adapter is only for local development and tests.
+
+## Installation
+
+```bash
+npm install @tuturuuu/ai
+# or
+yarn add @tuturuuu/ai
+# or
+bun add @tuturuuu/ai
+```
+
+## Development
+
+```bash
+# Install dependencies
+bun install
+
+# Run tests
+bun run test
+```
+
+## License
+
+MIT © [Tuturuuu](https://github.com/tutur3u)

package/package.json

@@ -0,0 +1,106 @@
+{
+  "name": "@tuturuuu/ai",
+  "license": "MIT",
+  "version": "0.0.10",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "files": ["src", "!src/**/*.test.ts", "!src/**/__tests__", "README.md"],
+  "scripts": {
+    "test": "vitest run",
+    "type-check": "tsgo --project tsconfig.typecheck.json"
+  },
+  "dependencies": {
+    "@ai-sdk/amazon-bedrock": "^4.0.111",
+    "@ai-sdk/anthropic": "^3.0.81",
+    "@ai-sdk/azure": "^3.0.68",
+    "@ai-sdk/cerebras": "^2.0.53",
+    "@ai-sdk/cohere": "^3.0.36",
+    "@ai-sdk/deepgram": "^2.0.33",
+    "@ai-sdk/deepinfra": "^2.0.51",
+    "@ai-sdk/deepseek": "^2.0.34",
+    "@ai-sdk/elevenlabs": "^2.0.33",
+    "@ai-sdk/fal": "^2.0.34",
+    "@ai-sdk/fireworks": "^2.0.52",
+    "@ai-sdk/gateway": "^3.0.121",
+    "@ai-sdk/gladia": "^2.0.33",
+    "@ai-sdk/google": "^3.0.80",
+    "@ai-sdk/google-vertex": "^4.0.140",
+    "@ai-sdk/groq": "^3.0.39",
+    "@ai-sdk/hume": "^2.0.33",
+    "@ai-sdk/lmnt": "^2.0.33",
+    "@ai-sdk/luma": "^2.0.33",
+    "@ai-sdk/mistral": "^3.0.37",
+    "@ai-sdk/openai": "^3.0.67",
+    "@ai-sdk/openai-compatible": "^2.0.47",
+    "@ai-sdk/perplexity": "^3.0.33",
+    "@ai-sdk/react": "^3.0.195",
+    "@ai-sdk/replicate": "^2.0.33",
+    "@ai-sdk/revai": "^2.0.33",
+    "@ai-sdk/togetherai": "^2.0.52",
+    "@ai-sdk/xai": "^3.0.93",
+    "@beeper/chat-adapter-matrix": "^0.2.0",
+    "@bitbasti/chat-adapter-webex": "^0.1.0",
+    "@chat-adapter/discord": "^4.29.0",
+    "@chat-adapter/gchat": "^4.29.0",
+    "@chat-adapter/github": "^4.29.0",
+    "@chat-adapter/linear": "^4.29.0",
+    "@chat-adapter/messenger": "^4.29.0",
+    "@chat-adapter/slack": "^4.29.0",
+    "@chat-adapter/state-ioredis": "^4.29.0",
+    "@chat-adapter/state-memory": "^4.29.0",
+    "@chat-adapter/state-pg": "^4.29.0",
+    "@chat-adapter/state-redis": "^4.29.0",
+    "@chat-adapter/teams": "^4.29.0",
+    "@chat-adapter/telegram": "^4.29.0",
+    "@chat-adapter/web": "^4.29.0",
+    "@chat-adapter/whatsapp": "^4.29.0",
+    "@json-render/core": "^0.19.0",
+    "@json-render/react": "^0.19.0",
+    "@liveblocks/chat-sdk-adapter": "^3.19.3",
+    "@octokit/rest": "^22.0.1",
+    "@resend/chat-sdk-adapter": "^0.2.2",
+    "@streamdown/cjk": "^1.0.3",
+    "@streamdown/code": "^1.1.1",
+    "@streamdown/math": "^1.0.2",
+    "@streamdown/mermaid": "^1.0.2",
+    "@tuturuuu/google": "0.0.1",
+    "@tuturuuu/internal-api": "0.0.2",
+    "@tuturuuu/supabase": "0.2.3",
+    "@tuturuuu/utils": "0.0.1",
+    "@vercel/sandbox": "^2.0.2",
+    "@zernio/chat-sdk-adapter": "^0.3.0",
+    "ai": "^6.0.193",
+    "bash-tool": "^1.3.17",
+    "chat": "^4.29.0",
+    "chat-adapter-baileys": "^2.0.2",
+    "chat-adapter-blooio": "^0.1.0",
+    "chat-adapter-imessage": "^0.1.1",
+    "chat-adapter-mattermost": "^1.1.3",
+    "chat-adapter-sendblue": "^0.2.0",
+    "chat-adapter-zalo": "^0.1.0",
+    "chat-state-cloudflare-do": "^0.2.0",
+    "chat-state-mysql": "^0.1.0",
+    "dayjs": "^1.11.20",
+    "next": "^16.2.6",
+    "qrcode": "^1.5.4",
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6",
+    "streamdown": "^2.5.0",
+    "uuid": "^14.0.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@tuturuuu/types": "0.2.4",
+    "@tuturuuu/typescript-config": "0.1.0",
+    "@types/node": "^25.9.1",
+    "@types/qrcode": "^1.5.6",
+    "@types/react": "^19.2.15",
+    "typescript": "^6.0.3"
+  },
+  "exports": {
+    "./*": "./src/*.ts"
+  },
+  "packageManager": "bun@1.3.14"
+}

package/src/api-key-hash.ts

@@ -0,0 +1,28 @@
+import { scrypt, timingSafeEqual } from 'node:crypto';
+import { promisify } from 'node:util';
+
+const scryptAsync = promisify(scrypt);
+const KEY_DERIVATION_LENGTH = 64;
+
+export async function validateApiKeyHash(
+  key: string,
+  storedHash: string
+): Promise<boolean> {
+  try {
+    const [salt, hash] = storedHash.split(':');
+
+    if (!salt || !hash) {
+      return false;
+    }
+
+    const derivedKey = (await scryptAsync(
+      key,
+      salt,
+      KEY_DERIVATION_LENGTH
+    )) as Buffer;
+
+    return timingSafeEqual(derivedKey, Buffer.from(hash, 'hex'));
+  } catch {
+    return false;
+  }
+}

package/src/calendar/events.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+
+export const calendarEventSchema = z.object({
+  title: z.string().min(1, 'Title is required').describe('Title of the event'),
+  description: z.string().optional().describe('Description of the event'),
+  start_at: z
+    .string()
+    .describe('Start date and time of the event in ISO format'),
+  end_at: z.string().describe('End date and time of the event in ISO format'),
+  color: z
+    .enum([
+      'BLUE',
+      'RED',
+      'GREEN',
+      'YELLOW',
+      'PURPLE',
+      'PINK',
+      'ORANGE',
+      'INDIGO',
+      'CYAN',
+      'GRAY',
+    ])
+    .default('BLUE')
+    .describe(
+      "Color of the event for display purposes. Should match one of the user's defined categories if applicable."
+    ),
+  location: z.string().optional().describe('Location of the event'),
+});
+
+export const calendarEventsSchema = z.object({
+  events: z.array(calendarEventSchema),
+});
+
+export type CalendarEvent = z.infer<typeof calendarEventSchema>;

package/src/calendar/route.ts

@@ -0,0 +1,114 @@
+import { google } from '@ai-sdk/google';
+import { createClient } from '@tuturuuu/supabase/next/server';
+import { ROOT_WORKSPACE_ID } from '@tuturuuu/utils/constants';
+import { Output, streamText } from 'ai';
+import { withAiMemory } from '../memory';
+import { calendarEventsSchema } from './events';
+
+export async function POST(req: Request) {
+  const context = (await req.json()) as {
+    prompt: string;
+    current_time: string;
+    existing_events?: Array<{
+      start_at: string;
+      end_at: string;
+      title?: string;
+      priority?: string;
+    }>;
+    categories?: Array<{
+      name: string;
+      color: string;
+    }>;
+    wsId?: string;
+  };
+
+  const supabase = await createClient();
+
+  const {
+    data: { user },
+  } = await supabase.auth.getUser();
+
+  if (!user?.email?.endsWith('@tuturuuu.com'))
+    return new Response('Unauthorized', { status: 401 });
+
+  // Extract timezone information from context if available
+  const userTimezone = extractTimezone(context.prompt);
+
+  // Extract priority information from the prompt
+  const priority = extractPriority(context.prompt) || 'medium';
+
+  // Build the prompt based on whether smart scheduling is enabled
+  let promptText =
+    `Current time: ${context.current_time}. ` +
+    `Generate a calendar event with the provided information with proper capitalization. Create start_at and end_at in ISO format that works with JavaScript's new Date(). ` +
+    `Use local time in the user's timezone (${userTimezone}). ` +
+    `Set the priority field to "${priority}" for this event. `;
+
+  // Add category color information if available
+  if (context.categories && context.categories.length > 0) {
+    promptText += `\nIMPORTANT: The user has defined the following event categories and associated colors:\n`;
+    context.categories.forEach((category, index) => {
+      promptText += `${index + 1}. ${category.name}: ${category.color}\n`;
+    });
+    promptText += `\nIt is CRITICAL that you analyze the event content and assign the MOST RELEVANT color based on the event category. DO NOT default to blue unless it truly matches.
+    
+For example:
+- If creating a "Team Meeting" event and "Work" category is blue, use "blue"
+- If creating a "Doctor Appointment" event and "Health" category is red, use "red"
+- If creating a "Family Dinner" event and "Family" category is purple, use "purple"
+- If creating a "Gym" event and "Personal" category is green, use "green"
+`;
+  }
+
+  promptText += `\nContext: ${context.prompt}`;
+
+  const result = streamText({
+    model: await withAiMemory({
+      addMemory: 'never',
+      customId: `calendar-event-${Date.now()}`,
+      model: google('gemini-3.1-flash-lite'),
+      product: 'calendar',
+      source: 'calendar_event_generation',
+      surface: 'calendar_event_generation',
+      userId: user.id,
+      wsId: context.wsId ?? ROOT_WORKSPACE_ID,
+    }),
+    output: Output.object({ schema: calendarEventsSchema }),
+    prompt: promptText,
+  });
+
+  return result.toTextStreamResponse();
+}
+
+// Helper function to extract timezone information from the context
+function extractTimezone(context: string): string {
+  // Default to UTC if no timezone found
+  let timezone = 'UTC';
+
+  try {
+    // Look for the timezone pattern in the context
+    const timezoneMatch = context.match(/User timezone:\s*([^)]+)/i);
+    if (timezoneMatch?.[1]) {
+      timezone = timezoneMatch[1].trim();
+    }
+  } catch (error) {
+    console.error('Error extracting timezone:', error);
+  }
+
+  return timezone;
+}
+
+// Helper function to extract priority information from the context
+function extractPriority(context: string): string | null {
+  try {
+    // Look for the priority pattern in the context
+    const priorityMatch = context.match(/Priority:\s*(low|medium|high)/i);
+    if (priorityMatch?.[1]) {
+      return priorityMatch[1].toLowerCase().trim();
+    }
+  } catch (error) {
+    console.error('Error extracting priority:', error);
+  }
+
+  return null;
+}

package/src/chat/credit-source.ts

@@ -0,0 +1 @@
+export type CreditSource = 'workspace' | 'personal';

package/src/chat/google/chat-request-schema.ts

@@ -0,0 +1,150 @@
+import { MAX_ID_LENGTH } from '@tuturuuu/utils/constants';
+import { generateRandomUUID } from '@tuturuuu/utils/uuid-helper';
+import type { UIMessage } from 'ai';
+import { z } from 'zod';
+
+const ChatRoleSchema = z
+  .string()
+  .trim()
+  .min(1)
+  .transform((value) => value.toLowerCase())
+  .pipe(z.enum(['assistant', 'system', 'user']));
+
+const UIMessagePartSchema = z
+  .object({
+    type: z.string().trim().min(1),
+  })
+  .catchall(z.unknown());
+
+const UIMessageSchema = z
+  .object({
+    id: z.string().optional(),
+    role: ChatRoleSchema,
+    parts: z.array(UIMessagePartSchema),
+    name: z.string().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+  })
+  .passthrough();
+
+const TaskBoardContextListSchema = z.object({
+  id: z.string().trim().min(1).max(MAX_ID_LENGTH),
+  name: z.string().trim().min(1).max(120).nullable().optional(),
+  status: z.string().trim().min(1).max(80).nullable().optional(),
+  position: z.number().nullable().optional(),
+});
+
+const TaskBoardContextSchema = z.object({
+  workspaceId: z.string().trim().min(1).max(MAX_ID_LENGTH).optional(),
+  workspaceName: z.string().trim().min(1).max(160).optional(),
+  boardId: z.string().trim().min(1).max(MAX_ID_LENGTH),
+  boardName: z.string().trim().min(1).max(160).optional(),
+  selectedList: TaskBoardContextListSchema.nullable().optional(),
+  lists: z.array(TaskBoardContextListSchema).max(80).default([]),
+});
+
+export const ChatRequestBodySchema = z.object({
+  id: z.string().optional(),
+  model: z.string().optional(),
+  messages: z.array(UIMessageSchema).optional(),
+  wsId: z.string().optional(),
+  workspaceContextId: z.string().optional(),
+  isMiraMode: z.boolean().optional(),
+  timezone: z.string().optional(),
+  thinkingMode: z.enum(['thinking', 'fast']).optional(),
+  creditSource: z.enum(['personal', 'workspace']).optional(),
+  creditWsId: z.string().trim().min(1).max(MAX_ID_LENGTH).optional(),
+  observabilityContext: z.array(z.record(z.string(), z.unknown())).optional(),
+  taskBoardContext: TaskBoardContextSchema.optional(),
+});
+
+export type ChatRequestBody = z.infer<typeof ChatRequestBodySchema>;
+export type ChatRequestTaskBoardContext = z.infer<
+  typeof TaskBoardContextSchema
+>;
+
+function isValidHttpUrl(value: string): boolean {
+  try {
+    const url = new URL(value);
+    return url.protocol === 'http:' || url.protocol === 'https:';
+  } catch {
+    return false;
+  }
+}
+
+function mapToUIMessageParts(
+  parts: z.infer<typeof UIMessageSchema>['parts']
+): UIMessage['parts'] {
+  const mappedParts: UIMessage['parts'] = [];
+
+  for (const rawPart of parts) {
+    const part = UIMessagePartSchema.parse(rawPart);
+
+    if (part.type === 'text' && typeof part.text === 'string') {
+      mappedParts.push({ type: 'text', text: part.text });
+      continue;
+    }
+
+    if (
+      part.type === 'dynamic-tool' &&
+      typeof part.toolName === 'string' &&
+      typeof part.toolCallId === 'string'
+    ) {
+      mappedParts.push({
+        type: 'text',
+        text: serializeToolPartForModelContext(part),
+      });
+      continue;
+    }
+
+    if (
+      part.type === 'source-url' &&
+      typeof part.sourceId === 'string' &&
+      typeof part.url === 'string' &&
+      isValidHttpUrl(part.url)
+    ) {
+      mappedParts.push({
+        type: 'text',
+        text: `Source: ${
+          typeof part.title === 'string' ? `${part.title} ` : ''
+        }${part.url}`,
+      });
+    }
+  }
+
+  return mappedParts;
+}
+
+function serializeToolPartForModelContext(part: Record<string, unknown>) {
+  const sections = [
+    `Tool result: ${part.toolName}`,
+    part.input === undefined ? null : `Input: ${safeStringify(part.input)}`,
+    part.output === undefined ? null : `Output: ${safeStringify(part.output)}`,
+    typeof part.errorText === 'string' ? `Error: ${part.errorText}` : null,
+  ].filter(Boolean);
+
+  return sections.join('\n');
+}
+
+function safeStringify(value: unknown) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+export function mapToUIMessages(
+  messages: ChatRequestBody['messages']
+): UIMessage[] {
+  if (!messages) return [];
+
+  return messages.map(
+    (message): UIMessage => ({
+      id: message.id ?? generateRandomUUID(),
+      role: message.role,
+      parts: mapToUIMessageParts(message.parts),
+      ...(message.name ? { name: message.name } : {}),
+      ...(message.metadata ? { metadata: message.metadata } : {}),
+    })
+  );
+}