Gemini 3 Pro: 1M Token Context Window Edge Cases

// Context window behavior at different scales
const contextBehavior = {
  // 0-128K: Full attention, highest quality
  tier1: {
    range: [0, 128_000],
    attention: 'full',
    quality: 'highest',
    latency: 'baseline'
  },

  // 128K-512K: Sliding window attention
  tier2: {
    range: [128_001, 512_000],
    attention: 'sliding_window',
    quality: 'degraded',
    latency: '+30%'
  },

  // 512K-1M: Sparse attention patterns
  tier3: {
    range: [512_001, 1_000_000],
    attention: 'sparse',
    quality: 'variable',
    latency: '+80%'
  }
};

// Production pattern: Strategic content placement
async function optimizeContextPlacement(content) {
  const critical = extractCriticalSections(content);
  const supporting = extractSupportingDocs(content);

  // Place critical content in tier 1
  const optimized = [
    ...critical.slice(0, 100_000),      // Instructions, key context
    ...supporting.slice(0, 400_000),     // Reference material
    ...critical.slice(100_000, 128_000)  // Recent conversation
  ];

  return optimized;
}

// Edge case: Token boundary handling
const edgeCases = {
  // Truncation without warning
  silentTruncation: {
    trigger: 'tokens > 1_000_000',
    behavior: 'Drops tokens beyond limit',
    detection: 'Compare input/output token counts'
  },

  // Context fragmentation
  fragmentedRetrieval: {
    trigger: 'multimodal inputs > 500K',
    behavior: 'Loses coherence across modalities',
    mitigation: 'Group modalities together'
  },

  // Attention collapse
  attentionCollapse: {
    trigger: 'recursive references > 10 levels',
    behavior: 'Fails to maintain reference chains',
    mitigation: 'Flatten recursive structures'
  }
};

// Production guard rails
async function safeGeminiCall(content, config) {
  const tokenCount = await countTokens(content);

  if (tokenCount > 950_000) {
    // Leave buffer for response tokens
    return await chunkAndCache(content, config);
  }

  if (hasMultimodalContent(content)) {
    // Reorganize for coherence
    content = groupByModality(content);
  }

  return await callGemini(content, config);
}

// Token consumption by modality
const modalityTokens = {
  text: {
    ratio: 1,  // 1 token ≈ 4 chars
    predictable: true
  },

  image: {
    // Variable based on resolution
    small: 258,      // 512x512
    medium: 1092,    // 1024x1024
    large: 2730,     // 2048x2048
    predictable: false  // Depends on compression
  },

  video: {
    // 1 second at 1fps
    tokensPerSecond: 300,
    maxDuration: 3600,  // 1 hour max
    totalTokens: (duration) => duration * 300
  },

  pdf: {
    // OCR + layout analysis
    perPage: 500,  // Average, varies by content
    includesLayout: true,
    includesImages: false  // Extracted separately
  }
};

// Production: Optimize multimodal mix
function optimizeMultimodalContext(inputs) {
  let tokenBudget = 950_000;  // Leave output buffer
  const optimized = [];

  // Prioritize by information density
  const sorted = inputs.sort((a, b) => {
    const densityA = a.importance / getTokenCount(a);
    const densityB = b.importance / getTokenCount(b);
    return densityB - densityA;
  });

  for (const input of sorted) {
    const tokens = getTokenCount(input);
    if (tokenBudget >= tokens) {
      optimized.push(input);
      tokenBudget -= tokens;
    }
  }

  return optimized;
}

// Fragmentation scenarios and mitigations
const fragmentationPatterns = {
  // Interleaved modalities break coherence
  interleavedModal: {
    bad: ['text', 'image', 'text', 'video', 'text'],
    good: ['text', 'text', 'text', 'image', 'video'],
    impact: '40% accuracy drop in cross-references'
  },

  // Token distance affects retrieval
  distantReferences: {
    threshold: 200_000,  // tokens between reference and query
    degradation: 'exponential',
    formula: 'accuracy = 0.95 * Math.exp(-distance/200000)'
  },

  // Modality switching cost
  switchingPenalty: {
    textToImage: 5000,   // effective token cost
    imageToVideo: 8000,
    videoToText: 3000,
    recommendation: 'Minimize modality switches'
  }
};

