diff --git a/apps/web/src/app/api/ai/chat/route.ts b/apps/web/src/app/api/ai/chat/route.ts
index 9a9dacfb2..7d2064a4b 100644
--- a/apps/web/src/app/api/ai/chat/route.ts
+++ b/apps/web/src/app/api/ai/chat/route.ts
@@ -71,6 +71,13 @@ import {
 } from '@/lib/ai/core/stream-abort-registry';
 import { validateUserMessageFileParts, hasFileParts } from '@/lib/ai/core/validate-image-parts';
 import { hasVisionCapability } from '@/lib/ai/core/model-capabilities';
+import {
+  determineMessagesToInclude,
+  getContextWindowSize,
+  estimateSystemPromptTokens,
+  estimateToolDefinitionTokens,
+} from '@pagespace/lib/ai-context-calculator';
+import { isContextLengthError } from '@/lib/ai/shared/error-messages';
 
 
 // Allow streaming responses up to 5 minutes for complex AI agent interactions
@@ -90,6 +97,7 @@ export async function POST(request: Request) {
   let selectedProvider: string | undefined;
   let selectedModel: string | undefined;
   let usagePromise: Promise<LanguageModelUsage | undefined> | undefined;
+  let wasTruncated = false;
   const usageLogger = loggers.ai.child({ module: 'page-ai-usage' });
   const permissionLogger = loggers.ai.child({ module: 'page-ai-permissions' });
 
@@ -741,13 +749,10 @@ export async function POST(request: Request) {
       });
     }
 
-    // Convert UIMessages to ModelMessages for the AI model
-    // First sanitize messages to remove tool parts without results (prevents "input-available" state errors)
+    // Sanitize messages to remove tool parts without results (prevents "input-available" state errors)
     // NOTE: We use database-loaded messages, NOT messages from client
+    // modelMessages is computed after system prompt is built so we can apply context truncation
     const sanitizedMessages = sanitizeMessagesForModel(conversationHistory);
-    const modelMessages = convertToModelMessages(sanitizedMessages, {
-      tools: filteredTools  // Use original tools - no wrapping needed
-    });
 
     // Fetch user personalization for AI system prompt injection
     const personalization = await getUserPersonalization(userId);
@@ -818,8 +823,66 @@ export async function POST(request: Request) {
     }
 
     loggers.ai.debug('AI Chat API: Tools configured for Page AI', { toolCount: Object.keys(filteredTools).length });
+
+    // Context-length guard: proactively truncate oldest messages to fit within the model's context window.
+    // This prevents AI_APICallError from providers when a conversation grows too long.
+    // We build modelMessages here (after system prompt) so we have accurate token budgeting.
+    const fullSystemPrompt = systemPrompt + timestampSystemPrompt + pageTreePrompt;
+    const contextWindow = getContextWindowSize(currentModel, currentProvider);
+    const systemPromptTokens = estimateSystemPromptTokens(fullSystemPrompt);
+    // Cast needed because filteredTools is a ToolSet (Vercel AI SDK type) but calculator expects plain object
+    const toolTokens = estimateToolDefinitionTokens(filteredTools as Record<string, unknown>);
+    // Reserve 25% headroom for output tokens and tokenizer inaccuracies
+    const inputBudget = Math.floor(contextWindow * 0.75);
+    const truncationResult = determineMessagesToInclude(
+      sanitizedMessages,
+      inputBudget,
+      systemPromptTokens,
+      toolTokens
+    );
+    const { includedMessages } = truncationResult;
+    wasTruncated = truncationResult.wasTruncated;
+
+    if (wasTruncated) {
+      loggers.ai.warn('AI Chat API: Conversation truncated to fit context window', {
+        originalMessageCount: sanitizedMessages.length,
+        includedMessageCount: includedMessages.length,
+        model: currentModel,
+        provider: currentProvider,
+        contextWindow,
+        inputBudget,
+        systemPromptTokens,
+        toolTokens,
+      });
+    }
+
+    // Guard: if truncation left zero messages, the latest message alone exceeds the budget
+    if (includedMessages.length === 0) {
+      loggers.ai.error('AI Chat API: No messages fit within context budget', {
+        model: currentModel,
+        provider: currentProvider,
+        contextWindow,
+        inputBudget,
+        systemPromptTokens,
+        toolTokens,
+        originalMessageCount: sanitizedMessages.length,
+      });
+      return NextResponse.json(
+        {
+          error: 'context_length_exceeded',
+          message: 'Your latest message is too large to fit within this model\'s context window. Try shortening your message or starting a new conversation.',
+          details: 'context_length_exceeded',
+        },
+        { status: 413 }
+      );
+    }
+
+    const modelMessages = convertToModelMessages(includedMessages as UIMessage[], {
+      tools: filteredTools  // Use original tools - no wrapping needed
+    });
+
     loggers.ai.info('AI Chat API: Starting streamText for Page AI', { model: currentModel, pageName: page.title });
-    
+
     // Create UI message stream with visual content injection support
     // This handles the case where tools return visual content that needs to be injected into the stream
     let result;
@@ -1199,8 +1262,21 @@ export async function POST(request: Request) {
     });
     
     // Return a proper error response
