Add OpenAI video generation and content retrieval support

docs/my-website/docs/completion/knowledgebase.md

@@ -412,6 +412,219 @@ This is sent to: `https://bedrock-agent-runtime.{aws_region}.amazonaws.com/knowl
 
 This process happens automatically whenever you include the `vector_store_ids` parameter in your request.
 
+## Accessing Search Results (Citations)
+
+When using vector stores, LiteLLM automatically returns search results in `provider_specific_fields`. This allows you to show users citations for the AI's response.
+
+### Key Concept
+
+Search results are always in: `response.choices[0].message.provider_specific_fields["search_results"]`
+
+For streaming: Results appear in the **final chunk** when `finish_reason == "stop"`
+
+### Non-Streaming Example
+
+
+**Non-Streaming Response with search results:**
+
+```json
+{
+  "id": "chatcmpl-abc123",
+  "choices": [{
+    "index": 0,
+    "message": {
+      "role": "assistant",
+      "content": "LiteLLM is a platform...",
+      "provider_specific_fields": {
+        "search_results": [{
+          "search_query": "What is litellm?",
+          "data": [{
+            "score": 0.95,
+            "content": [{"text": "...", "type": "text"}],
+            "filename": "litellm-docs.md",
+            "file_id": "doc-123"
+          }]
+        }]
+      }
+    },
+    "finish_reason": "stop"
+  }]
+}
+```
+
+<Tabs>
+<TabItem value="python-sdk" label="Python SDK">
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="http://localhost:4000",
+    api_key="your-litellm-api-key"
+)
+
+response = client.chat.completions.create(
+    model="claude-3-5-sonnet",
+    messages=[{"role": "user", "content": "What is litellm?"}],
+    tools=[{"type": "file_search", "vector_store_ids": ["T37J8R4WTM"]}]
+)
+
+# Get AI response
+print(response.choices[0].message.content)
+
+# Get search results (citations)
+search_results = response.choices[0].message.provider_specific_fields.get("search_results", [])
+
+for result_page in search_results:
+    for idx, item in enumerate(result_page['data'], 1):
+        print(f"[{idx}] {item.get('filename', 'Unknown')} (score: {item['score']:.2f})")
+```
+
+</TabItem>
+
+<TabItem value="typescript" label="TypeScript SDK">
+
+```typescript
+import OpenAI from 'openai';
+
+const client = new OpenAI({
+  baseURL: 'http://localhost:4000',
+  apiKey: process.env.LITELLM_API_KEY
+});
+
+const response = await client.chat.completions.create({
+  model: 'claude-3-5-sonnet',
+  messages: [{ role: 'user', content: 'What is litellm?' }],
+  tools: [{ type: 'file_search', vector_store_ids: ['T37J8R4WTM'] }]
+});
+
+// Get AI response
+console.log(response.choices[0].message.content);
+
+// Get search results (citations)
+const message = response.choices[0].message as any;
+const searchResults = message.provider_specific_fields?.search_results || [];
+
+searchResults.forEach((page: any) => {
+  page.data.forEach((item: any, idx: number) => {
+    console.log(`[${idx + 1}] ${item.filename || 'Unknown'} (${item.score.toFixed(2)})`);
+  });
+});
+```
+
+</TabItem>
+</Tabs>
+
+### Streaming Example
+
+**Streaming Response with search results (final chunk):**
+
+```json
+{
+  "id": "chatcmpl-abc123",
+  "choices": [{
+    "index": 0,
+    "delta": {
+      "provider_specific_fields": {
+        "search_results": [{
+          "search_query": "What is litellm?",
+          "data": [{
+            "score": 0.95,
+            "content": [{"text": "...", "type": "text"}],
+            "filename": "litellm-docs.md",
+            "file_id": "doc-123"
+          }]
+        }]
+      }
+    },
+    "finish_reason": "stop"
+  }]
+}
+```
+
+<Tabs>
+<TabItem value="python-sdk" label="Python SDK">
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="http://localhost:4000",
+    api_key="your-litellm-api-key"
+)
+
+stream = client.chat.completions.create(
+    model="claude-3-5-sonnet",
+    messages=[{"role": "user", "content": "What is litellm?"}],
+    tools=[{"type": "file_search", "vector_store_ids": ["T37J8R4WTM"]}],
+    stream=True
+)
+
+for chunk in stream:
+    # Stream content
+    if chunk.choices[0].delta.content:
+        print(chunk.choices[0].delta.content, end="", flush=True)
+
+    # Get citations in final chunk
+    if chunk.choices[0].finish_reason == "stop":
+        search_results = getattr(chunk.choices[0].delta, 'provider_specific_fields', {}).get('search_results', [])
+        if search_results:
+            print("\n\nSources:")
+            for page in search_results:
+                for idx, item in enumerate(page['data'], 1):
+                    print(f"  [{idx}] {item.get('filename', 'Unknown')} ({item['score']:.2f})")
+```
+
+</TabItem>
+
+<TabItem value="typescript" label="TypeScript SDK">
+
+```typescript
+import OpenAI from 'openai';
+
+const stream = await client.chat.completions.create({
+  model: 'claude-3-5-sonnet',
+  messages: [{ role: 'user', content: 'What is litellm?' }],
+  tools: [{ type: 'file_search', vector_store_ids: ['T37J8R4WTM'] }],
+  stream: true
+});
+
+for await (const chunk of stream) {
+  // Stream content
+  if (chunk.choices[0]?.delta?.content) {
+    process.stdout.write(chunk.choices[0].delta.content);
+  }
+
+  // Get citations in final chunk
+  if (chunk.choices[0]?.finish_reason === 'stop') {
+    const searchResults = (chunk.choices[0].delta as any).provider_specific_fields?.search_results || [];
+    if (searchResults.length > 0) {
+      console.log('\n\nSources:');
+      searchResults.forEach((page: any) => {
+        page.data.forEach((item: any, idx: number) => {
+          console.log(`  [${idx + 1}] ${item.filename || 'Unknown'} (${item.score.toFixed(2)})`);
+        });
+      });
+    }
+  }
+}
+```
+
+</TabItem>
+</Tabs>
+
+### Search Result Fields
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `search_query` | string | The query used to search the vector store |
+| `data` | array | Array of search results |
+| `data[].score` | float | Relevance score (0-1, higher is more relevant) |
+| `data[].content` | array | Content chunks with `text` and `type` |
+| `data[].filename` | string | Name of the source file (optional) |
+| `data[].file_id` | string | Identifier for the source file (optional) |
+| `data[].attributes` | object | Provider-specific metadata (optional) |
+
 ## API Reference
 
 ### LiteLLM Completion Knowledge Base Parameters

docs/my-website/docs/providers/bedrock_vector_store.md

@@ -138,7 +138,14 @@ print(response.choices[0].message.content)
 </Tabs>
 
 
-Futher Reading Vector Stores:
+## Accessing Search Results
+
+See how to access vector store search results in your response:
+- [Accessing Search Results (Non-Streaming & Streaming)](../completion/knowledgebase#accessing-search-results-citations)
+
+## Further Reading
+
+Vector Stores:
 - [Always on Vector Stores](https://docs.litellm.ai/docs/completion/knowledgebase#always-on-for-a-model)
 - [Listing available vector stores on litellm proxy](https://docs.litellm.ai/docs/completion/knowledgebase#listing-available-vector-stores)
 - [How LiteLLM Vector Stores Work](https://docs.litellm.ai/docs/completion/knowledgebase#how-it-works)

docs/my-website/docs/providers/openai.md

@@ -836,4 +836,10 @@ response = completion(
     model="gpt-5-pro", 
     messages=[{"role": "user", "content": "Solve this complex reasoning problem..."}]
 )
-```
+```
+
+## Video Generation
+
+LiteLLM supports OpenAI's video generation models including Sora.
+
+For detailed documentation on video generation, see [OpenAI Video Generation →](./openai/video_generation.md)

docs/my-website/docs/providers/openai/video_generation.md

@@ -0,0 +1,143 @@
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+# OpenAI Video Generation
+
+LiteLLM supports OpenAI's video generation models including Sora.
+
+## Quick Start
+
+### Required API Keys
+
+```python
+import os 
+os.environ["OPENAI_API_KEY"] = "your-api-key"
+```
+
+### Basic Usage
+
+```python
+from litellm import video_generation, video_retrieval
+import os
+
+os.environ["OPENAI_API_KEY"] = "your-api-key"
+
+# Generate a video
+response = video_generation(
+    prompt="A cat playing with a ball of yarn in a sunny garden",
+    model="sora-2",
+    seconds="8",
+    size="720x1280"
+)
+
+print(f"Video ID: {response.id}")
+print(f"Status: {response.status}")
+
+# Download video content when ready
+video_bytes = video_retrieval(
+    video_id=response.id,
+    model="sora-2"
+)
+
+# Save to file
+with open("generated_video.mp4", "wb") as f:
+    f.write(video_bytes)
+```
+
+## Supported Models
+
+| Model Name | Description | Max Duration | Supported Sizes |
+|------------|-------------|--------------|-----------------|
+| sora-2 | OpenAI's latest video generation model | 8 seconds | 720x1280, 1280x720 |
+
+## Video Generation Parameters
+
+- `prompt` (required): Text description of the desired video
+- `model` (optional): Model to use, defaults to "sora-2"
+- `seconds` (optional): Video duration in seconds (e.g., "8", "16")
+- `size` (optional): Video dimensions (e.g., "720x1280", "1280x720")
+- `input_reference` (optional): Reference image for video editing
+- `user` (optional): User identifier for tracking
+
+## Video Content Retrieval
+
+```python
+# Download video content
+video_bytes = video_retrieval(
+    video_id="video_1234567890",
+    model="sora-2"
+)
+
+# Save to file
+with open("video.mp4", "wb") as f:
+    f.write(video_bytes)
+```
+
+## Complete Workflow
+
+```python
+import litellm
+import time
+
+def generate_and_download_video(prompt):
+    # Step 1: Generate video
+    response = litellm.video_generation(
+        prompt=prompt,
+        model="sora-2",
+        seconds="8",
+        size="720x1280"
+    )
+
+    video_id = response.id
+    print(f"Video ID: {video_id}")
+
+    # Step 2: Wait for processing (in practice, poll status)
+    time.sleep(30)
+
+    # Step 3: Download video
+    video_bytes = litellm.video_retrieval(
+        video_id=video_id,
+        model="sora-2"
+    )
+
+    # Step 4: Save to file
+    with open(f"video_{video_id}.mp4", "wb") as f:
+        f.write(video_bytes)
+
+    return f"video_{video_id}.mp4"
+
+# Usage
+video_file = generate_and_download_video(
+    "A cat playing with a ball of yarn in a sunny garden"
+)
+```
+
+## Video Editing with Reference Images
+
+```python
+# Video editing with reference image
+response = litellm.video_generation(
+    prompt="Make the cat jump higher",
+    input_reference="path/to/image.jpg",  # Reference image
+    model="sora-2",
+    seconds="8"
+)
+
+print(f"Video ID: {response.id}")
+```
+
+## Error Handling
+
+```python
+from litellm.exceptions import BadRequestError, AuthenticationError
+
+try:
+    response = video_generation(
+        prompt="A cat playing with a ball of yarn",
+        model="sora-2"
+    )
+except AuthenticationError as e:
+    print(f"Authentication failed: {e}")
+except BadRequestError as e:
+    print(f"Bad request: {e}")
+```