@od-oneapp/ai-platform 0.1.0

package/src/server/messages/window.ts

@@ -0,0 +1,450 @@
+/**
+ * @fileoverview Message window factory for token-based message truncation.
+ * @module @od-oneapp/ai-platform/messages
+ *
+ * Provides factory for creating message windows that manage conversation
+ * history within token limits.
+ *
+ * @example
+ * ```ts
+ * import { createMessageWindow } from '@od-oneapp/ai-platform/messages';
+ *
+ * const window = createMessageWindow({
+ *   maxTokens: 8000,
+ *   preserveSystemMessage: true,
+ *   strategy: 'fifo',
+ * });
+ *
+ * const truncated = await window.apply(messages);
+ * const tokens = window.estimateTokens(messages);
+ * ```
+ */
+
+import { logWarn } from '@repo/shared/logs';
+
+import {
+  type MessageWindow,
+  type MessageWindowConfig,
+  type TokenizerType,
+  type UIMessage,
+} from './types';
+
+// =============================================================================
+// Default Configuration
+// =============================================================================
+
+/**
+ * Default configuration for message window.
+ */
+const DEFAULT_CONFIG: Required<Omit<MessageWindowConfig, 'summarizer'>> & {
+  summarizer: undefined;
+} = {
+  maxTokens: 4096,
+  tokenizer: 'cl100k_base',
+  preserveSystemMessage: true,
+  strategy: 'fifo',
+  summarizer: undefined,
+};
+
+// =============================================================================
+// Tokenizer Implementation
+// =============================================================================
+
+/**
+ * Estimates tokens per character for different tokenizers.
+ * These are approximations based on typical encoding ratios.
+ */
+const CHARS_PER_TOKEN: Record<string, number> = {
+  cl100k_base: 4.0, // GPT-4, GPT-3.5-turbo
+  p50k_base: 4.0, // GPT-3, Codex
+  default: 4.0,
+};
+
+/**
+ * Creates a tokenizer function from a tokenizer type.
+ *
+ * @param tokenizer - Tokenizer type or custom function.
+ * @returns Tokenizer function.
+ */
+function createTokenizer(tokenizer: TokenizerType): (text: string) => number {
+  if (typeof tokenizer === 'function') {
+    return tokenizer;
+  }
+
+  // Use character-based estimation for preset tokenizers
+  const charsPerToken = CHARS_PER_TOKEN[tokenizer] ?? CHARS_PER_TOKEN.default ?? 4.0;
+
+  return (text: string) => {
+    // Simple estimation: characters / chars_per_token
+    // Add overhead for message structure (~4 tokens per message)
+    return Math.ceil(text.length / charsPerToken) + 4;
+  };
+}
+
+/**
+ * Simple word-based tokenizer for rough estimates.
+ * Counts words and adds overhead.
+ *
+ * @param text - Text to estimate tokens for.
+ * @returns Estimated token count.
+ */
+export function wordBasedTokenizer(text: string): number {
+  // Split by whitespace and count
+  const words = text.split(/\s+/).filter(w => w.length > 0);
+  // Average ~1.3 tokens per word for English
+  return Math.ceil(words.length * 1.3) + 4;
+}
+
+// =============================================================================
+// Message Window Factory
+// =============================================================================
+
+/**
+ * Creates a message window for managing conversation history within token limits.
+ *
+ * The window applies truncation strategies to keep messages within the
+ * configured token budget while optionally preserving system messages.
+ *
+ * @param config - Window configuration options.
+ * @returns MessageWindow instance.
+ *
+ * @example Basic FIFO truncation
+ * ```ts
+ * const window = createMessageWindow({
+ *   maxTokens: 4000,
+ * });
+ *
+ * const truncated = await window.apply(messages);
+ * // Oldest messages removed to fit within 4000 tokens
+ * ```
+ *
+ * @example Preserve system message
+ * ```ts
+ * const window = createMessageWindow({
+ *   maxTokens: 8000,
+ *   preserveSystemMessage: true,
+ * });
+ *
+ * // System message always included, other messages truncated as needed
+ * const truncated = await window.apply(messages);
+ * ```
+ *
+ * @example Custom tokenizer
+ * ```ts
+ * import { encodingForModel } from 'js-tiktoken';
+ *
+ * const encoding = encodingForModel('gpt-4');
+ *
+ * const window = createMessageWindow({
+ *   maxTokens: 8000,
+ *   tokenizer: (text) => encoding.encode(text).length,
+ * });
+ * ```
+ *
+ * @example Summarize strategy
+ * ```ts
+ * const window = createMessageWindow({
+ *   maxTokens: 8000,
+ *   strategy: 'summarize',
+ *   summarizer: async (messages) => {
+ *     // Use LLM to summarize older messages
+ *     const summary = await generateSummary(messages);
+ *     return { role: 'system', content: `Previous context: ${summary}` };
+ *   },
+ * });
+ * ```
+ */
+export function createMessageWindow(config: MessageWindowConfig): MessageWindow {
+  const mergedConfig = { ...DEFAULT_CONFIG, ...config };
+  const tokenize = createTokenizer(mergedConfig.tokenizer);
+
+  /**
+   * Estimates tokens for a single message.
+   * @param message - Message to estimate.
+   * @returns Estimated token count.
+   */
+  function estimateMessageTokens(message: UIMessage): number {
+    let { content } = message;
+
+    // Include parts content if available
+    if (message.parts) {
+      for (const part of message.parts) {
+        if ('text' in part && typeof part.text === 'string') {
+          content += ` ${part.text}`;
+        }
+      }
+    }
+
+    return tokenize(content);
+  }
+
+  /**
+   * Estimates total tokens for an array of messages.
+   * @param messages - Messages to estimate.
+   * @returns Total estimated token count.
+   */
+  function estimateTokens(messages: readonly UIMessage[]): number {
+    let total = 0;
+    for (const message of messages) {
+      total += estimateMessageTokens(message);
+    }
+    return total;
+  }
+
+  /**
+   * Applies FIFO truncation strategy.
+   * Removes oldest messages first, optionally preserving system message.
+   * @param messages - Messages to truncate.
+   * @returns Truncated messages.
+   */
+  function applyFIFO(messages: readonly UIMessage[]): readonly UIMessage[] {
+    if (messages.length === 0) return messages;
+
+    // Separate system message if preserving
+    let systemMessage: UIMessage | undefined;
+    let nonSystemMessages: UIMessage[];
+
+    if (mergedConfig.preserveSystemMessage) {
+      systemMessage = messages.find(m => m.role === 'system');
+      nonSystemMessages = messages.filter(m => m.role !== 'system');
+    } else {
+      nonSystemMessages = [...messages];
+    }
+
+    // Calculate tokens for system message
+    const systemTokens = systemMessage ? estimateMessageTokens(systemMessage) : 0;
+    const availableTokens = mergedConfig.maxTokens - systemTokens;
+
+    // If system message alone exceeds budget, just return it
+    if (availableTokens <= 0 && systemMessage) {
+      return [systemMessage];
+    }
+
+    // Build result from the end (newest first)
+    const result: UIMessage[] = [];
+    let currentTokens = 0;
+
+    for (let i = nonSystemMessages.length - 1; i >= 0; i--) {
+      const message = nonSystemMessages[i];
+      if (!message) {
+        continue;
+      }
+      const messageTokens = estimateMessageTokens(message);
+
+      if (currentTokens + messageTokens <= availableTokens) {
+        result.unshift(message);
+        currentTokens += messageTokens;
+      } else {
+        // No more room
+        break;
+      }
+    }
+
+    // Add system message at the beginning if preserved
+    if (systemMessage) {
+      result.unshift(systemMessage);
+    }
+
+    return result;
+  }
+
+  /**
+   * Applies summarize truncation strategy.
+   * Summarizes older messages when they would be truncated.
+   * @param messages - Messages to process.
+   * @returns Processed messages with summaries.
+   */
+  async function applySummarize(messages: readonly UIMessage[]): Promise<readonly UIMessage[]> {
+    if (!mergedConfig.summarizer) {
+      // Fall back to FIFO if no summarizer provided
+      return applyFIFO(messages);
+    }
+
+    const currentTokens = estimateTokens(messages);
+
+    // If we're within budget, return as-is
+    if (currentTokens <= mergedConfig.maxTokens) {
+      return messages;
+    }
+
+    // Separate system message if preserving
+    let systemMessage: UIMessage | undefined;
+    let nonSystemMessages: UIMessage[];
+
+    if (mergedConfig.preserveSystemMessage) {
+      systemMessage = messages.find(m => m.role === 'system');
+      nonSystemMessages = messages.filter(m => m.role !== 'system');
+    } else {
+      nonSystemMessages = [...messages];
+    }
+
+    // Find split point - keep recent messages, summarize older ones
+    const systemTokens = systemMessage ? estimateMessageTokens(systemMessage) : 0;
+    const targetTokens = mergedConfig.maxTokens - systemTokens;
+
+    // Keep at least the last message
+    const toKeep: UIMessage[] = [];
+    let keepTokens = 0;
+    let splitIndex = nonSystemMessages.length;
+
+    for (let i = nonSystemMessages.length - 1; i >= 0; i--) {
+      const message = nonSystemMessages[i];
+      if (!message) {
+        continue;
+      }
+      const messageTokens = estimateMessageTokens(message);
+
+      // Reserve some tokens for the summary (~25% of available)
+      const reserveForSummary = Math.floor(targetTokens * 0.25);
+
+      if (keepTokens + messageTokens <= targetTokens - reserveForSummary) {
+        toKeep.unshift(message);
+        keepTokens += messageTokens;
+        splitIndex = i;
+      } else {
+        break;
+      }
+    }
+
+    // If nothing to summarize, return what we have
+    if (splitIndex === 0) {
+      const result = systemMessage ? [systemMessage, ...toKeep] : toKeep;
+      return result;
+    }
+
+    // Summarize older messages
+    const toSummarize = nonSystemMessages.slice(0, splitIndex);
+    const summaryMessage = await mergedConfig.summarizer(toSummarize);
+
+    // Build result
+    const result: UIMessage[] = [];
+    if (systemMessage) {
+      result.push(systemMessage);
+    }
+    result.push(summaryMessage);
+    result.push(...toKeep);
+
+    return result;
+  }
+
+  return {
+    async apply(messages: readonly UIMessage[]): Promise<readonly UIMessage[]> {
+      if (messages.length === 0) return messages;
+
+      const currentTokens = estimateTokens(messages);
+
+      // If we're within budget, return as-is
+      if (currentTokens <= mergedConfig.maxTokens) {
+        return messages;
+      }
+
+      // Apply strategy
+      if (mergedConfig.strategy === 'summarize') {
+        return applySummarize(messages);
+      }
+
+      return applyFIFO(messages);
+    },
+
+    applySync(messages: readonly UIMessage[]): readonly UIMessage[] {
+      if (messages.length === 0) return messages;
+
+      const currentTokens = estimateTokens(messages);
+
+      // If we're within budget, return as-is
+      if (currentTokens <= mergedConfig.maxTokens) {
+        return messages;
+      }
+
+      // Only FIFO works synchronously
+      if (mergedConfig.strategy === 'summarize') {
+        logWarn('applySync does not support summarize strategy, falling back to FIFO');
+      }
+
+      return applyFIFO(messages);
+    },
+
+    estimateTokens,
+    estimateMessageTokens,
+  };
+}
+
+// =============================================================================
+// Preset Windows
+// =============================================================================
+
+/**
+ * Creates a compact window for short context models (4K tokens).
+ *
+ * @returns MessageWindow with 4K token limit.
+ *
+ * @example
+ * ```ts
+ * const window = createCompactWindow();
+ * const truncated = await window.apply(messages);
+ * ```
+ */
+export function createCompactWindow(): MessageWindow {
+  return createMessageWindow({
+    maxTokens: 4096,
+    preserveSystemMessage: true,
+    strategy: 'fifo',
+  });
+}
+
+/**
+ * Creates a standard window for medium context models (8K tokens).
+ *
+ * @returns MessageWindow with 8K token limit.
+ *
+ * @example
+ * ```ts
+ * const window = createStandardWindow();
+ * const truncated = await window.apply(messages);
+ * ```
+ */
+export function createStandardWindow(): MessageWindow {
+  return createMessageWindow({
+    maxTokens: 8192,
+    preserveSystemMessage: true,
+    strategy: 'fifo',
+  });
+}
+
+/**
+ * Creates a large window for long context models (32K tokens).
+ *
+ * @returns MessageWindow with 32K token limit.
+ *
+ * @example
+ * ```ts
+ * const window = createLargeWindow();
+ * const truncated = await window.apply(messages);
+ * ```
+ */
+export function createLargeWindow(): MessageWindow {
+  return createMessageWindow({
+    maxTokens: 32768,
+    preserveSystemMessage: true,
+    strategy: 'fifo',
+  });
+}
+
+/**
+ * Creates an extended window for very long context models (128K tokens).
+ *
+ * @returns MessageWindow with 128K token limit.
+ *
+ * @example
+ * ```ts
+ * const window = createExtendedWindow();
+ * const truncated = await window.apply(messages);
+ * ```
+ */
+export function createExtendedWindow(): MessageWindow {
+  return createMessageWindow({
+    maxTokens: 131072,
+    preserveSystemMessage: true,
+    strategy: 'fifo',
+  });
+}