// Production implementation
class GeminiContextManager {
  constructor(maxTokens = 950_000) {
    this.maxTokens = maxTokens;
    this.cache = new Map();
  }

  async processMultimodal(inputs) {
    // Group by modality
    const grouped = this.groupByModality(inputs);

    // Order for optimal attention
    const ordered = [
      ...grouped.text,      // Instructions first
      ...grouped.pdf,       // Reference docs
      ...grouped.image,     // Visual context
      ...grouped.video      // Heaviest last
    ];

    // Apply caching for repeated context
    return this.applyCaching(ordered);
  }

  applyCaching(inputs) {
    const cached = [];
    let tokenCount = 0;

    for (const input of inputs) {
      const hash = this.hash(input);

      if (this.cache.has(hash)) {
        // Reference cached content instead
        cached.push({ ref: hash, tokens: 100 });
        tokenCount += 100;
      } else {
        const tokens = getTokenCount(input);
        if (tokenCount + tokens < this.maxTokens) {
          cached.push(input);
          this.cache.set(hash, input);
          tokenCount += tokens;
        }
      }
    }

    return cached;
  }
}

// Gemini 3 Pro agentic patterns
const agenticPatterns = {
  // Phase 1: Planning (happens in context)
  planning: {
    capability: 'Multi-step reasoning',
    limitation: 'No dynamic tool discovery',
    pattern: 'Declare all tools upfront'
  },

  // Phase 2: Execution (parallel by default)
  execution: {
    capability: 'Parallel tool calls',
    limitation: 'No conditional branching',
    pattern: 'Flatten conditional logic'
  }
};

// Production: Tool definition for Gemini
const geminiTools = {
  // Static tool declaration (no dynamic loading)
  tools: [
    {
      name: 'search',
      description: 'Search web for information',
      parameters: {
        type: 'object',
        properties: {
          query: { type: 'string' },
          filters: { type: 'object' }
        }
      }
    },
    {
      name: 'compute',
      description: 'Execute calculations',
      parameters: {
        type: 'object',
        properties: {
          expression: { type: 'string' },
          variables: { type: 'object' }
        }
      }
    }
  ],

  // Gemini-specific: tool use hints
  toolConfig: {
    functionCallingMode: 'AUTO',  // or 'ANY', 'NONE'
    allowedFunctions: ['search', 'compute'],
    parallelExecution: true
  }
};

// Comparison with other models
class AgenticComparison {
  // Claude with MCP
  async claudePattern(task) {
    // Dynamic tool loading via MCP
    const tools = await mcp.discoverTools(task);
    // Sequential execution with state
    return await claude.execute(task, tools);
  }

  // GPT with function calling
  async gptPattern(task) {
    // Conditional branching supported
    const result = await gpt.callFunction('analyze', task);
    if (result.needsMore) {
      return await gpt.callFunction('deepDive', result);
    }
    return result;
  }

  // Gemini 3 Pro pattern
  async geminiPattern(task) {
    // All tools declared upfront
    // Parallel execution, no branching
    const calls = await gemini.generateToolCalls(task, geminiTools);

    // Execute all in parallel
    const results = await Promise.all(
      calls.map(call => this.executeToolCall(call))
    );

    // Single synthesis pass
    return await gemini.synthesize(results);
  }
}

// Cost optimization strategies
class GeminiCostOptimizer {
  constructor() {
    this.pricePerMillion = {
      input: 2,
      output: 12,
      cachedInput: 0.5,  // 75% discount
      batchInput: 1       // 50% discount
    };
  }

