Stream Mode: Concise vs Full

import Perplexity from '@perplexity-ai/perplexity_ai';

const client = new Perplexity();

const stream = await client.chat.completions.create({
  model: "sonar-pro",
  messages: [{ role: "user", content: "What's the weather in Seattle?" }],
  stream: true,
  stream_mode: "concise"
});

for await (const chunk of stream) {
  console.log(`Chunk type: ${chunk.object}`);
  if (chunk.choices[0]?.delta?.content) {
    process.stdout.write((chunk.choices[0]?.delta?.content ?? '') as string);
  }
}

curl -X POST "https://api.perplexity.ai/v1/sonar" \
  -H "Authorization: Bearer $PERPLEXITY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "sonar-pro",
    "messages": [{"role": "user", "content": "What is the weather in Seattle?"}],
    "stream": true,
    "stream_mode": "concise"
  }'

def handle_reasoning_chunk(chunk):
    """Process reasoning stage updates"""
    if chunk.object == "chat.reasoning":
        delta = chunk.choices[0].delta

        if hasattr(delta, 'reasoning_steps'):
            for step in delta.reasoning_steps:
                print(f"\n[Reasoning] {step.thought}")

                if step.type == "web_search":
                    keywords = step.web_search.search_keywords
                    print(f"[Search] Keywords: {', '.join(keywords)}")

function handleReasoningChunk(chunk: any) {
  if (chunk.object === "chat.reasoning") {
    const delta = chunk.choices[0].delta;

    if (delta.reasoning_steps) {
      for (const step of delta.reasoning_steps) {
        console.log(`\n[Reasoning] ${step.thought}`);

        if (step.type === "web_search") {
          const keywords = step.web_search.search_keywords;
          console.log(`[Search] Keywords: ${keywords.join(', ')}`);
        }
      }
    }
  }
}

def handle_reasoning_done(chunk):
    """Process end of reasoning stage"""
    if chunk.object == "chat.reasoning.done":
        print("\n[Reasoning Complete]")

        # Access all search results
        if hasattr(chunk, 'search_results'):
            print(f"Found {len(chunk.search_results)} sources")
            for result in chunk.search_results[:3]:
                print(f"  • {result['title']}")

        # Access image results
        if hasattr(chunk, 'images'):
            print(f"Found {len(chunk.images)} images")

        # Partial usage stats available
        if hasattr(chunk, 'usage'):
            print(f"Tokens used so far: {chunk.usage.total_tokens}")

function handleReasoningDone(chunk: any) {
  if (chunk.object === "chat.reasoning.done") {
    console.log("\n[Reasoning Complete]");

    // Access all search results
    if (chunk.search_results) {
      console.log(`Found ${chunk.search_results.length} sources`);
      chunk.search_results.slice(0, 3).forEach((result: any) => {
        console.log(`  • ${result.title}`);
      });
    }

    // Access image results
    if (chunk.images) {
      console.log(`Found ${chunk.images.length} images`);
    }

    // Partial usage stats available
    if (chunk.usage) {
      console.log(`Tokens used so far: ${chunk.usage.total_tokens}`);
    }
  }
}

def handle_completion_chunk(chunk):
    """Process content generation updates"""
    if chunk.object == "chat.completion.chunk":
        delta = chunk.choices[0].delta

        if hasattr(delta, 'content') and delta.content:
            # Stream content to user
            print(delta.content, end='', flush=True)
            return delta.content

    return ""

function handleCompletionChunk(chunk: any): string {
  if (chunk.object === "chat.completion.chunk") {
    const delta = chunk.choices[0]?.delta;

    if (delta?.content) {
      // Stream content to user
      process.stdout.write(delta.content);
      return delta.content;
    }
  }

  return "";
}

def handle_completion_done(chunk):
    """Process stream completion"""
    if chunk.object == "chat.completion.done":
        print("\n\n[Stream Complete]")

        # Final aggregated message
        full_message = chunk.choices[0].message.content

        # Final search results
        if hasattr(chunk, 'search_results'):
            print(f"\nFinal sources: {len(chunk.search_results)}")

        # Complete usage and cost information
        if hasattr(chunk, 'usage'):
            usage = chunk.usage
            print(f"\nTokens: {usage.total_tokens}")

            if hasattr(usage, 'cost'):
                print(f"Cost: ${usage.cost.total_cost:.4f}")

        return {
            'content': full_message,
            'search_results': getattr(chunk, 'search_results', []),
            'images': getattr(chunk, 'images', []),
            'usage': getattr(chunk, 'usage', None)
        }

function handleCompletionDone(chunk: any) {
  if (chunk.object === "chat.completion.done") {
    console.log("\n\n[Stream Complete]");

    // Final aggregated message
    const fullMessage = chunk.choices[0].message.content;

    // Final search results
    if (chunk.search_results) {
      console.log(`\nFinal sources: ${chunk.search_results.length}`);
    }

    // Complete usage and cost information
    if (chunk.usage) {
      console.log(`\nTokens: ${chunk.usage.total_tokens}`);

      if (chunk.usage.cost) {
        console.log(`Cost: $${chunk.usage.cost.total_cost.toFixed(4)}`);
      }
    }

    return {
      content: fullMessage,
      search_results: chunk.search_results || [],
      images: chunk.images || [],
      usage: chunk.usage || null
    };
  }
}

import Perplexity from '@perplexity-ai/perplexity_ai';

interface StreamResult {
  content: string;
  reasoning_steps: any[];
  search_results: any[];
  images: any[];
  usage: any;
}

class ConciseStreamHandler {
  private content: string = "";
  private reasoning_steps: any[] = [];
  private search_results: any[] = [];
  private images: any[] = [];
  private usage: any = null;

