Gemini Stream Generate Content

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI({
  apiKey: process.env.GEMINI_API_KEY,
  httpOptions: {
    baseUrl: 'https://www.llmadaptive.uk/api/v1beta'
  }
});

const stream = await ai.models.generateContentStream({
  model: 'gemini-2.5-flash',
  contents: [
    {
      role: 'user',
      parts: [
        { text: 'Write a creative story about space exploration' }
      ]
    }
  ],
  config: {
    temperature: 0.9,
    maxOutputTokens: 2048
  }
});

// Process stream chunks
for await (const chunk of stream) {
  const text = chunk.candidates[0].content.parts[0].text;
  process.stdout.write(text);

  // Check for final chunk with usage metadata
  if (chunk.usageMetadata) {
    console.log('\n\nTokens used:', chunk.usageMetadata.totalTokenCount);
    console.log('Provider:', chunk.provider);
    console.log('Cache tier:', chunk.usageMetadata.cache_tier);
  }
}

import { GoogleGenAI } from '@google/genai';
import { useState } from 'react';

function StreamingChat() {
  const [response, setResponse] = useState('');
  const [isStreaming, setIsStreaming] = useState(false);

  const ai = new GoogleGenAI({
    apiKey: process.env.NEXT_PUBLIC_GEMINI_API_KEY,
    httpOptions: {
      baseUrl: 'https://www.llmadaptive.uk/api/v1beta'
    }
  });

  async function handleSubmit(prompt: string) {
    setIsStreaming(true);
    setResponse('');

    try {
      const stream = await ai.models.generateContentStream({
        model: 'gemini-2.5-flash',
        contents: [
          {
            role: 'user',
            parts: [{ text: prompt }]
          }
        ]
      });

      for await (const chunk of stream) {
        const text = chunk.candidates[0].content.parts[0].text;
        setResponse(prev => prev + text);
      }
    } catch (error) {
      console.error('Streaming error:', error);
    } finally {
      setIsStreaming(false);
    }
  }

  return (
    <div>
      <textarea
        disabled={isStreaming}
        onChange={(e) => handleSubmit(e.target.value)}
      />
      <div className="response">
        {response}
        {isStreaming && <span className="cursor">▊</span>}
      </div>
    </div>
  );
}

const conversationHistory = [
  {
    role: 'user',
    parts: [{ text: 'Tell me about the solar system' }]
  },
  {
    role: 'model',
    parts: [{ text: 'The solar system consists of...' }]
  },
  {
    role: 'user',
    parts: [{ text: 'What about Mars specifically?' }]
  }
];

const stream = await ai.models.generateContentStream({
  model: 'gemini-2.5-pro',
  contents: conversationHistory
});

for await (const chunk of stream) {
  // Process chunk
}

const stream = await ai.models.generateContentStream({
  model: 'gemini-2.5-flash',
  contents: [
    {
      role: 'user',
      parts: [{ text: 'Generate a Python web scraper' }]
    }
  ],
  config: {
    temperature: 0.3,
    maxOutputTokens: 3000
  },
  // Adaptive-specific features
  semantic_cache: {
    enabled: true,
    similarity_threshold: 0.95
  },
  fallback: {
    enabled: true,
    max_retries: 3
  },
  model_router: {
    cost_optimization: true,
    fallback_models: ['claude-3-5-haiku-20241022', 'gpt-4o-mini']
  }
});

let fullResponse = '';
for await (const chunk of stream) {
  const text = chunk.candidates[0].content.parts[0].text;
  fullResponse += text;

  // Update UI progressively
  updateUI(fullResponse);

  // Log metadata from final chunk
  if (chunk.usageMetadata) {
    console.log('Cache hit:', chunk.usageMetadata.cache_tier !== 'none');
    console.log('Provider used:', chunk.provider);
  }
}