-    return NextResponse.json({ 
-      error: 'Failed to process chat request. Please try again.' 
+    const errorMsg = error instanceof Error ? error.message : '';
+    if (isContextLengthError(errorMsg)) {
+      return NextResponse.json(
+        {
+          error: 'context_length_exceeded',
+          message: wasTruncated
+            ? 'The conversation still exceeds this model\'s context window even after trimming. Please start a new conversation.'
+            : 'The conversation is too long for this model\'s context window. Please start a new conversation or try a model with a larger context window.',
+          details: 'context_length_exceeded',
+        },
+        { status: 413 }
+      );
+    }
+    return NextResponse.json({
+      error: 'Failed to process chat request. Please try again.'
     }, { status: 500 });
   }
 }
diff --git a/apps/web/src/components/layout/right-sidebar/ai-assistant/SidebarChatTab.tsx b/apps/web/src/components/layout/right-sidebar/ai-assistant/SidebarChatTab.tsx
index 31a33a047..9e9fa3b61 100644
--- a/apps/web/src/components/layout/right-sidebar/ai-assistant/SidebarChatTab.tsx
+++ b/apps/web/src/components/layout/right-sidebar/ai-assistant/SidebarChatTab.tsx
@@ -1,5 +1,6 @@
 import React, { useEffect, useState, useRef, useMemo, useCallback } from 'react';
 import { UIMessage } from 'ai';
+import { getAIErrorMessage } from '@/lib/ai/shared/error-messages';
 import { usePathname } from 'next/navigation';
 import { Button } from '@/components/ui/button';
 import { ChatInput, type ChatInputRef } from '@/components/ai/chat/input';
