Deep Research APIs

import requests
import json
 
def stream_research_progress(thread_id):
    url = f"https://chordian-core.chordian.ai/research/stream/{thread_id}"
    
    with requests.get(url, stream=True) as response:
        for line in response.iter_lines():
            if line:
                decoded_line = line.decode('utf-8')
                
                # Parse SSE format
                if decoded_line.startswith('data: '):
                    data_str = decoded_line[6:]  # Remove 'data: ' prefix
                    try:
                        data = json.loads(data_str)
                        
                        if data.get('event') == 'clarification':
                            print(f"Clarification needed: {data.get('question')}")
                        elif data.get('event') == 'progress':
                            print(f"Progress: {data}")
                        elif data.get('event') == 'complete':
                            print(f"Research complete! {data.get('final_report')}")
                            break
                    except json.JSONDecodeError:
                        print(f"Received: {decoded_line}")
 
# Usage
stream_research_progress("your-thread-id")

const eventSource = new EventSource(
  `https://chordian-core.chordian.ai/research/stream/${threadId}`
);
 
eventSource.addEventListener('clarification', (event) => {
  const data = JSON.parse(event.data);
  console.log('Clarification needed:', data.question);
});
 
eventSource.addEventListener('progress', (event) => {
  const data = JSON.parse(event.data);
  console.log('Progress:', data);
});
 
eventSource.addEventListener('complete', (event) => {
  const data = JSON.parse(event.data);
  console.log('Research complete!', data.final_report);
  eventSource.close();
});
 
eventSource.onerror = (error) => {
  console.error('SSE error:', error);
  eventSource.close();
};

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.sse.EventSource;
import okhttp3.sse.EventSourceListener;
import okhttp3.sse.EventSources;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
 
public class ResearchStreamExample {
    public static void streamResearchProgress(String threadId) {
        OkHttpClient client = new OkHttpClient();
        
        Request request = new Request.Builder()
            .url("https://chordian-core.chordian.ai/research/stream/" + threadId)
            .build();
        
        EventSourceListener listener = new EventSourceListener() {
            @Override
            public void onEvent(EventSource eventSource, String id, 
                               String type, String data) {
                JsonObject jsonData = JsonParser.parseString(data)
                    .getAsJsonObject();
                
                switch (type) {
                    case "clarification":
                        System.out.println("Clarification needed: " + 
                            jsonData.get("question").getAsString());
                        break;
                    case "progress":
                        System.out.println("Progress: " + data);
                        break;
                    case "complete":
                        System.out.println("Research complete! " + 
                            jsonData.get("final_report").getAsString());
                        eventSource.cancel();
                        break;
                }
            }
            
            @Override
            public void onFailure(EventSource eventSource, Throwable t, 
                                 Response response) {
                System.err.println("SSE error: " + t.getMessage());
            }
        };
        
        EventSource eventSource = EventSources.createFactory(client)
            .newEventSource(request, listener);
    }
}

using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;
using Newtonsoft.Json.Linq;
 
public class ResearchStreamExample
{
    public static async Task StreamResearchProgress(string threadId)
    {
        using var client = new HttpClient();
        client.Timeout = TimeSpan.FromMinutes(10);
        
        var url = $"https://chordian-core.chordian.ai/research/stream/{threadId}";
        
        using var response = await client.GetAsync(url, 
            HttpCompletionOption.ResponseHeadersRead);
        using var stream = await response.Content.ReadAsStreamAsync();
        using var reader = new StreamReader(stream);
        
        while (!reader.EndOfStream)
        {
            var line = await reader.ReadLineAsync();
            
            if (line?.StartsWith("data: ") == true)
            {
                var dataStr = line.Substring(6); // Remove "data: " prefix
                
                try
                {
                    var data = JObject.Parse(dataStr);
                    var eventType = data["event"]?.ToString();
                    
                    switch (eventType)
                    {
                        case "clarification":
                            Console.WriteLine($"Clarification needed: {data["question"]}");
                            break;
                        case "progress":
                            Console.WriteLine($"Progress: {data}");
                            break;
                        case "complete":
                            Console.WriteLine($"Research complete! {data["final_report"]}");
                            return;
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Received: {line}");
                }
            }
        }
    }
}