📦 deps(thirdparty): update snapshots
This commit is contained in:
ci[bot]
@@ -0,0 +1,692 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Gemini Deep Research Skill - Execute autonomous multi-step research tasks.
|
||||
|
||||
Uses Google's Deep Research Agent for comprehensive, cited research reports.
|
||||
Research tasks take 2-10 minutes but produce detailed analysis.
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import asyncio
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
from typing import Any, AsyncIterator, Callable, Dict, List, Optional
|
||||
|
||||
try:
|
||||
import httpx
|
||||
except ImportError:
|
||||
print("Error: httpx not installed. Run: pip install httpx", file=sys.stderr)
|
||||
sys.exit(1)
|
||||
|
||||
try:
|
||||
from dotenv import load_dotenv
|
||||
load_dotenv()
|
||||
except ImportError:
|
||||
pass # dotenv is optional
|
||||
|
||||
|
||||
class DeepResearchError(Exception):
|
||||
"""Custom exception for Deep Research API errors."""
|
||||
pass
|
||||
|
||||
|
||||
class HistoryManager:
|
||||
"""Manage local research history cache."""
|
||||
|
||||
def __init__(self, cache_dir: Optional[str] = None):
|
||||
default_dir = os.path.expanduser("~/.cache/deep-research")
|
||||
self.cache_dir = Path(cache_dir or os.getenv("DEEP_RESEARCH_CACHE_DIR", default_dir))
|
||||
self.history_file = self.cache_dir / "history.json"
|
||||
self._ensure_cache_dir()
|
||||
|
||||
def _ensure_cache_dir(self):
|
||||
"""Create cache directory if it doesn't exist."""
|
||||
self.cache_dir.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
def _load_history(self) -> Dict:
|
||||
"""Load history from file."""
|
||||
if self.history_file.exists():
|
||||
try:
|
||||
return json.loads(self.history_file.read_text())
|
||||
except (json.JSONDecodeError, IOError):
|
||||
return {"interactions": []}
|
||||
return {"interactions": []}
|
||||
|
||||
def _save_history(self, history: Dict):
|
||||
"""Save history to file."""
|
||||
self.history_file.write_text(json.dumps(history, indent=2))
|
||||
|
||||
def add_interaction(self, interaction_id: str, query: str, status: str = "started"):
|
||||
"""Add or update an interaction in history."""
|
||||
history = self._load_history()
|
||||
|
||||
# Check if interaction already exists
|
||||
for item in history["interactions"]:
|
||||
if item["id"] == interaction_id:
|
||||
item["status"] = status
|
||||
item["updated_at"] = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
|
||||
self._save_history(history)
|
||||
return
|
||||
|
||||
# Add new interaction
|
||||
history["interactions"].insert(0, {
|
||||
"id": interaction_id,
|
||||
"query": query[:200] + "..." if len(query) > 200 else query,
|
||||
"started_at": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
|
||||
"status": status
|
||||
})
|
||||
|
||||
# Keep only last 50 interactions
|
||||
history["interactions"] = history["interactions"][:50]
|
||||
self._save_history(history)
|
||||
|
||||
def update_status(self, interaction_id: str, status: str):
|
||||
"""Update the status of an interaction."""
|
||||
history = self._load_history()
|
||||
for item in history["interactions"]:
|
||||
if item["id"] == interaction_id:
|
||||
item["status"] = status
|
||||
item["updated_at"] = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
|
||||
if status == "completed":
|
||||
item["completed_at"] = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
|
||||
break
|
||||
self._save_history(history)
|
||||
|
||||
def get_recent(self, limit: int = 10) -> List[Dict]:
|
||||
"""Get recent interactions."""
|
||||
history = self._load_history()
|
||||
return history["interactions"][:limit]
|
||||
|
||||
def get_interaction(self, interaction_id: str) -> Optional[Dict]:
|
||||
"""Get a specific interaction by ID."""
|
||||
history = self._load_history()
|
||||
for item in history["interactions"]:
|
||||
if item["id"] == interaction_id:
|
||||
return item
|
||||
return None
|
||||
|
||||
|
||||
class DeepResearchClient:
|
||||
"""Client for Gemini Deep Research API."""
|
||||
|
||||
BASE_URL = "https://generativelanguage.googleapis.com/v1beta/interactions"
|
||||
AGENT = "deep-research-pro-preview-12-2025"
|
||||
|
||||
def __init__(self, api_key: Optional[str] = None):
|
||||
self.api_key = api_key or os.getenv("GEMINI_API_KEY")
|
||||
if not self.api_key:
|
||||
raise DeepResearchError(
|
||||
"GEMINI_API_KEY not set. Set it in .env or environment variables."
|
||||
)
|
||||
self._client: Optional[httpx.AsyncClient] = None
|
||||
self.timeout = int(os.getenv("DEEP_RESEARCH_TIMEOUT", "600"))
|
||||
self.poll_interval = int(os.getenv("DEEP_RESEARCH_POLL_INTERVAL", "10"))
|
||||
self.history = HistoryManager()
|
||||
|
||||
async def _get_client(self) -> httpx.AsyncClient:
|
||||
"""Get or create the HTTP client."""
|
||||
if self._client is None or self._client.is_closed:
|
||||
self._client = httpx.AsyncClient(timeout=60.0)
|
||||
return self._client
|
||||
|
||||
async def close(self):
|
||||
"""Close the HTTP client."""
|
||||
if self._client and not self._client.is_closed:
|
||||
await self._client.aclose()
|
||||
|
||||
def _build_prompt(self, query: str, format_spec: Optional[str] = None) -> str:
|
||||
"""Build the research prompt with optional format specification."""
|
||||
prompt = query
|
||||
|
||||
if format_spec:
|
||||
prompt += f"\n\nFormat the output with the following structure:\n{format_spec}"
|
||||
|
||||
return prompt
|
||||
|
||||
async def start_research(
|
||||
self,
|
||||
query: str,
|
||||
format_spec: Optional[str] = None,
|
||||
previous_interaction_id: Optional[str] = None
|
||||
) -> str:
|
||||
"""
|
||||
Start a research task.
|
||||
|
||||
Args:
|
||||
query: The research query
|
||||
format_spec: Optional output format specification
|
||||
previous_interaction_id: Optional ID to continue from previous research
|
||||
|
||||
Returns:
|
||||
Interaction ID for polling results
|
||||
"""
|
||||
prompt = self._build_prompt(query, format_spec)
|
||||
client = await self._get_client()
|
||||
|
||||
payload: Dict[str, Any] = {
|
||||
"input": prompt,
|
||||
"agent": self.AGENT,
|
||||
"background": True
|
||||
}
|
||||
|
||||
if previous_interaction_id:
|
||||
payload["previous_interaction_id"] = previous_interaction_id
|
||||
|
||||
try:
|
||||
response = await client.post(
|
||||
self.BASE_URL,
|
||||
headers={
|
||||
"Content-Type": "application/json",
|
||||
"x-goog-api-key": str(self.api_key)
|
||||
},
|
||||
json=payload
|
||||
)
|
||||
|
||||
if response.status_code != 200:
|
||||
error_text = response.text
|
||||
raise DeepResearchError(f"API error {response.status_code}: {error_text}")
|
||||
|
||||
data = response.json()
|
||||
interaction_id = data.get("id") or data.get("name", "").split("/")[-1]
|
||||
|
||||
if not interaction_id:
|
||||
raise DeepResearchError("No interaction ID returned from API")
|
||||
|
||||
# Track in history
|
||||
self.history.add_interaction(interaction_id, query, "started")
|
||||
|
||||
return interaction_id
|
||||
|
||||
except httpx.HTTPError as e:
|
||||
raise DeepResearchError(f"HTTP error: {e}")
|
||||
|
||||
async def get_status(self, interaction_id: str) -> Dict[str, Any]:
|
||||
"""
|
||||
Get the status of a research task.
|
||||
|
||||
Returns:
|
||||
Dict with 'status' and optionally 'result' or 'error'
|
||||
"""
|
||||
client = await self._get_client()
|
||||
|
||||
try:
|
||||
response = await client.get(
|
||||
f"{self.BASE_URL}/{interaction_id}",
|
||||
headers={"x-goog-api-key": str(self.api_key)},
|
||||
timeout=30.0
|
||||
)
|
||||
|
||||
if response.status_code != 200:
|
||||
return {"status": "error", "error": f"API error: {response.status_code}"}
|
||||
|
||||
data = response.json()
|
||||
status = data.get("status", "unknown")
|
||||
|
||||
if status == "completed":
|
||||
outputs = data.get("outputs", [])
|
||||
if outputs:
|
||||
text = outputs[-1].get("text", "")
|
||||
return {"status": "completed", "result": text, "raw": data}
|
||||
return {"status": "completed", "result": None, "raw": data}
|
||||
elif status == "failed":
|
||||
return {"status": "failed", "error": data.get("error", "Unknown error")}
|
||||
else:
|
||||
return {"status": status, "raw": data}
|
||||
|
||||
except httpx.HTTPError as e:
|
||||
return {"status": "error", "error": str(e)}
|
||||
|
||||
async def wait_for_completion(
|
||||
self,
|
||||
interaction_id: str,
|
||||
timeout: Optional[int] = None,
|
||||
poll_interval: Optional[int] = None,
|
||||
progress_callback: Optional[Callable[[int, float, str], None]] = None
|
||||
) -> Dict[str, Any]:
|
||||
"""
|
||||
Wait for research to complete with polling.
|
||||
|
||||
Args:
|
||||
interaction_id: The interaction ID to poll
|
||||
timeout: Maximum wait time in seconds
|
||||
poll_interval: Seconds between polls
|
||||
progress_callback: Optional callback for progress updates
|
||||
|
||||
Returns:
|
||||
Dict with research result or error
|
||||
"""
|
||||
timeout = timeout or self.timeout
|
||||
poll_interval = poll_interval or self.poll_interval
|
||||
start_time = asyncio.get_event_loop().time()
|
||||
poll_count = 0
|
||||
|
||||
while True:
|
||||
elapsed = asyncio.get_event_loop().time() - start_time
|
||||
if elapsed > timeout:
|
||||
self.history.update_status(interaction_id, "timeout")
|
||||
return {"status": "timeout", "error": f"Research timed out after {timeout}s"}
|
||||
|
||||
result = await self.get_status(interaction_id)
|
||||
poll_count += 1
|
||||
|
||||
if progress_callback:
|
||||
progress_callback(poll_count, elapsed, result.get("status", "unknown"))
|
||||
|
||||
if result["status"] == "completed":
|
||||
self.history.update_status(interaction_id, "completed")
|
||||
return result
|
||||
elif result["status"] in ["failed", "error"]:
|
||||
self.history.update_status(interaction_id, "failed")
|
||||
return result
|
||||
|
||||
await asyncio.sleep(poll_interval)
|
||||
|
||||
async def stream_research(
|
||||
self,
|
||||
query: str,
|
||||
format_spec: Optional[str] = None
|
||||
) -> AsyncIterator[Dict[str, Any]]:
|
||||
"""
|
||||
Stream research progress in real-time.
|
||||
|
||||
Yields:
|
||||
Dict with event type and content
|
||||
"""
|
||||
prompt = self._build_prompt(query, format_spec)
|
||||
client = await self._get_client()
|
||||
|
||||
try:
|
||||
async with client.stream(
|
||||
"POST",
|
||||
f"{self.BASE_URL}?alt=sse",
|
||||
headers={
|
||||
"Content-Type": "application/json",
|
||||
"x-goog-api-key": str(self.api_key)
|
||||
},
|
||||
json={
|
||||
"input": prompt,
|
||||
"agent": self.AGENT,
|
||||
"background": True,
|
||||
"stream": True,
|
||||
"agent_config": {
|
||||
"type": "deep-research",
|
||||
"thinking_summaries": "auto"
|
||||
}
|
||||
},
|
||||
timeout=None # No timeout for streaming
|
||||
) as response:
|
||||
interaction_id = None
|
||||
buffer = ""
|
||||
|
||||
async for chunk in response.aiter_text():
|
||||
buffer += chunk
|
||||
|
||||
# Parse SSE events
|
||||
while "\n\n" in buffer:
|
||||
event_str, buffer = buffer.split("\n\n", 1)
|
||||
|
||||
if not event_str.strip():
|
||||
continue
|
||||
|
||||
# Parse SSE format
|
||||
data_line = None
|
||||
for line in event_str.split("\n"):
|
||||
if line.startswith("data: "):
|
||||
data_line = line[6:]
|
||||
break
|
||||
|
||||
if not data_line:
|
||||
continue
|
||||
|
||||
try:
|
||||
event = json.loads(data_line)
|
||||
except json.JSONDecodeError:
|
||||
continue
|
||||
|
||||
event_type = event.get("event_type", "")
|
||||
|
||||
if event_type == "interaction.start":
|
||||
interaction_id = event.get("interaction", {}).get("id")
|
||||
if interaction_id:
|
||||
self.history.add_interaction(interaction_id, query, "streaming")
|
||||
yield {"type": "start", "interaction_id": interaction_id}
|
||||
|
||||
elif event_type == "content.delta":
|
||||
delta = event.get("delta", {})
|
||||
delta_type = delta.get("type")
|
||||
|
||||
if delta_type == "text":
|
||||
yield {"type": "text", "content": delta.get("text", "")}
|
||||
elif delta_type == "thought_summary":
|
||||
content = delta.get("content", {})
|
||||
yield {"type": "thought", "content": content.get("text", "")}
|
||||
|
||||
elif event_type == "interaction.complete":
|
||||
if interaction_id:
|
||||
self.history.update_status(interaction_id, "completed")
|
||||
yield {"type": "complete"}
|
||||
|
||||
elif event_type == "error":
|
||||
if interaction_id:
|
||||
self.history.update_status(interaction_id, "failed")
|
||||
yield {"type": "error", "error": event.get("error", "Unknown error")}
|
||||
|
||||
except httpx.HTTPError as e:
|
||||
yield {"type": "error", "error": str(e)}
|
||||
|
||||
def parse_result(self, text: str) -> Optional[Dict]:
|
||||
"""
|
||||
Parse research result text into structured data if JSON.
|
||||
|
||||
Args:
|
||||
text: Raw text output from Gemini
|
||||
|
||||
Returns:
|
||||
Parsed JSON data or None if not JSON
|
||||
"""
|
||||
if not text:
|
||||
return None
|
||||
|
||||
# Try direct JSON parsing
|
||||
try:
|
||||
return json.loads(text)
|
||||
except json.JSONDecodeError:
|
||||
pass
|
||||
|
||||
# Try extracting JSON from markdown code blocks
|
||||
json_match = re.search(r'```(?:json)?\s*(\{.*?\})\s*```', text, re.DOTALL)
|
||||
if json_match:
|
||||
try:
|
||||
return json.loads(json_match.group(1))
|
||||
except json.JSONDecodeError:
|
||||
pass
|
||||
|
||||
# Try finding JSON object pattern
|
||||
json_match = re.search(r'\{[^{}]*"[^"]+"\s*:[^{}]*\}', text, re.DOTALL)
|
||||
if json_match:
|
||||
try:
|
||||
return json.loads(json_match.group(0))
|
||||
except json.JSONDecodeError:
|
||||
pass
|
||||
|
||||
return None
|
||||
|
||||
|
||||
def print_progress(poll_count: int, elapsed: float, status: str):
|
||||
"""Print progress update during polling."""
|
||||
mins = int(elapsed // 60)
|
||||
secs = int(elapsed % 60)
|
||||
print(f"\r[{mins:02d}:{secs:02d}] Poll #{poll_count} - Status: {status}", end="", flush=True)
|
||||
|
||||
|
||||
async def cmd_research(args):
|
||||
"""Execute a research query."""
|
||||
client = DeepResearchClient()
|
||||
|
||||
try:
|
||||
if args.stream:
|
||||
# Streaming mode
|
||||
print(f"Starting streaming research...\n")
|
||||
full_text = ""
|
||||
|
||||
async for event in client.stream_research(args.query, args.format):
|
||||
if event["type"] == "start":
|
||||
print(f"Interaction ID: {event['interaction_id']}\n")
|
||||
elif event["type"] == "thought":
|
||||
print(f"\n[Thinking] {event['content']}\n", file=sys.stderr)
|
||||
elif event["type"] == "text":
|
||||
print(event["content"], end="", flush=True)
|
||||
full_text += event["content"]
|
||||
elif event["type"] == "complete":
|
||||
print("\n\n[Research Complete]")
|
||||
elif event["type"] == "error":
|
||||
print(f"\n[Error] {event['error']}", file=sys.stderr)
|
||||
return 1
|
||||
|
||||
# Output JSON if requested
|
||||
if args.json and full_text:
|
||||
parsed = client.parse_result(full_text)
|
||||
if parsed:
|
||||
print("\n\n--- Parsed JSON ---")
|
||||
print(json.dumps(parsed, indent=2))
|
||||
else:
|
||||
# Polling mode
|
||||
previous_id = args.continue_from if hasattr(args, 'continue_from') else None
|
||||
|
||||
print(f"Starting research task...")
|
||||
interaction_id = await client.start_research(
|
||||
args.query,
|
||||
args.format,
|
||||
previous_id
|
||||
)
|
||||
print(f"Interaction ID: {interaction_id}")
|
||||
print(f"Estimated time: 2-10 minutes\n")
|
||||
|
||||
if args.no_wait:
|
||||
print(f"Research started. Check status with: --status {interaction_id}")
|
||||
return 0
|
||||
|
||||
print("Waiting for completion (Ctrl+C to cancel)...")
|
||||
result = await client.wait_for_completion(
|
||||
interaction_id,
|
||||
progress_callback=print_progress
|
||||
)
|
||||
print() # New line after progress
|
||||
|
||||
if result["status"] == "completed":
|
||||
text = result.get("result", "")
|
||||
|
||||
if args.json:
|
||||
parsed = client.parse_result(text)
|
||||
if parsed:
|
||||
print(json.dumps(parsed, indent=2))
|
||||
else:
|
||||
print(json.dumps({"text": text}, indent=2))
|
||||
elif args.raw:
|
||||
print(json.dumps(result.get("raw", {}), indent=2))
|
||||
else:
|
||||
print("\n--- Research Result ---\n")
|
||||
print(text)
|
||||
|
||||
return 0
|
||||
else:
|
||||
print(f"\nResearch failed: {result.get('error', 'Unknown error')}")
|
||||
return 1
|
||||
|
||||
except DeepResearchError as e:
|
||||
print(f"Error: {e}", file=sys.stderr)
|
||||
return 1
|
||||
except KeyboardInterrupt:
|
||||
print("\n\nCancelled by user.")
|
||||
return 130
|
||||
finally:
|
||||
await client.close()
|
||||
|
||||
|
||||
async def cmd_status(args):
|
||||
"""Check status of a research task."""
|
||||
client = DeepResearchClient()
|
||||
|
||||
try:
|
||||
result = await client.get_status(args.interaction_id)
|
||||
|
||||
if args.json:
|
||||
print(json.dumps(result, indent=2))
|
||||
else:
|
||||
print(f"Status: {result['status']}")
|
||||
|
||||
if result["status"] == "completed":
|
||||
text = result.get("result", "")
|
||||
if text:
|
||||
print(f"\n--- Result Preview ---\n{text[:500]}...")
|
||||
elif result["status"] in ["failed", "error"]:
|
||||
print(f"Error: {result.get('error', 'Unknown')}")
|
||||
|
||||
return 0 if result["status"] != "error" else 1
|
||||
|
||||
except DeepResearchError as e:
|
||||
print(f"Error: {e}", file=sys.stderr)
|
||||
return 1
|
||||
finally:
|
||||
await client.close()
|
||||
|
||||
|
||||
async def cmd_wait(args):
|
||||
"""Wait for a research task to complete."""
|
||||
client = DeepResearchClient()
|
||||
|
||||
try:
|
||||
print(f"Waiting for {args.interaction_id}...")
|
||||
result = await client.wait_for_completion(
|
||||
args.interaction_id,
|
||||
progress_callback=print_progress
|
||||
)
|
||||
print()
|
||||
|
||||
if result["status"] == "completed":
|
||||
text = result.get("result", "")
|
||||
|
||||
if args.json:
|
||||
parsed = client.parse_result(text)
|
||||
if parsed:
|
||||
print(json.dumps(parsed, indent=2))
|
||||
else:
|
||||
print(json.dumps({"text": text}, indent=2))
|
||||
else:
|
||||
print("\n--- Research Result ---\n")
|
||||
print(text)
|
||||
|
||||
return 0
|
||||
else:
|
||||
print(f"Research failed: {result.get('error', 'Unknown error')}")
|
||||
return 1
|
||||
|
||||
except DeepResearchError as e:
|
||||
print(f"Error: {e}", file=sys.stderr)
|
||||
return 1
|
||||
except KeyboardInterrupt:
|
||||
print("\n\nCancelled by user.")
|
||||
return 130
|
||||
finally:
|
||||
await client.close()
|
||||
|
||||
|
||||
async def cmd_list(args):
|
||||
"""List recent research tasks."""
|
||||
history = HistoryManager()
|
||||
interactions = history.get_recent(args.limit)
|
||||
|
||||
if not interactions:
|
||||
print("No research history found.")
|
||||
return 0
|
||||
|
||||
if args.json:
|
||||
print(json.dumps(interactions, indent=2))
|
||||
else:
|
||||
print(f"Recent research tasks (last {len(interactions)}):\n")
|
||||
for item in interactions:
|
||||
status_icon = {
|
||||
"completed": "[ok]",
|
||||
"failed": "[!!]",
|
||||
"started": "[..]",
|
||||
"streaming": "[>>]",
|
||||
"timeout": "[to]"
|
||||
}.get(item.get("status", ""), "[??]")
|
||||
|
||||
print(f"{status_icon} {item['id'][:12]}...")
|
||||
print(f" Query: {item['query'][:60]}{'...' if len(item['query']) > 60 else ''}")
|
||||
print(f" Started: {item.get('started_at', 'N/A')}")
|
||||
if item.get("completed_at"):
|
||||
print(f" Completed: {item['completed_at']}")
|
||||
print()
|
||||
|
||||
return 0
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(
|
||||
description="Gemini Deep Research - Autonomous multi-step research agent",
|
||||
formatter_class=argparse.RawDescriptionHelpFormatter,
|
||||
epilog="""
|
||||
Examples:
|
||||
# Start a research task and wait for results
|
||||
%(prog)s --query "Research the history of Kubernetes"
|
||||
|
||||
# With structured output format
|
||||
%(prog)s --query "Compare Python web frameworks" \\
|
||||
--format "1. Executive Summary\\n2. Comparison Table\\n3. Recommendations"
|
||||
|
||||
# Stream progress in real-time
|
||||
%(prog)s --query "Analyze EV battery market" --stream
|
||||
|
||||
# Start without waiting
|
||||
%(prog)s --query "Research topic" --no-wait
|
||||
|
||||
# Check status of running research
|
||||
%(prog)s --status abc123
|
||||
|
||||
# Continue from previous research
|
||||
%(prog)s --query "Elaborate on point 2" --continue abc123
|
||||
|
||||
# List recent research
|
||||
%(prog)s --list
|
||||
|
||||
Note: Research tasks typically take 2-10 minutes and cost $2-5 per task.
|
||||
"""
|
||||
)
|
||||
|
||||
# Main commands (mutually exclusive)
|
||||
cmd_group = parser.add_mutually_exclusive_group(required=True)
|
||||
cmd_group.add_argument("--query", "-q", help="Research query to execute")
|
||||
cmd_group.add_argument("--status", "-s", dest="interaction_id", metavar="ID",
|
||||
help="Check status of a research task")
|
||||
cmd_group.add_argument("--wait", "-w", dest="wait_id", metavar="ID",
|
||||
help="Wait for a research task to complete")
|
||||
cmd_group.add_argument("--list", "-l", action="store_true",
|
||||
help="List recent research tasks")
|
||||
|
||||
# Query options
|
||||
parser.add_argument("--format", "-f", metavar="SPEC",
|
||||
help="Output format specification")
|
||||
parser.add_argument("--continue", dest="continue_from", metavar="ID",
|
||||
help="Continue from previous research interaction")
|
||||
parser.add_argument("--stream", action="store_true",
|
||||
help="Stream progress in real-time")
|
||||
parser.add_argument("--no-wait", action="store_true",
|
||||
help="Start research without waiting for completion")
|
||||
|
||||
# Output options
|
||||
parser.add_argument("--json", "-j", action="store_true",
|
||||
help="Output results as JSON")
|
||||
parser.add_argument("--raw", "-r", action="store_true",
|
||||
help="Output raw API response")
|
||||
|
||||
# List options
|
||||
parser.add_argument("--limit", type=int, default=10,
|
||||
help="Number of recent tasks to show (default: 10)")
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
# Route to appropriate command
|
||||
if args.query:
|
||||
exit_code = asyncio.run(cmd_research(args))
|
||||
elif args.interaction_id:
|
||||
exit_code = asyncio.run(cmd_status(args))
|
||||
elif args.wait_id:
|
||||
args.interaction_id = args.wait_id
|
||||
exit_code = asyncio.run(cmd_wait(args))
|
||||
elif args.list:
|
||||
exit_code = asyncio.run(cmd_list(args))
|
||||
else:
|
||||
parser.print_help()
|
||||
exit_code = 1
|
||||
|
||||
sys.exit(exit_code)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user