  // Strategy 1: Context caching for repeated calls
  async cachedStrategy(baseContext, queries) {
    // Cache large context once
    const cacheToken = await gemini.cacheContext(baseContext);

    const results = [];
    for (const query of queries) {
      // Each call references cached context
      const result = await gemini.generate({
        cachedContext: cacheToken,
        prompt: query,
        maxTokens: 1000
      });
      results.push(result);
    }

    // Cost: 1x full context + N x cached price
    const cost = this.calculateCachedCost(baseContext, queries);
    return { results, cost };
  }

  // Strategy 2: Batching for throughput
  async batchStrategy(requests) {
    // Group into batches of 100
    const batches = chunk(requests, 100);

    const results = await Promise.all(
      batches.map(batch =>
        gemini.batchGenerate(batch, {
          timeout: 300000  // 5 min for batch
        })
      )
    );

    // 50% discount on input tokens
    const cost = this.calculateBatchCost(requests);
    return { results: results.flat(), cost };
  }

  // Strategy 3: Adaptive context sizing
  async adaptiveStrategy(content, importance) {
    const strategy = importance > 0.8
      ? 'full'      // Use all 1M tokens
      : importance > 0.5
      ? 'medium'    // Cap at 500K
      : 'minimal';  // Cap at 128K

    const truncated = this.truncateByStrategy(content, strategy);

    // Adjust max output based on input size
    const maxOutput = Math.min(
      100_000,
      1_000_000 - truncated.tokens
    );

    return await gemini.generate({
      prompt: truncated.content,
      maxTokens: maxOutput
    });
  }

  calculateCost(inputTokens, outputTokens, cached = false) {
    const inputCost = cached
      ? inputTokens * this.pricePerMillion.cachedInput / 1_000_000
      : inputTokens * this.pricePerMillion.input / 1_000_000;

    const outputCost = outputTokens * this.pricePerMillion.output / 1_000_000;

    return { inputCost, outputCost, total: inputCost + outputCost };
  }
}

// Latency patterns at different scales
const latencyProfile = {
  // First token latency (TTFT)
  firstToken: {
    '0-128K': 1.2,      // seconds
    '128K-512K': 2.8,
    '512K-1M': 5.4,
    formula: 'ttft = 1.2 * Math.pow(tokens/128000, 0.6)'
  },

  // Tokens per second after first
  throughput: {
    '0-128K': 85,       // tokens/sec
    '128K-512K': 62,
    '512K-1M': 41,
    degradation: 'linear after 128K'
  },

  // Total generation time
  totalTime(inputTokens, outputTokens) {
    const ttft = 1.2 * Math.pow(inputTokens/128000, 0.6);
    const tps = inputTokens > 512000 ? 41
               : inputTokens > 128000 ? 62
               : 85;

    return ttft + (outputTokens / tps);
  }
};

// Production latency management
class LatencyManager {
  async generateWithTimeout(prompt, config) {
    const inputTokens = await countTokens(prompt);
    const expectedLatency = latencyProfile.totalTime(
      inputTokens,
      config.maxTokens
    );

    // Add 20% buffer
    const timeout = expectedLatency * 1200;

    return Promise.race([
      gemini.generate(prompt, config),
      this.timeout(timeout)
    ]);
  }

  // Streaming for better UX
  async* streamGenerate(prompt, config) {
    const stream = await gemini.streamGenerate(prompt, config);

    let tokenCount = 0;
    let lastChunk = Date.now();

    for await (const chunk of stream) {
      tokenCount += chunk.tokens;
      const elapsed = Date.now() - lastChunk;

      // Detect stalling (>5s between chunks)
      if (elapsed > 5000) {
        console.warn('Stream stalled, possible timeout');
      }

      yield chunk;
      lastChunk = Date.now();
    }
  }
}

