vibefast-cli 0.2.2 → 0.2.4

package/recipes/chatbot/packages/backend/convex/chatbotHistory.ts

@@ -0,0 +1,307 @@
+import { getAuthUserId } from '@convex-dev/auth/server';
+import { paginationOptsValidator } from 'convex/server';
+import { v } from 'convex/values';
+
+import { mutation, query } from './_generated/server';
+
+/**
+ * Create a new conversation for a user
+ */
+export const createConversation = mutation({
+  args: {
+    name: v.optional(v.string()),
+  },
+  returns: v.id('conversations'),
+  handler: async (ctx, args) => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) {
+      throw new Error('Not authenticated');
+    }
+
+    const conversationId = await ctx.db.insert('conversations', {
+      userId,
+      name: args.name,
+    });
+    return conversationId;
+  },
+});
+
+/**
+ * Get or create a default conversation for a user
+ * This ensures each user has exactly one default conversation
+ */
+export const getOrCreateDefaultConversation = mutation({
+  args: {},
+  returns: v.id('conversations'),
+  handler: async (ctx, _args) => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) {
+      throw new Error('Not authenticated');
+    }
+
+    // First, try to find an existing conversation for this user
+    const existingConversation = await ctx.db
+      .query('conversations')
+      .withIndex('by_userId', (q) => q.eq('userId', userId))
+      .first();
+
+    if (existingConversation) {
+      return existingConversation._id;
+    }
+
+    // If no conversation exists, create a new one
+    const conversationId = await ctx.db.insert('conversations', {
+      userId,
+      name: 'Default Chat',
+    });
+    return conversationId;
+  },
+});
+
+/**
+ * Store a message in a conversation (for user messages and finalized AI responses)
+ */
+export const storeMessage = mutation({
+  args: {
+    conversationId: v.id('conversations'),
+    authorType: v.union(v.literal('user'), v.literal('bot')),
+    /** Whether the message is finished streaming */
+    isComplete: v.optional(v.boolean()),
+    text: v.optional(v.string()),
+    attachments: v.optional(
+      v.array(
+        v.object({
+          type: v.union(v.literal('image')),
+          storageId: v.id('_storage'),
+          url: v.optional(v.string()),
+          fileName: v.optional(v.string()),
+          mimeType: v.optional(v.string()),
+        }),
+      ),
+    ),
+    aiProvider: v.optional(v.string()),
+    aiModel: v.optional(v.string()),
+  },
+  returns: v.id('messages'),
+  handler: async (ctx, args) => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) {
+      throw new Error('Not authenticated');
+    }
+
+    const textToStore = args.text?.trim() ? args.text.trim() : undefined;
+    // If there's no text and no attachments, maybe don't store? Or store as empty.
+    // Current logic: if text is undefined/empty string but attachments exist, text will be undefined.
+    // If text is spaces only and no attachments, text will be undefined.
+    if (
+      textToStore === undefined &&
+      (!args.attachments || args.attachments.length === 0)
+    ) {
+      // Prevent storing messages that are truly empty (no text, no attachments).
+      // This was previously a comment, now it's enforced.
+      throw new Error(
+        'Cannot store a message with no text and no attachments.',
+      );
+    }
+
+    return await ctx.db.insert('messages', {
+      ...args,
+      userId,
+      text: textToStore, // Use the potentially undefined trimmed text
+    });
+  },
+});
+
+/**
+ * Store a finalized bot message after streaming completes
+ * Internal mutation called from the HTTP action
+ */
+export const storeFinalBotMessage = mutation({
+  args: {
+    conversationId: v.id('conversations'),
+    text: v.string(),
+    aiProvider: v.optional(v.string()),
+    aiModel: v.optional(v.string()),
+  },
+  returns: v.id('messages'),
+  handler: async (ctx, args) => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) {
+      throw new Error('Not authenticated');
+    }
+
+    return await ctx.db.insert('messages', {
+      conversationId: args.conversationId,
+      userId,
+      authorType: 'bot' as const,
+      text: args.text.trim() || undefined,
+      aiProvider: args.aiProvider,
+      aiModel: args.aiModel,
+    });
+  },
+});
+
+/**
+ * Clear all messages in a conversation
+ * Uses batching to handle large conversations without timeout
+ */
+export const clearConversationMessages = mutation({
+  args: { conversationId: v.id('conversations') },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) {
+      throw new Error('Not authenticated');
+    }
+
+    const conversation = await ctx.db.get(args.conversationId);
+    if (!conversation || conversation.userId !== userId) {
+      throw new Error('Conversation not found or access denied');
+    }
+
+    // Delete in batches to avoid timeout on large conversations
+    const BATCH_SIZE = 100;
+    let deletedCount = 0;
+
+    while (true) {
+      const messages = await ctx.db
+        .query('messages')
+        .withIndex('by_conversationId', (q) =>
+          q.eq('conversationId', args.conversationId),
+        )
+        .take(BATCH_SIZE);
+
+      if (messages.length === 0) {
+        break;
+      }
+
+      for (const message of messages) {
+        await ctx.db.delete(message._id);
+        deletedCount++;
+      }
+
+      // If we got fewer than BATCH_SIZE, we're done
+      if (messages.length < BATCH_SIZE) {
+        break;
+      }
+    }
+
+    console.log(
+      `[clearConversationMessages] Cleared ${deletedCount} messages from conversation ${args.conversationId}`,
+    );
+  },
+});
+
+/**
+ * Delete a single user-authored message. Used to roll back optimistic UI when
+ * downstream agent execution fails.
+ */
+export const deleteUserMessage = mutation({
+  args: {
+    messageId: v.id('messages'),
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) {
+      throw new Error('Not authenticated');
+    }
+
+    const message = await ctx.db.get(args.messageId);
+    if (!message) {
+      return null;
+    }
+
+    if (message.userId !== userId) {
+      throw new Error('Cannot delete message owned by another user.');
+    }
+
+    if (message.authorType !== 'user') {
+      throw new Error('Only user messages can be deleted via this pathway.');
+    }
+
+    await ctx.db.delete(args.messageId);
+    return null;
+  },
+});
+
+/**
+ * List messages in a conversation with pagination
+ */
+export const listMessages = query({
+  args: {
+    conversationId: v.id('conversations'),
+    paginationOpts: paginationOptsValidator,
+  },
+  returns: v.object({
+    page: v.array(
+      v.object({
+        _id: v.id('messages'),
+        _creationTime: v.number(),
+        conversationId: v.id('conversations'),
+        userId: v.id('users'),
+        authorType: v.union(v.literal('user'), v.literal('bot')),
+        text: v.optional(v.string()),
+        toolCalls: v.optional(
+          v.array(
+            v.object({
+              toolName: v.string(),
+              args: v.any(),
+              result: v.optional(v.any()),
+            }),
+          ),
+        ),
+        metadata: v.optional(
+          v.object({
+            streamId: v.optional(v.string()),
+            status: v.optional(v.string()),
+            usage: v.optional(
+              v.object({
+                promptTokens: v.optional(v.number()),
+                completionTokens: v.optional(v.number()),
+                totalTokens: v.optional(v.number()),
+              }),
+            ),
+          }),
+        ),
+        attachments: v.optional(
+          v.array(
+            v.object({
+              type: v.union(v.literal('image')),
+              storageId: v.id('_storage'),
+              url: v.optional(v.string()),
+              fileName: v.optional(v.string()),
+              mimeType: v.optional(v.string()),
+            }),
+          ),
+        ),
+        aiProvider: v.optional(v.string()),
+        aiModel: v.optional(v.string()),
+      }),
+    ),
+    isDone: v.boolean(),
+    continueCursor: v.union(v.string(), v.null()),
+    pageStatus: v.optional(v.union(v.string(), v.null())),
+    splitCursor: v.optional(v.union(v.string(), v.null())),
+  }),
+  handler: async (ctx, args) => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) {
+      throw new Error('Not authenticated');
+    }
+
+    // Verify the user owns this conversation
+    const conversation = await ctx.db.get(args.conversationId);
+    if (!conversation || conversation.userId !== userId) {
+      throw new Error('Conversation not found or access denied');
+    }
+
+    return await ctx.db
+      .query('messages')
+      .withIndex('by_conversationId', (q) =>
+        q.eq('conversationId', args.conversationId),
+      )
+      .order('desc')
+      .paginate(args.paginationOpts);
+  },
+});