package/src/server/rate-limit/env.ts

@@ -0,0 +1,8 @@
+const requiredEnvVars = ['UPSTASH_REDIS_REST_URL', 'UPSTASH_REDIS_REST_TOKEN'] as const;
+
+export function hasRateLimitConfig(): boolean {
+  return requiredEnvVars.every(name => {
+    const value = process.env[name];
+    return typeof value === 'string' && value.length > 0;
+  });
+}

package/src/server/rate-limit/rate-limit.ts

@@ -0,0 +1,165 @@
+/**
+ * @fileoverview rate-limit.ts
+ */
+
+import { Ratelimit, Redis } from '@integrations/upstash/redis-client';
+import { logError, logWarn } from '@repo/shared/logs';
+
+import { hasRateLimitConfig } from './env';
+
+/**
+ * Rate limiter instance that allows 4 requests per day per identifier.
+ * Uses sliding window algorithm for rate limiting.
+ *
+ * @example
+ * ```ts
+ * // Use the rate limiter
+ * const result = await ratelimit.limit('user-123');
+ * ```
+ */
+export const ratelimit = new Ratelimit({
+  redis: Redis.fromEnv(),
+  limiter: Ratelimit.slidingWindow(4, '1d'),
+  analytics: true,
+  prefix: '@upstash/ratelimit',
+});
+
+/**
+ * Rate limit result type.
+ *
+ * @typedef {object} RateLimitResult
+ * @property {boolean} success - Whether the request is allowed
+ * @property {number} limit - Maximum requests allowed
+ * @property {number} remaining - Remaining requests in the window
+ * @property {number} reset - Timestamp when the limit resets
+ * @property {Promise<unknown>} pending - Pending promise for async operations
+ * @property {object} headers - HTTP headers for rate limit information
+ */
+type RateLimitResult = {
+  success: boolean;
+  limit: number;
+  remaining: number;
+  reset: number;
+  pending: Promise<unknown>;
+  headers: {
+    'X-RateLimit-Limit': string;
+    'X-RateLimit-Remaining': string;
+    'X-RateLimit-Reset': string;
+  };
+};
+
+/**
+ * Checks rate limit for a given identifier.
+ * Falls back gracefully if rate limiting is not configured or fails.
+ *
+ * @param {string} identifier - Unique identifier for rate limiting (e.g., user ID, IP address)
+ * @returns {Promise<RateLimitResult>} Rate limit check result with headers
+ *
+ * @example
+ * ```ts
+ * // Check rate limit for a user
+ * const result = await checkRateLimit('user-123');
+ * if (!result.success) {
+ *   return new Response('Rate limit exceeded', { status: 429 });
+ * }
+ * ```
+ */
+export const checkRateLimit = async (identifier: string): Promise<RateLimitResult> => {
+  try {
+    const { success, limit, reset, remaining, pending } = await ratelimit.limit(identifier);
+
+    return {
+      success,
+      limit,
+      reset,
+      remaining,
+      pending,
+      headers: {
+        'X-RateLimit-Limit': limit.toString(),
+        'X-RateLimit-Remaining': remaining.toString(),
+        'X-RateLimit-Reset': reset.toString(),
+      },
+    };
+  } catch (error: unknown) {
+    // Log the error for monitoring
+    logError(error instanceof Error ? error : new Error(String(error)), {
+      message: 'Rate limit check failed',
+      identifier,
+    });
+
+    // If rate limiting is not configured, allow the request
+    if (!hasRateLimitConfig()) {
+      logWarn('Rate limiting not configured, allowing request', { identifier });
+      return {
+        success: true,
+        limit: 150,
+        reset: Date.now() + 24 * 60 * 60 * 1000, // 24 hours from now
+        remaining: 149,
+        pending: Promise.resolve(),
+        headers: {
+          'X-RateLimit-Limit': '150',
+          'X-RateLimit-Remaining': '149',
+          'X-RateLimit-Reset': (Date.now() + 24 * 60 * 60 * 1000).toString(),
+        },
+      };
+    }
+
+    // If rate limiting is configured but failed, be more conservative
+    // Return a default success response if rate limiting fails
+    // This prevents the API from breaking if Upstash is down
+    logWarn('Rate limit service unavailable, allowing request with fallback limits', {
+      identifier,
+    });
+    return {
+      success: true,
+      limit: 150,
+      reset: Date.now() + 24 * 60 * 60 * 1000, // 24 hours from now
+      remaining: 149,
+      pending: Promise.resolve(),
+      headers: {
+        'X-RateLimit-Limit': '150',
+        'X-RateLimit-Remaining': '149',
+        'X-RateLimit-Reset': (Date.now() + 24 * 60 * 60 * 1000).toString(),
+      },
+    };
+  }
+};
+
+/**
+ * Extracts client IP address from request headers.
+ * Handles various proxy headers (x-forwarded-for, x-real-ip, cf-connecting-ip).
+ *
+ * @param {Request | Headers} req - Request object or Headers object
+ * @returns {string} Client IP address or 'unknown' if not found
+ *
+ * @example
+ * ```ts
+ * // Get client IP from request
+ * const ip = getClientIP(request);
+ * // or from headers
+ * const headers = await headers();
+ * const ip = getClientIP(headers);
+ * ```
+ */
+export const getClientIP = (req: Request | Headers): string => {
+  // Handle both Request objects and Headers objects
+  const headers = req instanceof Headers ? req : req.headers;
+
+  const forwarded = headers.get('x-forwarded-for');
+  const real = headers.get('x-real-ip');
+  const cfConnectingIP = headers.get('cf-connecting-ip');
+
+  if (forwarded) {
+    return forwarded.split(',')[0]?.trim() ?? 'unknown';
+  }
+
+  if (real) {
+    return real;
+  }
+
+  if (cfConnectingIP) {
+    return cfConnectingIP;
+  }
+
+  return 'unknown';
+};