@@ -787,16 +788,7 @@ const SidebarChatTab: React.FC = () => {
         {error && showError && (
           <div className="p-2 bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800 rounded text-xs flex items-center justify-between">
             <p className="text-red-700 dark:text-red-300">
-              {error.message?.includes('Unauthorized') || error.message?.includes('401')
-                ? 'Authentication failed. Please refresh the page and try again.'
-                : (error.message?.toLowerCase().includes('rate') ||
-                   error.message?.toLowerCase().includes('limit') ||
-                   error.message?.includes('429') ||
-                   error.message?.includes('402') ||
-                   error.message?.includes('Failed after') ||
-                   error.message?.includes('Provider returned error'))
-                ? 'Free tier rate limit hit. Please try again in a few seconds or subscribe for premium models and access.'
-                : 'Something went wrong. Please try again.'}
+              {getAIErrorMessage(error.message)}
             </p>
             <button
               onClick={() => setShowError(false)}
diff --git a/apps/web/src/lib/ai/shared/error-messages.ts b/apps/web/src/lib/ai/shared/error-messages.ts
index 82846236e..aa63c7b48 100644
--- a/apps/web/src/lib/ai/shared/error-messages.ts
+++ b/apps/web/src/lib/ai/shared/error-messages.ts
@@ -8,11 +8,35 @@
 export function getAIErrorMessage(errorMessage: string | undefined): string {
   if (!errorMessage) return 'Something went wrong. Please try again.';
 
+  const msg = errorMessage.toLowerCase();
+
   // Authentication errors
   if (errorMessage.includes('Unauthorized') || errorMessage.includes('401')) {
     return 'Authentication failed. Please refresh the page and try again.';
   }
 
+  // Request size errors (distinct from context-window limits)
+  if (
+    msg.includes('request body too large') ||
+    msg.includes('payload too large') ||
+    msg.includes('entity too large')
+  ) {
+    return 'Your request is too large. Try sending a shorter message or fewer/lower-size attachments.';
+  }
+
+  // Context length errors
+  if (isContextLengthError(errorMessage)) {
+    // Preserve server-provided guidance when present (e.g. "even after trimming", "latest message too large")
+    if (
+      msg.includes('latest message is too large') ||
+      msg.includes('even after trimming') ||
+      msg.includes('too long for this model')
+    ) {
+      return errorMessage;
+    }
+    return 'The conversation is too long for this model\'s context window. Please start a new conversation or use a model with a larger context window.';
+  }
+
   // Rate limit errors
   if (
     errorMessage.toLowerCase().includes('rate') ||
@@ -36,11 +60,43 @@ export function isAuthenticationError(errorMessage: string | undefined): boolean
   return errorMessage.includes('Unauthorized') || errorMessage.includes('401');
 }
 
+/**
+ * Check if error is a context length / token limit error
+ */
+export function isContextLengthError(errorMessage: string | undefined): boolean {
+  if (!errorMessage) return false;
+  const msg = errorMessage.toLowerCase();
+
+  // Explicitly exclude non-context 413 payload errors
+  if (
+    msg.includes('request body too large') ||
+    msg.includes('payload too large') ||
+    msg.includes('entity too large')
+  ) {
+    return false;
+  }
+
+  return (
+    msg.includes('context_length') ||     // API error key: context_length_exceeded
+    msg.includes('context length') ||     // Human-readable variant
+    msg.includes('context window') ||
+    msg.includes('maximum context') ||
+    msg.includes('token limit') ||
+    msg.includes('tokens exceeds') ||
+    msg.includes('too many tokens') ||
+    errorMessage.includes('413') ||
+    // OpenRouter / provider-specific phrasing
+    (msg.includes('maximum') && msg.includes('tokens'))
+  );
+}
+
 /**
  * Check if error is a rate limit error
  */
 export function isRateLimitError(errorMessage: string | undefined): boolean {
   if (!errorMessage) return false;
+  // Exclude context-length errors that also contain "limit"
+  if (isContextLengthError(errorMessage)) return false;
   return (
     errorMessage.toLowerCase().includes('rate') ||
     errorMessage.toLowerCase().includes('limit') ||
diff --git a/packages/lib/src/monitoring/ai-context-calculator.ts b/packages/lib/src/monitoring/ai-context-calculator.ts
index ad7760989..4b6d73b59 100644
--- a/packages/lib/src/monitoring/ai-context-calculator.ts
+++ b/packages/lib/src/monitoring/ai-context-calculator.ts
@@ -48,16 +48,21 @@ export interface ContextCalculation {
 }
 
 /**
- * Estimate tokens in a text string
- * Uses 4 characters per token as a rough estimate
- * This is conservative - actual token count may be slightly lower
+ * Estimate tokens in a text string.
+ * Uses ~4 chars/token for Latin text, ~2 chars/token when significant
+ * non-ASCII / CJK content is detected (CJK characters often tokenize to 1-2 tokens each).
  */
 export function estimateTokens(text: string): number {
   if (!text) return 0;
 
-  // GPT-style tokenization: ~4 characters per token
-  // This is conservative to avoid underestimating
-  return Math.ceil(text.length / 4);
+  // Detect non-ASCII heavy content (CJK, emoji, etc.)
+  // CJK Unified Ideographs, Hiragana, Katakana, Hangul, etc.
+  const nonAsciiCount = (text.match(/[^\x00-\x7F]/g) || []).length;
+  const nonAsciiRatio = nonAsciiCount / text.length;
+
+  // Use 2 chars/token when >20% non-ASCII (CJK-heavy), else 4 chars/token
+  const charsPerToken = nonAsciiRatio > 0.2 ? 2 : 4;
+  return Math.ceil(text.length / charsPerToken);
 }
 
 /**
@@ -137,6 +142,42 @@ export function getContextWindowSize(model: string, provider?: string): number {
   const providerLower = provider?.toLowerCase() || '';
   const modelLower = model.toLowerCase();
 
+  // OpenRouter must be checked first — its models contain names like 'claude', 'gpt', 'gemini'
+  // that would otherwise match the provider-specific branches below.
+  if (providerLower === 'openrouter') {
+    // Claude models via OpenRouter
+    if (modelLower.includes('claude')) return 200_000;
+    // Gemini models via OpenRouter
+    if (modelLower.includes('gemini-2.5')) return 1_000_000;
+    if (modelLower.includes('gemini-2.0') || modelLower.includes('gemini-1.5')) return 1_000_000;
+    // GPT models via OpenRouter
+    if (modelLower.includes('gpt-5.2')) {
+      return modelLower.includes('mini') || modelLower.includes('nano') ? 256_000 : 400_000;
+    }
+    if (modelLower.includes('gpt-5.1')) return 400_000;
+    if (modelLower.includes('gpt-5')) {
+      return modelLower.includes('mini') || modelLower.includes('nano') ? 128_000 : 272_000;
+    }
+    if (modelLower.includes('gpt-4o') || modelLower.includes('gpt-4-turbo')) return 128_000;
+    // Grok models via OpenRouter
+    if (modelLower.includes('grok-4-fast')) return 2_000_000;
+    if (modelLower.includes('grok')) return 128_000;
+    // DeepSeek models - commonly 64k or 128k
+    if (modelLower.includes('deepseek-r1') || modelLower.includes('deepseek-v3')) return 128_000;
+    if (modelLower.includes('deepseek')) return 64_000;
+    // Qwen models
+    if (modelLower.includes('qwen-2.5') || modelLower.includes('qwq')) return 128_000;
+    if (modelLower.includes('qwen')) return 32_000;
+    // Llama models
+    if (modelLower.includes('llama-3') || modelLower.includes('llama3')) return 128_000;
+    if (modelLower.includes('llama')) return 32_000;
+    // Mistral models
+    if (modelLower.includes('mistral-large') || modelLower.includes('mistral-nemo')) return 128_000;
+    if (modelLower.includes('mistral')) return 32_000;
+    // OpenRouter platform hard cap is 400k for many endpoints - use 200k as safe default
+    return 200_000;
+  }
+
   // OpenAI models
   if (providerLower === 'openai' || modelLower.includes('gpt')) {
     // GPT-5.2 models (400k/256k context)
@@ -217,8 +258,8 @@ export function getContextWindowSize(model: string, provider?: string): number {
     return 128_000; // Default for older MiniMax models
   }
 
-  // OpenRouter or unknown
-  return 200_000; // Conservative default
+  // Unknown provider/model - conservative default
+  return 200_000;
 }
 
 /**