package/recipes/chatbot/packages/backend/convex/lib/rateLimit.ts

@@ -0,0 +1,100 @@
+import type { Id } from '../_generated/dataModel';
+import type { MutationCtx } from '../_generated/server';
+
+const AGENT_WINDOW_MS = 60 * 1000; // 1 minute
+const AGENT_LIMIT = 12; // max agent calls per window
+
+const TOOL_WINDOW_MS = 60 * 1000;
+const TOOL_LIMIT = 20;
+
+type RateLimitFields =
+  | [
+      'agentRateLimitWindowStart',
+      'agentRateLimitCount',
+      typeof AGENT_WINDOW_MS,
+      typeof AGENT_LIMIT,
+    ]
+  | [
+      'toolRateLimitWindowStart',
+      'toolRateLimitCount',
+      typeof TOOL_WINDOW_MS,
+      typeof TOOL_LIMIT,
+    ];
+
+const getNow = () => Date.now();
+
+async function enforceRateLimit(
+  db: MutationCtx['db'],
+  userId: Id<'users'>,
+  [windowField, countField, windowMs, limit]: RateLimitFields,
+  friendlyName: string,
+) {
+  const userDoc = await db.get(userId);
+  if (!userDoc) {
+    throw new Error('User not found while enforcing rate limit.');
+  }
+
+  const nowMs = getNow();
+  const record = userDoc as unknown as Record<string, number | undefined>;
+  const windowStart = record[windowField] ?? 0;
+  const currentCount = record[countField] ?? 0;
+
+  const withinWindow = nowMs - windowStart < windowMs;
+  const nextCount = withinWindow ? currentCount + 1 : 1;
+
+  if (withinWindow && nextCount > limit) {
+    const retrySeconds = Math.ceil((windowMs - (nowMs - windowStart)) / 1000);
+    const message = `${friendlyName} limit reached. Please wait ${retrySeconds}s before trying again.`;
+    const error = new Error(message);
+    (error as Error & { code?: string }).code = 'RATE_LIMIT';
+    throw error;
+  }
+
+  await db.patch(userId, {
+    [windowField]: withinWindow ? windowStart : nowMs,
+    [countField]: nextCount,
+  });
+}
+
+export function enforceAgentRateLimit(
+  db: MutationCtx['db'],
+  userId: Id<'users'>,
+) {
+  return enforceRateLimit(
+    db,
+    userId,
+    [
+      'agentRateLimitWindowStart',
+      'agentRateLimitCount',
+      AGENT_WINDOW_MS,
+      AGENT_LIMIT,
+    ],
+    'Chat agent',
+  );
+}
+
+export function enforceToolRateLimit(
+  db: MutationCtx['db'],
+  userId: Id<'users'>,
+) {
+  return enforceRateLimit(
+    db,
+    userId,
+    [
+      'toolRateLimitWindowStart',
+      'toolRateLimitCount',
+      TOOL_WINDOW_MS,
+      TOOL_LIMIT,
+    ],
+    'Tool usage',
+  );
+}
+
+export function resetRateLimits(db: MutationCtx['db'], userId: Id<'users'>) {
+  return db.patch(userId, {
+    agentRateLimitWindowStart: undefined,
+    agentRateLimitCount: undefined,
+    toolRateLimitWindowStart: undefined,
+    toolRateLimitCount: undefined,
+  });
+}

package/recipes/chatbot/packages/backend/convex/lib/telemetry.ts

@@ -0,0 +1,29 @@
+export type TelemetryMode = 'off' | 'sample' | 'debug';
+
+function normalizeMode(raw: string | undefined): TelemetryMode {
+  if (raw === 'sample' || raw === 'debug') {
+    return raw;
+  }
+  return 'off';
+}
+
+export function getChatTelemetryMode(): TelemetryMode {
+  return normalizeMode(process.env.CHAT_LATENCY_TELEMETRY_MODE);
+}
+
+export function isChatTelemetryEnabled(): boolean {
+  return getChatTelemetryMode() !== 'off';
+}
+
+export function shouldSampleChatTelemetry(probability = 0.1): boolean {
+  const mode = getChatTelemetryMode();
+  if (mode === 'off') {
+    return false;
+  }
+  if (mode === 'debug') {
+    return true;
+  }
+
+  const clampedProbability = Math.min(Math.max(probability, 0), 1);
+  return Math.random() < clampedProbability;
+}