  async streamQuery(query: string, model: string = "sonar-pro"): Promise<StreamResult> {
    const client = new Perplexity();

    const stream = await client.chat.completions.create({
      model,
      messages: [{ role: "user", content: query }],
      stream: true,
      stream_mode: "concise"
    });

    for await (const chunk of stream) {
      this.processChunk(chunk);
    }

    return this.getResult();
  }

  private processChunk(chunk: any) {
    const chunkType = chunk.object;

    switch (chunkType) {
      case "chat.reasoning":
        this.handleReasoning(chunk);
        break;
      case "chat.reasoning.done":
        this.handleReasoningDone(chunk);
        break;
      case "chat.completion.chunk":
        this.handleContent(chunk);
        break;
      case "chat.completion.done":
        this.handleDone(chunk);
        break;
    }
  }

  private handleReasoning(chunk: any) {
    const delta = chunk.choices[0].delta;

    if (delta.reasoning_steps) {
      for (const step of delta.reasoning_steps) {
        this.reasoning_steps.push(step);
        console.log(`💭 ${step.thought}`);
      }
    }
  }

  private handleReasoningDone(chunk: any) {
    if (chunk.search_results) {
      this.search_results = chunk.search_results;
      console.log(`\n🔍 Found ${this.search_results.length} sources`);
    }

    if (chunk.images) {
      this.images = chunk.images;
      console.log(`🖼️  Found ${this.images.length} images`);
    }

    console.log("\n📝 Generating response...\n");
  }

  private handleContent(chunk: any) {
    const delta = chunk.choices[0]?.delta;

    if (delta?.content) {
      this.content += delta.content;
      process.stdout.write(delta.content);
    }
  }

  private handleDone(chunk: any) {
    if (chunk.usage) {
      this.usage = chunk.usage;
      console.log(`\n\n✅ Complete | Tokens: ${this.usage.total_tokens}`);

      if (this.usage.cost) {
        console.log(`💰 Cost: $${this.usage.cost.total_cost.toFixed(4)}`);
      }
    }
  }

  private getResult(): StreamResult {
    return {
      content: this.content,
      reasoning_steps: this.reasoning_steps,
      search_results: this.search_results,
      images: this.images,
      usage: this.usage
    };
  }
}

// Usage
const handler = new ConciseStreamHandler();
const result = await handler.streamQuery("What's the latest news in AI?");

console.log(`\n\nFinal content length: ${result.content.length} characters`);
console.log(`Sources used: ${result.search_results.length}`);

import os
import requests
import json

def stream_concise_mode(query: str):
    """Handle concise streaming with raw HTTP"""
    url = "https://api.perplexity.ai/v1/sonar"
    headers = {
        "Authorization": f"Bearer {os.environ.get('PERPLEXITY_API_KEY')}",
        "Content-Type": "application/json"
    }
    payload = {
        "model": "sonar-pro",
        "messages": [{"role": "user", "content": query}],
        "stream": True,
        "stream_mode": "concise"
    }

    response = requests.post(url, headers=headers, json=payload, stream=True)

    content = ""
    search_results = []
    usage = None

    for line in response.iter_lines():
        if line:
            line = line.decode('utf-8')
            if line.startswith('data: '):
                data_str = line[6:]
                if data_str == '[DONE]':
                    break

                try:
                    chunk = json.loads(data_str)
                    chunk_type = chunk.get('object')

                    if chunk_type == 'chat.reasoning':
                        # Handle reasoning
                        delta = chunk['choices'][0]['delta']
                        if 'reasoning_steps' in delta:
                            for step in delta['reasoning_steps']:
                                print(f"💭 {step['thought']}")

                    elif chunk_type == 'chat.reasoning.done':
                        # Handle reasoning completion
                        if 'search_results' in chunk:
                            search_results = chunk['search_results']
                            print(f"\n🔍 Found {len(search_results)} sources\n")

                    elif chunk_type == 'chat.completion.chunk':
                        # Handle content
                        delta = chunk['choices'][0]['delta']
                        if 'content' in delta and delta['content']:
                            content += delta['content']
                            print(delta['content'], end='', flush=True)

                    elif chunk_type == 'chat.completion.done':
                        # Handle completion
                        if 'usage' in chunk:
                            usage = chunk['usage']
                            print(f"\n\n✅ Tokens: {usage['total_tokens']}")

                except json.JSONDecodeError:
                    continue

    return {
        'content': content,
        'search_results': search_results,
        'usage': usage
    }

# Usage
result = stream_concise_mode("What's the latest news in AI?")

from perplexity import Perplexity

client = Perplexity()

stream = client.chat.completions.create(
    model="sonar-pro",
    messages=[{"role": "user", "content": "What's the weather?"}],
    stream=True,
    stream_mode="concise"  # Enable concise mode
)

for chunk in stream:
    # Multiple chunk types - route appropriately
    if chunk.object == "chat.reasoning":
        # New: Handle reasoning steps
        if chunk.choices[0].delta.reasoning_steps:
            print("Reasoning in progress...")

    elif chunk.object == "chat.reasoning.done":
        # New: Reasoning complete, search results available
        if hasattr(chunk, 'search_results'):
            print(f"Sources: {len(chunk.search_results)}")

    elif chunk.object == "chat.completion.chunk":
        # Content chunks (similar to full mode)
        if chunk.choices[0].delta.content:
            print(chunk.choices[0].delta.content, end="")

    elif chunk.object == "chat.completion.done":
        # Final chunk with complete metadata
        print(f"\nTotal tokens: {chunk.usage.total_tokens}")