// Platform comparison for production
const platformComparison = {
  geminiAPI: {
    pros: [
      'Simple integration',
      'No GCP dependency',
      'Global availability',
      'Faster updates'
    ],
    cons: [
      'Limited quotas',
      'No private endpoints',
      'Basic monitoring',
      'No SLA guarantees'
    ],
    useWhen: [
      'Prototyping',
      'Small scale (<1M tokens/day)',
      'Multi-cloud architecture',
      'Simple use cases'
    ]
  },

  vertexAI: {
    pros: [
      'Enterprise SLA',
      'Private endpoints',
      'Model garden access',
      'Advanced monitoring',
      'Fine-tuning support'
    ],
    cons: [
      'GCP lock-in',
      'Complex setup',
      'Higher base cost',
      'Slower feature rollout'
    ],
    useWhen: [
      'Production scale',
      'Compliance requirements',
      'Need other GCP services',
      'Custom model training'
    ]
  }
};

// Production setup for Vertex AI
class VertexGeminiClient {
  constructor(projectId, location = 'us-central1') {
    this.endpoint = `${location}-aiplatform.googleapis.com`;
    this.model = `projects/${projectId}/locations/${location}/models/gemini-3-pro`;

    // Private endpoint for VPC
    if (process.env.USE_PRIVATE_ENDPOINT) {
      this.endpoint = `${location}-aiplatform.private.googleapis.com`;
    }
  }

  async generate(prompt, config) {
    const request = {
      instances: [{ prompt }],
      parameters: {
        temperature: config.temperature ?? 0.7,
        maxOutputTokens: config.maxTokens ?? 2048,
        topK: config.topK ?? 40,
        topP: config.topP ?? 0.95
      }
    };

    // Vertex-specific: request metadata
    const metadata = {
      model: this.model,
      monitoring: {
        displayName: config.operationName,
        userMetadata: config.metadata
      }
    };

    return await this.predict(request, metadata);
  }

  // Vertex-exclusive: batch prediction
  async batchPredict(inputs, outputGcsPath) {
    const job = {
      displayName: 'gemini-batch-' + Date.now(),
      model: this.model,
      inputConfig: {
        instancesFormat: 'jsonl',
        gcsSource: { uris: inputs }
      },
      outputConfig: {
        predictionsFormat: 'jsonl',
        gcsDestination: { outputUriPrefix: outputGcsPath }
      },
      // Vertex-specific: machine type selection
      dedicatedResources: {
        machineSpec: {
          machineType: 'n1-standard-32',
          acceleratorType: 'NVIDIA_TESLA_V100',
          acceleratorCount: 4
        }
      }
    };

    return await this.createBatchPredictionJob(job);
  }
}

// Decision matrix for model selection
const modelSelection = {
  useGemini3Pro: {
    when: [
      'Need 500K+ token context',
      'Multimodal (especially video)',
      'Parallel tool execution',
      'Batch processing at scale',
      'GCP ecosystem integration'
    ],
    sweetSpots: [
      'Document analysis with images/tables',
      'Video understanding tasks',
      'Large codebase analysis',
      'Multi-document synthesis'
    ]
  },

  useClaudeOpus: {
    when: [
      'Need highest reasoning quality',
      'Complex multi-turn dialogue',
      'Dynamic tool discovery (MCP)',
      'Nuanced writing tasks'
    ]
  },

  useGPT4: {
    when: [
      'Need branching logic',
      'Established OpenAI tooling',
      'Function calling workflows',
      'JSON mode requirements'
    ]
  }
};

// Production decision logic
function selectModel(task) {
  const factors = {
    contextSize: getContextSize(task),
    hasMultimodal: checkMultimodal(task),
    needsBranching: checkBranching(task),
    parallelizable: checkParallelizable(task)
  };

  if (factors.contextSize > 500_000 || factors.hasMultimodal) {
    return 'gemini-3-pro';
  }

  if (factors.needsBranching || !factors.parallelizable) {
    return 'gpt-4-turbo';
  }

  // Default to Claude for quality
  return 'claude-3-opus';
}